complete InterferenceItems' serialization

GUI/Model/Sample/InterferenceItems.cpp

@@ -82,6 +82,15 @@ SelectionDescriptor<FTDecayFunction1DItem*> Interference1DLatticeItem::decayFunc
     return m_decayFunction;
 }
 
+void Interference1DLatticeItem::serialize(Serializer& s)
+{
+    s.assertVersion(0);
+    s.rw(m_positionVariance);
+    s.rw(m_length);
+    s.rw(m_rotationAngle);
+    s.rw<FTDecayFunction1DItemCatalog>(m_decayFunction);
+}
+
 // --------------------------------------------------------------------------------------------- //
 
 SelectionDescriptor<Lattice2DItem*> Interference2DAbstractLatticeItem::latticeType() const
@@ -132,6 +141,15 @@ std::unique_ptr<IInterference> Interference2DLatticeItem::createInterference() c
     return std::unique_ptr<IInterference>(result.release());
 }
 
+void Interference2DLatticeItem::serialize(Serializer& s)
+{
+    s.assertVersion(0);
+    s.rw(m_positionVariance);
+    s.rw("integrate", m_xiIntegration);
+    s.rw<Lattice2DItemCatalog>(m_latticeType);
+    s.rw<FTDecayFunction2DItemCatalog>(m_decayFunction);
+}
+
 void Interference2DLatticeItem::setDecayFunctionType(FTDecayFunction2DItem* p)
 {
     m_decayFunction.set(p);
@@ -175,6 +193,19 @@ std::unique_ptr<IInterference> Interference2DParaCrystalItem::createInterference
     return std::unique_ptr<IInterference>(result.release());
 }
 
+void Interference2DParaCrystalItem::serialize(Serializer& s)
+{
+    s.assertVersion(0);
+    s.rw(m_positionVariance);
+    s.rw("integrate", m_xiIntegration);
+    s.rw<Lattice2DItemCatalog>(m_latticeType);
+    s.rw(m_dampingLength);
+    s.rw(m_domainSize1);
+    s.rw(m_domainSize2);
+    s.rw<FTDistribution2DItemCatalog>(m_pdf1);
+    s.rw<FTDistribution2DItemCatalog>(m_pdf2);
+}
+
 DoubleDescriptor Interference2DParaCrystalItem::dampingLength() const
 {
     return m_dampingLength;
@@ -250,6 +281,16 @@ std::unique_ptr<IInterference> InterferenceFinite2DLatticeItem::createInterferen
     return std::unique_ptr<IInterference>(result.release());
 }
 
+void InterferenceFinite2DLatticeItem::serialize(Serializer& s)
+{
+    s.assertVersion(0);
+    s.rw(m_positionVariance);
+    s.rw("integrate", m_xiIntegration);
+    s.rw<Lattice2DItemCatalog>(m_latticeType);
+    s.rw(m_domainSize1);
+    s.rw(m_domainSize2);
+}
+
 UIntDescriptor InterferenceFinite2DLatticeItem::domainSize1()
 {
     return m_domainSize1;
@@ -286,6 +327,14 @@ std::unique_ptr<IInterference> InterferenceHardDiskItem::createInterference() co
     return std::unique_ptr<IInterference>(result.release());
 }
 
+void InterferenceHardDiskItem::serialize(Serializer& s)
+{
+    s.assertVersion(0);
+    s.rw(m_positionVariance);
+    s.rw(m_radius);
+    s.rw(m_density);
+}
+
 DoubleDescriptor InterferenceHardDiskItem::density() const
 {
     return m_density;
@@ -324,6 +373,17 @@ std::unique_ptr<IInterference> InterferenceRadialParaCrystalItem::createInterfer
     return std::unique_ptr<IInterference>(result.release());
 }
 
+void InterferenceRadialParaCrystalItem::serialize(Serializer& s)
+{
+    s.assertVersion(0);
+    s.rw(m_positionVariance);
+    s.rw(m_peakDistance);
+    s.rw(m_dampingLength);
+    s.rw(m_domainSize);
+    s.rw(m_kappa);
+    s.rw<FTDistribution1DItemCatalog>(m_pdf);
+}
+
 DoubleDescriptor InterferenceRadialParaCrystalItem::peakDistance() const
 {
     return m_peakDistance;

GUI/Model/Sample/InterferenceItems.h

@@ -30,23 +30,24 @@ class InterferenceItem {
 public:
     virtual ~InterferenceItem() = default;
     virtual std::unique_ptr<IInterference> createInterference() const = 0;
+    virtual void serialize(Serializer& s) = 0;
 
     DoubleDescriptor positionVariance() const;
 
-    virtual void serialize(Serializer& s);
-
 protected:
     InterferenceItem();
 
-private:
     DoubleProperty m_positionVariance;
 };
 
+// ------------------------------------------------------------------------------------------------
+
 class Interference1DLatticeItem : public InterferenceItem {
 public:
     Interference1DLatticeItem();
 
     std::unique_ptr<IInterference> createInterference() const override;
+    void serialize(Serializer& s) override;
 
     DoubleDescriptor length() const;
     DoubleDescriptor rotationAngle() const;
@@ -60,6 +61,8 @@ private:
     SelectionProperty<FTDecayFunction1DItem*> m_decayFunction;
 };
 
+// ------------------------------------------------------------------------------------------------
+
 class Interference2DAbstractLatticeItem : public InterferenceItem {
 public:
     SelectionDescriptor<Lattice2DItem*> latticeType() const;
@@ -71,14 +74,17 @@ public:
 protected:
     explicit Interference2DAbstractLatticeItem(bool xiIntegration);
 
-    bool m_xiIntegration; // #baMigration serialize
+    bool m_xiIntegration;
     SelectionProperty<Lattice2DItem*> m_latticeType;
 };
 
+// ------------------------------------------------------------------------------------------------
+
 class Interference2DLatticeItem : public Interference2DAbstractLatticeItem {
 public:
     Interference2DLatticeItem();
     std::unique_ptr<IInterference> createInterference() const override;
+    void serialize(Serializer& s) override;
 
     void setDecayFunctionType(FTDecayFunction2DItem* p);
     SelectionDescriptor<FTDecayFunction2DItem*> decayFunction() const;
@@ -87,10 +93,13 @@ protected:
     SelectionProperty<FTDecayFunction2DItem*> m_decayFunction;
 };
 
+// ------------------------------------------------------------------------------------------------
+
 class Interference2DParaCrystalItem : public Interference2DAbstractLatticeItem {
 public:
     Interference2DParaCrystalItem();
     std::unique_ptr<IInterference> createInterference() const override;
+    void serialize(Serializer& s) override;
 
     DoubleDescriptor dampingLength() const;
     void setDampingLength(double dampingLength);
@@ -114,10 +123,13 @@ private:
     SelectionProperty<FTDistribution2DItem*> m_pdf2;
 };
 
+// ------------------------------------------------------------------------------------------------
+
 class InterferenceFinite2DLatticeItem : public Interference2DAbstractLatticeItem {
 public:
     InterferenceFinite2DLatticeItem();
     std::unique_ptr<IInterference> createInterference() const override;
+    void serialize(Serializer& s) override;
 
     UIntDescriptor domainSize1();
     void setDomainSize1(unsigned int domain_size1);
@@ -129,10 +141,13 @@ private:
     UIntProperty m_domainSize2;
 };
 
+// ------------------------------------------------------------------------------------------------
+
 class InterferenceHardDiskItem : public InterferenceItem {
 public:
     InterferenceHardDiskItem();
     std::unique_ptr<IInterference> createInterference() const override;
+    void serialize(Serializer& s) override;
 
     DoubleDescriptor radius() const;
     DoubleDescriptor density() const;
@@ -142,10 +157,13 @@ private:
     DoubleProperty m_density;
 };
 
+// ------------------------------------------------------------------------------------------------
+
 class InterferenceRadialParaCrystalItem : public InterferenceItem {
 public:
     InterferenceRadialParaCrystalItem();
     std::unique_ptr<IInterference> createInterference() const override;
+    void serialize(Serializer& s) override;
 
     DoubleDescriptor peakDistance() const;
     DoubleDescriptor dampingLength() const;