updated for Lemma 0.2.0

CMakeLists.txt

 # Configure Merlin 
 set(MERLIN_VERSION_MAJOR "0")
 set(MERLIN_VERSION_MINOR "0")
-set(MERLIN_VERSION_PATCH "1")
+set(MERLIN_VERSION_PATCH "2")
 set(MERLIN_VERSION "\"${MERLIN_VERSION_MAJOR}.${MERLIN_VERSION_MINOR}.${MERLIN_VERSION_PATCH}\"")
 set(MERLIN_VERSION_NOQUOTES "${MERLIN_VERSION_MAJOR}.${MERLIN_VERSION_MINOR}.${MERLIN_VERSION_PATCH}")
 

include/Coupling.h

 
         friend std::ostream &operator<<(std::ostream &stream, const Coupling &ob);
 
-        protected:
-        /*
-         *  This key is used to lock the constructor. It is protected so that inhereted
-         *  classes also have the key to contruct their base class.
-         */
-        struct ctor_key {};
-
         public:
 
         // ====================  LIFECYCLE     =======================

include/DataFID.h

          *  This key is used to lock the constructor. It is protected so that inhereted
          *  classes also have the key to contruct their base class.
          */
-        struct ctor_key {};
-
         public:
 
         // ====================  LIFECYCLE     =======================

include/ForwardFID.h

 
         friend std::ostream &operator<<(std::ostream &stream, const ForwardFID &ob);
 
-        protected:
-        /*
-         *  This key is used to lock the constructor. It is protected so that inhereted
-         *  classes also have the key to contruct their base class.
-         */
-        struct ctor_key {};
-
         public:
 
         // ====================  LIFECYCLE     =======================

include/KernelV0.h

          *  This key is used to lock the constructor. It is protected so that inhereted
          *  classes also have the key to contruct their base class.
          */
-        struct ctor_key {};
 
         public:
 

include/LayeredEarthMR.h

 
         friend std::ostream &operator<<(std::ostream &stream, const LayeredEarthMR &ob);
 
-        protected:
-        /*
-         *  This key is used to lock the constructor. It is protected so that inhereted
-         *  classes also have the key to contruct their base class.
-         */
-        struct ctor_key {};
-
         public:
 
         // ====================  LIFECYCLE     =======================

include/LoopInteractions.h

             return stream;
         }
 
-        protected:
-        /*
-         *  This key is used to lock the constructor. It is protected so that inhereted
-         *  classes also have the key to contruct their base class.
-         */
-        struct ctor_key {};
-
         public:
 
         // ====================  LIFECYCLE     =======================
          *       in c++-17, this curiosity may be resolved.
          * @see LoopInteractions::NewSP
          */
-        explicit LoopInteractions ( const ctor_key& ) : LemmaObject () { }
+        explicit LoopInteractions ( const ctor_key& key ) : LemmaObject (key) { }
 
         /**
          * DeSerializing constructor.
          *       in c++-17, this curiosity may be resolved.
          * @see LoopInteractions::DeSerialize
          */
-        LoopInteractions ( const YAML::Node& node, const ctor_key& ) : LemmaObject(node) { }
+        LoopInteractions ( const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) { }
 
         /**
          * Default destructor.

include/MerlinObject.h

 
         friend std::ostream &operator<<(std::ostream &stream, const MerlinObject &ob);
 
-        protected:
-        /*
-         *  This key is used to lock the constructor. It is protected so that inhereted
-         *  classes also have the key to contruct their base class.
-         */
-
         public:
 
         // ====================  LIFECYCLE     =======================
          *       in c++-17, this curiosity may be resolved.
          * @see MerlinObject::NewSP
          */
-        explicit MerlinObject ( );
+        explicit MerlinObject ( const ctor_key& key );
 
         /**
          * DeSerializing constructor.
          *       in c++-17, this curiosity may be resolved.
          * @see MerlinObject::DeSerialize
          */
-        MerlinObject ( const YAML::Node& node );
+        MerlinObject ( const YAML::Node& node, const ctor_key& key );
 
         /**
          * Default destructor.

src/Coupling.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const Coupling &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n"; // End of doc ---
         return stream;
     }
 
     //      Method:  Coupling
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    Coupling::Coupling (const ctor_key&) : LemmaObject( ) {
+    Coupling::Coupling (const ctor_key& key) : LemmaObject( key ) {
 
     }  // -----  end of method Coupling::Coupling  (constructor)  -----
 
     //      Method:  Coupling
     // Description:  DeSerializing constructor (locked)
     //--------------------------------------------------------------------------------------
-    Coupling::Coupling (const YAML::Node& node, const ctor_key&) : LemmaObject(node) {
+    Coupling::Coupling (const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
 
     }  // -----  end of method Coupling::Coupling  (constructor)  -----
 

src/DataFID.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const DataFID &ob) {
-        stream <<"%YAML 1.2\n---\n" << ob.Serialize()  << "\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     //      Method:  DataFID
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    DataFID::DataFID (const ctor_key&) : MerlinObject( ) {
+    DataFID::DataFID (const ctor_key& key) : MerlinObject( key ) {
 
     }  // -----  end of method DataFID::DataFID  (constructor)  -----
 
     //      Method:  DataFID
     // Description:  DeSerializing constructor (locked)
     //--------------------------------------------------------------------------------------
-    DataFID::DataFID (const YAML::Node& node, const ctor_key&) : MerlinObject(node) {
+    DataFID::DataFID (const YAML::Node& node, const ctor_key& key) : MerlinObject(node, key) {
 
     }  // -----  end of method DataFID::DataFID  (constructor)  -----
 

src/ForwardFID.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const ForwardFID &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     //      Method:  ForwardFID
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    ForwardFID::ForwardFID (const ctor_key&) : MerlinObject( ) {
+    ForwardFID::ForwardFID (const ctor_key& key) : MerlinObject( key ) {
 
     }  // -----  end of method ForwardFID::ForwardFID  (constructor)  -----
 
     //      Method:  ForwardFID
     // Description:  DeSerializing constructor (locked)
     //--------------------------------------------------------------------------------------
-    ForwardFID::ForwardFID (const YAML::Node& node, const ctor_key&) : MerlinObject(node) {
+    ForwardFID::ForwardFID (const YAML::Node& node, const ctor_key& key) : MerlinObject(node, key) {
 
     }  // -----  end of method ForwardFID::ForwardFID  (constructor)  -----
 

src/KernelV0.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const KernelV0 &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n"; // End of doc ---
         return stream;
     }
 
     //      Method:  KernelV0
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    KernelV0::KernelV0 (const ctor_key&) : LemmaObject( ) {
+    KernelV0::KernelV0 (const ctor_key& key) : LemmaObject( key ) {
 
     }  // -----  end of method KernelV0::KernelV0  (constructor)  -----
 
     //      Method:  KernelV0
     // Description:  DeSerializing constructor (locked)
     //--------------------------------------------------------------------------------------
-    KernelV0::KernelV0 (const YAML::Node& node, const ctor_key&) : LemmaObject(node) {
-        std::cout << "Deserializing Kernel" << std::endl;
+    KernelV0::KernelV0 (const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
         //node["PulseType"] = "FID";
         Larmor = node["Larmor"].as<Real>();
         Temperature = node["Temperature"].as<Real>();

src/LayeredEarthMR.cpp

     //      Method:  LayeredEarthMR
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    LayeredEarthMR::LayeredEarthMR (const ctor_key&) : LayeredEarth( ) {
+    LayeredEarthMR::LayeredEarthMR (const ctor_key& key) : LayeredEarth( key ) {
 
     }  // -----  end of method LayeredEarthMR::LayeredEarthMR  (constructor)  -----
 
     //      Method:  LayeredEarthMR
     // Description:  DeSerializing constructor (locked)
     //--------------------------------------------------------------------------------------
-    LayeredEarthMR::LayeredEarthMR (const YAML::Node& node, const ctor_key&) : LayeredEarth(node) {
+    LayeredEarthMR::LayeredEarthMR (const YAML::Node& node, const ctor_key& key) : LayeredEarth(node, key) {
         Interfaces = node["Interfaces"].as<VectorXr>();
         T2StarBins = node["T2StarBins"].as<VectorXr>();
         T2StarBinEdges = node["T2StarBinEdges"].as<VectorXr>();

src/MerlinObject.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const MerlinObject &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n"; // End of doc ---
         return stream;
     }
 
     //      Method:  MerlinObject
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    MerlinObject::MerlinObject ( ) : LemmaObject( ) {
+    MerlinObject::MerlinObject ( const ctor_key& key ) : LemmaObject( key ) {
 
     }  // -----  end of method MerlinObject::MerlinObject  (constructor)  -----
 
     //      Method:  MerlinObject
     // Description:  DeSerializing constructor (locked)
     //--------------------------------------------------------------------------------------
-    MerlinObject::MerlinObject (const YAML::Node& node ) : LemmaObject(node) {
+    MerlinObject::MerlinObject (const YAML::Node& node, const ctor_key& key ) : LemmaObject(node, key) {
 
     }  // -----  end of method MerlinObject::MerlinObject  (constructor)  -----
 
     // Description:  public constructor returing a shared_ptr
     //--------------------------------------------------------------------------------------
     std::shared_ptr< MerlinObject >  MerlinObject::NewSP() {
-        return std::make_shared< MerlinObject >( );
+        return std::make_shared< MerlinObject >( ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
         if (node.Tag() !=  "MerlinObject" ) {
             throw  DeSerializeTypeMismatch( "MerlinObject", node.Tag());
         }
-        return std::make_shared< MerlinObject > ( node );
+        return std::make_shared< MerlinObject > ( node, ctor_key() );
     }		// -----  end of method MerlinObject::DeSerialize  -----
 
 } // ----  end of namespace Lemma  ----