#851 make molecule sgroups movable

api/c/indigo/src/indigo_molecule.cpp

@@ -3174,8 +3174,8 @@ CEXPORT int indigoAddSGroupAttachmentPoint(int sgroup, int aidx, int lvidx, cons
     INDIGO_BEGIN
     {
         Superatom& sup = IndigoSuperatom::cast(self.getObject(sgroup)).get();
-        int ap_idx = sup.attachment_points.add();
-        Superatom::_AttachmentPoint& ap = sup.attachment_points.at(ap_idx);
+        int ap_idx = sup.getAttachmentPoints().add();
+        Superatom::_AttachmentPoint& ap = sup.getAttachmentPoints().at(ap_idx);
         ap.aidx = aidx;
         ap.lvidx = lvidx;
         ap.apid.readString(apid, true);
@@ -3189,7 +3189,7 @@ CEXPORT int indigoDeleteSGroupAttachmentPoint(int sgroup, int ap_idx)
     INDIGO_BEGIN
     {
         Superatom& sup = IndigoSuperatom::cast(self.getObject(sgroup)).get();
-        sup.attachment_points.remove(ap_idx);
+        sup.getAttachmentPoints().remove(ap_idx);
         return 1;
     }
     INDIGO_END(-1);

core/indigo-core/common/base_cpp/array.h

@@ -44,11 +44,9 @@ namespace indigo
         {
         }
 
-        Array(Array&& other) : _reserved(other._reserved), _length(other._length), _array(other._array)
+        Array(Array&& other) noexcept : Array()
         {
-            other._array = nullptr;
-            other._length = 0;
-            other._reserved = 0;
+            swap(other);
         }
 
         ~Array()
@@ -62,6 +60,12 @@ namespace indigo
             }
         }
 
+        Array& operator=(Array&& src) noexcept
+        {
+            swap(src);
+            return *this;
+        }
+
         void clear()
         {
             _length = 0;
@@ -358,7 +362,7 @@ namespace indigo
             _length = newsize;
         }
 
-        void swap(Array<T>& other)
+        void swap(Array<T>& other) noexcept
         {
             std::swap(_array, other._array);
             std::swap(_reserved, other._reserved);

core/indigo-core/common/base_cpp/string_pool.cpp

@@ -65,7 +65,7 @@ int StringPool::add(int size)
     return _add(0, size);
 }
 
-int StringPool::add(Array<char>& str)
+int StringPool::add(const Array<char>& str)
 {
     return _add(str.ptr(), str.size());
 }

core/indigo-core/common/base_cpp/string_pool.h

@@ -39,7 +39,7 @@ namespace indigo
         ~StringPool();
 
         int add(const char* str);
-        int add(Array<char>& str);
+        int add(const Array<char>& str);
         int add(int size);
         void remove(int idx);
         int size() const;

core/indigo-core/molecule/base_molecule.h

@@ -176,7 +176,7 @@ namespace indigo
         int getTemplateAtomAttachmentPoint(int atom_idx, int order);
         void getTemplateAtomAttachmentPointId(int atom_idx, int order, Array<char>& apid);
         int getTemplateAtomAttachmentPointsCount(int atom_idx);
-        int getTemplateAtomAttachmentPointById(int atom_idx, Array<char>& att_id);
+        int getTemplateAtomAttachmentPointById(int atom_idx, const Array<char>& att_id);
 
         void addAttachmentPoint(int order, int atom_index);
 

core/indigo-core/molecule/molecule_sgroups.h

@@ -19,6 +19,8 @@
 #ifndef __molecule_sgroups__
 #define __molecule_sgroups__
 
+#include <memory>
+
 #include "base_cpp/array.h"
 #include "base_cpp/obj_pool.h"
 #include "base_cpp/ptr_pool.h"
@@ -99,7 +101,13 @@ namespace indigo
         };
 
         SGroup();
-        virtual ~SGroup();
+        SGroup(const SGroup&) = delete;
+        SGroup(SGroup&&) noexcept = default;
+
+        virtual ~SGroup() = default;
+
+        SGroup& operator=(const SGroup&) = delete;
+        SGroup& operator=(SGroup&&) noexcept = default;
 
         int sgroup_type;    // group type, represnted with STY in Molfile format
         int sgroup_subtype; // group subtype, represnted with SST in Molfile format
@@ -116,16 +124,17 @@ namespace indigo
 
         static const char* typeToString(int sg_type);
         static int getType(const char* sg_type);
-
-    private:
-        SGroup(const SGroup&);
     };
 
     class DLLEXPORT DataSGroup : public SGroup
     {
     public:
         DataSGroup();
-        ~DataSGroup() override;
+        DataSGroup(const DataSGroup&) = delete;
+        DataSGroup(DataSGroup&&) noexcept = default;
+
+        DataSGroup& operator=(const DataSGroup&) = delete;
+        DataSGroup& operator=(DataSGroup&&) noexcept = default;
 
         Array<char> description; // SDT in Molfile format (filed units or format)
         Array<char> name;        // SDT in Molfile format (field name)
@@ -140,15 +149,17 @@ namespace indigo
         int num_chars; // number of characters
         int dasp_pos;
         char tag; // tag
-    private:
-        DataSGroup(const DataSGroup&);
     };
 
     class DLLEXPORT Superatom : public SGroup
     {
     public:
         Superatom();
-        ~Superatom() override;
+        Superatom(const Superatom&) = delete;
+        Superatom(Superatom&&) noexcept = default;
+
+        Superatom& operator=(const Superatom&) = delete;
+        Superatom& operator=(Superatom&&) noexcept = default;
 
         Array<char> subscript;     // SMT in Molfile format
         Array<char> sa_class;      // SCL in Molfile format
@@ -163,7 +174,9 @@ namespace indigo
             int lvidx;
             Array<char> apid;
         };
-        ObjPool<_AttachmentPoint> attachment_points; // SAP in Molfile format
+        const ObjPool<_AttachmentPoint>& getAttachmentPoints() const;
+        ObjPool<_AttachmentPoint>& getAttachmentPoints();
+        bool hasAttachmentPoints() const;
 
         struct _BondConnection
         {
@@ -173,40 +186,47 @@ namespace indigo
         Array<_BondConnection> bond_connections; // SBV in Molfile format
 
     private:
-        Superatom(const Superatom&);
+        mutable std::unique_ptr<ObjPool<_AttachmentPoint>> _attachment_points; // SAP in Molfile format
     };
 
     class DLLEXPORT RepeatingUnit : public SGroup
     {
     public:
         RepeatingUnit();
-        ~RepeatingUnit() override;
+        RepeatingUnit(const RepeatingUnit&) = delete;
+        RepeatingUnit(RepeatingUnit&&) noexcept = default;
+
+        RepeatingUnit& operator=(const RepeatingUnit&) = delete;
+        RepeatingUnit& operator=(RepeatingUnit&&) noexcept = default;
 
         int connectivity;
         Array<char> subscript; // SMT in Molfile format
-    private:
-        RepeatingUnit(const RepeatingUnit&);
     };
 
     class DLLEXPORT MultipleGroup : public SGroup
     {
     public:
         MultipleGroup();
-        ~MultipleGroup() override;
+        MultipleGroup(const MultipleGroup&) = delete;
+        MultipleGroup(MultipleGroup&&) noexcept = default;
+
+        MultipleGroup& operator=(const MultipleGroup&) = delete;
+        MultipleGroup& operator=(MultipleGroup&&) noexcept = default;
 
         Array<int> parent_atoms;
         int multiplier;
-
-    private:
-        MultipleGroup(const MultipleGroup&);
     };
 
     class Tree;
     class DLLEXPORT MoleculeSGroups
     {
     public:
         MoleculeSGroups();
-        ~MoleculeSGroups();
+        MoleculeSGroups(const MoleculeSGroups&) = delete;
+        MoleculeSGroups(MoleculeSGroups&&) noexcept = default;
+
+        MoleculeSGroups& operator=(const MoleculeSGroups&) = delete;
+        MoleculeSGroups& operator=(MoleculeSGroups&&) noexcept = default;
 
         DECL_ERROR;
 
@@ -248,7 +268,7 @@ namespace indigo
         void registerUnfoldedHydrogen(int idx, int new_h_idx);
 
     protected:
-        PtrPool<SGroup> _sgroups;
+        std::unique_ptr<PtrPool<SGroup>> _sgroups;
 
     private:
         int _findSGroupById(int id);