Boilerplate for handling PBC in restraints. [ci skip]

Author: lohedges

corelib/src/libs/SireMM/anglerestraints.cpp

@@ -227,11 +227,11 @@ static const RegisterMetaType<AngleRestraints> r_angrests;
 
 QDataStream &operator<<(QDataStream &ds, const AngleRestraints &angrests)
 {
-    writeHeader(ds, r_angrests, 1);
+    writeHeader(ds, r_angrests, 2);
 
     SharedDataStream sds(ds);
 
-    sds << angrests.r
+    sds << angrests.r << angrests.use_pbc
         << static_cast<const Restraints &>(angrests);
 
     return ds;
@@ -249,8 +249,15 @@ QDataStream &operator>>(QDataStream &ds, AngleRestraints &angrests)
         sds >> angrests.r >>
             static_cast<Restraints &>(angrests);
     }
+    else if (v == 2)
+    {
+        SharedDataStream sds(ds);
+
+        sds >> angrests.r >> angrests.use_pbc
+            >> static_cast<Restraints &>(angrests);
+    }
     else
-        throw version_error(v, "1", r_angrests, CODELOC);
+        throw version_error(v, "1,2", r_angrests, CODELOC);
 
     return ds;
 }
@@ -303,7 +310,7 @@ AngleRestraints::AngleRestraints(const QString &name,
 }
 
 AngleRestraints::AngleRestraints(const AngleRestraints &other)
-    : ConcreteProperty<AngleRestraints, Restraints>(other), r(other.r)
+    : ConcreteProperty<AngleRestraints, Restraints>(other), r(other.r), use_pbc(other.use_pbc)
 {
 }
 
@@ -318,14 +325,15 @@ AngleRestraints &AngleRestraints::operator=(const AngleRestraints &other)
     {
         Restraints::operator=(other);
         r = other.r;
+        use_pbc = other.use_pbc;
     }
 
     return *this;
 }
 
 bool AngleRestraints::operator==(const AngleRestraints &other) const
 {
-    return r == other.r and Restraints::operator==(other);
+    return r == other.r and Restraints::operator==(other) and use_pbc == other.use_pbc;
 }
 
 bool AngleRestraints::operator!=(const AngleRestraints &other) const
@@ -379,9 +387,10 @@ QString AngleRestraints::toString() const
         }
     }
 
-    return QObject::tr("AngleRestraints( name=%1, size=%2\n%3\n )")
+    return QObject::tr("AngleRestraints( name=%1, size=%2, use_pbc=%3\n%4\n )")
         .arg(this->name())
         .arg(n)
+        .arg(this->use_pbc ? "true" : "false")
         .arg(parts.join("\n"));
 }
 
@@ -477,3 +486,15 @@ AngleRestraints AngleRestraints::operator+(const AngleRestraints &restraints) co
     ret += restraints;
     return *this;
 }
+
+/** Set whether or not periodic boundary conditions are to be used */
+void AngleRestraints::setUsesPeriodicBoundaryConditions(bool use_pbc)
+{
+    this->use_pbc = use_pbc;
+}
+
+/** Return whether or not periodic boundary conditions are to be used */
+bool AngleRestraints::getUsesPeriodicBoundaryConditions() const
+{
+    return this->use_pbc;
+}

corelib/src/libs/SireMM/anglerestraints.h

@@ -161,9 +161,15 @@ namespace SireMM
         AngleRestraints operator+(const AngleRestraint &restraint) const;
         AngleRestraints operator+(const AngleRestraints &restraints) const;
 
+        void setUsesPeriodicBoundaryConditions(bool use_pbc);
+        bool getUsesPeriodicBoundaryConditions() const;
+
     private:
         /** List of restraints */
         QList<AngleRestraint> r;
+
+        /** Whether the restraints use periodic boundary conditions */
+        bool use_pbc = false;
     };
 }
 

corelib/src/libs/SireMM/bondrestraints.cpp

@@ -350,11 +350,11 @@ static const RegisterMetaType<BondRestraints> r_bndrests;
 
 QDataStream &operator<<(QDataStream &ds, const BondRestraints &bndrests)
 {
-    writeHeader(ds, r_bndrests, 1);
+    writeHeader(ds, r_bndrests, 2);
 
     SharedDataStream sds(ds);
 
-    sds << bndrests.r
+    sds << bndrests.r << bndrests.use_pbc
         << static_cast<const Restraints &>(bndrests);
 
     return ds;
@@ -370,8 +370,15 @@ QDataStream &operator>>(QDataStream &ds, BondRestraints &bndrests)
 
         sds >> bndrests.r >> static_cast<Restraints &>(bndrests);
     }
+    else if (v == 2)
+    {
+        SharedDataStream sds(ds);
+
+        sds >> bndrests.r >> bndrests.use_pbc
+            >> static_cast<Restraints &>(bndrests);
+    }
     else
-        throw version_error(v, "1", r_bndrests, CODELOC);
+        throw version_error(v, "1,2", r_bndrests, CODELOC);
 
     return ds;
 }
@@ -435,13 +442,14 @@ BondRestraints::~BondRestraints()
 BondRestraints &BondRestraints::operator=(const BondRestraints &other)
 {
     r = other.r;
+    use_pbc = other.use_pbc;
     Restraints::operator=(other);
     return *this;
 }
 
 bool BondRestraints::operator==(const BondRestraints &other) const
 {
-    return r == other.r and Restraints::operator==(other);
+    return r == other.r and Restraints::operator==(other) and use_pbc == other.use_pbc;
 }
 
 bool BondRestraints::operator!=(const BondRestraints &other) const
@@ -495,7 +503,11 @@ QString BondRestraints::toString() const
         }
     }
 
-    return QObject::tr("BondRestraints( name=%1, size=%2\n%3\n)").arg(this->name()).arg(n).arg(parts.join("\n"));
+    return QObject::tr("BondRestraints( name=%1, size=%2, use_pbc=$3\n%4\n)")
+            .arg(this->name())
+            .arg(n)
+            .arg(this->use_pbc ? "true" : "false")
+            .arg(parts.join("\n"));
 }
 
 /** Return whether or not this is empty */
@@ -678,3 +690,15 @@ BondRestraints BondRestraints::operator+(const BondRestraints &restraints) const
     ret += restraints;
     return *this;
 }
+
+/** Set whether or not periodic boundary conditions are to be used */
+void BondRestraints::setUsesPeriodicBoundaryConditions(bool use_pbc)
+{
+    this->use_pbc = use_pbc;
+}
+
+/** Return whether or not periodic boundary conditions are to be used */
+bool BondRestraints::getUsesPeriodicBoundaryConditions() const
+{
+    return this->use_pbc;
+}

corelib/src/libs/SireMM/bondrestraints.h

@@ -191,9 +191,15 @@ namespace SireMM
         BondRestraints operator+(const BondRestraint &restraint) const;
         BondRestraints operator+(const BondRestraints &restraints) const;
 
+        void setUsesPeriodicBoundaryConditions(bool use_pbc);
+        bool getUsesPeriodicBoundaryConditions() const;
+
     private:
         /** The actual list of restraints*/
         QList<BondRestraint> r;
+
+        /** Whether the restraints use periodic boundary conditions */
+        bool use_pbc = false;
     };
 
 }

corelib/src/libs/SireMM/boreschrestraints.cpp

@@ -343,11 +343,11 @@ static const RegisterMetaType<BoreschRestraints> r_borrests;
 
 QDataStream &operator<<(QDataStream &ds, const BoreschRestraints &borrests)
 {
-    writeHeader(ds, r_borrests, 1);
+    writeHeader(ds, r_borrests, 2);
 
     SharedDataStream sds(ds);
 
-    sds << borrests.r
+    sds << borrests.r << borrests.use_pbc
         << static_cast<const Restraints &>(borrests);
 
     return ds;
@@ -363,8 +363,15 @@ QDataStream &operator>>(QDataStream &ds, BoreschRestraints &borrests)
 
         sds >> borrests.r >> static_cast<Restraints &>(borrests);
     }
+    else if (v == 2)
+    {
+        SharedDataStream sds(ds);
+
+        sds >> borrests.r >> borrests.use_pbc
+            >> static_cast<Restraints &>(borrests);
+    }
     else
-        throw version_error(v, "1", r_borrests, CODELOC);
+        throw version_error(v, "1,2", r_borrests, CODELOC);
 
     return ds;
 }
@@ -417,7 +424,7 @@ BoreschRestraints::BoreschRestraints(const QString &name,
 }
 
 BoreschRestraints::BoreschRestraints(const BoreschRestraints &other)
-    : ConcreteProperty<BoreschRestraints, Restraints>(other), r(other.r)
+    : ConcreteProperty<BoreschRestraints, Restraints>(other), r(other.r), use_pbc(other.use_pbc)
 {
 }
 
@@ -428,13 +435,15 @@ BoreschRestraints::~BoreschRestraints()
 BoreschRestraints &BoreschRestraints::operator=(const BoreschRestraints &other)
 {
     r = other.r;
+    use_pbc = other.use_pbc;
     Restraints::operator=(other);
     return *this;
 }
 
 bool BoreschRestraints::operator==(const BoreschRestraints &other) const
 {
-    return r == other.r and Restraints::operator==(other);
+    return r == other.r and Restraints::operator==(other) and
+           use_pbc == other.use_pbc;
 }
 
 bool BoreschRestraints::operator!=(const BoreschRestraints &other) const
@@ -488,7 +497,11 @@ QString BoreschRestraints::toString() const
         }
     }
 
-    return QObject::tr("BoreschRestraints( name=%1, size=%2\n%3\n)").arg(this->name()).arg(n).arg(parts.join("\n"));
+    return QObject::tr("BoreschRestraints( name=%1, size=%2, use_pbc=%3\n%4\n)")
+            .arg(this->name())
+            .arg(n)
+            .arg(this->use_pbc ? "true" : "false")
+            .arg(parts.join("\n"));
 }
 
 /** Return whether or not this is empty */
@@ -583,3 +596,15 @@ BoreschRestraints BoreschRestraints::operator+(const BoreschRestraints &restrain
     ret += restraints;
     return *this;
 }
+
+/** Set whether or not periodic boundary conditions are to be used */
+void BoreschRestraints::setUsesPeriodicBoundaryConditions(bool use_pbc)
+{
+    this->use_pbc = use_pbc;
+}
+
+/** Return whether or not periodic boundary conditions are to be used */
+bool BoreschRestraints::getUsesPeriodicBoundaryConditions() const
+{
+    return this->use_pbc;
+}

corelib/src/libs/SireMM/boreschrestraints.h

@@ -194,9 +194,15 @@ namespace SireMM
         BoreschRestraints operator+(const BoreschRestraint &restraint) const;
         BoreschRestraints operator+(const BoreschRestraints &restraints) const;
 
+        void setUsesPeriodicBoundaryConditions(bool use_pbc);
+        bool getUsesPeriodicBoundaryConditions() const;
+
     private:
         /** The actual list of restraints*/
         QList<BoreschRestraint> r;
+
+        /** Whether the restraints use periodic boundary conditions */
+        bool use_pbc = false;
     };
 
 }

corelib/src/libs/SireMM/dihedralrestraints.cpp

@@ -225,11 +225,11 @@ static const RegisterMetaType<DihedralRestraints> r_dihrests;
 
 QDataStream &operator<<(QDataStream &ds, const DihedralRestraints &dihrests)
 {
-    writeHeader(ds, r_dihrests, 1);
+    writeHeader(ds, r_dihrests, 2);
 
     SharedDataStream sds(ds);
 
-    sds << dihrests.r
+    sds << dihrests.r << dihrests.use_pbc
         << static_cast<const Restraints &>(dihrests);
 
     return ds;
@@ -247,8 +247,15 @@ QDataStream &operator>>(QDataStream &ds, DihedralRestraints &dihrests)
         sds >> dihrests.r >>
             static_cast<Restraints &>(dihrests);
     }
+    else if (v == 2)
+    {
+        SharedDataStream sds(ds);
+
+        sds >> dihrests.r >> dihrests.use_pbc
+            >> static_cast<Restraints &>(dihrests);
+    }
     else
-        throw version_error(v, "1", r_dihrests, CODELOC);
+        throw version_error(v, "1,2", r_dihrests, CODELOC);
 
     return ds;
 }
@@ -301,7 +308,7 @@ DihedralRestraints::DihedralRestraints(const QString &name,
 }
 
 DihedralRestraints::DihedralRestraints(const DihedralRestraints &other)
-    : ConcreteProperty<DihedralRestraints, Restraints>(other), r(other.r)
+    : ConcreteProperty<DihedralRestraints, Restraints>(other), r(other.r), use_pbc(other.use_pbc)
 {
 }
 
@@ -316,14 +323,16 @@ DihedralRestraints &DihedralRestraints::operator=(const DihedralRestraints &othe
     {
         Restraints::operator=(other);
         r = other.r;
+        use_pbc = other.use_pbc;
     }
 
     return *this;
 }
 
 bool DihedralRestraints::operator==(const DihedralRestraints &other) const
 {
-    return r == other.r and Restraints::operator==(other);
+    return r == other.r and Restraints::operator==(other) and
+           use_pbc == other.use_pbc;
 }
 
 bool DihedralRestraints::operator!=(const DihedralRestraints &other) const
@@ -377,9 +386,10 @@ QString DihedralRestraints::toString() const
         }
     }
 
-    return QObject::tr("DihedralRestraints( name=%1, size=%2\n%3\n )")
+    return QObject::tr("DihedralRestraints( name=%1, size=%2, use_pbc=%3\n%4\n )")
         .arg(this->name())
         .arg(n)
+        .arg(this->use_pbc ? "true" : "false")
         .arg(parts.join("\n"));
 }
 
@@ -474,4 +484,16 @@ DihedralRestraints DihedralRestraints::operator+(const DihedralRestraints &restr
     DihedralRestraints ret(*this);
     ret += restraints;
     return *this;
-}
+}
+
+/** Set whether or not periodic boundary conditions are to be used */
+void DihedralRestraints::setUsesPeriodicBoundaryConditions(bool use_pbc)
+{
+    this->use_pbc = use_pbc;
+}
+
+/** Return whether or not periodic boundary conditions are to be used */
+bool DihedralRestraints::getUsesPeriodicBoundaryConditions() const
+{
+    return this->use_pbc;
+}