Fix copy constructor & assignment operator warning in FairMQChannel

Fix Weffc++ warnings

  - Add missing copy constructors and assignment operators .
  - Hide the warning from FairMQStateMachine.h where it is produced by boost and/or is intended.
  - Some code cleanup.

fairmq/FairMQChannel.cxx

@@ -63,6 +63,47 @@ FairMQChannel::FairMQChannel(const string& type, const string& method, const str
 {
 }
 
+FairMQChannel::FairMQChannel(const FairMQChannel& chan)
+    : fType(chan.fType)
+    , fMethod(chan.fMethod)
+    , fAddress(chan.fAddress)
+    , fSndBufSize(chan.fSndBufSize)
+    , fRcvBufSize(chan.fRcvBufSize)
+    , fRateLogging(chan.fRateLogging)
+    , fSocket(nullptr)
+    , fChannelName(chan.fChannelName)
+    , fIsValid(false)
+    , fPoller(nullptr)
+    , fCmdSocket(nullptr)
+    , fTransportFactory(nullptr)
+    , fNoBlockFlag(chan.fNoBlockFlag)
+    , fSndMoreFlag(chan.fSndMoreFlag)
+    , fSndTimeoutInMs(chan.fSndTimeoutInMs)
+    , fRcvTimeoutInMs(chan.fRcvTimeoutInMs)
+{}
+
+FairMQChannel& FairMQChannel::operator=(const FairMQChannel& chan)
+{
+    fType = chan.fType;
+    fMethod = chan.fMethod;
+    fAddress = chan.fAddress;
+    fSndBufSize = chan.fSndBufSize;
+    fRcvBufSize = chan.fRcvBufSize;
+    fRateLogging = chan.fRateLogging;
+    fSocket = nullptr;
+    fChannelName = chan.fChannelName;
+    fIsValid = false;
+    fPoller = nullptr;
+    fCmdSocket = nullptr;
+    fTransportFactory = nullptr;
+    fNoBlockFlag = chan.fNoBlockFlag;
+    fSndMoreFlag = chan.fSndMoreFlag;
+    fSndTimeoutInMs = chan.fSndTimeoutInMs;
+    fRcvTimeoutInMs = chan.fRcvTimeoutInMs;
+
+    return *this;
+}
+
 string FairMQChannel::GetType() const
 {
     try

fairmq/FairMQChannel.h

@@ -41,6 +41,12 @@ class FairMQChannel
     /// @param address Network address to bind/connect to (e.g. "tcp://127.0.0.1:5555" or "ipc://abc")
     FairMQChannel(const std::string& type, const std::string& method, const std::string& address);
 
+    /// Copy Constructor
+    FairMQChannel(const FairMQChannel&);
+
+    /// Assignment operator
+    FairMQChannel& operator=(const FairMQChannel&);
+
     /// Default destructor
     virtual ~FairMQChannel();
 

fairmq/FairMQDevice.h

@@ -45,6 +45,10 @@ class FairMQDevice : public FairMQStateMachine, public FairMQConfigurable
 
     /// Default constructor
     FairMQDevice();
+    /// Copy constructor (disabled)
+    FairMQDevice(const FairMQDevice&) = delete;
+    /// Assignment operator (disabled)
+    FairMQDevice operator=(const FairMQDevice&) = delete;
     /// Default destructor
     virtual ~FairMQDevice();
 
@@ -173,10 +177,6 @@ class FairMQDevice : public FairMQStateMachine, public FairMQConfigurable
     /// Signal handler
     void SignalHandler(int signal);
     bool fCatchingSignals;
-
-    /// Copy Constructor
-    FairMQDevice(const FairMQDevice&);
-    FairMQDevice operator=(const FairMQDevice&);
 };
 
 #endif /* FAIRMQDEVICE_H_ */

fairmq/FairMQStateMachine.h

@@ -57,6 +57,15 @@ struct internal_IDLE         { std::string name() const { return "internal_IDLE"
 struct END                   { std::string name() const { return "END"; } };
 struct ERROR_FOUND           { std::string name() const { return "ERROR_FOUND"; } };
 
+// deactivate the warning for non-virtual destructor thrown in the boost library
+#if defined(__clang__)
+_Pragma("clang diagnostic push")
+_Pragma("clang diagnostic ignored \"-Wnon-virtual-dtor\"")
+#elif defined(__GNUC__) || defined(__GNUG__)
+_Pragma("GCC diagnostic push")
+_Pragma("GCC diagnostic ignored \"-Wnon-virtual-dtor\"")
+#endif
+
 // defining the boost MSM state machine
 struct FairMQFSM_ : public msm::front::state_machine_def<FairMQFSM_>
 {
@@ -459,6 +468,13 @@ struct FairMQFSM_ : public msm::front::state_machine_def<FairMQFSM_>
     std::atomic<State> fState;
 };
 
+// reactivate the warning for non-virtual destructor
+#if defined(__clang__)
+_Pragma("clang diagnostic pop")
+#elif defined(__GNUC__) || defined(__GNUG__)
+_Pragma("GCC diagnostic pop")
+#endif
+
 typedef msm::back::state_machine<FairMQFSM_> FairMQFSM;
 } // namespace FairMQFSM
 

fairmq/devices/BaseDeserializationPolicy.h

@@ -8,24 +8,19 @@
 #ifndef BASEDESERIALIZATIONPOLICY_H
 #define BASEDESERIALIZATIONPOLICY_H
 
-
 #include "FairMQMessage.h"
 
 // c++11 code
 #include <type_traits>
 
-
-
 //  CRTP base class
 template <typename TDerived >
 class BaseDeserializationPolicy
 {
   public:
-    BaseDeserializationPolicy() 
+    BaseDeserializationPolicy() {}
-    {}
 
-    virtual ~BaseDeserializationPolicy()
+    virtual ~BaseDeserializationPolicy() {}
-    {}
 
     template<typename C = TDerived>
     auto DeserializeMsg(FairMQMessage* msg)-> decltype(static_cast<C*>(this)->DeserializeMsg(msg))
@@ -33,7 +28,6 @@ public:
         static_assert(std::is_same<C, TDerived>{}, "BaseDeserializationPolicy::DeserializeMsg hack broken");
         return static_cast<TDerived*>(this)->DeserializeMsg(msg);
     }
-
 };
 
 
@@ -58,4 +52,3 @@ public:
 };*/
 
 #endif /* BASEDESERIALIZATIONPOLICY_H */
-

fairmq/devices/BaseProcessorTaskPolicy.h

@@ -15,11 +15,9 @@ template <typename TDerived >
 class BaseProcessorTaskPolicy
 {
   public:
-    BaseProcessorTaskPolicy() 
+    BaseProcessorTaskPolicy() {}
-    {}
 
-    virtual ~BaseProcessorTaskPolicy()
+    virtual ~BaseProcessorTaskPolicy() {}
-    {}
 
     template<typename C = TDerived>
     auto GetOutputData() -> decltype(static_cast<C*>(this)->GetOutputData())
@@ -34,8 +32,6 @@ public:
         static_assert(std::is_same<C, TDerived>{}, "BaseProcessorTaskPolicy::ExecuteTask hack broken");
         return static_cast<TDerived*>(this)->ExecuteTask(container);
     }
-
-
 };
 
 /*
@@ -65,5 +61,5 @@ public:
 
 };
 */
-#endif	/* BASEPROCESSORTASKPOLICY_H */
 
+#endif /* BASEPROCESSORTASKPOLICY_H */

fairmq/devices/BaseSerializationPolicy.h

@@ -16,11 +16,9 @@ template <typename TDerived >
 class BaseSerializationPolicy
 {
   public:
-    BaseSerializationPolicy() 
+    BaseSerializationPolicy() {}
-    {}
 
-    virtual ~BaseSerializationPolicy()
+    virtual ~BaseSerializationPolicy() {}
-    {}
 
     template<typename CONTAINER_TYPE, typename C = TDerived>
     auto SerializeMsg(CONTAINER_TYPE container) -> decltype(static_cast<C*>(this)->SerializeMsg(container) )
@@ -35,7 +33,6 @@ public:
         static_assert(std::is_same<C, TDerived>{}, "BaseSerializationPolicy::SetMessage hack broken");
         return static_cast<TDerived*>(this)->SetMessage(msg);
     }
-
 };
 
 /*
@@ -64,5 +61,5 @@ public:
 
 };
 */
-#endif	/* BASESERIALIZATIONPOLICY_H */
 
+#endif /* BASESERIALIZATIONPOLICY_H */

fairmq/devices/BaseSinkPolicy.h

@@ -8,18 +8,16 @@
 #ifndef BASESINKPOLICY_H
 #define BASESINKPOLICY_H
 
-
 #include <type_traits>
+
 //  CRTP base class
 template <typename TDerived >
 class BaseSinkPolicy
 {
   public:
-    BaseSinkPolicy() 
+    BaseSinkPolicy() {}
-    {}
 
-    virtual ~BaseSinkPolicy()
+    virtual ~BaseSinkPolicy() {}
-    {}
 
     template<typename CONTAINER_TYPE, typename C = TDerived>
     auto AddToFile(CONTAINER_TYPE container) -> decltype(static_cast<C*>(this)->AddToFile(container) )
@@ -34,8 +32,6 @@ public:
         static_assert(std::is_same<C, TDerived>{}, "BaseSinkPolicy::InitOutputFile hack broken");
         return static_cast<TDerived*>(this)->InitOutputFile();
     }
-
 };
 
 #endif /* BASESINKPOLICY_H */
-

fairmq/devices/BaseSourcePolicy.h

@@ -9,17 +9,16 @@
 #define BASESOURCEPOLICY_H
 
 #include <type_traits>
+
 // c++11 code
 //  CRTP base class
 template <typename TDerived >
 class BaseSourcePolicy
 {
   public:
-    BaseSourcePolicy() 
+    BaseSourcePolicy() {}
-    {}
 
-    virtual ~BaseSourcePolicy()
+    virtual ~BaseSourcePolicy() {}
-    {}
 
     template<typename C = TDerived>
     auto InitSource()-> decltype(static_cast<C*>(this)->InitSource() )
@@ -49,7 +48,6 @@ public:
         static_assert(std::is_same<C, TDerived>{}, "BaseSourcePolicy::GetOutData hack broken");
         return static_cast<TDerived*>(this)->GetOutData();
     }
-
 };
 
 /*
@@ -87,5 +85,5 @@ public:
 
 };
 */
-#endif	/* BASESOURCEPOLICY_H */
 
+#endif /* BASESOURCEPOLICY_H */

fairmq/devices/GenericMerger.h

@@ -72,4 +72,3 @@ class GenericMerger : public FairMQDevice, public MergerPolicy, public InputPoli
 };
 
 #endif /* GENERICMERGER_H */
-

fairmq/devices/GenericSampler.tpl

@@ -13,6 +13,7 @@ base_GenericSampler<T,U,K,L>::base_GenericSampler()
   , fEventRate(1)
   , fEventCounter(0)
   , fContinuous(false)
+  , fTaskList()
 {
 }
 

fairmq/nanomsg/FairMQMessageNN.h

@@ -25,6 +25,8 @@ class FairMQMessageNN : public FairMQMessage
     FairMQMessageNN();
     FairMQMessageNN(size_t size);
     FairMQMessageNN(void* data, size_t size, fairmq_free_fn *ffn = NULL, void* hint = NULL);
+    FairMQMessageNN(const FairMQMessageNN&) = delete;
+    FairMQMessageNN operator=(const FairMQMessageNN&) = delete;
 
     virtual void Rebuild();
     virtual void Rebuild(size_t size);
@@ -50,10 +52,6 @@ class FairMQMessageNN : public FairMQMessage
     bool fReceiving;
 
     void Clear();
-
-    /// Copy Constructor
-    FairMQMessageNN(const FairMQMessageNN&);
-    FairMQMessageNN operator=(const FairMQMessageNN&);
 };
 
 #endif /* FAIRMQMESSAGENN_H_ */

fairmq/nanomsg/FairMQPollerNN.h

@@ -33,6 +33,8 @@ class FairMQPollerNN : public FairMQPoller
   public:
     FairMQPollerNN(const std::vector<FairMQChannel>& channels);
     FairMQPollerNN(std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, std::initializer_list<std::string> channelList);
+    FairMQPollerNN(const FairMQPollerNN&) = delete;
+    FairMQPollerNN operator=(const FairMQPollerNN&) = delete;
 
     virtual void Poll(const int timeout);
     virtual bool CheckInput(const int index);
@@ -49,10 +51,6 @@ class FairMQPollerNN : public FairMQPoller
     int fNumItems;
 
     std::unordered_map<std::string, int> fOffsetMap;
-
-    /// Copy Constructor
-    FairMQPollerNN(const FairMQPollerNN&);
-    FairMQPollerNN operator=(const FairMQPollerNN&);
 };
 
 #endif /* FAIRMQPOLLERNN_H_ */

fairmq/nanomsg/FairMQSocketNN.h

@@ -27,6 +27,8 @@ class FairMQSocketNN : public FairMQSocket
 {
   public:
     FairMQSocketNN(const std::string& type, const std::string& name, int numIoThreads); // numIoThreads is not used in nanomsg.
+    FairMQSocketNN(const FairMQSocketNN&) = delete;
+    FairMQSocketNN operator=(const FairMQSocketNN&) = delete;
 
     virtual std::string GetId();
 
@@ -67,10 +69,6 @@ class FairMQSocketNN : public FairMQSocket
     unsigned long fBytesRx;
     unsigned long fMessagesTx;
     unsigned long fMessagesRx;
-
-    /// Copy Constructor
-    FairMQSocketNN(const FairMQSocketNN&);
-    FairMQSocketNN operator=(const FairMQSocketNN&);
 };
 
 #endif /* FAIRMQSOCKETNN_H_ */

fairmq/options/FairProgOptions.cxx

@@ -22,11 +22,15 @@ FairProgOptions::FairProgOptions() :
                         fGenericDesc("Generic options description"),
                         fConfigDesc("Configuration options description"),
                         fHiddenDesc("Hidden options description"),
-                        fEnvironmentDesc("Environment Variables"),
+                        fEnvironmentDesc("Environment variables"),
                         fCmdLineOptions("Command line options"),
                         fConfigFileOptions("Configuration file options"),
                         fVisibleOptions("Visible options"),
-                        fVerboseLvl("INFO"), fUseConfigFile(false), fConfigFile()
+                        fVerboseLvl("INFO"),
+                        fUseConfigFile(false),
+                        fConfigFile(),
+                        fVarMap(),
+                        fSeverityMap()
 {
     // define generic options
     fGenericDesc.add_options()

fairmq/options/FairProgOptionsHelper.h

@@ -25,8 +25,6 @@
 #include <iterator>
 #include <tuple>
 
-
-
 template<class T>
 std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
 {
@@ -36,7 +34,6 @@ std::ostream& operator<<(std::ostream& os, const std::vector<T>& v)
 
 namespace fairmq
 {
-    
     namespace po = boost::program_options;
 
     //_____________________________________________________________________________________________________________________________
@@ -108,6 +105,7 @@ namespace fairmq
             return std::string("empty value");
         }
     };
+
 //_____________________________________________________________________________________________________________________________
 
     // policy to convert variable value content into a tuple with value, type, defaulted, empty information

fairmq/tools/runSimpleMQStateMachine.h

@@ -28,8 +28,6 @@
 #include "FairMQParser.h"
 #include "FairMQProgOptions.h"
 
-
-
 // template function that take any device, 
 // and run a simple MQ state machine configured from a JSON file
 template<typename TMQDevice>
@@ -114,6 +112,4 @@ inline int runNonInteractiveStateMachine(TMQDevice& device, FairMQProgOptions& c
     return 0;
 }
 
-
 #endif /* RUNSIMPLEMQSTATEMACHINE_H */
-

fairmq/zeromq/FairMQContextZMQ.h

@@ -20,6 +20,8 @@ class FairMQContextZMQ
   public:
     /// Constructor
     FairMQContextZMQ(int numIoThreads);
+    FairMQContextZMQ(const FairMQContextZMQ&) = delete;
+    FairMQContextZMQ operator=(const FairMQContextZMQ&) = delete;
 
     virtual ~FairMQContextZMQ();
     void* GetContext();
@@ -27,10 +29,6 @@ class FairMQContextZMQ
 
   private:
     void* fContext;
-
-    /// Copy Constructor
-    FairMQContextZMQ(const FairMQContextZMQ&);
-    FairMQContextZMQ operator=(const FairMQContextZMQ&);
 };
 
 #endif /* FAIRMQCONTEXTZMQ_H_ */

fairmq/zeromq/FairMQPollerZMQ.h

@@ -33,6 +33,8 @@ class FairMQPollerZMQ : public FairMQPoller
   public:
     FairMQPollerZMQ(const std::vector<FairMQChannel>& channels);
     FairMQPollerZMQ(std::unordered_map<std::string, std::vector<FairMQChannel>>& channelsMap, std::initializer_list<std::string> channelList);
+    FairMQPollerZMQ(const FairMQPollerZMQ&) = delete;
+    FairMQPollerZMQ operator=(const FairMQPollerZMQ&) = delete;
 
     virtual void Poll(const int timeout);
     virtual bool CheckInput(const int index);
@@ -49,10 +51,6 @@ class FairMQPollerZMQ : public FairMQPoller
     int fNumItems;
 
     std::unordered_map<std::string,int> fOffsetMap;
-
-    /// Copy Constructor
-    FairMQPollerZMQ(const FairMQPollerZMQ&);
-    FairMQPollerZMQ operator=(const FairMQPollerZMQ&);
 };
 
 #endif /* FAIRMQPOLLERZMQ_H_ */

fairmq/zeromq/FairMQSocketZMQ.h

@@ -24,6 +24,8 @@ class FairMQSocketZMQ : public FairMQSocket
 {
   public:
     FairMQSocketZMQ(const std::string& type, const std::string& name, int numIoThreads);
+    FairMQSocketZMQ(const FairMQSocketZMQ&) = delete;
+    FairMQSocketZMQ operator=(const FairMQSocketZMQ&) = delete;
 
     virtual std::string GetId();
 
@@ -66,10 +68,6 @@ class FairMQSocketZMQ : public FairMQSocket
     unsigned long fMessagesRx;
 
     static boost::shared_ptr<FairMQContextZMQ> fContext;
-
-    /// Copy Constructor
-    FairMQSocketZMQ(const FairMQSocketZMQ&);
-    FairMQSocketZMQ operator=(const FairMQSocketZMQ&);
 };
 
 #endif /* FAIRMQSOCKETZMQ_H_ */