Cleaning up yaml parts of Lemma.

LemmaCore/include/EarthModel.h

         public:
 
             // ====================  LIFECYCLE     =======================
-            #ifdef HAVE_YAMLCPP
             /** YAML Serializing method
              */
             YAML::Node Serialize() const;
             //static LayeredEarth* DeSerialize(const YAML::Node& node);
-            #endif
 
             // ====================  OPERATORS     =======================
 
             /// Default protected constructor.
             EarthModel (const std::string& name);
 
-            #ifdef HAVE_YAMLCPP
             /** Deserialize constructor */
             EarthModel (const YAML::Node& node);
-            #endif
 
             /// Default protected constructor.
             ~EarthModel ();

LemmaCore/include/GridReader.h

      */
     class GridReader : public LemmaObject {
 
-        friend std::ostream &operator<<(std::ostream &stream,
-                const GridReader &ob) {
-            stream << *(LemmaObject*)(&ob);
+        friend std::ostream &operator << (std::ostream &stream, const GridReader &ob) {
+            stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
             return stream;
         }
 

LemmaCore/include/LayeredEarth.h

              */
 			Real GetLayerDepth(const int & lay);
 
-            #ifdef HAVE_YAMLCPP
             /** YAML Serializing method
              */
             YAML::Node Serialize() const;
             //static LayeredEarth* DeSerialize(const YAML::Node& node);
-            #endif
 
 		protected:
 
 			/** Default protected constructor. */
 			LayeredEarth (const std::string& name);
 
-            #ifdef HAVE_YAMLCPP
             /** Default protected constructor. */
 			LayeredEarth (const YAML::Node& node);
-            #endif
 
 			/** Default protected constructor. */
 			~LayeredEarth ();

LemmaCore/include/LemmaObject.h

 
 #include "helper.h"
 #include "lemma.h"
-
-#ifdef HAVE_YAMLCPP
 #include "yaml-cpp/yaml.h"
-#endif
 
 #include <chrono>
 #include <memory>
   */
 class LemmaObject {
 
-    /** Recursively prints information about this object
+    /**
+     *  Streams class information as YAML::Node
      */
-    friend std::ostream &operator<<(std::ostream &stream, const LemmaObject &ob);
-
-    #ifdef HAVE_YAMLCPP
     friend YAML::Emitter& operator << (YAML::Emitter& out, const LemmaObject &ob) ;
-    #endif
 
     friend class LemmaObjectDeleter;
 
         /** Returns the name of the class, similiar to Python's type */
         std::string GetName() const;
 
-        #ifdef HAVE_YAMLCPP
         /**
          *  Uses YAML to serialize this object.
          *  @return a YAML::Node
          */
         virtual YAML::Node Serialize() const {
             YAML::Node node = YAML::Node();
-
             std::time_t now = std::chrono::system_clock::to_time_t( std::chrono::system_clock::now() );
             node["Serialized"] = std::ctime(&now);
             return node;
         };
-        #endif
 
     protected:
 
          */
         LemmaObject (const std::string &name);
 
-        #ifdef HAVE_YAMLCPP
         /** Protected DeDerializing constructor, use factory DeSerialize  method*/
         LemmaObject (const YAML::Node& node);
-        #endif
 
         /** Protected default destructor. This is an abstract class and
          *  cannot be instantiated.
 
         // ====================  DATA MEMBERS  ==============================
 
+        static const std::string  CName;
+
         /** Stores an ASCII string representation of the class name */
         std::string Name;
 
         void operator()(LemmaObject* p) { delete p; }
 };
 
-    /////////////////////////////////////////////////////////////////
-    // BOILERPLATE MACROS
-    #define DESERIALIZECHECK( node, Object ) { \
-        if (node.Tag() != Object->GetName()) {  \
-            throw  DeSerializeTypeMismatch(Object, node.Tag()) ; \
-        } } \
+//     /////////////////////////////////////////////////////////////////
+//     // BOILERPLATE MACROS
+//     #define DESERIALIZECHECK( node, Object ) { \
+//         if (node.Tag() != Object->GetName()) {  \
+//             throw  DeSerializeTypeMismatch(Object, node.Tag()) ; \
+//         } } \
 
     /////////////////////////////////////////////////////////////////
     // Error Classes
      */
     class DeSerializeTypeMismatch : public std::runtime_error {
         public:
-            DeSerializeTypeMismatch(LemmaObject *ptr, const std::string& got);
+            DeSerializeTypeMismatch(const std::string& expected, const std::string& got);
 
     };
 

LemmaCore/include/helper.h

 #define  HELPER_INC
 
 #include "lemma.h"
-
-#ifdef HAVE_YAMLCPP
 #include "yaml-cpp/yaml.h"
-#endif
 
 namespace Lemma {
 
 
 } // end namespace Lemma
 
-#ifdef HAVE_YAMLCPP
-
 ///////////////////////////////////////////////////////
 // YAML Serializing helper functions. Can we move this into helper.h
 namespace YAML {
 };
 
 }
-#endif //HAVE_YAMLCPP
 
 #endif   // ----- #ifndef HELPER_INC  -----
 

LemmaCore/src/ASCIIParser.cpp

 
     // ====================  FRIEND METHODS  =====================
 
-    std::ostream &operator<<(std::ostream &stream, const ASCIIParser &ob) {
-
-        stream << *(LemmaObject*)(&ob);
-
+    std::ostream &operator << (std::ostream &stream, const ASCIIParser &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
         return stream;
     }
 

LemmaCore/src/CubicSplineInterpolator.cpp

 
     // ====================  FRIEND METHODS  =====================
 
-    std::ostream &operator<<(std::ostream &stream, const CubicSplineInterpolator &ob) {
-
-        stream << *(LemmaObject*)(&ob);
-
+    std::ostream &operator << (std::ostream &stream, const CubicSplineInterpolator &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
         return stream;
     }
 

LemmaCore/src/Data.cpp

 
 namespace Lemma {
 
-	std::ostream &operator<<(std::ostream &stream,
-			const Data &ob) {
-		stream << *(LemmaObject*)(&ob);
-		return stream;
-	}
+    std::ostream &operator << (std::ostream &stream, const Data &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
 
 	Data::Data(const std::string &name) : LemmaObject(name) {
 	}

LemmaCore/src/DataReader.cpp

 
 namespace Lemma {
 
-	std::ostream &operator<<(std::ostream &stream,
-		const DataReader &ob) {
-		stream << *(LemmaObject*)(&ob);
-		return stream;
-	}
+    std::ostream &operator << (std::ostream &stream, const DataReader &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
 
 	DataReader::DataReader(const std::string &name) :
 			LemmaObject(name) {

LemmaCore/src/EarthModel.cpp

 
 namespace Lemma {
 
-	std::ostream &operator<<(std::ostream &stream,
-				const EarthModel &ob) {
-
-		stream << *(LemmaObject*)(&ob);
-		return stream;
-	}
+    std::ostream &operator << (std::ostream &stream, const EarthModel &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
 
 	// ====================  LIFECYCLE     =======================
 
 			LemmaObject(name), BField(0,0,0), BFieldUnit(0,0,0), BInc(0), BDec(0), BMag(0) {
 	}
 
-    #ifdef HAVE_YAMLCPP
     EarthModel::EarthModel(const YAML::Node& node) : LemmaObject(node) {
         BInc = node["BInc"].as<double>();
         BDec = node["BDec"].as<double>();
         node["BMag"] = BMag;
         return node;
     }
-    #endif
 
 	EarthModel::~EarthModel() {
 	}

LemmaCore/src/Grid.cpp

 
 namespace Lemma {
 
-	std::ostream &operator<<(std::ostream &stream,
-				const Grid &ob) {
+    std::ostream &operator << (std::ostream &stream, const Grid &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
 
-		stream << *(LemmaObject*)(&ob);
-		return stream;
-	}
 
 	Grid::Grid  ( const std::string& name ) : LemmaObject(name) {
 	}

LemmaCore/src/Instrument.cpp

 
 namespace Lemma {
 
-	std::ostream &operator<<(std::ostream &stream,
-				const Instrument &ob) {
-
-		stream << *(LemmaObject*)(&ob);
-		return stream;
-	}
+    std::ostream &operator << (std::ostream &stream, const Instrument &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
 
 	Instrument::Instrument(const std::string &name) :
 			LemmaObject(name) {

LemmaCore/src/LayeredEarth.cpp

 namespace Lemma {
 
 	// ====================    FRIENDS     ======================
+
+    /*
 	std::ostream &operator<<(std::ostream &stream,
 				const LayeredEarth &ob) {
 		stream << *(EarthModel*)(&ob);
   		//stream << "Class Name : "<< ob.Name  << "\n";
   		stream << "Number of Layers "<< ob.NumberOfLayers  << "\n";
-
   		return stream;
 	}
+    */
+
+    std::ostream &operator << (std::ostream &stream, const LayeredEarth &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
 
 	// ====================  LIFECYCLE     ===================================
 
 	LayeredEarth::~LayeredEarth() {
 	}
 
-    #ifdef HAVE_YAMLCPP
     LayeredEarth::LayeredEarth(const YAML::Node& node) : EarthModel(node)
     {
         NumberOfLayers = node["NumberOfLayers"].as<int>();
 
     YAML::Node LayeredEarth::Serialize() const {
         YAML::Node node = EarthModel::Serialize();
-
         node["NumberOfLayers"] = NumberOfLayers;
         node["NumberOfInterfaces"] = NumberOfInterfaces;
         node["LayerThickness"] = LayerThickness;
         node.SetTag( this->GetName() );
         return node;
     }
-    #endif
 
 	// ====================  OPERATIONS    ===================================
 

LemmaCore/src/LemmaObject.cpp

 
 namespace Lemma {
 
-    std::ostream &operator<<(std::ostream &stream,
-                const LemmaObject &ob) {
-      stream << "Class name= " << ob.Name  << "\n";
-      return stream;
-    }
+    //LemmaObject::CName = std::string("LemmaObject");
 
-    #ifdef HAVE_YAMLCPP
     YAML::Emitter& operator << (YAML::Emitter& out, const LemmaObject& ob) {
         out << YAML::BeginMap;
         out << YAML::Key <<"Class Name"    << YAML::Value << ob.GetName();
         return out;
     }
-    #endif
 
     // ====================  LIFECYCLE     ==============================
 
     LemmaObject::LemmaObject(const std::string& name) : Name(name) {
     }
 
-    #ifdef HAVE_YAMLCPP
     LemmaObject::LemmaObject(const YAML::Node &node) : Name(node.Tag()) {
     }
-    #endif
 
     // Destructor
     LemmaObject::~LemmaObject() {
     //////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////////////////////////////
 
-    DeSerializeTypeMismatch::DeSerializeTypeMismatch(LemmaObject *ptr, const std::string& got) :
+    DeSerializeTypeMismatch::DeSerializeTypeMismatch(const std::string& expected, const std::string& got) :
         runtime_error("DESERIALIZE TYPE MISMATCH") {
-            std::cerr << "Expected " << ptr->GetName() << " got " << got << std::endl;
+            std::cerr << "Expected " << expected << " got " << got << std::endl;
         }
 
     RequestToReturnNullPointer::

LemmaCore/src/RectilinearGrid.cpp

 
 namespace Lemma {
 
+    std::ostream &operator << (std::ostream &stream, const RectilinearGrid &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
 
+    /*
 	std::ostream &operator<<(std::ostream &stream, const
 	    RectilinearGrid &ob) {
-
 		stream << *(LemmaObject*)(&ob);
-
         stream << "\tnx=" << ob.nx << "\tny=" << ob.ny << "\tnz=" << ob.nz << std::endl;
         stream << "\tox=" << ob.ox << "\toy=" << ob.oy << "\toz=" << ob.oz << std::endl;
         stream << "\tdx=" << ob.dx.transpose() << std::endl;
         stream << "\tdz=" << ob.dz.transpose() << std::endl;
 		return stream;
 	}
+    */
 
     // ====================  LIFECYCLE     =======================
 

LemmaCore/src/RectilinearGridReader.cpp

 
     // ====================  FRIEND METHODS  =====================
 
-    std::ostream &operator<<(std::ostream &stream, const RectilinearGridReader &ob) {
-
-        stream << *(GridReader*)(&ob);
-
+    std::ostream &operator << (std::ostream &stream, const RectilinearGridReader &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
         return stream;
     }
 

LemmaCore/src/RectilinearGridVTKExporter.cpp

 
 // ====================  FRIEND METHODS  =====================
 
-std::ostream &operator<<(std::ostream &stream, const RectilinearGridVTKExporter &ob) {
-    stream << *(LemmaObject*)(&ob);
+std::ostream &operator << (std::ostream &stream, const RectilinearGridVTKExporter &ob) {
+    stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
     return stream;
 }
 
+
 // ====================  LIFECYCLE     =======================
 
 //--------------------------------------------------------------------------------------

vim/c.vim

+"===================================================================================
+"
+"         FILE:  c.vim
+"  DESCRIPTION:  syntax file
+"                enable syntax based folding
+"                part of the c-support plugin
+"
+"       AUTHOR:  Trevor Irons
+"        EMAIL:  tirons@mines.edu
+"      COMPANY:  FH Südwestfalen, Iserlohn
+"      VERSION:  1.0
+"      CREATED:  11.03.2006
+"     REVISION:  ---
+"===================================================================================
+"
+" fold C blocks
+"
+syn region cBlock start="{" end="}" transparent fold
+set foldmethod=syntax
+set foldlevel=999
+

vim/cpp.cpp.template

+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+$
+== cpp.cin ==
+cin	>> <CURSOR>;
+$
+== cpp.cout-variabe ==
+cout	<< <CURSOR> << endl;
+$
+== cpp.cout-string ==
+cout	<< "<CURSOR>\n";
+$
+== cpp.cout-operator == insert ==
+<< "<CURSOR>"
+$
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.output-manipulator-boolalpha       == insert ==
+<< boolalpha <CURSOR>
+== cpp.output-manipulator-dec             == insert ==
+<< dec <CURSOR>
+== cpp.output-manipulator-endl            == insert ==
+<< endl <CURSOR>
+== cpp.output-manipulator-fixed           == insert ==
+<< fixed <CURSOR>
+== cpp.output-manipulator-flush           == insert ==
+<< flush <CURSOR>
+== cpp.output-manipulator-hex             == insert ==
+<< hex <CURSOR>
+== cpp.output-manipulator-internal        == insert ==
+<< internal <CURSOR>
+== cpp.output-manipulator-left            == insert ==
+<< left <CURSOR>
+== cpp.output-manipulator-oct             == insert ==
+<< oct <CURSOR>
+== cpp.output-manipulator-right           == insert ==
+<< right <CURSOR>
+== cpp.output-manipulator-scientific      == insert ==
+<< scientific <CURSOR>
+== cpp.output-manipulator-setbase         == insert ==
+<< setbase(10<CURSOR>)
+== cpp.output-manipulator-setfill         == insert ==
+<< setfill(<CURSOR>)
+== cpp.output-manipulator-setiosflag      == insert ==
+<< setiosflags(<CURSOR>)
+== cpp.output-manipulator-setprecision    == insert ==
+<< setprecision(6<CURSOR>)
+== cpp.output-manipulator-setw            == insert ==
+<< setw(0<CURSOR>)
+== cpp.output-manipulator-showbase        == insert ==
+<< showbase <CURSOR>
+== cpp.output-manipulator-showpoint       == insert ==
+<< showpoint <CURSOR>
+== cpp.output-manipulator-showpos         == insert ==
+<< showpos <CURSOR>
+== cpp.output-manipulator-uppercase       == insert ==
+<< uppercase <CURSOR>
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.method-implementation ==
+//--------------------------------------------------------------------------------------
+//       Class:  |?CLASSNAME|
+//      Method:  |?METHODNAME|
+//--------------------------------------------------------------------------------------
+<CURSOR>void |CLASSNAME|::|METHODNAME| (  ) {
+    return ;
+}		// -----  end of method |CLASSNAME|::|METHODNAME|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.accessor-implementation ==
+//--------------------------------------------------------------------------------------
+//       Class:  |?CLASSNAME|
+//      Method:  get_|?ATTRIBUTE|
+//--------------------------------------------------------------------------------------
+inline <CURSOR>int |CLASSNAME|::get_|ATTRIBUTE| (  ) {
+	return |ATTRIBUTE|;
+}		// -----  end of method |CLASSNAME|::get_|ATTRIBUTE|  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  set_|ATTRIBUTE|
+//--------------------------------------------------------------------------------------
+inline void |CLASSNAME|::set_|ATTRIBUTE| ( int value ) {
+	|ATTRIBUTE|	= value;
+	return ;
+}		// -----  end of method |CLASSNAME|::set_|ATTRIBUTE|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.class-definition ==
+/**
+   \brief  <CURSOR>
+   \details
+ */
+class |?CLASSNAME:c| : public |?BASECLASS:c| {
+
+// ====================  LIFECYCLE     =======================
+
+/** Default constructor */
+|CLASSNAME| ( );
+
+/** Default destructor */
+~|CLASSNAME| ();
+
+// ====================  OPERATORS     =======================
+
+// ====================  OPERATIONS    =======================
+
+// ====================  ACCESS        =======================
+
+// ====================  INQUIRY       =======================
+
+protected:
+
+// ====================  DATA MEMBERS  =========================
+
+private:
+
+}; // -----  end of class  |CLASSNAME|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.class-definitionLemma ==
+#pragma once
+#include "|?BASECLASS|.h"
+
+namespace Lemma {
+
+/**
+   \brief  <CURSOR>
+   \details
+ */
+class |?CLASSNAME:c| : public |BASECLASS:c| {
+
+	friend std::ostream &operator<<(std::ostream &stream, const |CLASSNAME| &ob);
+
+	public:
+
+	    // ====================  LIFECYCLE     =======================
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type |CLASSNAME|
+         */
+	    static std::shared_ptr< |CLASSNAME| > NewSP();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *   @see |CLASSNAME|::DeSerialize
+         */
+        YAML::Node Serialize() const;
+
+        /**
+         *   Constructs an |CLASSNAME| object from a YAML::Node.
+         *   @see |CLASSNAME|::Serialize
+         */
+        static std::shared_ptr<|CLASSNAME|> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+
+
+
+    protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * Default protected constructor, use NewSP methods to construct
+         * @see |CLASSNAME|::NewSP
+         */
+        |CLASSNAME| (const std::string& name);
+
+        /**
+         * Protected DeDerializing constructor, use factory DeSerialize  method.
+         * @see |CLASSNAME|::DeSerialize
+         */
+        |CLASSNAME| (const YAML::Node& node);
+
+        /** Default protected destructor, use smart pointers (std::shared_ptr) */
+        ~|CLASSNAME| ();
+
+	// ====================  DATA MEMBERS  =========================
+
+    private:
+
+}; // -----  end of class  |CLASSNAME|  -----
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.class-definitionLemmaAbstract ==
+/**
+   \brief  <CURSOR>
+   \details
+ */
+class |?CLASSNAME:c| : public |?BASECLASS:c| {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const |CLASSNAME| &ob) {
+        stream << *(|BASECLASS|*)(&ob);
+        return stream;
+    }
+
+    public:
+
+// ====================  LIFECYCLE     =======================
+
+// ====================  OPERATORS     =======================
+
+// ====================  OPERATIONS    =======================
+virtual void APIDemo()=0; // REMEMBER TO MAKE PURE VIRTUAL DUMMY
+
+// ====================  ACCESS        =======================
+
+// ====================  INQUIRY       =======================
+
+protected:
+
+// ====================  LIFECYCLE     =======================
+
+/** Default protected constructor, abstract class this cannot be called */
+|CLASSNAME| (const std::string& name);
+
+/** Default protected destructor, this is an abstract class, this cannot be called */
+~|CLASSNAME| ();
+
+// ====================  DATA MEMBERS  =========================
+
+private:
+
+}; // -----  end of class  |CLASSNAME|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.class-implementationLemma ==
+#include "|?CLASSNAME|.h"
+
+namespace Lemma {
+
+// ====================  FRIEND METHODS  =====================
+
+std::ostream &operator << (std::ostream &stream, const |CLASSNAME| &ob) {
+    stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+    return stream;
+}
+
+// ====================  LIFECYCLE     =======================
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  |CLASSNAME|
+// Description:  constructor (protected)
+//--------------------------------------------------------------------------------------
+|CLASSNAME|::|CLASSNAME| (const std::string& name) : |?BASECLASS|(name) {
+
+}  // -----  end of method |CLASSNAME|::|CLASSNAME|  (constructor)  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  |CLASSNAME|
+// Description:  DeSerializing constructor (protected)
+//--------------------------------------------------------------------------------------
+|CLASSNAME|::|CLASSNAME| (const YAML::Node& node) : |BASECLASS|(node) {
+
+}  // -----  end of method |CLASSNAME|::|CLASSNAME|  (constructor)  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  NewSP()
+// Description:  public constructor returing a shared_ptr
+//--------------------------------------------------------------------------------------
+std::shared_ptr< |CLASSNAME| >  |CLASSNAME|::NewSP() {
+    std::shared_ptr< |CLASSNAME| > sp(new  |CLASSNAME|("|CLASSNAME|"), LemmaObjectDeleter() );
+    return sp;
+}
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  ~|CLASSNAME|
+// Description:  destructor (protected)
+//--------------------------------------------------------------------------------------
+|CLASSNAME|::~|CLASSNAME| () {
+
+}  // -----  end of method |CLASSNAME|::~|CLASSNAME|  (destructor)  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  Serialize
+//--------------------------------------------------------------------------------------
+YAML::Node  |CLASSNAME|::Serialize (  ) const {
+    YAML::Node node = |BASECLASS|::Serialize();
+    node.SetTag( GetName() );
+    // FILL IN CLASS SPECIFICS HERE
+    return node;
+}		// -----  end of method |CLASSNAME|::Serialize  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  DeSerialize
+//--------------------------------------------------------------------------------------
+std::shared_ptr<|CLASSNAME|> |CLASSNAME|::DeSerialize ( const YAML::Node& node  ) {
+    if (node.Tag() !=  "|CLASSNAME|" ) {
+        throw  DeSerializeTypeMismatch( "|CLASSNAME|", node.Tag());
+    }
+    std::shared_ptr< |CLASSNAME| > Object(new |CLASSNAME|(node), LemmaObjectDeleter() );
+    return Object ;
+}		// -----  end of method |CLASSNAME|::DeSerialize  -----
+
+} // ----  end of namespace Lemma  ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.class-implementation ==
+
+// ====================  LIFECYCLE     =======================
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  |CLASSNAME|
+// Description:  constructor (protected)
+//--------------------------------------------------------------------------------------
+|CLASSNAME|::|CLASSNAME| ( ) : |BASECLASS|(name) {
+
+}  // -----  end of method |CLASSNAME|::|CLASSNAME|  (constructor)  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  ~|CLASSNAME|
+// Description:  destructor
+//--------------------------------------------------------------------------------------
+|CLASSNAME|::~|CLASSNAME| () {
+<CURSOR>
+}  // -----  end of method |CLASSNAME|::~|CLASSNAME|  (destructor)  -----
+
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.class-using-new-definition ==
+// =====================================================================================
+//        Class:  |?CLASSNAME:c|
+//  Description:  <CURSOR>
+// =====================================================================================
+class |CLASSNAME|
+{
+  public:
+
+    // ====================  LIFECYCLE     =======================================
+    |CLASSNAME| ();                             // constructor
+    |CLASSNAME| ( const |CLASSNAME| &other );   // copy constructor
+    ~|CLASSNAME| ();                            // destructor
+
+    // ====================  OPERATORS     =======================================
+    const |CLASSNAME|& operator = ( const |CLASSNAME| &other ); // assignment operator
+
+    // ====================  OPERATIONS    =======================================
+
+    // ====================  ACCESS        =======================================
+
+    // ====================  INQUIRY       =======================================
+
+    // ====================  DATA MEMBERS  =======================================
+  protected:
+
+  private:
+
+}; // -----  end of class  |CLASSNAME|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.class-using-new-implementation ==
+//--------------------------------------------------------------------------------------
+//       Class:  |?CLASSNAME|
+//      Method:  |CLASSNAME|
+// Description:  constructor
+//--------------------------------------------------------------------------------------
+|CLASSNAME|::|CLASSNAME| ()
+{
+}  // -----  end of method |CLASSNAME|::|CLASSNAME|  (constructor)  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  |CLASSNAME|
+// Description:  copy constructor
+//--------------------------------------------------------------------------------------
+|CLASSNAME|::|CLASSNAME| ( const |CLASSNAME| &other )
+{
+}  // -----  end of method |CLASSNAME|::|CLASSNAME|  (copy constructor)  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  ~|CLASSNAME|
+// Description:  destructor
+//--------------------------------------------------------------------------------------
+|CLASSNAME|::~|CLASSNAME| ()
+{
+}  // -----  end of method |CLASSNAME|::~|CLASSNAME|  (destructor)  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  operator =
+// Description:  assignment operator
+//--------------------------------------------------------------------------------------
+const |CLASSNAME|&
+|CLASSNAME|::operator = ( const |CLASSNAME| &other )
+{
+  if ( this != &other ) {
+  }
+  return *this;
+}  // -----  end of method |CLASSNAME|::operator =  (assignment operator)  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.error-class ==
+// =====================================================================================
+//        Class:  |?CLASSNAME:c|
+//  Description:  <CURSOR>
+// =====================================================================================
+class |CLASSNAME|
+{
+  public:     |CLASSNAME| ( string msg = "|CLASSNAME|" ):message(msg)  { }
+              virtual ~|CLASSNAME| ( )  { }
+              virtual string what ( ) const throw ( )  { return message; }
+  protected:  string  message;
+}; // ----------  end of class  |CLASSNAME|  ----------
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.template-method-implementation ==
+template < class T >
+void<CURSOR> |?CLASSNAME|<T>::|?METHODNAME| (  )
+{
+	return ;
+}		// -----  end of method |CLASSNAME|<T>::|METHODNAME|  -----
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.template-accessor-implementation ==
+//--------------------------------------------------------------------------------------
+//       Class:  |?CLASSNAME|
+//      Method:  get_|?ATTRIBUTE|
+//--------------------------------------------------------------------------------------
+template < class T >
+inline  <CURSOR>int |CLASSNAME|<T>::get_|ATTRIBUTE| (  )
+{
+	return |ATTRIBUTE|;
+}		// -----  end of method |CLASSNAME|<T>::get_|ATTRIBUTE|  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  set_|ATTRIBUTE|
+//--------------------------------------------------------------------------------------
+template < class T >
+inline  void |CLASSNAME|<T>::set_|ATTRIBUTE| ( int value )
+{
+	|ATTRIBUTE|	= value;
+	return ;
+}		// -----  end of method |CLASSNAME|<T>::set_|ATTRIBUTE|  -----
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.template-class-definition ==
+// =====================================================================================
+//        Class:  |?CLASSNAME:c|
+//  Description:  <CURSOR>
+// =====================================================================================
+
+template < class T >
+class |CLASSNAME|
+{
+  public:
+
+    // ====================  LIFECYCLE     =======================================
+    |CLASSNAME| ();                             // constructor
+
+    // ====================  OPERATORS     =======================================
+
+    // ====================  OPERATIONS    =======================================
+
+    // ====================  ACCESS        =======================================
+
+    // ====================  INQUIRY       =======================================
+
+    // ====================  DATA MEMBERS  =======================================
+  protected:
+
+  private:
+
+}; // -----  end of template class  |CLASSNAME|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.template-class-implementation ==
+//--------------------------------------------------------------------------------------
+//       Class:  |?CLASSNAME|
+//      Method:  |CLASSNAME|
+// Description:  constructor
+//--------------------------------------------------------------------------------------
+template < class T >
+|CLASSNAME| <T>:: |CLASSNAME| ()
+{
+}  // -----  end of constructor of template class |CLASSNAME|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.template-class-using-new-definition ==
+// =====================================================================================
+//        Class:  |?CLASSNAME:c|
+//  Description:  <CURSOR>
+// =====================================================================================
+
+template < class T >
+class |CLASSNAME|
+{
+  public:
+
+    // ====================  LIFECYCLE     =======================================
+    |CLASSNAME| ();                           // constructor
+    |CLASSNAME| ( const |CLASSNAME| &other ); // copy constructor
+    ~|CLASSNAME| ();                          // destructor
+
+    // ====================  OPERATORS     =======================================
+
+    const |CLASSNAME|& operator = ( const |CLASSNAME| &other ); // assignment operator
+
+    // ====================  OPERATIONS    =======================================
+
+    // ====================  ACCESS        =======================================
+
+    // ====================  INQUIRY       =======================================
+
+    // ====================  DATA MEMBERS  =======================================
+  protected:
+
+  private:
+
+}; // -----  end of template class  |CLASSNAME|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.template-class-using-new-implementation ==
+//--------------------------------------------------------------------------------------
+//       Class:  |?CLASSNAME|
+//      Method:  |CLASSNAME|
+// Description:  constructor
+//--------------------------------------------------------------------------------------
+template < class T >
+|CLASSNAME|<T>::|CLASSNAME| ()
+{
+}  // -----  end of constructor of template class |CLASSNAME|  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  |CLASSNAME|
+// Description:  copy constructor
+//--------------------------------------------------------------------------------------
+template < class T >
+|CLASSNAME|<T>::|CLASSNAME| ( const |CLASSNAME| &other )
+{
+}  // -----  end of copy constructor of template class |CLASSNAME|  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  ~|CLASSNAME|
+// Description:  destructor
+//--------------------------------------------------------------------------------------
+template < class T >
+|CLASSNAME|<T>::~|CLASSNAME| ()
+{
+}  // -----  end of destructor of template class |CLASSNAME|  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  |CLASSNAME|
+//      Method:  operator =
+// Description:  assignment operator
+//--------------------------------------------------------------------------------------
+template < class T >
+const |CLASSNAME|<T>& |CLASSNAME|<T>::operator = ( const |CLASSNAME| &other )
+{
+  if ( this != &other ) {
+  }
+  return *this;
+}  // -----  end of assignment operator of template class |CLASSNAME|  -----
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.template-function ==
+template <class T>
+<CURSOR>void |?TEMPALTE_FUNCTION_NAME| ( T param )
+{
+	return ;
+}		// -----  end of template function |?TEMPALTE_FUNCTION_NAME|  -----
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.operator-in ==
+ostream &
+operator << ( ostream & os, const |?CLASSNAME| & obj )
+{
+	os << obj.<CURSOR> ;
+	return os;
+}		// -----  end of function operator <<  -----
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.operator-out ==
+istream &
+operator >> ( istream & is, |?CLASSNAME| & obj )
+{
+	is >> obj.<CURSOR> ;
+	return is;
+}		// -----  end of function operator >>  -----
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.try-catch ==
+try {
+<SPLIT>}
+catch ( const <CURSOR> &ExceptObj ) {		// handle exception:
+}
+catch (...) {		// handle exception: unspezified
+}
+
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.catch ==
+catch ( <CURSOR>const &ExceptObj ) {		// handle exception:
+<SPLIT>}
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.catch-points ==
+catch (...) {		// handle exception:
+<SPLIT>}
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.extern ==
+extern "C" {<CURSOR>
+<SPLIT>}
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.open-input-file ==
+string    ifs_file_name = "<CURSOR>";                 // input  file name
+ifstream  ifs;                                // create ifstream object
+
+ifs.open ( ifs_file_name.c_str() );           // open ifstream
+if (!ifs) {
+	cerr << "\nERROR : failed to open input  file " << ifs_file_name << endl;
+	exit (EXIT_FAILURE);
+}
+
+
+ifs.close ();                                 // close ifstream
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.open-output-file ==
+string    ofs_file_name = "<CURSOR>";                 // input  file name
+ofstream  ofs;                                // create ofstream object
+
+ofs.open ( ofs_file_name.c_str() );           // open ofstream
+if (!ofs) {
+	cerr << "\nERROR : failed to open output file " << ofs_file_name << endl;
+	exit (EXIT_FAILURE);
+}
+
+
+ofs.close ();                                 // close ofstream
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.namespace-std ==
+using namespace std;
+== cpp.namespace ==
+using namespace |?NAMESPACE|;
+== cpp.namespace-block ==
+namespace |?NAMESPACE| {
+<CURSOR>
+<SPLIT>}		// -----  end of |NAMESPACE|  name  -----
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+== cpp.rtti-typeid == insert ==
+typeid(<CURSOR><SPLIT>)
+$
+== cpp.rtti-static-cast == insert ==
+static_cast<>(<CURSOR><SPLIT>)
+$
+== cpp.rtti-const-cast == insert ==
+const_cast<>(<CURSOR><SPLIT>)
+$
+== cpp.rtti-reinterpret-cast == insert ==
+reinterpret_cast<>(<CURSOR><SPLIT>)
+$
+== cpp.rtti-dynamic-cast == insert ==
+dynamic_cast<>(<CURSOR><SPLIT>)
+$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */