Refactoring: apply rule of 0 or rule of 5 for special members (part 2)

Author: doxygen

libxml/xml.h

@@ -55,7 +55,13 @@ class XMLHandlers
 class XMLLocator
 {
   public:
-    virtual ~XMLLocator() {}
+    XMLLocator() = default;
+    XMLLocator(const XMLLocator &) = delete;
+    XMLLocator &operator=(const XMLLocator &) = delete;
+    XMLLocator(XMLLocator &&) = delete;
+    XMLLocator &operator=(XMLLocator &&) = delete;
+    virtual ~XMLLocator() = default;
+
     virtual int lineNr() const = 0;
     virtual std::string fileName() const = 0;
 };
@@ -72,6 +78,10 @@ class XMLParser : public XMLLocator
     XMLParser(const XMLHandlers &handlers);
     /*! Destructor */
    ~XMLParser();
+    XMLParser(const XMLParser &) = delete;
+    XMLParser &operator=(const XMLParser &) = delete;
+    XMLParser(XMLParser &&) = delete;
+    XMLParser &operator=(XMLParser &&) = delete;
 
    using Transcode = bool(std::string &,const char *);
 

src/classdef.cpp

@@ -417,7 +417,9 @@ class ClassDefAliasImpl : public DefinitionAliasMixin<ClassDef>
   public:
     ClassDefAliasImpl(const Definition *newScope,const ClassDef *cd)
       : DefinitionAliasMixin(newScope,cd) { init(); }
-    ~ClassDefAliasImpl() override { deinit(); }
+   ~ClassDefAliasImpl() override { deinit(); }
+    NON_COPYABLE(ClassDefAliasImpl)
+
     DefType definitionType() const override { return TypeClass; }
 
     const ClassDef *getCdAlias() const { return toClassDef(getAlias()); }

src/classdef.h

@@ -103,6 +103,8 @@ using ClassDefSet = std::unordered_set<const ClassDef*>;
 class ClassDef : public Definition
 {
   public:
+    ABSTRACT_BASE_CLASS(ClassDef)
+
     /** The various compound types */
     enum CompoundType { Class,     //=Entry::CLASS_SEC,
                         Struct,    //=Entry::STRUCT_SEC,
@@ -408,6 +410,8 @@ class ClassDef : public Definition
 class ClassDefMutable : public DefinitionMutable, public ClassDef
 {
   public:
+    ABSTRACT_BASE_CLASS(ClassDefMutable)
+
     //-----------------------------------------------------------------------------------
     // --- setters ----
     //-----------------------------------------------------------------------------------

src/codefragment.h

@@ -19,6 +19,7 @@
 #include <memory>
 
 #include "qcstring.h"
+#include "construct.h"
 
 class OutputCodeList;
 class Definition;
@@ -39,6 +40,7 @@ class CodeFragmentManager
   private:
     CodeFragmentManager();
     ~CodeFragmentManager();
+    NON_COPYABLE(CodeFragmentManager)
 
     struct Private;
     std::unique_ptr<Private> p;

src/commentscan.h

@@ -18,6 +18,7 @@
 
 #include <memory>
 #include "types.h"
+#include "construct.h"
 
 class Entry;
 class OutlineParserInterface;
@@ -30,6 +31,7 @@ class CommentScanner
   public:
     CommentScanner();
    ~CommentScanner();
+    NON_COPYABLE(CommentScanner)
 
     /** Invokes the comment block parser with the request to parse a
      *  single comment block.

src/conceptdef.cpp

@@ -34,6 +34,7 @@ class ConceptDefImpl : public DefinitionMixin<ConceptDefMutable>
     ConceptDefImpl(const QCString &fileName,int startLine,int startColumn,
                    const QCString &name,const QCString &tagRef=QCString(),const QCString &tagFile=QCString());
    ~ConceptDefImpl();
+    NON_COPYABLE(ConceptDefImpl);
 
     ConceptDef *resolveAlias() { return this; }
 
@@ -103,6 +104,7 @@ class ConceptDefAliasImpl : public DefinitionAliasMixin<ConceptDef>
     ConceptDefAliasImpl(const Definition *newScope,const ConceptDef *cd)
       : DefinitionAliasMixin(newScope,cd) { init(); }
     ~ConceptDefAliasImpl() override { deinit(); }
+    NON_COPYABLE(ConceptDefAliasImpl)
 
     const ConceptDef *getCdAlias() const { return toConceptDef(getAlias()); }
     ConceptDef *resolveAlias() { return const_cast<ConceptDef*>(getCdAlias()); }

src/conceptdef.h

@@ -26,6 +26,8 @@ class ModuleDef;
 class ConceptDef : public Definition
 {
   public:
+    ABSTRACT_BASE_CLASS(ConceptDef)
+
     virtual DefType definitionType() const = 0;
     virtual QCString getOutputFileBase() const = 0;
     virtual bool hasDetailedDescription() const = 0;
@@ -48,6 +50,8 @@ class ConceptDef : public Definition
 class ConceptDefMutable : public DefinitionMutable, public ConceptDef
 {
   public:
+    ABSTRACT_BASE_CLASS(ConceptDefMutable)
+
     virtual void setIncludeFile(FileDef *fd,const QCString &incName,bool local,bool force) = 0;
     virtual void setTemplateArguments(const ArgumentList &al) = 0;
     virtual void setNamespace(NamespaceDef *nd) = 0;

src/definition.cpp

@@ -69,6 +69,13 @@ class DeepCopyUniquePtr : public std::unique_ptr<T>
       if (*this!=other) this->reset(other ? new T(*other) : nullptr);
       return *this;
     }
+    DeepCopyUniquePtr(DeepCopyUniquePtr &&other) : std::unique_ptr<T>(std::move(other)) {}
+    DeepCopyUniquePtr &operator=(DeepCopyUniquePtr &&other)
+    {
+      std::unique_ptr<T>::operator=(std::move(other));
+      return *this;
+    }
+   ~DeepCopyUniquePtr() = default;
 };
 
 //! Helper to create an object wrapped in a DeepCopyUniquePtr.

src/definition.h

@@ -20,6 +20,7 @@
 
 #include "types.h"
 #include "reflist.h"
+#include "construct.h"
 
 #ifdef _MSC_VER
 // To disable 'inherits via dominance' warnings with MSVC.
@@ -74,6 +75,8 @@ struct BodyInfo
 class Definition
 {
   public:
+    ABSTRACT_BASE_CLASS(Definition)
+
     /*! Types of derived classes */
     enum DefType
     {
@@ -291,9 +294,6 @@ class Definition
     virtual void _setSymbolName(const QCString &name) = 0;
     virtual QCString _symbolName() const = 0;
 
-    // ---------------------------------
-    virtual ~Definition() = default;
-
   private:
     friend class DefinitionImpl;
     friend DefinitionMutable* toDefinitionMutable(Definition *);
@@ -305,7 +305,7 @@ class Definition
 class DefinitionMutable
 {
   public:
-
+    ABSTRACT_BASE_CLASS(DefinitionMutable)
 
     //-----------------------------------------------------------------------------------
     // ----  setters -----
@@ -385,9 +385,6 @@ class DefinitionMutable
     virtual void writeDocAnchorsToTagFile(TextStream &) const = 0;
     virtual void writeToc(OutputList &ol, const LocalToc &lt) const = 0;
 
-    // ---------------------------------
-    virtual ~DefinitionMutable() = default;
-
   private:
     friend Definition* toDefinition(DefinitionMutable *);
     virtual Definition *toDefinition_() = 0;

src/definitionimpl.h

@@ -33,6 +33,10 @@ class DefinitionImpl
         const QCString &name,const char *b=nullptr,const char *d=nullptr,
         bool isSymbol=TRUE);
     ~DefinitionImpl();
+    DefinitionImpl(const DefinitionImpl &d);
+    DefinitionImpl &operator=(const DefinitionImpl &d);
+    DefinitionImpl(DefinitionImpl &&d) = delete;
+    DefinitionImpl &operator=(DefinitionImpl &&d) = delete;
 
     const QCString &name() const;
     bool isAnonymous() const;
@@ -124,7 +128,6 @@ class DefinitionImpl
     void _setSymbolName(const QCString &name);
     QCString _symbolName() const;
 
-    DefinitionImpl(const DefinitionImpl &d);
 
   private:
 
@@ -150,7 +153,11 @@ class DefinitionMixin : public Base
         const QCString &defFileName,int defLine,int defColumn,
         const QCString &name,const char *b=nullptr,const char *d=nullptr,
         bool isSymbol=TRUE) : m_impl(this,defFileName,defLine,defColumn,name,b,d,isSymbol) {}
-    ~DefinitionMixin() = default;
+    DefinitionMixin(const DefinitionMixin &) = default;
+    DefinitionMixin &operator=(const DefinitionMixin &) = default;
+    DefinitionMixin(DefinitionMixin &&) = delete;
+    DefinitionMixin &operator=(DefinitionMixin &&) = delete;
+   ~DefinitionMixin() = default;
 
     bool isAlias() const override { return FALSE; }
 
@@ -286,10 +293,6 @@ class DefinitionMixin : public Base
     QCString _symbolName() const override
     { return m_impl._symbolName(); }
 
-  protected:
-
-    DefinitionMixin(const DefinitionMixin &def) = default;
-
   private:
     Definition *toDefinition_() override { return this; }
     DefinitionMutable *toDefinitionMutable_() override { return this; }
@@ -303,6 +306,8 @@ class DefinitionAliasImpl
   public:
     DefinitionAliasImpl(Definition *def,const Definition *scope,const Definition *alias);
     virtual ~DefinitionAliasImpl();
+    NON_COPYABLE(DefinitionAliasImpl)
+
     void init();
     void deinit();
     const QCString &name() const;
@@ -321,11 +326,12 @@ class DefinitionAliasMixin : public Base
   public:
     DefinitionAliasMixin(const Definition *scope,const Definition *alias)
       : m_impl(this,scope,alias), m_scope(scope), m_alias(alias) {}
+    virtual ~DefinitionAliasMixin() = default;
+    NON_COPYABLE(DefinitionAliasMixin)
 
     void init() { m_impl.init(); }
     void deinit() { m_impl.deinit(); }
 
-    virtual ~DefinitionAliasMixin() = default;
 
     bool isAlias() const override { return TRUE; }