Takes care of proper special member generation globally, fixes #1689

Phew, a lot of classes were affected by this. The rationale for the
changes are as follows:

- When a type X declares any constructor, the default constructor is
  not declared, so there is no need for X() = delete there. In fact,
  there is brutal difference between those two: deleted members
  participate in overload resolution, but not-declared members do not!

- When a type X wants to be non-copyable (e.g. to be only movable, like
  threads, unique_ptrs, and so on), you can either do it by inheriting
  from boost::noncopyable (the old way), or better declare both (!) the
  copy constructor _and_ the copy assignment operator as deleted:

      X(X const&) = delete;
      X& operator=(X const&) = delete;

  We had tons of types with deleted copy constructors that were lacking
  a corresponding deleted copy assignment operator, making them still
  copyable and you wouldn't even notice (read: scary)!

References:

- http://accu.org/content/conf2014/Howard_Hinnant_Accu_2014.pdf
- http://www.boost.org/doc/libs/master/libs/core/doc/html/core/noncopyable.html

Note: I know, I'm quoting Hinnant's extraordinary slides a lot, but
getting the sematic right here is so incredibly important.

include/storage/shared_memory.hpp

@@ -58,7 +58,10 @@ class SharedMemory
         }
 
         shm_remove() : m_shmid(INT_MIN), m_initialized(false) {}
+
         shm_remove(const shm_remove &) = delete;
+        shm_remove &operator=(const shm_remove &) = delete;
+
         ~shm_remove()
         {
             if (m_initialized)
@@ -75,7 +78,6 @@ class SharedMemory
   public:
     void *Ptr() const { return region.get_address(); }
 
-    SharedMemory() = delete;
     SharedMemory(const SharedMemory &) = delete;
     SharedMemory &operator=(const SharedMemory &) = delete;
 
@@ -193,8 +195,6 @@ class SharedMemory
     class shm_remove
     {
       private:
-        shm_remove(const shm_remove &) = delete;
-        shm_remove &operator=(const shm_remove &) = delete;
         char *m_shmid;
         bool m_initialized;
 
@@ -207,6 +207,9 @@ class SharedMemory
 
         shm_remove() : m_shmid("undefined"), m_initialized(false) {}
 
+        shm_remove(const shm_remove &) = delete;
+        shm_remove &operator=(const shm_remove &) = delete;
+
         ~shm_remove()
         {
             if (m_initialized)
@@ -324,34 +327,33 @@ class SharedMemory
 
 template <typename IdentifierT, typename LockFileT = OSRMLockFile>
 SharedMemory *makeSharedMemory(const IdentifierT &id,
-    const uint64_t size = 0,
-    bool read_write = false,
-    bool remove_prev = true)
+                               const uint64_t size = 0,
+                               bool read_write = false,
+                               bool remove_prev = true)
 {
-  try
-  {
-    LockFileT lock_file;
-    if (!boost::filesystem::exists(lock_file()))
+    try
     {
-      if (0 == size)
-      {
-        throw util::exception("lock file does not exist, exiting");
-      }
-      else
-      {
-        boost::filesystem::ofstream ofs(lock_file());
-      }
+        LockFileT lock_file;
+        if (!boost::filesystem::exists(lock_file()))
+        {
+            if (0 == size)
+            {
+                throw util::exception("lock file does not exist, exiting");
+            }
+            else
+            {
+                boost::filesystem::ofstream ofs(lock_file());
+            }
+        }
+        return new SharedMemory(lock_file(), id, size, read_write, remove_prev);
+    }
+    catch (const boost::interprocess::interprocess_exception &e)
+    {
+        util::SimpleLogger().Write(logWARNING) << "caught exception: " << e.what() << ", code "
+                                               << e.get_error_code();
+        throw util::exception(e.what());
     }
-    return new SharedMemory(lock_file(), id, size, read_write, remove_prev);
-  }
-  catch (const boost::interprocess::interprocess_exception &e)
-  {
-    util::SimpleLogger().Write(logWARNING) << "caught exception: " << e.what() << ", code "
-      << e.get_error_code();
-    throw util::exception(e.what());
-  }
 }
-
 }
 }