Remove explicitly deleted methods in Mutation classes

This commit removes the explicitly deleted move constructor, and
move and copy operators, in Mutation classes, as they are deleted
in the base class Mutation.h.

src/libaevol/mutation/Deletion.h

@@ -44,7 +44,7 @@ class Deletion : public Rearrangement {
   // ==========================================================================
   Deletion() = default; //< Default ctor
   Deletion(const Deletion&) = default; //< Copy ctor
-  Deletion(Deletion&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
   Deletion(int32_t pos1, int32_t pos2,
            int32_t length, int16_t align_score = -1);
 
@@ -58,11 +58,7 @@ class Deletion : public Rearrangement {
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  Deletion& operator=(const Deletion& other) = delete;
-
-  /// Move assignment
-  Deletion& operator=(Deletion&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods

src/libaevol/mutation/Duplication.h

@@ -46,7 +46,7 @@ class Duplication : public Rearrangement {
   // ==========================================================================
   Duplication() = default; //< Default ctor
   Duplication(const Duplication&) = default; //< Copy ctor
-  Duplication(Duplication&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
   Duplication(int32_t pos1, int32_t pos2, int32_t pos3, int32_t length, int16_t align_score = -1) :
                pos1_{pos1},  pos2_{pos2},  pos3_{pos3},length_{length}, align_score_{align_score} {}
 
@@ -60,11 +60,7 @@ class Duplication : public Rearrangement {
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  Duplication& operator=(const Duplication& other) = delete;
-
-  /// Move assignment
-  Duplication& operator=(Duplication&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods

src/libaevol/mutation/InsertionHT.h

@@ -48,7 +48,7 @@ class InsertionHT : public HorizontalTransfer {
   // ==========================================================================
   InsertionHT() = default; //< Default ctor
   InsertionHT(const InsertionHT&) = default; //< Copy ctor
-  InsertionHT(InsertionHT&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
   InsertionHT(VisAVis& donor_donor_align, VisAVis& exo_recv_align,
               int32_t length, char* seq, int32_t donor_id);
 
@@ -62,11 +62,7 @@ class InsertionHT : public HorizontalTransfer {
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  InsertionHT& operator=(const InsertionHT& other) = delete;
-
-  /// Move assignment
-  InsertionHT& operator=(InsertionHT&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods

src/libaevol/mutation/Inversion.h

@@ -47,7 +47,7 @@ class Inversion : public Rearrangement{
   // ==========================================================================
   Inversion() = default; //< Default ctor
   Inversion(const Inversion&) = default; //< Copy ctor
-  Inversion(Inversion&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
   Inversion(int32_t pos1, int32_t pos2,
             int32_t length, int16_t align_score = -1);
 
@@ -61,11 +61,7 @@ class Inversion : public Rearrangement{
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  Inversion& operator=(const Inversion& other) = delete;
-
-  /// Move assignment
-  Inversion& operator=(Inversion&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods

src/libaevol/mutation/PointMutation.h

@@ -48,7 +48,7 @@ class PointMutation : public LocalMutation {
   // ==========================================================================
   PointMutation() = default; //< Default ctor
   PointMutation(const PointMutation&) = default; //< Copy ctor
-  PointMutation(PointMutation&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
   PointMutation(int32_t pos);
 
   virtual Mutation* Clone() const override { return new PointMutation(*this); };
@@ -61,10 +61,7 @@ class PointMutation : public LocalMutation {
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  PointMutation& operator=(const PointMutation& other) = delete;
-  /// Move assignment
-  PointMutation& operator=(PointMutation&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods

src/libaevol/mutation/ReplacementHT.h

@@ -48,7 +48,7 @@ class ReplacementHT : public HorizontalTransfer {
   // ==========================================================================
   ReplacementHT() = default; //< Default ctor
   ReplacementHT(const ReplacementHT&) = default; //< Copy ctor
-  ReplacementHT(ReplacementHT&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
   ReplacementHT(const VisAVis& align1, const VisAVis& align2,
                 int32_t length, int32_t replaced_seq_length,
                 char* seq, int32_t donor_id);
@@ -63,11 +63,7 @@ class ReplacementHT : public HorizontalTransfer {
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  ReplacementHT& operator=(const ReplacementHT& other) = delete;
-
-  /// Move assignment
-  ReplacementHT& operator=(ReplacementHT&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods

src/libaevol/mutation/SmallDeletion.h

@@ -48,7 +48,7 @@ class SmallDeletion : public LocalMutation {
   // ==========================================================================
   SmallDeletion() = default; //< Default ctor
   SmallDeletion(const SmallDeletion&) = default; //< Copy ctor
-  SmallDeletion(SmallDeletion&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
   SmallDeletion(int32_t pos, int16_t length);
 
   virtual Mutation* Clone() const override { return new SmallDeletion(*this); };
@@ -61,11 +61,7 @@ class SmallDeletion : public LocalMutation {
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  SmallDeletion& operator=(const SmallDeletion& other) = delete;
-
-  /// Move assignment
-  SmallDeletion& operator=(SmallDeletion&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods

src/libaevol/mutation/SmallInsertion.h

@@ -48,7 +48,7 @@ class SmallInsertion : public LocalMutation {
   // ==========================================================================
   SmallInsertion() = default; //< Default ctor
   SmallInsertion(const SmallInsertion&); //< Copy ctor
-  SmallInsertion(SmallInsertion&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
   SmallInsertion(int32_t pos, int32_t length, const char* seq);
 
   virtual Mutation* Clone() const override { return new SmallInsertion(*this); };
@@ -61,11 +61,7 @@ class SmallInsertion : public LocalMutation {
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  SmallInsertion& operator=(const SmallInsertion& other) = delete;
-
-  /// Move assignment
-  SmallInsertion& operator=(SmallInsertion&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods

src/libaevol/mutation/Translocation.h

@@ -47,7 +47,7 @@ class Translocation : public Rearrangement {
   // ==========================================================================
   Translocation() = default; //< Default ctor
   Translocation(const Translocation&) = default; //< Copy ctor
-  Translocation(Translocation&&) = delete; //< Move ctor
+  // The move constructor is implicitly deleted.
 
   Translocation(int32_t pos1, int32_t pos2, int32_t pos3, int32_t pos4,
                 int32_t length,
@@ -64,11 +64,7 @@ class Translocation : public Rearrangement {
   // ==========================================================================
   //                                Operators
   // ==========================================================================
-  /// Copy assignment
-  Translocation& operator=(const Translocation& other) = delete;
-
-  /// Move assignment
-  Translocation& operator=(Translocation&& other) = delete;
+  // The copy and move operators are implicitly deleted.
 
   // ==========================================================================
   //                              Public Methods