diff --git a/src/eckit/cmd/CmdResource.h b/src/eckit/cmd/CmdResource.h index 0f2449c24..50cbeddab 100644 --- a/src/eckit/cmd/CmdResource.h +++ b/src/eckit/cmd/CmdResource.h @@ -14,13 +14,12 @@ #include "eckit/cmd/Arg.h" #include "eckit/cmd/CmdArg.h" #include "eckit/eckit.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { -class CmdResource : private eckit::NonCopyable { +class CmdResource { using Proc = void (*)(CmdResource*, CmdArg&, std::istream&, std::ostream&); @@ -30,6 +29,11 @@ class CmdResource : private eckit::NonCopyable { CmdResource(const std::string&); + CmdResource(const CmdResource&) = delete; + CmdResource& operator=(const CmdResource&) = delete; + CmdResource(CmdResource&&) = delete; + CmdResource& operator=(CmdResource&&) = delete; + // -- Destructor virtual ~CmdResource(); diff --git a/src/eckit/cmd/RemoteCommandable.h b/src/eckit/cmd/RemoteCommandable.h index a120741a2..b78f65ab6 100644 --- a/src/eckit/cmd/RemoteCommandable.h +++ b/src/eckit/cmd/RemoteCommandable.h @@ -25,13 +25,18 @@ namespace eckit { /// A RemoteCommand-able object -class RemoteCommandable : private eckit::NonCopyable { +class RemoteCommandable { public: // -- Contructors RemoteCommandable(int port = 0); + RemoteCommandable(const RemoteCommandable&) = delete; + RemoteCommandable& operator=(const RemoteCommandable&) = delete; + RemoteCommandable(RemoteCommandable&&) = delete; + RemoteCommandable& operator=(RemoteCommandable&&) = delete; + // -- Destructor ~RemoteCommandable(); diff --git a/src/eckit/config/EtcTable.h b/src/eckit/config/EtcTable.h index fb07b1ce4..1d42923d9 100644 --- a/src/eckit/config/EtcTable.h +++ b/src/eckit/config/EtcTable.h @@ -17,20 +17,24 @@ #include #include -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" namespace eckit { -class EtcTable : private NonCopyable { +class EtcTable { public: - // -- Contructors + // -- Constructors EtcTable(const std::string&, int = 0, const std::string& = "etc"); + EtcTable(const EtcTable&) = delete; + EtcTable& operator=(const EtcTable&) = delete; + EtcTable(EtcTable&&) = delete; + EtcTable& operator=(EtcTable&&) = delete; + // -- Destructor virtual ~EtcTable(); diff --git a/src/eckit/config/ResourceBase.h b/src/eckit/config/ResourceBase.h index 042159855..bac5ac1b5 100644 --- a/src/eckit/config/ResourceBase.h +++ b/src/eckit/config/ResourceBase.h @@ -17,7 +17,6 @@ #include -#include "eckit/memory/NonCopyable.h" #include "eckit/utils/Tokenizer.h" #include "eckit/utils/Translator.h" @@ -28,12 +27,17 @@ namespace eckit { class Configurable; class Url; -class ResourceBase : private NonCopyable { +class ResourceBase { public: // methods ResourceBase(Configurable* owner, const std::string& str); + ResourceBase(const ResourceBase&) = delete; + ResourceBase& operator=(const ResourceBase&) = delete; + ResourceBase(ResourceBase&&) = delete; + ResourceBase& operator=(ResourceBase&&) = delete; + virtual ~ResourceBase(); void reset() { inited_ = false; } diff --git a/src/eckit/config/ResourceMgr.h b/src/eckit/config/ResourceMgr.h index 88953b2ba..319dd7116 100644 --- a/src/eckit/config/ResourceMgr.h +++ b/src/eckit/config/ResourceMgr.h @@ -18,7 +18,6 @@ #include #include -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" namespace eckit { @@ -50,7 +49,7 @@ class ResourceQualifier { //---------------------------------------------------------------------------------------------------------------------- -class ResourceMgr : private eckit::NonCopyable { +class ResourceMgr { public: // class methods @@ -64,6 +63,11 @@ class ResourceMgr : private eckit::NonCopyable { ResourceMgr(); + ResourceMgr(const ResourceMgr&) = delete; + ResourceMgr& operator=(const ResourceMgr&) = delete; + ResourceMgr(ResourceMgr&&) = delete; + ResourceMgr& operator=(ResourceMgr&&) = delete; + bool doLookUp(const std::string&, const std::string&, const std::string&, std::string&); // Only for my friends diff --git a/src/eckit/config/YAMLConfiguration.h b/src/eckit/config/YAMLConfiguration.h index 3abfa2aa4..33216da16 100644 --- a/src/eckit/config/YAMLConfiguration.h +++ b/src/eckit/config/YAMLConfiguration.h @@ -16,7 +16,6 @@ #include "eckit/config/Configuration.h" #include "eckit/io/SharedBuffer.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -25,7 +24,7 @@ class Stream; //---------------------------------------------------------------------------------------------------------------------- -class YAMLConfiguration : public Configuration, private eckit::NonCopyable { +class YAMLConfiguration : public Configuration { public: @@ -35,6 +34,11 @@ class YAMLConfiguration : public Configuration, private eckit::NonCopyable { YAMLConfiguration(const std::string&, char separator = '.'); YAMLConfiguration(const SharedBuffer&, char separator = '.'); + YAMLConfiguration(const YAMLConfiguration&) = delete; + YAMLConfiguration& operator=(const YAMLConfiguration&) = delete; + YAMLConfiguration(YAMLConfiguration&&) = delete; + YAMLConfiguration& operator=(YAMLConfiguration&&) = delete; + ~YAMLConfiguration() override; private: // members diff --git a/src/eckit/container/BTree.h b/src/eckit/container/BTree.h index 832b5c61a..50141b08b 100644 --- a/src/eckit/container/BTree.h +++ b/src/eckit/container/BTree.h @@ -22,7 +22,6 @@ #include "eckit/exception/Exceptions.h" #include "eckit/filesystem/PathName.h" #include "eckit/io/PooledFileDescriptor.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/memory/Padded.h" #include "eckit/os/Stat.h" #include "eckit/thread/AutoLock.h" @@ -63,7 +62,7 @@ class BTreeNoLock { /// @invariant L implements locking policy /// template -class BTree : private NonCopyable { +class BTree { public: using key_type = K; @@ -74,6 +73,11 @@ class BTree : private NonCopyable { BTree(const PathName&, bool readOnly = false, off_t offset = 0); + BTree(const BTree&) = delete; + BTree& operator=(const BTree&) = delete; + BTree(BTree&&) = delete; + BTree& operator=(BTree&&) = delete; + // -- Destructor ~BTree(); diff --git a/src/eckit/container/BloomFilter.h b/src/eckit/container/BloomFilter.h index e4de286d2..e12d80afd 100644 --- a/src/eckit/container/BloomFilter.h +++ b/src/eckit/container/BloomFilter.h @@ -17,8 +17,6 @@ #ifndef eckit_containers_BloomFilter_H #define eckit_containers_BloomFilter_H -#include "eckit/memory/NonCopyable.h" - #include #include @@ -28,7 +26,7 @@ namespace eckit { //---------------------------------------------------------------------------------------------------------------------- template -class BloomFilter : private NonCopyable { +class BloomFilter { public: // types @@ -37,6 +35,12 @@ class BloomFilter : private NonCopyable { public: // methods BloomFilter(size_t size); + + BloomFilter(const BloomFilter&) = delete; + BloomFilter& operator=(const BloomFilter&) = delete; + BloomFilter(BloomFilter&&) = delete; + BloomFilter& operator=(BloomFilter&&) = delete; + ~BloomFilter(); bool empty() const; diff --git a/src/eckit/container/Cache.h b/src/eckit/container/Cache.h index c4b62c4da..2aa5ea927 100644 --- a/src/eckit/container/Cache.h +++ b/src/eckit/container/Cache.h @@ -23,8 +23,6 @@ #include "eckit/eckit.h" -#include "eckit/memory/NonCopyable.h" - //----------------------------------------------------------------------------- namespace eckit { @@ -36,7 +34,7 @@ namespace eckit { /// @todo implement the expire() and the different policies template -class Cache : private NonCopyable { +class Cache { public: // types @@ -89,6 +87,11 @@ class Cache : private NonCopyable { Cache(); + Cache(const Cache&) = delete; + Cache& operator=(const Cache&) = delete; + Cache(Cache&&) = delete; + Cache& operator=(Cache&&) = delete; + ~Cache(); /// inserts an object in the cache diff --git a/src/eckit/container/CacheLRU.h b/src/eckit/container/CacheLRU.h index f8b250356..cf314684e 100644 --- a/src/eckit/container/CacheLRU.h +++ b/src/eckit/container/CacheLRU.h @@ -20,14 +20,13 @@ #include "eckit/exception/Exceptions.h" #include "eckit/log/CodeLocation.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- template -class CacheLRU : private NonCopyable { +class CacheLRU { public: // types @@ -59,6 +58,11 @@ class CacheLRU : private NonCopyable { CacheLRU(size_t capacity, purge_handler_type purge = 0); + CacheLRU(const CacheLRU&) = delete; + CacheLRU& operator=(const CacheLRU&) = delete; + CacheLRU(CacheLRU&&) = delete; + CacheLRU& operator=(CacheLRU&&) = delete; + ~CacheLRU(); /// Inserts an entry into the cache, overwrites if already exists diff --git a/src/eckit/container/ClassExtent.h b/src/eckit/container/ClassExtent.h index 9ceac6aea..7f8077119 100644 --- a/src/eckit/container/ClassExtent.h +++ b/src/eckit/container/ClassExtent.h @@ -17,23 +17,26 @@ #include #include "eckit/exception/Exceptions.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/AutoLock.h" #include "eckit/thread/Mutex.h" - namespace eckit { //----------------------------------------------------------------------------- template -class ClassExtent : private NonCopyable { +class ClassExtent { public: // -- Contructors ClassExtent(T*); + ClassExtent(const ClassExtent&) = delete; + ClassExtent& operator=(const ClassExtent&) = delete; + ClassExtent(ClassExtent&&) = delete; + ClassExtent& operator=(ClassExtent&&) = delete; + // -- Destructor ~ClassExtent(); diff --git a/src/eckit/container/MappedArray.h b/src/eckit/container/MappedArray.h index f732b742c..c53b26637 100644 --- a/src/eckit/container/MappedArray.h +++ b/src/eckit/container/MappedArray.h @@ -18,7 +18,6 @@ #include "eckit/exception/Exceptions.h" #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/os/Semaphore.h" @@ -29,7 +28,7 @@ namespace eckit { // Used to std::map an array to a file template -class MappedArray : private NonCopyable { +class MappedArray { public: // stl compatibility @@ -41,6 +40,9 @@ class MappedArray : private NonCopyable { MappedArray(const PathName&, unsigned long); + MappedArray(const MappedArray&) = delete; + MappedArray& operator=(const MappedArray&) = delete; + // -- Destructor ~MappedArray(); diff --git a/src/eckit/container/SharedMemArray.h b/src/eckit/container/SharedMemArray.h index 9e18859cb..33303bfa4 100644 --- a/src/eckit/container/SharedMemArray.h +++ b/src/eckit/container/SharedMemArray.h @@ -17,7 +17,6 @@ #include -#include "eckit/memory/NonCopyable.h" #include "eckit/os/Semaphore.h" #include "eckit/memory/Padded.h" @@ -35,7 +34,7 @@ namespace eckit { /// Maps an array to shared memory template -class SharedMemArray : private NonCopyable { +class SharedMemArray { public: // types using iterator = T*; @@ -45,6 +44,11 @@ class SharedMemArray : private NonCopyable { SharedMemArray(const PathName&, const std::string& shmName, size_t); + SharedMemArray(const SharedMemArray&) = delete; + SharedMemArray& operator=(const SharedMemArray&) = delete; + SharedMemArray(SharedMemArray&&) = delete; + SharedMemArray& operator=(SharedMemArray&&) = delete; + ~SharedMemArray(); void sync(); diff --git a/src/eckit/container/Trie.h b/src/eckit/container/Trie.h index 62b24b1ac..f542eeb08 100644 --- a/src/eckit/container/Trie.h +++ b/src/eckit/container/Trie.h @@ -17,8 +17,6 @@ #ifndef eckit_containers_Trie_H #define eckit_containers_Trie_H -#include "eckit/memory/NonCopyable.h" - #include #include @@ -28,11 +26,17 @@ namespace eckit { //---------------------------------------------------------------------------------------------------------------------- template -class Trie : private NonCopyable { +class Trie { public: // methods Trie(); + + Trie(const Trie&) = delete; + Trie& operator=(const Trie&) = delete; + Trie(Trie&&) = delete; + Trie& operator=(Trie&&) = delete; + ~Trie(); bool empty() const { return kids_.empty() && !set_; } diff --git a/src/eckit/distributed/Actor.h b/src/eckit/distributed/Actor.h index d3cabd4aa..e9b49f0ef 100644 --- a/src/eckit/distributed/Actor.h +++ b/src/eckit/distributed/Actor.h @@ -17,8 +17,6 @@ #include -#include "eckit/memory/NonCopyable.h" - namespace eckit::distributed { @@ -27,7 +25,7 @@ class Message; //---------------------------------------------------------------------------------------------------------------------- -class Actor : private eckit::NonCopyable { +class Actor { public: enum MessageTags { @@ -44,6 +42,12 @@ class Actor : private eckit::NonCopyable { public: // methods Actor(Transport& transport); + + Actor(const Actor&) = delete; + Actor& operator=(const Actor&) = delete; + Actor(Actor&&) = delete; + Actor& operator=(Actor&&) = delete; + virtual ~Actor(); virtual void run() = 0; diff --git a/src/eckit/distributed/Transport.h b/src/eckit/distributed/Transport.h index d1c50e6e5..d0b46c80a 100644 --- a/src/eckit/distributed/Transport.h +++ b/src/eckit/distributed/Transport.h @@ -19,7 +19,6 @@ #include #include "eckit/distributed/TransportStatistics.h" -#include "eckit/memory/NonCopyable.h" namespace eckit::option { @@ -34,10 +33,16 @@ class Message; //---------------------------------------------------------------------------------------------------------------------- -class Transport : private eckit::NonCopyable { +class Transport { public: // methods Transport(const eckit::option::CmdArgs& args); + + Transport(const Transport&) = delete; + Transport& operator=(const Transport&) = delete; + Transport(Transport&&) = delete; + Transport& operator=(Transport&&) = delete; + virtual ~Transport(); virtual void sendMessageToNextWorker(const Message& message) = 0; diff --git a/src/eckit/filesystem/BasePathName.h b/src/eckit/filesystem/BasePathName.h index b08cb6cd4..9f0f83d9b 100644 --- a/src/eckit/filesystem/BasePathName.h +++ b/src/eckit/filesystem/BasePathName.h @@ -20,16 +20,20 @@ #include "eckit/io/DataHandle.h" #include "eckit/io/Length.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { -class BasePathName : protected NonCopyable { +class BasePathName { public: BasePathName() {} + BasePathName(const BasePathName&) = delete; + BasePathName& operator=(const BasePathName&) = delete; + BasePathName(BasePathName&&) = delete; + BasePathName& operator=(BasePathName&&) = delete; + virtual ~BasePathName(); virtual BasePathName* clone() const = 0; diff --git a/src/eckit/filesystem/FileSpace.h b/src/eckit/filesystem/FileSpace.h index 3acf1ecc9..6bc7739e4 100644 --- a/src/eckit/filesystem/FileSpace.h +++ b/src/eckit/filesystem/FileSpace.h @@ -17,13 +17,12 @@ #define eckit_FileSpace_h #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class FileSpace : private NonCopyable { +class FileSpace { public: // methods @@ -46,6 +45,11 @@ class FileSpace : private NonCopyable { FileSpace(const std::string&); + FileSpace(const FileSpace&) = delete; + FileSpace& operator=(const FileSpace&) = delete; + FileSpace(FileSpace&&) = delete; + FileSpace& operator=(FileSpace&&) = delete; + ~FileSpace(); void load() const; diff --git a/src/eckit/filesystem/FileSpaceStrategies.h b/src/eckit/filesystem/FileSpaceStrategies.h index 528d5814c..a3c6d216b 100644 --- a/src/eckit/filesystem/FileSpaceStrategies.h +++ b/src/eckit/filesystem/FileSpaceStrategies.h @@ -17,15 +17,16 @@ #define eckit_FileSpaceStrategies_h #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class FileSpaceStrategies : private NonCopyable { +class FileSpaceStrategies { public: + FileSpaceStrategies() = delete; + static const PathName& selectFileSystem(const std::vector& fileSystems, const std::string& s); static const PathName& leastUsed(const std::vector& fileSystems); diff --git a/src/eckit/filesystem/PathExpander.h b/src/eckit/filesystem/PathExpander.h index f12f956e3..dcf709246 100644 --- a/src/eckit/filesystem/PathExpander.h +++ b/src/eckit/filesystem/PathExpander.h @@ -15,17 +15,15 @@ #define eckit_PathExpander_h #include -#include #include -#include "eckit/memory/NonCopyable.h" #include "eckit/types/Types.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class PathExpander : private eckit::NonCopyable { +class PathExpander { public: // methods static std::string expand(const std::string& path); @@ -36,6 +34,11 @@ class PathExpander : private eckit::NonCopyable { PathExpander(const std::string&); + PathExpander(const PathExpander&) = delete; + PathExpander& operator=(const PathExpander&) = delete; + PathExpander(PathExpander&&) = delete; + PathExpander& operator=(PathExpander&&) = delete; + virtual ~PathExpander(); virtual void print(std::ostream&) const; diff --git a/src/eckit/filesystem/PathNameFactory.cc b/src/eckit/filesystem/PathNameFactory.cc index c60cb1051..36d040da1 100644 --- a/src/eckit/filesystem/PathNameFactory.cc +++ b/src/eckit/filesystem/PathNameFactory.cc @@ -22,11 +22,20 @@ static PathNameBuilder localBuilder("local"); //---------------------------------------------------------------------------------------------------------------------- -class PathNameFactoryImpl : private eckit::NonCopyable { +class PathNameFactoryImpl { public: // methods static PathNameFactoryImpl& instance(); + PathNameFactoryImpl() = default; + + PathNameFactoryImpl(const PathNameFactoryImpl&) = delete; + PathNameFactoryImpl& operator=(const PathNameFactoryImpl&) = delete; + PathNameFactoryImpl(PathNameFactoryImpl&&) = delete; + PathNameFactoryImpl& operator=(PathNameFactoryImpl&&) = delete; + + ~PathNameFactoryImpl() = default; + void enregister(const std::string& name, const PathNameBuilderBase* builder); void deregister(const PathNameBuilderBase* builder); diff --git a/src/eckit/filesystem/PathNameFactory.h b/src/eckit/filesystem/PathNameFactory.h index afb5a3ffa..68aad0d28 100644 --- a/src/eckit/filesystem/PathNameFactory.h +++ b/src/eckit/filesystem/PathNameFactory.h @@ -15,7 +15,6 @@ #define eckit_filesystem_PathNameFactory_h #include "eckit/filesystem/BasePathNameT.h" -#include "eckit/memory/NonCopyable.h" #include #include diff --git a/src/eckit/filesystem/StdDir.h b/src/eckit/filesystem/StdDir.h index 3ec4e7b1c..48607728b 100644 --- a/src/eckit/filesystem/StdDir.h +++ b/src/eckit/filesystem/StdDir.h @@ -16,15 +16,13 @@ #include #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { class LocalPathName; //---------------------------------------------------------------------------------------------------------------------- -class StdDir : private NonCopyable { +class StdDir { private: // members @@ -36,6 +34,11 @@ class StdDir : private NonCopyable { StdDir(const char* d); StdDir(const eckit::LocalPathName& p); + StdDir(const StdDir&) = delete; + StdDir& operator=(const StdDir&) = delete; + StdDir(StdDir&&) = delete; + StdDir& operator=(StdDir&&) = delete; + ~StdDir(); /* noexcept(false) */ operator DIR*() { return d_; } diff --git a/src/eckit/filesystem/TmpDir.h b/src/eckit/filesystem/TmpDir.h index 3166c2327..c4b46b46c 100644 --- a/src/eckit/filesystem/TmpDir.h +++ b/src/eckit/filesystem/TmpDir.h @@ -15,19 +15,22 @@ #define eckit_TmpDir_h #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class TmpDir : public PathName, private NonCopyable { +class TmpDir : public PathName { public: TmpDir(const char* base = nullptr); + TmpDir(const TmpDir&) = delete; + TmpDir& operator=(const TmpDir&) = delete; + TmpDir(TmpDir&& rhs); + TmpDir& operator=(TmpDir&& rhs) = delete; ~TmpDir() noexcept(false); }; diff --git a/src/eckit/filesystem/TmpFile.h b/src/eckit/filesystem/TmpFile.h index 10abdd911..c658be7ea 100644 --- a/src/eckit/filesystem/TmpFile.h +++ b/src/eckit/filesystem/TmpFile.h @@ -16,18 +16,22 @@ #define eckit_TmpFile_h #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class TmpFile : public PathName, private NonCopyable { +class TmpFile : public PathName { public: TmpFile(bool verbose = true); + TmpFile(const TmpFile&) = delete; + TmpFile& operator=(const TmpFile&) = delete; + TmpFile(TmpFile&& rhs) = delete; + TmpFile& operator=(TmpFile&& rhs) = delete; + ~TmpFile(); private: diff --git a/src/eckit/io/AIOHandle.cc b/src/eckit/io/AIOHandle.cc index 564e4f473..32d200d76 100644 --- a/src/eckit/io/AIOHandle.cc +++ b/src/eckit/io/AIOHandle.cc @@ -34,11 +34,17 @@ namespace eckit { #if eckit_HAVE_AIO -struct AIOBuffer : private eckit::NonCopyable { +struct AIOBuffer { public: // methods explicit AIOBuffer() { eckit::zero(aio_); } + + AIOBuffer(const AIOBuffer&) = delete; + AIOBuffer& operator=(const AIOBuffer&) = delete; + AIOBuffer(AIOBuffer&&) = delete; + AIOBuffer& operator=(AIOBuffer&&) = delete; + ~AIOBuffer() { delete buff_; } void resize(size_t sz) { @@ -249,7 +255,12 @@ void AIOHandle::flush() { #else // NO eckit_HAVE_AIO -struct AIOBuffer : private eckit::NonCopyable {}; +struct AIOBuffer { + AIOBuffer() = default; + AIOBuffer(const AIOBuffer&) = delete; + AIOBuffer& operator=(const AIOBuffer&) = delete; + ~AIOBuffer() = default; +}; AIOHandle::AIOHandle(const PathName& path, size_t count, size_t size, bool fsync) { NOTIMP; diff --git a/src/eckit/io/Buffer.h b/src/eckit/io/Buffer.h index 7bce54e63..708a0a6e5 100644 --- a/src/eckit/io/Buffer.h +++ b/src/eckit/io/Buffer.h @@ -18,13 +18,11 @@ #include #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { /// Simple class to implement memory buffers -class Buffer : private NonCopyable { +class Buffer { public: // methods /// Creates a buffer with 'size' many bytes. @@ -42,6 +40,12 @@ class Buffer : private NonCopyable { /// @param size of data Buffer(const void* src, size_t size); + /// Copy constructor (deleted). + Buffer(const Buffer&) = delete; + + /// Copy assignment (deleted). + Buffer& operator=(const Buffer&) = delete; + /// Move constructor. Note that rhs is not guaranteed to be valid! Buffer(Buffer&& rhs) noexcept; diff --git a/src/eckit/io/BufferList.h b/src/eckit/io/BufferList.h index 958033cc1..f12839bce 100644 --- a/src/eckit/io/BufferList.h +++ b/src/eckit/io/BufferList.h @@ -18,7 +18,6 @@ #include "eckit/io/Buffer.h" #include "eckit/io/Length.h" -#include "eckit/memory/OnlyMovable.h" namespace eckit { @@ -26,10 +25,19 @@ namespace eckit { /// A class to aggregate buffers into a single object that can be read as a whole -class BufferList : public OnlyMovable { +class BufferList { public: // methods + BufferList() = default; + + BufferList(const BufferList&) = delete; + BufferList& operator=(const BufferList&) = delete; + BufferList(BufferList&&) = default; + BufferList& operator=(BufferList&&) = default; + + ~BufferList() = default; + void append(Buffer&& buf); size_t count() const { return buffers_.size(); } diff --git a/src/eckit/io/CircularBuffer.h b/src/eckit/io/CircularBuffer.h index 5d36b2c01..211351b6a 100644 --- a/src/eckit/io/CircularBuffer.h +++ b/src/eckit/io/CircularBuffer.h @@ -18,8 +18,6 @@ #include #include "eckit/eckit.h" - -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" namespace eckit { @@ -27,12 +25,17 @@ namespace eckit { // A simple class to implement buffers -class CircularBuffer : public eckit::NonCopyable { +class CircularBuffer { public: // methods CircularBuffer(size_t size = 64 * 1024, size_t capactity = std::numeric_limits::max()); + CircularBuffer(const CircularBuffer&) = delete; + CircularBuffer& operator=(const CircularBuffer&) = delete; + CircularBuffer(CircularBuffer&&) = delete; + CircularBuffer& operator=(CircularBuffer&&) = delete; + ~CircularBuffer(); size_t write(const void* buffer, size_t length); diff --git a/src/eckit/io/DblBuffer.h b/src/eckit/io/DblBuffer.h index 8288535db..7a41fdd75 100644 --- a/src/eckit/io/DblBuffer.h +++ b/src/eckit/io/DblBuffer.h @@ -18,20 +18,24 @@ #include "eckit/io/DataHandle.h" #include "eckit/io/Length.h" #include "eckit/io/TransferWatcher.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" namespace eckit { -class DblBuffer : private NonCopyable { +class DblBuffer { public: // -- Contructors DblBuffer(long count = 5, long size = 1024 * 1024, TransferWatcher& = TransferWatcher::dummy()); + DblBuffer(const DblBuffer&) = delete; + DblBuffer& operator=(const DblBuffer&) = delete; + DblBuffer(DblBuffer&&) = delete; + DblBuffer& operator=(DblBuffer&&) = delete; + // -- Destructor ~DblBuffer(); diff --git a/src/eckit/io/FileLock.h b/src/eckit/io/FileLock.h index 1dd071bc4..fdefff8ab 100644 --- a/src/eckit/io/FileLock.h +++ b/src/eckit/io/FileLock.h @@ -17,7 +17,6 @@ #define eckit_io_FileLock_h #include "eckit/io/FileLocker.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -25,7 +24,7 @@ class PathName; //---------------------------------------------------------------------------------------------------------------------- -class FileLock : public NonCopyable { +class FileLock { public: @@ -33,6 +32,11 @@ class FileLock : public NonCopyable { /// creates the lock file if needed FileLock(const PathName& lockFile); + FileLock(const FileLock&) = delete; + FileLock& operator=(const FileLock&) = delete; + FileLock(FileLock&&) = delete; + FileLock& operator=(FileLock&&) = delete; + ~FileLock(); void lock(); diff --git a/src/eckit/io/FilePool.h b/src/eckit/io/FilePool.h index bcb33128d..002abf4cd 100644 --- a/src/eckit/io/FilePool.h +++ b/src/eckit/io/FilePool.h @@ -16,7 +16,6 @@ #define eckit_io_FilePool_h #include "eckit/container/CacheLRU.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/MutexCond.h" namespace eckit { @@ -37,12 +36,17 @@ namespace eckit { /// /// @note this class is thread-safe /// -class FilePool : private eckit::NonCopyable { +class FilePool { public: FilePool(size_t capacity); + FilePool(const FilePool&) = delete; + FilePool& operator=(const FilePool&) = delete; + FilePool(FilePool&&) = delete; + FilePool& operator=(FilePool&&) = delete; + ~FilePool(); /// Checkout a DataHandle for use diff --git a/src/eckit/io/Pipeline.h b/src/eckit/io/Pipeline.h index 191dc8f38..a393432bb 100644 --- a/src/eckit/io/Pipeline.h +++ b/src/eckit/io/Pipeline.h @@ -17,7 +17,6 @@ #include "eckit/io/DataHandle.h" #include "eckit/io/Length.h" #include "eckit/io/TransferWatcher.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" //----------------------------------------------------------------------------- @@ -26,13 +25,18 @@ namespace eckit { //----------------------------------------------------------------------------- -class Pipeline : private NonCopyable { +class Pipeline { public: // -- Contructors Pipeline(TransferWatcher& = TransferWatcher::dummy()); + Pipeline(const Pipeline&) = delete; + Pipeline& operator=(const Pipeline&) = delete; + Pipeline(Pipeline&&) = delete; + Pipeline& operator=(Pipeline&&) = delete; + // -- Destructor virtual ~Pipeline(); diff --git a/src/eckit/io/PooledFile.h b/src/eckit/io/PooledFile.h index 239f26de2..46cd691a7 100644 --- a/src/eckit/io/PooledFile.h +++ b/src/eckit/io/PooledFile.h @@ -17,18 +17,22 @@ #include "eckit/exception/Exceptions.h" #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { class PoolFileEntry; -class PooledFile : private NonCopyable { +class PooledFile { public: PooledFile(const PathName& name); + PooledFile(const PooledFile&) = delete; + PooledFile& operator=(const PooledFile&) = delete; + PooledFile(PooledFile&&) = delete; + PooledFile& operator=(PooledFile&&) = delete; + /// @pre must have been closed ~PooledFile(); diff --git a/src/eckit/io/Select.h b/src/eckit/io/Select.h index 0d8e2d039..ba6d7cbc8 100644 --- a/src/eckit/io/Select.h +++ b/src/eckit/io/Select.h @@ -17,8 +17,6 @@ #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { @@ -29,7 +27,7 @@ class TCPSocket; }; /// Wraps calls to select -class Select : private NonCopyable { +class Select { public: @@ -39,6 +37,11 @@ class Select : private NonCopyable { explicit Select(int); explicit Select(net::TCPSocket&); + Select(const Select&) = delete; + Select& operator=(const Select&) = delete; + Select(Select&&) = delete; + Select& operator=(Select&&) = delete; + // -- Destructor ~Select(); diff --git a/src/eckit/io/StdFile.h b/src/eckit/io/StdFile.h index 526d3980f..6ec179cae 100644 --- a/src/eckit/io/StdFile.h +++ b/src/eckit/io/StdFile.h @@ -18,7 +18,6 @@ #include #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -28,11 +27,16 @@ class PathName; /// Wrapper around a stdio FILE* /// Use this for class members -class StdFile : private NonCopyable { +class StdFile { public: StdFile(const PathName& name, const std::string& mode = "r"); + StdFile(const StdFile&) = delete; + StdFile& operator=(const StdFile&) = delete; + StdFile(StdFile&&) = delete; + StdFile& operator=(StdFile&&) = delete; + /// @pre must have been closed ~StdFile(); diff --git a/src/eckit/io/StdPipe.h b/src/eckit/io/StdPipe.h index f46184427..13f2d406b 100644 --- a/src/eckit/io/StdPipe.h +++ b/src/eckit/io/StdPipe.h @@ -19,17 +19,21 @@ #include #include "eckit/io/AutoCloser.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { /// Simple wrapper for pipes -class StdPipe : private NonCopyable { +class StdPipe { public: StdPipe(const std::string& name, const std::string& mode = "r"); + StdPipe(const StdPipe&) = delete; + StdPipe& operator=(const StdPipe&) = delete; + StdPipe(StdPipe&&) = delete; + StdPipe& operator=(StdPipe&&) = delete; + /// @pre must have been closed ~StdPipe(); diff --git a/src/eckit/io/cluster/ClusterDisks.cc b/src/eckit/io/cluster/ClusterDisks.cc index d9304e327..db0e5ba8b 100644 --- a/src/eckit/io/cluster/ClusterDisks.cc +++ b/src/eckit/io/cluster/ClusterDisks.cc @@ -138,13 +138,20 @@ inline unsigned long version(ClusterDisk*) { //---------------------------------------------------------------------------------------------------------------------- -class DiskArray : private eckit::NonCopyable { +class DiskArray { public: using iterator = ClusterDisk*; using const_iterator = const ClusterDisk*; + DiskArray() = default; + + DiskArray(const DiskArray&) = delete; + DiskArray& operator=(const DiskArray&) = delete; + DiskArray(DiskArray&&) = delete; + DiskArray& operator=(DiskArray&&) = delete; + virtual ~DiskArray() {} virtual void sync() = 0; diff --git a/src/eckit/io/cluster/ClusterNode.h b/src/eckit/io/cluster/ClusterNode.h index 3906ce7b3..0b3dfdab8 100644 --- a/src/eckit/io/cluster/ClusterNode.h +++ b/src/eckit/io/cluster/ClusterNode.h @@ -14,8 +14,6 @@ #ifndef eckit_ClusterNode_h #define eckit_ClusterNode_h -#include "eckit/memory/NonCopyable.h" - #include #include @@ -26,11 +24,16 @@ namespace eckit { class Stream; class NodeInfo; -class ClusterNode : private eckit::NonCopyable { +class ClusterNode { public: ClusterNode(); + ClusterNode(const ClusterNode&) = delete; + ClusterNode& operator=(const ClusterNode&) = delete; + ClusterNode(ClusterNode&&) = delete; + ClusterNode& operator=(ClusterNode&&) = delete; + virtual ~ClusterNode(); void heartbeat(); diff --git a/src/eckit/log/BigNum.h b/src/eckit/log/BigNum.h index d83894754..6caf96f9a 100644 --- a/src/eckit/log/BigNum.h +++ b/src/eckit/log/BigNum.h @@ -17,19 +17,22 @@ #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { /// Class used to print large numbers -class BigNum : private eckit::NonCopyable { +class BigNum { public: BigNum(long long v) : value_(v) {} + BigNum(const BigNum&) = delete; + BigNum& operator=(const BigNum&) = delete; + BigNum(BigNum&&) = delete; + BigNum& operator=(BigNum&&) = delete; + private: void print(std::ostream&) const; diff --git a/src/eckit/log/Channel.h b/src/eckit/log/Channel.h index ee34ff4ba..565080148 100644 --- a/src/eckit/log/Channel.h +++ b/src/eckit/log/Channel.h @@ -16,8 +16,6 @@ #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { class ChannelBuffer; @@ -29,12 +27,17 @@ using channel_callback_t = void (*)(void* data, const char* msg); /// Output channel that is an std::ostream but more functional -class Channel : public std::ostream, private NonCopyable { +class Channel : public std::ostream { public: // methods Channel(LogTarget* = nullptr); + Channel(const Channel&) = delete; + Channel& operator=(const Channel&) = delete; + Channel(Channel&&) = delete; + Channel& operator=(Channel&&) = delete; + ~Channel() override; bool operator!() const; diff --git a/src/eckit/log/ChannelBuffer.h b/src/eckit/log/ChannelBuffer.h index 73594a61a..cd85c24b2 100644 --- a/src/eckit/log/ChannelBuffer.h +++ b/src/eckit/log/ChannelBuffer.h @@ -20,7 +20,6 @@ #include #include "eckit/log/Channel.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -29,13 +28,18 @@ namespace eckit { class LogTarget; /// Stream buffer to be usedby Channel -class ChannelBuffer : public std::streambuf, private NonCopyable { +class ChannelBuffer : public std::streambuf { private: // methods /// constructor, taking ownership of stream ChannelBuffer(std::size_t size = 1024); + ChannelBuffer(const ChannelBuffer&) = delete; + ChannelBuffer& operator=(const ChannelBuffer&) = delete; + ChannelBuffer(ChannelBuffer&&) = delete; + ChannelBuffer& operator=(ChannelBuffer&&) = delete; + ~ChannelBuffer() override; bool active() const; diff --git a/src/eckit/log/JSON.h b/src/eckit/log/JSON.h index 18a004cc2..1f5df0b52 100644 --- a/src/eckit/log/JSON.h +++ b/src/eckit/log/JSON.h @@ -24,7 +24,6 @@ #include #include "eckit/eckit.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -34,7 +33,7 @@ class DateTime; //---------------------------------------------------------------------------------------------------------------------- -class JSON : private NonCopyable { +class JSON { public: @@ -83,6 +82,11 @@ class JSON : private NonCopyable { JSON(std::ostream&, bool null = true); JSON(std::ostream&, Formatting); + JSON(const JSON&) = delete; + JSON& operator=(const JSON&) = delete; + JSON(JSON&&) = delete; + JSON& operator=(JSON&&) = delete; + ~JSON(); JSON& operator<<(bool); diff --git a/src/eckit/log/Plural.h b/src/eckit/log/Plural.h index 64553a5fb..fd167b458 100644 --- a/src/eckit/log/Plural.h +++ b/src/eckit/log/Plural.h @@ -15,17 +15,20 @@ #include "eckit/log/BigNum.h" -#include "eckit/memory/NonCopyable.h" - namespace eckit { -class Plural : private eckit::NonCopyable { +class Plural { public: // methods Plural(int count, const std::string& s) : s_(s), count_(count) {} + Plural(const Plural&) = delete; + Plural& operator=(const Plural&) = delete; + Plural(Plural&&) = delete; + Plural& operator=(Plural&&) = delete; + ~Plural() {} protected: // methods diff --git a/src/eckit/log/ResourceUsage.h b/src/eckit/log/ResourceUsage.h index 8e218add9..2b88b40dd 100644 --- a/src/eckit/log/ResourceUsage.h +++ b/src/eckit/log/ResourceUsage.h @@ -19,7 +19,6 @@ #include "eckit/exception/Exceptions.h" #include "eckit/log/Log.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/system/MemoryInfo.h" @@ -27,7 +26,7 @@ namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class ResourceUsage : private NonCopyable { +class ResourceUsage { public: explicit ResourceUsage(); @@ -40,6 +39,11 @@ class ResourceUsage : private NonCopyable { /// @param o output stream to use for output explicit ResourceUsage(const char* name, std::ostream& o = Log::info()); + ResourceUsage(const ResourceUsage&) = delete; + ResourceUsage& operator=(const ResourceUsage&) = delete; + ResourceUsage(ResourceUsage&&) = delete; + ResourceUsage& operator=(ResourceUsage&&) = delete; + ~ResourceUsage(); protected: // methods diff --git a/src/eckit/log/Timer.h b/src/eckit/log/Timer.h index 6b845dc66..853e256b1 100644 --- a/src/eckit/log/Timer.h +++ b/src/eckit/log/Timer.h @@ -18,13 +18,12 @@ #include #include "eckit/log/Log.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { //----------------------------------------------------------------------------- -class Timer : private NonCopyable { +class Timer { public: explicit Timer(); @@ -37,6 +36,11 @@ class Timer : private NonCopyable { /// @param o output stream to use for output explicit Timer(const char* name, std::ostream& o = Log::info()); + Timer(const Timer&) = delete; + Timer& operator=(const Timer&) = delete; + Timer(Timer&&) = delete; + Timer& operator=(Timer&&) = delete; + ~Timer(); void start(); diff --git a/src/eckit/log/UserChannel.h b/src/eckit/log/UserChannel.h index 9ed3e8ba8..de86949ae 100644 --- a/src/eckit/log/UserChannel.h +++ b/src/eckit/log/UserChannel.h @@ -14,12 +14,6 @@ #ifndef eckit_log_UserChannel_h #define eckit_log_UserChannel_h - -#include - -#include "eckit/memory/NonCopyable.h" - - namespace eckit { //----------------------------------------------------------------------------- @@ -38,7 +32,7 @@ class UserMsg { class UserBuffer; -class UserChannel : public std::ostream, private NonCopyable { +class UserChannel : public std::ostream { public: // types enum MsgType { @@ -53,6 +47,11 @@ class UserChannel : public std::ostream, private NonCopyable { /// Constructor UserChannel(); + UserChannel(const UserChannel&) = delete; + UserChannel& operator=(const UserChannel&) = delete; + UserChannel(UserChannel&&) = delete; + UserChannel& operator=(UserChannel&&) = delete; + /// Destructor ~UserChannel(); diff --git a/src/eckit/maths/MatrixLapack.h b/src/eckit/maths/MatrixLapack.h index bd91d020b..f4a678729 100644 --- a/src/eckit/maths/MatrixLapack.h +++ b/src/eckit/maths/MatrixLapack.h @@ -70,7 +70,7 @@ inline Scalar det(Scalar m[16]); } // namespace detail template -class Matrix : private eckit::NonCopyable { +class Matrix { protected: diff --git a/src/eckit/memory/Counted.h b/src/eckit/memory/Counted.h index d0e4a7662..5b4c7b9b8 100644 --- a/src/eckit/memory/Counted.h +++ b/src/eckit/memory/Counted.h @@ -16,7 +16,6 @@ #ifndef eckit_Counted_h #define eckit_Counted_h -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" @@ -50,7 +49,7 @@ class NoLock { /// Subclass from this class if you want reference counting object. /// @note Remember to use 'virtual' inheritance in case of multiple inheritance -class Counted : private NonCopyable, private memory::detail::ThreadedLock { +class Counted : private memory::detail::ThreadedLock { public: // methods void attach() const { @@ -80,6 +79,11 @@ class Counted : private NonCopyable, private memory::detail::ThreadedLock { Counted() : count_(0) {} + Counted(const Counted&) = delete; + Counted& operator=(const Counted&) = delete; + Counted(Counted&&) = delete; + Counted& operator=(Counted&&) = delete; + virtual ~Counted(); private: // members diff --git a/src/eckit/memory/MapAllocator.h b/src/eckit/memory/MapAllocator.h index 6d20c2974..90bf55d2f 100644 --- a/src/eckit/memory/MapAllocator.h +++ b/src/eckit/memory/MapAllocator.h @@ -15,7 +15,6 @@ #define eckit_MapAllocator_h #include "eckit/exception/Exceptions.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/types/Types.h" @@ -31,11 +30,16 @@ class MapAllocatorTooSmall : public Exception { //---------------------------------------------------------------------------------------------------------------------- -class MapAllocator : private eckit::NonCopyable { +class MapAllocator { public: MapAllocator(size_t); + MapAllocator(const MapAllocator&) = delete; + MapAllocator& operator=(const MapAllocator&) = delete; + MapAllocator(MapAllocator&&) = delete; + MapAllocator& operator=(MapAllocator&&) = delete; + ~MapAllocator(); void* allocate(size_t); diff --git a/src/eckit/memory/MemoryBuffer.h b/src/eckit/memory/MemoryBuffer.h index d5a8383d2..f068a8f7a 100644 --- a/src/eckit/memory/MemoryBuffer.h +++ b/src/eckit/memory/MemoryBuffer.h @@ -19,15 +19,13 @@ #include "eckit/eckit.h" -#include "eckit/memory/NonCopyable.h" - namespace eckit { //---------------------------------------------------------------------------------------------------------------------- // A simple class to implement buffers -class MemoryBuffer : private NonCopyable { +class MemoryBuffer { public: // methods @@ -35,6 +33,11 @@ class MemoryBuffer : private NonCopyable { MemoryBuffer(const std::string& s); MemoryBuffer(const char*, size_t size); + MemoryBuffer(const MemoryBuffer&) = delete; + MemoryBuffer& operator=(const MemoryBuffer&) = delete; + MemoryBuffer(MemoryBuffer&&) = delete; + MemoryBuffer& operator=(MemoryBuffer&&) = delete; + ~MemoryBuffer(); operator char*() { return static_cast(buffer_); } diff --git a/src/eckit/memory/OnlyMovable.h b/src/eckit/memory/OnlyMovable.h index 823ab07ff..b337eb952 100644 --- a/src/eckit/memory/OnlyMovable.h +++ b/src/eckit/memory/OnlyMovable.h @@ -14,7 +14,7 @@ namespace eckit { -/// Inherit from this class to make a NonCopyable class +/// Inherit from this class to make a OnlyMovable class class OnlyMovable { protected: diff --git a/src/eckit/memory/Owned.h b/src/eckit/memory/Owned.h index 3b6929cc5..2dfe4d5a4 100644 --- a/src/eckit/memory/Owned.h +++ b/src/eckit/memory/Owned.h @@ -26,12 +26,17 @@ namespace eckit { /// Subclass from this class to use a SharedPtr class template -class OwnedT : private NonCopyable, public LOCK { +class OwnedT : public LOCK { public: // methods OwnedT() : count_(0) {} + OwnedT(const OwnedT&) = delete; + OwnedT& operator=(const OwnedT&) = delete; + OwnedT(OwnedT&&) = delete; + OwnedT& operator=(OwnedT&&) = delete; + virtual ~OwnedT() {} void attach() const { diff --git a/src/eckit/memory/ScopedPtr.h b/src/eckit/memory/ScopedPtr.h index db72ad3ab..ca2d6ba41 100644 --- a/src/eckit/memory/ScopedPtr.h +++ b/src/eckit/memory/ScopedPtr.h @@ -14,7 +14,6 @@ #include "eckit/deprecated.h" #include "eckit/exception/Exceptions.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -26,7 +25,7 @@ namespace eckit { /// However due to lack of C++11 support, it does not support move semantics. template -class DEPRECATED("Use C++11 std::unique_ptr instead") ScopedPtr : private NonCopyable { +class DEPRECATED("Use C++11 std::unique_ptr instead") ScopedPtr { public: // types @@ -40,6 +39,11 @@ class DEPRECATED("Use C++11 std::unique_ptr instead") ScopedPtr : private NonCop /// @throws nothing explicit ScopedPtr(pointer_type ptr = nullptr) : ptr_(ptr) {} + ScopedPtr(const ScopedPtr&) = delete; + ScopedPtr& operator=(const ScopedPtr&) = delete; + ScopedPtr(ScopedPtr&&) = delete; + ScopedPtr& operator=(ScopedPtr&&) = delete; + /// Destructor /// @throws nothing ~ScopedPtr() { destroy(); } diff --git a/src/eckit/message/Reader.h b/src/eckit/message/Reader.h index c4fce4abc..50a2de082 100644 --- a/src/eckit/message/Reader.h +++ b/src/eckit/message/Reader.h @@ -19,7 +19,6 @@ #include #include "eckit/io/PeekHandle.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/message/Message.h" @@ -34,7 +33,7 @@ namespace eckit::message { class Message; class Splitter; -class Reader : public eckit::NonCopyable { +class Reader { public: Reader(eckit::DataHandle*, bool opened = false); @@ -42,6 +41,11 @@ class Reader : public eckit::NonCopyable { Reader(const eckit::PathName&); + Reader(const Reader&) = delete; + Reader& operator=(const Reader&) = delete; + Reader(Reader&&) = delete; + Reader& operator=(Reader&&) = delete; + ~Reader(); Message next(); diff --git a/src/eckit/mpi/Comm.h b/src/eckit/mpi/Comm.h index 27f8f7081..33f5dd4cb 100644 --- a/src/eckit/mpi/Comm.h +++ b/src/eckit/mpi/Comm.h @@ -20,7 +20,6 @@ #include "eckit/filesystem/PathName.h" #include "eckit/io/SharedBuffer.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/mpi/Buffer.h" #include "eckit/mpi/DataType.h" @@ -82,13 +81,20 @@ struct is_std_vector > : std::true_type {}; //---------------------------------------------------------------------------------------------------------------------- -class Comm : private eckit::NonCopyable { +class Comm { friend class Environment; public: // class methods static Comm& comm(std::string_view name = {}); + Comm() = default; + + Comm(const Comm&) = delete; + Comm& operator=(const Comm&) = delete; + Comm(Comm&&) = delete; + Comm& operator=(Comm&&) = delete; + public: // methods std::string name() const { return name_; } diff --git a/src/eckit/mpi/Serial.cc b/src/eckit/mpi/Serial.cc index 7a4d807db..39f4cb556 100644 --- a/src/eckit/mpi/Serial.cc +++ b/src/eckit/mpi/Serial.cc @@ -34,7 +34,7 @@ namespace eckit::mpi { //---------------------------------------------------------------------------------------------------------------------- -class SerialRequestPool : private NonCopyable { +class SerialRequestPool { public: static SerialRequestPool& instance() { @@ -42,6 +42,11 @@ class SerialRequestPool : private NonCopyable { return request_pool; } + SerialRequestPool(const SerialRequestPool&) = delete; + SerialRequestPool& operator=(const SerialRequestPool&) = delete; + SerialRequestPool(SerialRequestPool&&) = delete; + SerialRequestPool& operator=(SerialRequestPool&&) = delete; + Request createSendRequest(const void* buffer, size_t count, Data::Code type, int tag) { Request r = registerRequest(new SendRequest(buffer, count, type, tag)); send_[tag].push_back(r); diff --git a/src/eckit/net/HttpHeader.h b/src/eckit/net/HttpHeader.h index 548096deb..8e2b3633b 100644 --- a/src/eckit/net/HttpHeader.h +++ b/src/eckit/net/HttpHeader.h @@ -18,7 +18,6 @@ #include "eckit/exception/Exceptions.h" #include "eckit/io/MemoryHandle.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -55,13 +54,18 @@ class HttpError : public Exception { }; -class HttpHeader : private eckit::NonCopyable { +class HttpHeader { public: // methods HttpHeader(); HttpHeader(net::TCPSocket&); + HttpHeader(const HttpHeader&) = delete; + HttpHeader& operator=(const HttpHeader&) = delete; + HttpHeader(HttpHeader&&) = delete; + HttpHeader& operator=(HttpHeader&&) = delete; + ~HttpHeader(); HttpHeader& operator=(std::map >&); diff --git a/src/eckit/net/TCPClient.h b/src/eckit/net/TCPClient.h index fb20acada..06bebad7b 100644 --- a/src/eckit/net/TCPClient.h +++ b/src/eckit/net/TCPClient.h @@ -21,12 +21,17 @@ namespace eckit::net { class Endpoint; -class TCPClient : public TCPSocket, private eckit::NonCopyable { +class TCPClient : public TCPSocket { public: TCPClient(const SocketOptions& options = SocketOptions::none()); TCPClient(int port, const SocketOptions& options = SocketOptions::none()); + TCPClient(TCPClient&) = delete; + TCPClient& operator=(TCPClient&) = delete; + TCPClient(TCPClient&&) = delete; + TCPClient& operator=(TCPClient&&) = delete; + ~TCPClient(); virtual TCPSocket& connect(const std::string& host, int port, int retries = 5, int timeout = 0, int retryDelay = 5); diff --git a/src/eckit/net/TCPServer.h b/src/eckit/net/TCPServer.h index b09f24689..84e68d510 100644 --- a/src/eckit/net/TCPServer.h +++ b/src/eckit/net/TCPServer.h @@ -20,12 +20,17 @@ namespace eckit::net { -class TCPServer : public TCPSocket, private NonCopyable { +class TCPServer : public TCPSocket { public: TCPServer(const SocketOptions& = SocketOptions::server()); explicit TCPServer(int port, const SocketOptions& = SocketOptions::server()); + TCPServer(const TCPServer&) = delete; + TCPServer& operator=(const TCPServer&) = delete; + TCPServer(TCPServer&&) = delete; + TCPServer& operator=(TCPServer&&) = delete; + ~TCPServer() override; void willFork(bool); diff --git a/src/eckit/net/UDPClient.h b/src/eckit/net/UDPClient.h index 4a113c180..921374075 100644 --- a/src/eckit/net/UDPClient.h +++ b/src/eckit/net/UDPClient.h @@ -14,8 +14,6 @@ #include #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { @@ -25,13 +23,18 @@ class Configuration; namespace net { -class UDPClient : private NonCopyable { +class UDPClient { public: // methods explicit UDPClient(const Configuration& cfg); UDPClient(const std::string& hostname, int port); + UDPClient(const UDPClient&) = delete; + UDPClient& operator=(const UDPClient&) = delete; + UDPClient(UDPClient&&) = delete; + UDPClient& operator=(UDPClient&&) = delete; + ~UDPClient(); void send(const void* buf, size_t length); diff --git a/src/eckit/net/UDPServer.h b/src/eckit/net/UDPServer.h index 9f5feb755..c718ae9ca 100644 --- a/src/eckit/net/UDPServer.h +++ b/src/eckit/net/UDPServer.h @@ -14,8 +14,6 @@ #include #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { @@ -24,12 +22,17 @@ class Buffer; namespace net { -class UDPServer : private NonCopyable { +class UDPServer { public: // methods explicit UDPServer(int port); + UDPServer(const UDPServer&) = delete; + UDPServer& operator=(const UDPServer&) = delete; + UDPServer(UDPServer&&) = delete; + UDPServer& operator=(UDPServer&&) = delete; + ~UDPServer(); size_t receive(void* buf, long length); diff --git a/src/eckit/option/CmdArgs.h b/src/eckit/option/CmdArgs.h index 63378f1a6..a1784ce5f 100644 --- a/src/eckit/option/CmdArgs.h +++ b/src/eckit/option/CmdArgs.h @@ -22,7 +22,6 @@ #include #include "eckit/config/LocalConfiguration.h" -#include "eckit/memory/NonCopyable.h" namespace eckit::option { @@ -31,7 +30,7 @@ namespace eckit::option { class Option; -class CmdArgs : public LocalConfiguration, private NonCopyable { +class CmdArgs : public LocalConfiguration { public: // types @@ -50,6 +49,11 @@ class CmdArgs : public LocalConfiguration, private NonCopyable { CmdArgs(std::function usage, std::vector& options, int args_count = -1, int minimum_args = 0, bool throw_on_error = false); + CmdArgs(const CmdArgs&) = delete; + CmdArgs& operator=(const CmdArgs&) = delete; + CmdArgs(CmdArgs&&) = delete; + CmdArgs& operator=(CmdArgs&&) = delete; + ~CmdArgs(); // Accessors diff --git a/src/eckit/option/Option.h b/src/eckit/option/Option.h index 4d74dc749..0be018e8a 100644 --- a/src/eckit/option/Option.h +++ b/src/eckit/option/Option.h @@ -23,11 +23,10 @@ #include "eckit/config/Configuration.h" #include "eckit/config/Configured.h" -#include "eckit/memory/NonCopyable.h" namespace eckit::option { -class Option : private eckit::NonCopyable { +class Option { public: using args_t = std::vector; @@ -35,6 +34,12 @@ class Option : private eckit::NonCopyable { public: // methods Option(const std::string& name, const std::string& description); + + Option(const Option&) = delete; + Option& operator=(const Option&) = delete; + Option(Option&&) = delete; + Option& operator=(Option&&) = delete; + virtual ~Option() = default; [[nodiscard]] const std::string& name() const { return name_; }; diff --git a/src/eckit/os/SemLocker.h b/src/eckit/os/SemLocker.h index bca2b87ef..db72ec95b 100644 --- a/src/eckit/os/SemLocker.h +++ b/src/eckit/os/SemLocker.h @@ -16,14 +16,13 @@ #define eckit_os_SemLocker_h #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class SemLocker : private NonCopyable { +class SemLocker { static const int SLEEP = 1; @@ -36,6 +35,11 @@ class SemLocker : private NonCopyable { SemLocker(int sem, const eckit::PathName& path, int maxWaitLock = 60); + SemLocker(const SemLocker&) = delete; + SemLocker& operator=(const SemLocker&) = delete; + SemLocker(SemLocker&&) = delete; + SemLocker& operator=(SemLocker&&) = delete; + ~SemLocker(); }; diff --git a/src/eckit/os/Semaphore.h b/src/eckit/os/Semaphore.h index 49b22b376..42627c33c 100644 --- a/src/eckit/os/Semaphore.h +++ b/src/eckit/os/Semaphore.h @@ -15,7 +15,6 @@ #define eckit_os_Semaphore_h #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" @@ -23,12 +22,17 @@ namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class Semaphore : private NonCopyable { +class Semaphore { public: // methods Semaphore(const PathName& name, int count = 1); + Semaphore(const Semaphore&) = delete; + Semaphore& operator=(const Semaphore&) = delete; + Semaphore(Semaphore&&) = delete; + Semaphore& operator=(Semaphore&&) = delete; + ~Semaphore(); void lock(void); diff --git a/src/eckit/os/SignalHandler.h b/src/eckit/os/SignalHandler.h index f33bcb99d..279e3f58e 100644 --- a/src/eckit/os/SignalHandler.h +++ b/src/eckit/os/SignalHandler.h @@ -17,7 +17,6 @@ #include "eckit/eckit.h" #include "eckit/exception/Exceptions.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -26,7 +25,7 @@ namespace eckit { /// @warning This class has not been widely tested, and we don't // know if they delete objects properly when the signal is caugth -class SignalHandler : private NonCopyable { +class SignalHandler { public: // methods @@ -39,6 +38,11 @@ class SignalHandler : private NonCopyable { SignalHandler(void (*)(int) = interrupt, Signal = SigInt); + SignalHandler(const SignalHandler&) = delete; + SignalHandler& operator=(const SignalHandler&) = delete; + SignalHandler(SignalHandler&&) = delete; + SignalHandler& operator=(SignalHandler&&) = delete; + // -- Destructor ~SignalHandler(); diff --git a/src/eckit/parser/StreamParser.h b/src/eckit/parser/StreamParser.h index af8f3c171..7f009b3d8 100644 --- a/src/eckit/parser/StreamParser.h +++ b/src/eckit/parser/StreamParser.h @@ -18,13 +18,12 @@ #include #include "eckit/exception/Exceptions.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class StreamParser : private NonCopyable { +class StreamParser { public: // types @@ -37,6 +36,12 @@ class StreamParser : private NonCopyable { public: // methods StreamParser(std::istream& in, bool comments = false, const char* comment = "#"); + + StreamParser(const StreamParser&) = delete; + StreamParser& operator=(const StreamParser&) = delete; + StreamParser(StreamParser&&) = delete; + StreamParser& operator=(StreamParser&&) = delete; + virtual ~StreamParser() = default; char peek(bool spaces = false); diff --git a/src/eckit/persist/Exporter.h b/src/eckit/persist/Exporter.h index 980a5845e..de06490c3 100644 --- a/src/eckit/persist/Exporter.h +++ b/src/eckit/persist/Exporter.h @@ -18,8 +18,6 @@ #include #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { @@ -27,7 +25,7 @@ namespace eckit { class DataHandle; -class Exporter : private NonCopyable { +class Exporter { class Datatype { char type_; @@ -67,6 +65,11 @@ class Exporter : private NonCopyable { Exporter(DataHandle&); + Exporter(const Exporter&) = delete; + Exporter& operator=(const Exporter&) = delete; + Exporter(Exporter&&) = delete; + Exporter& operator=(Exporter&&) = delete; + // -- Destructor ~Exporter(); diff --git a/src/eckit/runtime/Main.h b/src/eckit/runtime/Main.h index 0fc0379e2..0ccdf0837 100644 --- a/src/eckit/runtime/Main.h +++ b/src/eckit/runtime/Main.h @@ -14,7 +14,6 @@ #include #include "eckit/log/Channel.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -23,11 +22,16 @@ namespace eckit { class LogStream; class PathName; -class Main : private NonCopyable { +class Main { protected: Main(int argc, char** argv, const char* homeenv = nullptr); + Main(const Main&) = delete; + Main& operator=(const Main&) = delete; + Main(Main&&) = delete; + Main& operator=(Main&&) = delete; + virtual ~Main(); public: // methods diff --git a/src/eckit/runtime/Metrics.cc b/src/eckit/runtime/Metrics.cc index 10598bfce..3997d2604 100644 --- a/src/eckit/runtime/Metrics.cc +++ b/src/eckit/runtime/Metrics.cc @@ -1,3 +1,13 @@ +/* + * (C) Copyright 1996- ECMWF. + * + * This software is licensed under the terms of the Apache Licence Version 2.0 + * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0. + * In applying this licence, ECMWF does not waive the privileges and immunities + * granted to it by virtue of its status as an intergovernmental organisation nor + * does it submit to any jurisdiction. + */ + #include "eckit/runtime/Metrics.h" #include @@ -14,7 +24,6 @@ #include "eckit/utils/Tokenizer.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/value/Value.h" namespace eckit { @@ -102,10 +111,16 @@ struct MetricsPrefixInfo { //---------------------------------------------------------------------------------------------------------------------- -class MetricsCollector : private eckit::NonCopyable { +class MetricsCollector { public: // methods MetricsCollector(); + + MetricsCollector(const MetricsCollector&) = delete; + MetricsCollector& operator=(const MetricsCollector&) = delete; + MetricsCollector(MetricsCollector&&) = delete; + MetricsCollector& operator=(MetricsCollector&&) = delete; + ~MetricsCollector(); void set(const std::string& name, const Value& value, bool overrideOk); diff --git a/src/eckit/runtime/Monitor.h b/src/eckit/runtime/Monitor.h index 47dbaa836..0cf59e957 100644 --- a/src/eckit/runtime/Monitor.h +++ b/src/eckit/runtime/Monitor.h @@ -16,9 +16,7 @@ #define eckit_Monitor_h #include "eckit/eckit.h" - #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/runtime/TaskInfo.h" #include "eckit/thread/AutoLock.h" #include "eckit/thread/ThreadSingleton.h" @@ -27,17 +25,24 @@ namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class Monitor : private NonCopyable { +class Monitor { public: // types - class TaskArray : private eckit::NonCopyable { + class TaskArray { public: using iterator = TaskInfo*; using const_iterator = const TaskInfo*; + TaskArray() = default; + + TaskArray(const TaskArray&) = delete; + TaskArray& operator=(const TaskArray&) = delete; + TaskArray(TaskArray&&) = delete; + TaskArray& operator=(TaskArray&&) = delete; + virtual ~TaskArray(); virtual void sync() = 0; @@ -59,6 +64,11 @@ class Monitor : private NonCopyable { static Monitor& instance(); + Monitor(const Monitor&) = delete; + Monitor& operator=(const Monitor&) = delete; + Monitor(Monitor&&) = delete; + Monitor& operator=(Monitor&&) = delete; + static bool active(); static void active(bool a); diff --git a/src/eckit/runtime/Pipe.h b/src/eckit/runtime/Pipe.h index e7d5b9d5b..924ea491f 100644 --- a/src/eckit/runtime/Pipe.h +++ b/src/eckit/runtime/Pipe.h @@ -15,7 +15,6 @@ #include "eckit/exception/Exceptions.h" #include "eckit/log/CodeLocation.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/AutoLock.h" #include "eckit/thread/Mutex.h" #include "eckit/thread/MutexCond.h" @@ -33,7 +32,7 @@ template struct OnePayload; template -class Pipe : private NonCopyable { +class Pipe { public: using Proc = void (*)(Pipe&); @@ -42,6 +41,11 @@ class Pipe : private NonCopyable { Pipe(long count = 2); + Pipe(const Pipe&) = delete; + Pipe& operator=(const Pipe&) = delete; + Pipe(Pipe&&) = delete; + Pipe& operator=(Pipe&&) = delete; + // -- Destructor ~Pipe(); diff --git a/src/eckit/runtime/Task.h b/src/eckit/runtime/Task.h index c40fb8b40..720997315 100644 --- a/src/eckit/runtime/Task.h +++ b/src/eckit/runtime/Task.h @@ -14,17 +14,20 @@ #ifndef eckit_Task_h #define eckit_Task_h -#include "eckit/memory/NonCopyable.h" - namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class Task : private NonCopyable { +class Task { public: Task(); + Task(const Task&) = delete; + Task& operator=(const Task&) = delete; + Task(Task&&) = delete; + Task& operator=(Task&&) = delete; + virtual ~Task(); virtual void start() = 0; diff --git a/src/eckit/runtime/TaskInfo.h b/src/eckit/runtime/TaskInfo.h index fdf339660..bbacc22cb 100644 --- a/src/eckit/runtime/TaskInfo.h +++ b/src/eckit/runtime/TaskInfo.h @@ -93,11 +93,16 @@ struct Info { //---------------------------------------------------------------------------------------------------------------------- -/// @warning This class is written to disk! Any change must ensure binary compatibility. -class TaskInfo : public NonCopyable { +class TaskInfo { public: TaskInfo(); + + TaskInfo(const TaskInfo&) = delete; + TaskInfo& operator=(const TaskInfo&) = delete; + TaskInfo(TaskInfo&&) = delete; + TaskInfo& operator=(TaskInfo&&) = delete; + ~TaskInfo(); void out(char*, char*); diff --git a/src/eckit/runtime/Telemetry.cc b/src/eckit/runtime/Telemetry.cc index 6112bfc58..2e24a1c41 100644 --- a/src/eckit/runtime/Telemetry.cc +++ b/src/eckit/runtime/Telemetry.cc @@ -63,7 +63,7 @@ std::string report_type_to_name(Report::Type t) { //---------------------------------------------------------------------------------------------------------------------- -class Reporter : public NonCopyable { +class Reporter { public: static Reporter& instance(); @@ -71,6 +71,11 @@ class Reporter : public NonCopyable { Reporter(); + Reporter(const Reporter&) = delete; + Reporter& operator=(const Reporter&) = delete; + Reporter(Reporter&&) = delete; + Reporter& operator=(Reporter&&) = delete; + ~Reporter() = default; bool enabled() { return not clients_.empty(); } diff --git a/src/eckit/runtime/Telemetry.h b/src/eckit/runtime/Telemetry.h index 194ab6b22..701110094 100644 --- a/src/eckit/runtime/Telemetry.h +++ b/src/eckit/runtime/Telemetry.h @@ -17,8 +17,6 @@ #include #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { class JSON; @@ -52,9 +50,11 @@ class Report { //---------------------------------------------------------------------------------------------------------------------- -class Telemetry : public NonCopyable { +class Telemetry { public: + Telemetry() = delete; + static std::string report(Report::Type); static std::string report(Report::Type, const Report&); static std::string report(Report::Type, std::function); diff --git a/src/eckit/serialisation/Stream.h b/src/eckit/serialisation/Stream.h index 69c622ee9..84882fcfb 100644 --- a/src/eckit/serialisation/Stream.h +++ b/src/eckit/serialisation/Stream.h @@ -17,10 +17,8 @@ #include #include -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" - namespace eckit { @@ -32,9 +30,14 @@ template class IOBuffer; class Buffer; -class Stream : private NonCopyable { +class Stream { public: + Stream(const Stream&) = delete; + Stream& operator=(const Stream&) = delete; + Stream(Stream&&) = delete; + Stream& operator=(Stream&&) = delete; + virtual ~Stream(); // Output diff --git a/src/eckit/serialisation/Streamable.h b/src/eckit/serialisation/Streamable.h index 799b8b956..8d6a5d4ed 100644 --- a/src/eckit/serialisation/Streamable.h +++ b/src/eckit/serialisation/Streamable.h @@ -14,7 +14,6 @@ #ifndef eckit_Streamable_h #define eckit_Streamable_h -#include "eckit/memory/NonCopyable.h" #include "eckit/serialisation/Reanimator.h" #include "eckit/serialisation/Stream.h" @@ -22,7 +21,7 @@ namespace eckit { //----------------------------------------------------------------------------- -class Streamable : private NonCopyable { +class Streamable { public: friend Stream& operator<<(Stream&, const Streamable&); @@ -30,8 +29,14 @@ class Streamable : private NonCopyable { // -- Contructors Streamable() {} + Streamable(Stream&); + Streamable(const Stream&) = delete; + Streamable& operator=(const Stream&) = delete; + Streamable(Stream&&) = delete; + Streamable& operator=(Stream&&) = delete; + // -- Destructor virtual ~Streamable() {} diff --git a/src/eckit/sql/SQLOutput.h b/src/eckit/sql/SQLOutput.h index 7dedb591e..ea54a726f 100644 --- a/src/eckit/sql/SQLOutput.h +++ b/src/eckit/sql/SQLOutput.h @@ -15,7 +15,6 @@ #ifndef eckit_sql_SQLOutput_H #define eckit_sql_SQLOutput_H -#include "eckit/memory/NonCopyable.h" #include "eckit/sql/SQLOutputConfig.h" namespace eckit::sql { @@ -28,10 +27,16 @@ class SQLSelect; //---------------------------------------------------------------------------------------------------------------------- -class SQLOutput : private eckit::NonCopyable { +class SQLOutput { public: SQLOutput(); + + SQLOutput(const SQLOutput&) = delete; + SQLOutput& operator=(const SQLOutput&) = delete; + SQLOutput(SQLOutput&&) = delete; + SQLOutput& operator=(SQLOutput&&) = delete; + virtual ~SQLOutput(); virtual void preprepare(SQLSelect&); @@ -64,9 +69,6 @@ class SQLOutput : private eckit::NonCopyable { private: - // No copy allowed - SQLOutput(const SQLOutput&); - SQLOutput& operator=(const SQLOutput&); // -- Friends friend std::ostream& operator<<(std::ostream& s, const SQLOutput& p) { p.print(s); diff --git a/src/eckit/sql/SQLSession.h b/src/eckit/sql/SQLSession.h index 4cad104a0..447d95ca6 100644 --- a/src/eckit/sql/SQLSession.h +++ b/src/eckit/sql/SQLSession.h @@ -24,7 +24,6 @@ class DataHandle; #include -#include "eckit/memory/OnlyMovable.h" #include "eckit/sql/SQLSelectFactory.h" // #include "eckit/sql/SQLInsertFactory.h" #include "eckit/sql/SQLDatabase.h" @@ -40,7 +39,7 @@ class SQLStatement; class SQLTable; class SQLOutputConfig; -class SQLSession : private eckit::OnlyMovable { +class SQLSession { public: // Constructors @@ -51,6 +50,11 @@ class SQLSession : private eckit::OnlyMovable { SQLSession(std::unique_ptr out, const std::string& csvDelimiter); SQLSession(const std::string& csvDelimiter = ","); + SQLSession(const SQLSession&) = delete; + SQLSession& operator=(const SQLSession&) = delete; + SQLSession(SQLSession&&) = default; + SQLSession& operator=(SQLSession&&) = default; + virtual ~SQLSession(); // For sqly.y (used parsing SQL strings) diff --git a/src/eckit/sql/SQLTable.h b/src/eckit/sql/SQLTable.h index 78f50bf5a..f1ed7a6d3 100644 --- a/src/eckit/sql/SQLTable.h +++ b/src/eckit/sql/SQLTable.h @@ -19,7 +19,6 @@ #include #include "eckit/filesystem/PathName.h" -#include "eckit/memory/NonCopyable.h" #include "eckit/sql/SQLTypedefs.h" #include "eckit/sql/type/SQLType.h" @@ -46,10 +45,16 @@ class SQLTableIterator { using ColumnNames = std::vector; -class SQLTable : private eckit::NonCopyable { +class SQLTable { public: SQLTable(SQLDatabase&, const std::string&, const std::string&); + + SQLTable(const SQLTable&) = delete; + SQLTable& operator=(const SQLTable&) = delete; + SQLTable(SQLTable&&) = delete; + SQLTable& operator=(SQLTable&&) = delete; + virtual ~SQLTable(); void loadIOMAP(std::istream&); diff --git a/src/eckit/sql/type/SQLType.h b/src/eckit/sql/type/SQLType.h index 993e40c2b..07a1a1e3a 100644 --- a/src/eckit/sql/type/SQLType.h +++ b/src/eckit/sql/type/SQLType.h @@ -16,8 +16,6 @@ #include -#include "eckit/memory/NonCopyable.h" - namespace eckit::sql { //---------------------------------------------------------------------------------------------------------------------- @@ -26,7 +24,7 @@ class SQLOutput; namespace type { -class SQLType : private eckit::NonCopyable { +class SQLType { public: enum { @@ -40,6 +38,11 @@ class SQLType : private eckit::NonCopyable { SQLType(const std::string&); + SQLType(const SQLType&) = delete; + SQLType& operator=(const SQLType&) = delete; + SQLType(SQLType&&) = delete; + SQLType& operator=(SQLType&&) = delete; + virtual ~SQLType(); const std::string& name() const { return name_; } diff --git a/src/eckit/system/Library.h b/src/eckit/system/Library.h index 4d2dda810..5e19958eb 100644 --- a/src/eckit/system/Library.h +++ b/src/eckit/system/Library.h @@ -19,7 +19,6 @@ #include #include -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" namespace eckit { @@ -31,11 +30,16 @@ namespace system { //---------------------------------------------------------------------------------------------------------------------- -class Library : private eckit::NonCopyable { +class Library { public: // methods Library(const std::string& name); + Library(const Library&) = delete; + Library& operator=(const Library&) = delete; + Library(Library&&) = delete; + Library& operator=(Library&&) = delete; + virtual ~Library(); const std::string& name() const; diff --git a/src/eckit/system/LibraryManager.h b/src/eckit/system/LibraryManager.h index 4f82cf944..574e08c04 100644 --- a/src/eckit/system/LibraryManager.h +++ b/src/eckit/system/LibraryManager.h @@ -18,7 +18,6 @@ #include #include "eckit/filesystem/LocalPathName.h" -#include "eckit/memory/NonCopyable.h" namespace eckit::system { @@ -27,9 +26,18 @@ class Plugin; //---------------------------------------------------------------------------------------------------------------------- -class LibraryManager : private eckit::NonCopyable { +class LibraryManager { public: // class methods + LibraryManager() = default; // Necessary, because class is used as base class + + LibraryManager(const LibraryManager&) = delete; + LibraryManager& operator=(const LibraryManager&) = delete; + LibraryManager(LibraryManager&&) = delete; + LibraryManager& operator=(LibraryManager&&) = delete; + + virtual ~LibraryManager() = default; // Necessary, because class is used as base class + /// @brief Register a library static void enregister(const std::string& name, Library* obj); diff --git a/src/eckit/system/SystemInfo.h b/src/eckit/system/SystemInfo.h index 45d262258..f4b65d3cd 100644 --- a/src/eckit/system/SystemInfo.h +++ b/src/eckit/system/SystemInfo.h @@ -19,7 +19,6 @@ #include "eckit/filesystem/PathName.h" #include "eckit/log/Log.h" -#include "eckit/memory/NonCopyable.h" namespace eckit::system { @@ -27,12 +26,19 @@ struct MemoryInfo; //-------------------------------------------------------------------------------------------------- -class SystemInfo : private eckit::NonCopyable { +class SystemInfo { public: // methods static bool isBigEndian(); static bool isLittleEndian(); + SystemInfo() = default; + + SystemInfo(const SystemInfo&) = delete; + SystemInfo& operator=(const SystemInfo&) = delete; + SystemInfo(SystemInfo&&) = delete; + SystemInfo& operator=(SystemInfo&&) = delete; + virtual ~SystemInfo(); static const SystemInfo& instance(); diff --git a/src/eckit/thread/AutoLock.h b/src/eckit/thread/AutoLock.h index 5094e6fbb..f3e583e68 100644 --- a/src/eckit/thread/AutoLock.h +++ b/src/eckit/thread/AutoLock.h @@ -14,8 +14,6 @@ #include "eckit/log/Seconds.h" #include "eckit/log/Timer.h" #include "eckit/log/TraceTimer.h" -#include "eckit/memory/NonCopyable.h" - namespace eckit { @@ -25,7 +23,7 @@ namespace eckit { // environment. AutoLocks are exception safe. template -class AutoLock : private NonCopyable { +class AutoLock { public: @@ -35,6 +33,11 @@ class AutoLock : private NonCopyable { AutoLock(T* resource) : resource_(*resource) { resource_.lock(); } + AutoLock(const AutoLock&) = delete; + AutoLock& operator=(const AutoLock&) = delete; + AutoLock(AutoLock&&) = delete; + AutoLock& operator=(AutoLock&&) = delete; + // -- Destructor ~AutoLock() { resource_.unlock(); } @@ -47,7 +50,7 @@ class AutoLock : private NonCopyable { //---------------------------------------------------------------------------------------------------------------------- template -class AutoSharedLock : private NonCopyable { +class AutoSharedLock { public: // -- Contructors @@ -55,6 +58,9 @@ class AutoSharedLock : private NonCopyable { AutoSharedLock(T& resource) : resource_(resource) { resource_.lockShared(); } AutoSharedLock(T* resource) : resource_(*resource) { resource_.lockShared(); } + AutoSharedLock(const AutoSharedLock&) = delete; + AutoSharedLock& operator=(const AutoSharedLock&) = delete; + // -- Destructor ~AutoSharedLock() { resource_.unlock(); } @@ -67,7 +73,7 @@ class AutoSharedLock : private NonCopyable { //---------------------------------------------------------------------------------------------------------------------- template -class TimedAutoLock : private NonCopyable { +class TimedAutoLock { public: // -- Constructors @@ -77,6 +83,9 @@ class TimedAutoLock : private NonCopyable { timer_.report(message + " (acquire)"); } + TimedAutoLock(const TimedAutoLock&) = delete; + TimedAutoLock& operator=(const TimedAutoLock&) = delete; + // -- Destructor ~TimedAutoLock() { resource_.unlock(); } @@ -90,7 +99,7 @@ class TimedAutoLock : private NonCopyable { //---------------------------------------------------------------------------------------------------------------------- template -class TraceAutoLock : private NonCopyable { +class TraceAutoLock { public: // -- Constructors @@ -100,6 +109,9 @@ class TraceAutoLock : private NonCopyable { timer_.report(message + " (acquire)"); } + TraceAutoLock(const TraceAutoLock&) = delete; + TraceAutoLock& operator=(const TraceAutoLock&) = delete; + // -- Destructor ~TraceAutoLock() { resource_.unlock(); } diff --git a/src/eckit/thread/Mutex.h b/src/eckit/thread/Mutex.h index a4de458d9..db85a9d42 100644 --- a/src/eckit/thread/Mutex.h +++ b/src/eckit/thread/Mutex.h @@ -17,8 +17,6 @@ #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { //---------------------------------------------------------------------------------------------------------------------- @@ -27,11 +25,16 @@ namespace eckit { /// In addition to std::reentrant_mutex this checks valida construction before usage /// and add an optional tag, both of which can be useful when debugging, /// especially when dealing with construction before main() execution (eg self-registration classes) -class Mutex : private NonCopyable { +class Mutex { public: // methods Mutex(char tag = ' '); + Mutex(const Mutex&) = delete; + Mutex& operator=(const Mutex&) = delete; + Mutex(Mutex&&) = delete; + Mutex& operator=(Mutex&&) = delete; + ~Mutex(); void lock(); diff --git a/src/eckit/thread/MutexCond.h b/src/eckit/thread/MutexCond.h index 4fc4053f2..61e75165c 100644 --- a/src/eckit/thread/MutexCond.h +++ b/src/eckit/thread/MutexCond.h @@ -16,8 +16,6 @@ #include -#include "eckit/memory/NonCopyable.h" - //----------------------------------------------------------------------------- namespace eckit { @@ -27,13 +25,18 @@ namespace eckit { // A mutex and a condition variable // for Producer/Consumer architectures -class MutexCond : private NonCopyable { +class MutexCond { public: // -- Contructors MutexCond(char tag = ' '); + MutexCond(const MutexCond&) = delete; + MutexCond& operator=(const MutexCond&) = delete; + MutexCond(MutexCond&&) = delete; + MutexCond& operator=(MutexCond&&) = delete; + // -- Destructor ~MutexCond(); diff --git a/src/eckit/thread/Once.h b/src/eckit/thread/Once.h index 27deded8d..cb9fb39b2 100644 --- a/src/eckit/thread/Once.h +++ b/src/eckit/thread/Once.h @@ -13,21 +13,24 @@ #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { //---------------------------------------------------------------------------------------------------------------------- template -class Once : private NonCopyable { +class Once { public: // -- Contructors Once(); + Once(const Once&) = delete; + Once& operator=(const Once&) = delete; + Once(Once&&) = delete; + Once& operator=(Once&&) = delete; + // -- Destructor ~Once(); diff --git a/src/eckit/thread/StaticMutex.h b/src/eckit/thread/StaticMutex.h index 2441ae308..80cb47e73 100644 --- a/src/eckit/thread/StaticMutex.h +++ b/src/eckit/thread/StaticMutex.h @@ -19,7 +19,6 @@ #include -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -27,12 +26,17 @@ namespace eckit { /// Class meant to be used only for static mutexes protecting local resources inside a single compilation unit -class StaticMutex : private NonCopyable { +class StaticMutex { public: // methods StaticMutex(); + StaticMutex(const StaticMutex&) = delete; + StaticMutex& operator=(const StaticMutex&) = delete; + StaticMutex(StaticMutex&&) = delete; + StaticMutex& operator=(StaticMutex&&) = delete; + ~StaticMutex(); void lock(); diff --git a/src/eckit/thread/Thread.h b/src/eckit/thread/Thread.h index 0f7fd9a44..a336f7b63 100644 --- a/src/eckit/thread/Thread.h +++ b/src/eckit/thread/Thread.h @@ -15,7 +15,6 @@ #ifndef eckit_Thread_h #define eckit_Thread_h -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" @@ -25,13 +24,18 @@ namespace eckit { // This should be a Task -class Thread : private NonCopyable { +class Thread { public: friend class ThreadControler; Thread(bool autodel = true); + Thread(const Thread&) = delete; + Thread& operator=(const Thread&) = delete; + Thread(Thread&&) = delete; + Thread& operator=(Thread&&) = delete; + virtual ~Thread(); void stop(); diff --git a/src/eckit/thread/ThreadPool.h b/src/eckit/thread/ThreadPool.h index 3fa555146..17549a82b 100644 --- a/src/eckit/thread/ThreadPool.h +++ b/src/eckit/thread/ThreadPool.h @@ -43,12 +43,17 @@ class ThreadPoolTask { //----------------------------------------------------------------------------- -class ThreadPool : private NonCopyable { +class ThreadPool { public: // methods ThreadPool(const std::string& name, size_t count, size_t stack = 0); + ThreadPool(const ThreadPool&) = delete; + ThreadPool& operator=(const ThreadPool&) = delete; + ThreadPool(ThreadPool&&) = delete; + ThreadPool& operator=(ThreadPool&&) = delete; + ~ThreadPool(); void push(ThreadPoolTask*); diff --git a/src/eckit/thread/ThreadSingleton.h b/src/eckit/thread/ThreadSingleton.h index e958c5a5d..0917f315a 100644 --- a/src/eckit/thread/ThreadSingleton.h +++ b/src/eckit/thread/ThreadSingleton.h @@ -17,7 +17,6 @@ #include #include "eckit/exception/Exceptions.h" -#include "eckit/memory/NonCopyable.h" namespace eckit { @@ -39,12 +38,17 @@ struct NewAlloc1 { //---------------------------------------------------------------------------------------------------------------------- template > -class ThreadSingleton : private NonCopyable { +class ThreadSingleton { public: ThreadSingleton(); ThreadSingleton(const A& alloc); + ThreadSingleton(const ThreadSingleton&) = delete; + ThreadSingleton& operator=(const ThreadSingleton&) = delete; + ThreadSingleton(ThreadSingleton&&) = delete; + ThreadSingleton& operator=(ThreadSingleton&&) = delete; + ~ThreadSingleton(); T& instance(); diff --git a/src/eckit/transaction/TxnLog.cc b/src/eckit/transaction/TxnLog.cc index 2cc6fbb09..87e3a894d 100644 --- a/src/eckit/transaction/TxnLog.cc +++ b/src/eckit/transaction/TxnLog.cc @@ -34,13 +34,19 @@ namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class TxnArray : private eckit::NonCopyable { +class TxnArray { public: using iterator = TxnID*; using const_iterator = const TxnID*; + TxnArray() = default; + TxnArray(const TxnArray&) = delete; + TxnArray& operator=(const TxnArray&) = delete; + TxnArray(TxnArray&&) = delete; + TxnArray& operator=(TxnArray&&) = delete; + virtual ~TxnArray() {} virtual void lock() = 0; diff --git a/src/eckit/utils/Hash.h b/src/eckit/utils/Hash.h index 4ef23acb6..5471b4034 100644 --- a/src/eckit/utils/Hash.h +++ b/src/eckit/utils/Hash.h @@ -19,14 +19,13 @@ #include #include -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class Hash : private eckit::NonCopyable { +class Hash { public: // types @@ -36,6 +35,11 @@ class Hash : private eckit::NonCopyable { Hash(); + Hash(const Hash&) = delete; + Hash& operator=(const Hash&) = delete; + Hash(Hash&&) = delete; + Hash& operator=(Hash&&) = delete; + virtual ~Hash(); virtual void reset() const = 0; diff --git a/src/eckit/utils/RendezvousHash.h b/src/eckit/utils/RendezvousHash.h index 06e8a414e..d9824ac6d 100644 --- a/src/eckit/utils/RendezvousHash.h +++ b/src/eckit/utils/RendezvousHash.h @@ -15,7 +15,6 @@ #include #include -#include "eckit/memory/NonCopyable.h" #include "eckit/thread/Mutex.h" namespace eckit { @@ -29,7 +28,7 @@ namespace eckit { /// /// @todo Make node a template parameter? Must be a serializable object -class RendezvousHash : private eckit::NonCopyable { +class RendezvousHash { public: // types @@ -51,6 +50,11 @@ class RendezvousHash : private eckit::NonCopyable { RendezvousHash(const std::vector& nodes, const hash_func_ptr hash = &md5); + RendezvousHash(const RendezvousHash&) = delete; + RendezvousHash& operator=(const RendezvousHash&) = delete; + RendezvousHash(RendezvousHash&&) = delete; + RendezvousHash& operator=(RendezvousHash&&) = delete; + ~RendezvousHash(); /// Provide a list of nodes / indices in the list of nodes for the given key diff --git a/src/eckit/utils/StringTools.h b/src/eckit/utils/StringTools.h index c36a682b9..4abda7517 100644 --- a/src/eckit/utils/StringTools.h +++ b/src/eckit/utils/StringTools.h @@ -19,17 +19,17 @@ #include #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { //---------------------------------------------------------------------------------------------------------------------- -class StringTools : private NonCopyable { +class StringTools { public: + StringTools() = delete; + static std::string substitute(const std::string&, const std::map&); /// @deprecated Use extract variables @@ -63,10 +63,6 @@ class StringTools : private NonCopyable { static bool isQuoted(const std::string& value); static std::string unQuote(const std::string& value); - -private: - - StringTools(); // Non instantiable }; //---------------------------------------------------------------------------------------------------------------------- diff --git a/src/eckit/utils/Tokenizer.h b/src/eckit/utils/Tokenizer.h index bf03ff0c5..33574c1b3 100644 --- a/src/eckit/utils/Tokenizer.h +++ b/src/eckit/utils/Tokenizer.h @@ -19,19 +19,22 @@ #include #include -#include "eckit/memory/NonCopyable.h" - namespace eckit { //--------------------------------------------------------------------------------------------------------------------- -class Tokenizer : private NonCopyable { +class Tokenizer { public: // methods Tokenizer(char, bool keepEmpty = false); Tokenizer(const std::string&, bool keepEmpty = false); + Tokenizer(const Tokenizer&) = delete; + Tokenizer& operator=(const Tokenizer&) = delete; + Tokenizer(Tokenizer&&) = delete; + Tokenizer& operator=(Tokenizer&&) = delete; + ~Tokenizer(); void operator()(const std::string&, std::vector&) const; diff --git a/src/eckit/value/Expression.h b/src/eckit/value/Expression.h index b1592fb33..ace6655b9 100644 --- a/src/eckit/value/Expression.h +++ b/src/eckit/value/Expression.h @@ -17,7 +17,6 @@ #include #include -#include "eckit/memory/NonCopyable.h" #include "eckit/value/Value.h" //==================================================================== @@ -77,11 +76,17 @@ class EvalError : public eckit::Exception { }; template -class Expression : private eckit::NonCopyable { +class Expression { virtual void print(std::ostream&) const = 0; public: + Expression() = default; + Expression(const Expression&) = delete; + Expression& operator=(const Expression&) = delete; + Expression(Expression&&) = delete; + Expression& operator=(Expression&&) = delete; + virtual eckit::Value eval(T&) const = 0; virtual ~Expression() {} friend std::ostream& operator<<(std::ostream& s, const Expression& c) { diff --git a/src/eckit/web/FtpRequest.h b/src/eckit/web/FtpRequest.h index e67c2cfd2..570da0c25 100644 --- a/src/eckit/web/FtpRequest.h +++ b/src/eckit/web/FtpRequest.h @@ -16,8 +16,6 @@ #include -#include "eckit/memory/NonCopyable.h" - //----------------------------------------------------------------------------- class Retrieve; @@ -27,12 +25,17 @@ namespace eckit { class Length; class PathName; -class FtpRequest : private eckit::NonCopyable { +class FtpRequest { public: // -- Contructors - FtpRequest() {} + FtpRequest() = default; + + FtpRequest(const FtpRequest&) = delete; + FtpRequest& operator=(const FtpRequest&) = delete; + FtpRequest(FtpRequest&&) = delete; + FtpRequest& operator=(FtpRequest&&) = delete; // -- Destructor diff --git a/src/eckit/web/HttpResource.h b/src/eckit/web/HttpResource.h index 66ba2e862..ed9b644c9 100644 --- a/src/eckit/web/HttpResource.h +++ b/src/eckit/web/HttpResource.h @@ -15,7 +15,6 @@ #include -#include "eckit/memory/NonCopyable.h" #include "eckit/web/HtmlObject.h" @@ -26,11 +25,16 @@ namespace eckit { class Stream; class HttpStream; -class HttpResource : public HtmlObject, public eckit::NonCopyable { +class HttpResource : public HtmlObject { public: // methods HttpResource(const std::string&); + HttpResource(const HttpResource&) = delete; + HttpResource& operator=(const HttpResource&) = delete; + HttpResource(HttpResource&&) = delete; + HttpResource& operator=(HttpResource&&) = delete; + ~HttpResource() override; virtual bool restricted() { return false; } diff --git a/src/eckit/web/Url.h b/src/eckit/web/Url.h index 9b2da4a25..c2d4d2d1c 100644 --- a/src/eckit/web/Url.h +++ b/src/eckit/web/Url.h @@ -43,12 +43,17 @@ class UrlAccess { //---------------------------------------------------------------------------------------------------------------------- -class Url : private eckit::NonCopyable { +class Url { public: Url(std::istream&); Url(const std::string&); + Url(const Url&) = delete; + Url& operator=(const Url&) = delete; + Url(Url&&) = delete; + Url& operator=(Url&&) = delete; + ~Url(); UrlAccess operator[](const std::string&); diff --git a/src/sandbox/memsharedlimit.cc b/src/sandbox/memsharedlimit.cc index 373cb27ea..b020dca3f 100644 --- a/src/sandbox/memsharedlimit.cc +++ b/src/sandbox/memsharedlimit.cc @@ -48,10 +48,15 @@ class MemorySharedLimit { using parts_t = unsigned short; - struct Token : private eckit::NonCopyable { + struct Token { Token(MemorySharedLimit& limit, parts_t parts) : limit_(limit), parts_(parts) {} + Token(const Token&) = delete; + Token& operator=(const Token&) = delete; + Token(Token&&) = delete; + Token& operator=(Token&&) = delete; + ~Token() { limit_.release(parts_); } private: