build fixup

Author: iceseer

src/se/impl/async_dispatcher_impl.hpp

@@ -13,10 +13,16 @@
 namespace jam::se {
 
   template <uint32_t kCount, uint32_t kPoolSize>
-  class AsyncDispatcher final : public IDispatcher,
-                                utils::NoCopy,
-                                utils::NoMove {
+  class AsyncDispatcher final : public IDispatcher {
    public:
+    // Disable copying
+    AsyncDispatcher(const AsyncDispatcher&) = delete;
+    AsyncDispatcher& operator=(const AsyncDispatcher&) = delete;
+    
+    // Disable moving
+    AsyncDispatcher(AsyncDispatcher&&) = delete;
+    AsyncDispatcher& operator=(AsyncDispatcher&&) = delete;
+
     static constexpr uint32_t kHandlersCount = kCount;
     static constexpr uint32_t kPoolThreadsCount = kPoolSize;
 

src/se/impl/scheduler_impl.hpp

@@ -21,7 +21,7 @@
 
 namespace jam::se {
 
-  class SchedulerBase : public IScheduler, utils::NoCopy, utils::NoMove {
+  class SchedulerBase : public IScheduler {
    private:
     using Time = std::chrono::high_resolution_clock;
     using Timepoint = std::chrono::time_point<Time>;
@@ -118,6 +118,14 @@ namespace jam::se {
     }
 
    public:
+    // Disable copying
+    SchedulerBase(const SchedulerBase&) = delete;
+    SchedulerBase& operator=(const SchedulerBase&) = delete;
+    
+    // Disable moving  
+    SchedulerBase(SchedulerBase&&) = delete;
+    SchedulerBase& operator=(SchedulerBase&&) = delete;
+
     SchedulerBase() : is_busy_(false) {
       proceed_.test_and_set();
     }

src/se/impl/subscriber.hpp

@@ -15,17 +15,26 @@ namespace jam::se {
   using SubscriptionSetId = uint32_t;
 
   /**
-   * Base class that determines the subscriber.
-   * @tparam EventKey type of listening event
+   * Base implementation of subscription system's subscriber.
+   * @tparam EventKey type to specify notified events
    * @tparam Dispatcher thread dispatcher to execute tasks
    * @tparam Arguments list of event arguments
    */
   template <typename EventKey, typename Dispatcher, typename... Arguments>
   class Subscriber : public std::enable_shared_from_this<
-                         Subscriber<EventKey, Dispatcher, Arguments...>>,
-                     utils::NoMove,
-                     utils::NoCopy {
+                         Subscriber<EventKey, Dispatcher, Arguments...>> {
    public:
+    // Default constructor
+    Subscriber() = default;
+    
+    // Disable copying
+    Subscriber(const Subscriber&) = delete;
+    Subscriber& operator=(const Subscriber&) = delete;
+    
+    // Disable moving
+    Subscriber(Subscriber&&) = delete;
+    Subscriber& operator=(Subscriber&&) = delete;
+
     using EventType = EventKey;
     virtual ~Subscriber() = default;
 

src/se/impl/subscription_engine.hpp

@@ -32,10 +32,16 @@ namespace jam::se {
   class SubscriptionEngine final
       : public IDisposable,
         public std::enable_shared_from_this<
-            SubscriptionEngine<EventKey, Dispatcher, Receiver>>,
-        utils::NoMove,
-        utils::NoCopy {
+            SubscriptionEngine<EventKey, Dispatcher, Receiver>> {
    public:
+    // Disable copying
+    SubscriptionEngine(const SubscriptionEngine&) = delete;
+    SubscriptionEngine& operator=(const SubscriptionEngine&) = delete;
+    
+    // Disable moving
+    SubscriptionEngine(SubscriptionEngine&&) = delete;
+    SubscriptionEngine& operator=(SubscriptionEngine&&) = delete;
+
     using EventKeyType = EventKey;
     using ReceiverType = Receiver;
     using SubscriberType = Receiver;

src/se/impl/subscription_manager.hpp

@@ -28,10 +28,16 @@ namespace jam::se {
   template <uint32_t kHandlersCount, uint32_t kPoolSize>
   class SubscriptionManager final
       : public std::enable_shared_from_this<
-            SubscriptionManager<kHandlersCount, kPoolSize>>,
-        utils::NoMove,
-        utils::NoCopy {
+            SubscriptionManager<kHandlersCount, kPoolSize>> {
    public:
+    // Disable copying
+    SubscriptionManager(const SubscriptionManager&) = delete;
+    SubscriptionManager& operator=(const SubscriptionManager&) = delete;
+    
+    // Disable moving
+    SubscriptionManager(SubscriptionManager&&) = delete;
+    SubscriptionManager& operator=(SubscriptionManager&&) = delete;
+
     using Dispatcher = jam::se::IDispatcher;
 
    private:
@@ -73,7 +79,7 @@ namespace jam::se {
         {
           std::shared_lock lock(engines_cs_);
           for (auto &descriptor : engines_) {
-            utils::reinterpret_pointer_cast<IDisposable>(descriptor.second)
+            std::reinterpret_pointer_cast<IDisposable>(descriptor.second)
                 ->dispose();
           }
         }
@@ -98,12 +104,12 @@ namespace jam::se {
       {
         std::shared_lock lock(engines_cs_);
         if (auto it = engines_.find(engineId); it != engines_.end()) {
-          return utils::reinterpret_pointer_cast<EngineType>(it->second);
+          return std::reinterpret_pointer_cast<EngineType>(it->second);
         }
       }
       std::unique_lock lock(engines_cs_);
       if (auto it = engines_.find(engineId); it != engines_.end()) {
-        return utils::reinterpret_pointer_cast<EngineType>(it->second);
+        return std::reinterpret_pointer_cast<EngineType>(it->second);
       }
 
       /// To be sure IDisposable is the first base class, because of later cast
@@ -114,7 +120,7 @@ namespace jam::se {
                  reinterpret_cast<EngineType *>(0x1))));
 
       auto obj = std::make_shared<EngineType>(dispatcher_);
-      engines_[engineId] = utils::reinterpret_pointer_cast<void>(obj);
+      engines_[engineId] = std::reinterpret_pointer_cast<void>(obj);
       return obj;
     }
 
@@ -152,7 +158,7 @@ namespace jam::se {
       {
         std::shared_lock lock(engines_cs_);
         if (auto it = engines_.find(engineId); it != engines_.end()) {
-          engine = utils::reinterpret_pointer_cast<EngineType>(it->second);
+          engine = std::reinterpret_pointer_cast<EngineType>(it->second);
         } else {
           return;
         }

src/se/impl/sync_dispatcher_impl.hpp

@@ -12,13 +12,21 @@
 namespace jam::se {
 
   template <uint32_t kCount, uint32_t kPoolSize>
-  class SyncDispatcher final : public IDispatcher,
-                               utils::NoCopy,
-                               utils::NoMove {
+  class SyncDispatcher final : public IDispatcher {
    private:
     using Parent = IDispatcher;
 
    public:
+    // Disable copying
+    SyncDispatcher(const SyncDispatcher&) = delete;
+    SyncDispatcher& operator=(const SyncDispatcher&) = delete;
+    
+    // Disable moving
+    SyncDispatcher(SyncDispatcher&&) = delete;
+    SyncDispatcher& operator=(SyncDispatcher&&) = delete;
+
+    static constexpr uint32_t kHandlersCount = kCount;
+
     SyncDispatcher() = default;
 
     void dispose() override {}