reworking key

Modules/FDEM1D/include/LayeredEarthEMReader.h

 namespace Lemma {
 
     /**
-      \brief
-      \details
+      \brief Reads ASCII representation of LayeredEarth, similiar to UBC format.
+      \details Largely superceded by YAML serialisation, this class remains for legacy purposes.
      */
     class LayeredEarthEMReader : public LemmaObject {
 
 		friend std::ostream &operator<<(std::ostream &stream,
 			const LayeredEarthEMReader &ob);
 
-        friend std::ostream &operator<<(std::ostream &stream,
-                const LayeredEarthEMReader &ob);
-
         struct ctor_key{};
 
         public:
         // ====================  LIFECYCLE     =======================
 
         /**
-         * @copybrief LemmaObject::New()
-         * @copydetails LemmaObject::New()
+         * @copybrief LemmaObject::NewSP()
+         * @copydetails LemmaObject::NewSP()
          */
-        static LayeredEarthEMReader* New();
+        static std::shared_ptr<LayeredEarthEMReader> NewSP();
+
+        /** Default locked constructor, use New */
+        explicit LayeredEarthEMReader ( const ctor_key& );
+
+        /** Locked deserializing constructor. */
+			LayeredEarthEMReader ( const YAML::Node& node, const ctor_key& );
+
+        /** Default destructor */
+        virtual ~LayeredEarthEMReader ();
+
+        /** YAML Serializing method
+         */
+        YAML::Node Serialize() const;
 
         /**
-         *  @copybrief   LemmaObject::Delete()
-         *  @copydetails LemmaObject::Delete()
+         *   Constructs an object from a YAML::Node.
          */
-        void Delete();
+        static std::shared_ptr< LayeredEarthEMReader > DeSerialize(const YAML::Node& node);
 
         // ====================  OPERATORS     =======================
 
 
         // ====================  INQUIRY       =======================
 
+        /** Returns the name of the underlying class, similiar to Python's type */
+        virtual std::string GetName() const {
+            return this->CName;
+        }
+
         protected:
 
         // ====================  LIFECYCLE     =======================
 
-        /** Default protected constructor, use New */
-        LayeredEarthEMReader (const std::string& name);
-
-        /** Default protected destructor, use Delete */
-        ~LayeredEarthEMReader ();
-
-        /**
-         *  @copybrief   LemmaObject::Release()
-         *  @copydetails LemmaObject::Release()
-         */
-        void Release();
-
         private:
 
         // ====================  DATA MEMBERS  =========================
 
         LayeredEarthEM*         LayEarth;
 
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "LayeredEarthEMReader";
+
     }; // -----  end of class  LayeredEarthEMReader  -----
 
 

Modules/FDEM1D/src/CMakeLists.txt

 	${FDEM1DSOURCE}
 
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEM.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEMReader.cpp
 	
 	${CMAKE_CURRENT_SOURCE_DIR}/FieldPoints.cpp
 	

Modules/FDEM1D/src/LayeredEarthEM.cpp

 
     // ====================  LIFECYCLE     ===================================
 
-    LayeredEarthEM::LayeredEarthEM( const ctor_key& ) : LayeredEarth() {
+    LayeredEarthEM::LayeredEarthEM( const ctor_key& key ) : LayeredEarth( LayeredEarth::ctor_key() ) {
     }
 
     LayeredEarthEM::LayeredEarthEM( const YAML::Node& node, const ctor_key& ) : LayeredEarth(node) {

Modules/FDEM1D/src/LayeredEarthEMReader.cpp

 
     // ====================  FRIEND METHODS  =====================
 
-    std::ostream &operator<<(std::ostream &stream, const LayeredEarthEMReader &ob) {
-
-        stream << *(LemmaObject*)(&ob);
-
+    std::ostream &operator << (std::ostream &stream, const LayeredEarthEMReader &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
         return stream;
     }
 
+
     // ====================  LIFECYCLE     =======================
 
     //--------------------------------------------------------------------------------------
     //      Method:  LayeredEarthEMReader
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    LayeredEarthEMReader::LayeredEarthEMReader (const std::string& name) : LemmaObject(name),
-        LayEarth(NULL) {
+    LayeredEarthEMReader::LayeredEarthEMReader ( const ctor_key& key ) : LemmaObject(),
+        LayEarth(nullptr) {
 
     }  // -----  end of method LayeredEarthEMReader::LayeredEarthEMReader  (constructor)  -----
 

Modules/LemmaCore/include/ASCIIParser.h

     /*
      *  This key is used to lock the constructors
      */
-    struct ctor_key {};
+    //struct ctor_key {};
 
     public:
 

Modules/LemmaCore/include/LayeredEarth.h

         friend class LayeredEarthEM;
         friend class LayeredEarthMR;
 
+        struct ctor_key{};
+
 		public:
 
 			// ====================    FRIENDS     ===========================
 			// ====================  LIFECYCLE     ===========================
 
 			/** Default protected constructor. */
-			LayeredEarth ( );
+			LayeredEarth ( const ctor_key& );
 
             /** Default protected constructor. */
 			LayeredEarth (const YAML::Node& node);

Modules/LemmaCore/include/LemmaObject.h

      */
     //friend YAML::Emitter& operator << (YAML::Emitter& out, const LemmaObject &ob) ;
 
-    friend class LemmaObjectDeleter;
+    protected:
+        struct ctor_key{};
 
     public:
+
         // Needed because many derived classes have Eigen vectors as members,
         // causing alignment issues when vectorisation is enabled.
         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
         /** Protected default constructor. This is an abstract class and
          *  cannot be instantiated.
          */
-        LemmaObject ( );
+        LemmaObject ( const ctor_key& );
 
         /** Protected DeSerializing constructor */
-        LemmaObject (const YAML::Node& node);
+        LemmaObject ( const YAML::Node& node, const ctor_key& );
 
+        /** Disable copying Lemma Object */
         LemmaObject( const LemmaObject& ) = delete;
 
         /** Protected default destructor. This is an abstract class and
 
 }; // -----  end of class  LemmaObject  -----
 
-class LemmaObjectDeleter
-{
-    public:
-        void operator()(LemmaObject* p) { delete p; }
-};
-
     /////////////////////////////////////////////////////////////////
     // Error Classes
 

Modules/LemmaCore/src/ASCIIParser.cpp

     //      Method:  ASCIIParser
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    ASCIIParser::ASCIIParser ( const ctor_key& ) : LemmaObject( ), input(),
+    ASCIIParser::ASCIIParser ( const ctor_key& key ) : LemmaObject( key ), input(),
             CommentString("//"), BufferSize(255) {
 
     }  // -----  end of method ASCIIParser::ASCIIParser  (constructor)  -----
     //      Method:  ASCIIParser
     // Description:  DeSerializing constructor (protected)
     //--------------------------------------------------------------------------------------
-    ASCIIParser::ASCIIParser (const YAML::Node& node, const ctor_key&  key) : LemmaObject(node) {
+    ASCIIParser::ASCIIParser (const YAML::Node& node, const ctor_key&  key) : LemmaObject(node, key) {
         this->CommentString = node["CommentString"].as<std::string>();
         this->BufferSize = node["BufferSize"].as<int>();
     }  // -----  end of method ASCIIParser::ASCIIParser  (constructor)  -----

Modules/LemmaCore/src/LayeredEarth.cpp

 
 	// ====================  LIFECYCLE     ===================================
 
-	LayeredEarth::LayeredEarth( ) : EarthModel( ),
+	LayeredEarth::LayeredEarth( const ctor_key& key ) : EarthModel( ),
 		NumberOfLayers(0), 	NumberOfInterfaces(0) {
 	}
 

Modules/LemmaCore/src/LemmaObject.cpp

 
 namespace Lemma {
 
-//     YAML::Emitter& operator << (YAML::Emitter& out, const LemmaObject& ob) {
-//         out << YAML::Flow;
-//         out << YAML::BeginMap;
-//         out << YAML::Key <<"Class Name"    << YAML::Value << ob.GetName();
-//         return out;
-//     }
-
     // ====================  LIFECYCLE     ==============================
 
     // Constructor
-    LemmaObject::LemmaObject(  ) {
+    LemmaObject::LemmaObject( const ctor_key& ) {
 
     }
 
-    LemmaObject::LemmaObject(const YAML::Node &node) {
+    LemmaObject::LemmaObject( const YAML::Node &node, const ctor_key& ) {
     }
 
     // Destructor