Mirror/FairMQ
1
0
Fork 0
mirror of https://github.com/FairRootGroup/FairMQ.git synced 2025-10-13 16:46:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix copy constructor & assignment operator warning in FairMQChannel

Browse Source 
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.
This commit is contained in:
Alexey Rybalchenko 2016-01-06 13:52:24 +01:00 committed by Florian Uhlig
parent 9a0a8c7516
commit e4fed2fa1b
21 changed files with 133 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
fairmq/FairMQChannel.cxx
View File

@ -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

6
fairmq/FairMQChannel.h
View File

@ -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();

8
fairmq/FairMQDevice.h
View File

@ -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_ */

16
fairmq/FairMQStateMachine.h
View File

@ -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

15
fairmq/devices/BaseDeserializationPolicy.h
View File

@ -8,32 +8,26 @@
#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()
{}
public:
BaseDeserializationPolicy() {}
virtual ~BaseDeserializationPolicy()
{}
virtual ~BaseDeserializationPolicy() {}
template<typename C = TDerived>
auto DeserializeMsg(FairMQMessage* msg)-> decltype(static_cast<C*>(this)->DeserializeMsg(msg) )
auto DeserializeMsg(FairMQMessage* msg)-> decltype(static_cast<C*>(this)->DeserializeMsg(msg))
{
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 */

18
fairmq/devices/BaseProcessorTaskPolicy.h
View File

@ -14,31 +14,27 @@
template <typename TDerived >
class BaseProcessorTaskPolicy
{
public:
BaseProcessorTaskPolicy()
{}
public:
BaseProcessorTaskPolicy() {}
virtual ~BaseProcessorTaskPolicy()
{}
virtual ~BaseProcessorTaskPolicy() {}
template<typename C = TDerived>
auto GetOutputData() -> decltype(static_cast<C*>(this)->GetOutputData() )
auto GetOutputData() -> decltype(static_cast<C*>(this)->GetOutputData())
{
static_assert(std::is_same<C, TDerived>{}, "BaseProcessorTaskPolicy::GetOutputData hack broken");
return static_cast<TDerived*>(this)->GetOutputData();
}
template<typename CONTAINER_TYPE, typename C = TDerived>
auto ExecuteTask(CONTAINER_TYPE container) -> decltype( static_cast<C*>(this)->ExecuteTask(container) )
auto ExecuteTask(CONTAINER_TYPE container) -> decltype( static_cast<C*>(this)->ExecuteTask(container))
{
static_assert(std::is_same<C, TDerived>{}, "BaseProcessorTaskPolicy::ExecuteTask hack broken");
return static_cast<TDerived*>(this)->ExecuteTask(container);
}
};
/*
/*
// c++14 code only
// CRTP base class
@ -65,5 +61,5 @@ public:
};
*/
#endif /* BASEPROCESSORTASKPOLICY_H */
#endif /* BASEPROCESSORTASKPOLICY_H */

13
fairmq/devices/BaseSerializationPolicy.h
View File

@ -15,12 +15,10 @@
template <typename TDerived >
class BaseSerializationPolicy
{
public:
BaseSerializationPolicy()
{}
public:
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,10 +33,9 @@ public:
static_assert(std::is_same<C, TDerived>{}, "BaseSerializationPolicy::SetMessage hack broken");
return static_cast<TDerived*>(this)->SetMessage(msg);
}
};
/*
/*
// CRTP base class
// c++14 code
template <typename TDerived >
@ -64,5 +61,5 @@ public:
};
*/
#endif /* BASESERIALIZATIONPOLICY_H */
#endif /* BASESERIALIZATIONPOLICY_H */

12
fairmq/devices/BaseSinkPolicy.h
View File

@ -8,18 +8,16 @@
#ifndef BASESINKPOLICY_H
#define BASESINKPOLICY_H
#include <type_traits>
// CRTP base class
template <typename TDerived >
class BaseSinkPolicy
{
public:
BaseSinkPolicy()
{}
public:
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 */

12
fairmq/devices/BaseSourcePolicy.h
View File

@ -9,17 +9,16 @@
#define BASESOURCEPOLICY_H
#include <type_traits>
// c++11 code
// CRTP base class
template <typename TDerived >
class BaseSourcePolicy
{
public:
BaseSourcePolicy()
{}
public:
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 */

1
fairmq/devices/GenericMerger.h
View File

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

1
fairmq/devices/GenericSampler.tpl
View File

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

6
fairmq/nanomsg/FairMQMessageNN.h
View File

@ -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_ */

6
fairmq/nanomsg/FairMQPollerNN.h
View File

@ -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_ */

6
fairmq/nanomsg/FairMQSocketNN.h
View File

@ -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_ */

10
fairmq/options/FairProgOptions.cxx
View File

@ -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()
@ -141,7 +145,7 @@ int FairProgOptions::ParseCmdLine(const int argc, char** argv, const po::options
int FairProgOptions::ParseCmdLine(const int argc, char** argv, const po::options_description& desc, bool allowUnregistered)
{
return ParseCmdLine(argc,argv,desc,fVarMap,allowUnregistered);
return ParseCmdLine(argc, argv, desc, fVarMap, allowUnregistered);
}
int FairProgOptions::ParseCfgFile(ifstream& ifs, const po::options_description& desc, po::variables_map& varmap, bool allowUnregistered)

2
fairmq/options/FairProgOptions.h
View File

@ -97,7 +97,7 @@ class FairProgOptions
// convert value to string that corresponds to the key
std::string GetStringValue(const std::string& key);
const po::variables_map& GetVarMap() const {return fVarMap;}
const po::variables_map& GetVarMap() const { return fVarMap; }
// boost prog options parsers
int ParseCmdLine(const int argc, char** argv, const po::options_description& desc, po::variables_map& varmap, bool allowUnregistered = false);

4
fairmq/options/FairProgOptionsHelper.h
View File

@ -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

4
fairmq/tools/runSimpleMQStateMachine.h
View File

@ -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 */

6
fairmq/zeromq/FairMQContextZMQ.h
View File

@ -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_ */

6
fairmq/zeromq/FairMQPollerZMQ.h
View File

@ -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_ */

6
fairmq/zeromq/FairMQSocketZMQ.h
View File

@ -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_ */