More cleaning up towards the port to c++-11. Documentation and consistency and better testing.

Modules/LemmaCore/examples/CubicSplineInterpolator.cpp

  * @copyright Copyright (c) 2016, Trevor Irons & Lemma Software, LLC
  */
 
-#include "CubicSplineInterpolator.h"
-#include "ASCIIParser.h"
+#include "LemmaCore"
 using namespace Lemma;
 
 int main() {
+    auto win = WindowFilter::NewSP();
+        std::cout << *win << std::endl;
     //auto Spline = CubicSplineInterpolator::NewSP();
     //auto Spline2 = CubicSplineInterpolator();
-    auto Parser = ASCIIParser::NewSP();
+    //auto Parser = ASCIIParser::NewSP();
     //ASCIIParser Parser2 = ASCIIParser();
     //    Parser2.SetCommentString( "#");
     //auto Parser3 = ASCIIParser(Parser2);

Modules/LemmaCore/include/ASCIIParser.h

 
     friend std::ostream &operator<<(std::ostream &stream,
             const ASCIIParser &ob);
-
+    /*
+     *  This key is used to lock the constructors
+     */
     struct ctor_key {};
 
     public:
 
     // ====================  LIFECYCLE     =======================
 
-    /** Default constructor */
+    /** Default constructor
+     * @note This method is locked
+     * @see ASCIIParser::NewSP
+     */
     explicit ASCIIParser ( const ctor_key& );
 
-    /** Constructor using YAML::Node */
+    /**
+     * DeSerializing constructor.
+     * @note This method is locked, and cannot be called directly.
+     *       The reason that the method is public is to enable the use
+     *       of make_shared whilst enforcing the use of shared_ptr,
+     *       in c++-17, this curiosity may be resolved.
+     * @see ASCIIParser::DeSerialize
+     */
     ASCIIParser ( const YAML::Node& node, const ctor_key& );
 
-    /** Default  destructor */
+    /** Default  destructor
+     *  @note This should never be called explicitly, use NewSP
+     */
     virtual ~ASCIIParser ();
 
     /**
      *  Uses YAML to serialize this object.
      *  @return a YAML::Node
      */
-    YAML::Node Serialize() const;
+    virtual YAML::Node Serialize() const;
 
     // ====================  OPERATORS     =======================
 
      */
     void SetCommentString( const std::string& key );
 
-    /** Sets the buffer size. This affects the maximum number of column in a line. Defaults
+    /** Sets the buffer size. This affects the maximum number of columns in a line. Defaults
      *  is 255.
      *  @param[in] BufferSize is the size of the buffer to use
      */

Modules/LemmaCore/include/CubicSplineInterpolator.h

 class CubicSplineInterpolator : public LemmaObject {
 
     friend std::ostream &operator<<(std::ostream &stream,
-            const CubicSplineInterpolator &ob);
+            const CubicSplineInterpolator& ob);
 
     struct ctor_key {};
 
      *  Uses YAML to serialize this object.
      *  @return a YAML::Node
      */
-    YAML::Node Serialize() const;
+    virtual YAML::Node Serialize() const;
 
     /**
      *   Constructs an object from a YAML::Node.

Modules/LemmaCore/include/Data.h

 
             // ====================  LIFECYCLE     =======================
 
-            /** Copies the *structure* of this class to a new object and
-             * returns a pointer to this object. Memory management is
-             * the responsibility of the receiver!. The data values are
-             * not copied.
+            /**
+             * Returns a deep copy
              */
-            virtual Data* Clone()=0;
+            virtual std::shared_ptr<Data> DeepCopy()=0;
 
             // ====================  OPERATORS     =======================
 
             /** Default protected constructor. */
             Data (  );
 
+            /** Deserializing contructor */
+            Data ( const YAML::Node& node );
+
             /** Default protected constructor. */
-            ~Data ();
+            ~Data ( );
 
             // ====================  DATA MEMBERS  =========================
 
             /** ASCII string representation of the class name */
             static constexpr auto CName = "Data";
 
+            Data ( const Data& ) = delete;
+
     }; // -----  end of class  Data  -----
 
 }       // -----  end of Lemma  name  -----

Modules/LemmaCore/include/DataReader.h

         // ====================  OPERATIONS    =======================
 
         // ====================  ACCESS        =======================
-        virtual Data* GetData()=0;
+        virtual std::shared_ptr< Data > GetData()=0;
 
         // ====================  INQUIRY       =======================
         /** Returns the name of the underlying class, similiar to Python's type */
         DataReader ( );
 
         /// Default protected constructor.
+        DataReader ( const YAML::Node& node );
+
+        /// Default protected constructor.
         ~DataReader ( );
 
         // ====================  DATA MEMBERS  =========================
         /** ASCII string representation of the class name */
         static constexpr auto CName = "DataReader";
 
+        DataReader( const DataReader& ) = delete;
+
 }; // -----  end of class  DataReader  -----
 
 }       // -----  end of Lemma  name  -----

Modules/LemmaCore/include/EarthModel.h

 
     // ===================================================================
     //        Class:  EarthModel
-    /// \ingroup LemmaGroup
+    /// \ingroup LemmaCore
     /// \brief abstract class for Earth models
     /// \details
     // ===================================================================
 
         private:
 
+            EarthModel(const EarthModel& ) = delete;
+
             /** ASCII string representation of the class name */
             static constexpr auto CName = "EarthModel";
 

Modules/LemmaCore/include/Filter.h

 
     class Filter : public LemmaObject {
 
+        friend std::ostream &operator<<(std::ostream &stream, const Filter& ob);
+
         public:
 
             // ====================  LIFECYCLE     =======================
+            /**
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
+             */
+            virtual YAML::Node Serialize() const;
 
             // ====================  OPERATORS     =======================
 
             // ====================  OPERATIONS    =======================
 
+
             // ====================  ACCESS        =======================
 
             // ====================  INQUIRY       =======================
             Filter ( );
 
             /// Default protected constructor.
-            ~Filter ();
+            Filter ( const YAML::Node& node );
+
+            /// Default protected constructor.
+            virtual ~Filter ();
 
             // ====================  DATA MEMBERS  =========================
 

Modules/LemmaCore/include/Grid.h

 
         // ====================  LIFECYCLE     ===================================
 
-        YAML::Node Serialize() const;
+        virtual YAML::Node Serialize() const;
 
         // ====================  OPERATORS     ===================================
 
         Grid ( );
 
         /// Default protected constructor.
-        ~Grid ();
+        virtual ~Grid ( );
 
         // ====================  DATA MEMBERS  ===================================
 

Modules/LemmaCore/include/Instrument.h

 
 			// ====================  LIFECYCLE     ===========================
 
+            /**
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
+             */
+            YAML::Node Serialize() const;
+
 			// ====================  OPERATORS     ===========================
 
 			// ====================  OPERATIONS    ===========================
 
 			// ====================  LIFECYCLE     ===========================
 
+            /// Default protected constructor.
+			Instrument ( const YAML::Node& node );
+
 			/// Default protected constructor.
 			Instrument ( );
 

Modules/LemmaCore/include/LayeredEarth.h

             /** YAML Serializing method
              */
             YAML::Node Serialize() const;
-            //static LayeredEarth* DeSerialize(const YAML::Node& node);
 
             /** Returns the name of the underlying class, similiar to Python's type */
             virtual inline std::string GetName() const {
 			// ====================  DATA MEMBERS  ===========================
 
         private:
+
             /** ASCII string representation of the class name */
             static constexpr auto CName = "LayeredEarth";
 
+            /** no copy */
+            LayeredEarth ( const LayeredEarth& ) = delete;
+
 			/** Number of layers in the model, including the air layer,
 			 * and counting from 0
              */

Modules/LemmaCore/include/LemmaObject.h

     friend class LemmaObjectDeleter;
 
     public:
-
-        // ====================  LIFECYCLE     ==============================
-
         // Needed because many derived classes have Eigen vectors as members,
         // causing alignment issues when vectorisation is enabled.
         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
-        // ====================  OPERATORS     ==============================
-
-        // ====================  OPERATIONS    ==============================
-
-        // ====================  ACCESS        ==============================
-
-        // ====================  INQUIRY       ==============================
-
-        /** Returns the name of the underlying class; Run-time type information (RTTI). This approach
-            Was chosen over typeid due to name mangling among various compilers, and the need for consistency
-            in Serialized objects.
-         */
-        virtual inline std::string GetName() const {
-            return this->CName;
-        }
+        // ====================  LIFECYCLE     ==============================
 
         /**
          *  Uses YAML to serialize this object.
             return node;
         };
 
+        // ====================  OPERATORS     ==============================
+
+        // ====================  OPERATIONS    ==============================
+
+        // ====================  ACCESS        ==============================
+
+        // ====================  INQUIRY       ==============================
+
+        /** Returns the name of the underlying class; Run-time type information (RTTI). This approach
+            Was chosen over typeid due to name mangling among various compilers, and the need for consistency
+            in Serialized objects.
+         */
+        virtual inline std::string GetName() const {
+            return this->CName;
+        }
+
     protected:
 
         // ====================  LIFECYCLE     ==============================

Modules/LemmaCore/include/RectilinearGrid.h

              *  Uses YAML to serialize this object.
              *  @return a YAML::Node
              */
-            YAML::Node Serialize() const;
+            virtual YAML::Node Serialize() const;
 
             /**
              *   Constructs an object from a YAML::Node.

Modules/LemmaCore/include/WindowFilter.h

 #include "Filter.h"
 
 namespace Lemma {
-    /** Types of filter window that are supported.
-     */
-    enum WINDOWTYPE { HAMMING, /*!< A hamming window */
-                      HANNING, /*!< A hanning window */
-                      RECTANGULAR /*!< Rectangular window */
-                    };
 
     // ===================================================================
     //  Class:  WindowFilter
     // ===================================================================
     class WindowFilter : public Filter {
 
+        friend std::ostream &operator<<(std::ostream &stream, const WindowFilter& ob);
+
+        struct ctor_key {};
+
         public:
 
             // ====================  LIFECYCLE     =======================
 
-           /**
-            *  Factory method for generating concrete class.
-            *  @return a std::shared_ptr of type WindowFilter
-            */
+            /** Default constructor, inaccessible use NewSP  */
+            explicit WindowFilter ( const ctor_key& );
+
+            /** DeSerializing constructor, usees factory DeSerialize  method, inaccessible use DeSerialize*/
+            WindowFilter ( const YAML::Node& node, const ctor_key& );
+
+            /** Default constructor. */
+            virtual ~WindowFilter ( );
+
+            /**
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
+             */
+            YAML::Node Serialize() const;
+
+            /**
+             *   Constructs an object from a YAML::Node.
+             */
+            static std::shared_ptr< WindowFilter > DeSerialize(const YAML::Node& node);
+
+            /**
+             *  Factory method for generating concrete class.
+             *  @return a std::shared_ptr of type WindowFilter
+             */
             static std::shared_ptr< WindowFilter > NewSP();
 
             // ====================  OPERATORS     =======================
 
             // ====================  LIFECYCLE     =======================
 
-            /// Default protected constructor.
-            WindowFilter ( );
-
-            /// Default protected constructor.
-            ~WindowFilter ( );
 
+        private:
             // ====================  DATA MEMBERS  =========================
 
             /// Width of the window
             /// The type of filter to use
             WINDOWTYPE  Type;
 
-        private:
+            /** ASCII string representation of the class name */
+            static constexpr auto CName = "WindowFilter";
 
-        /** ASCII string representation of the class name */
-        static constexpr auto CName = "WindowFilter";
+            WindowFilter ( const WindowFilter& ) = delete;
 
     }; // -----  end of class  WindowFilter  -----
 

Modules/LemmaCore/include/helper.h

     std::string enum2String(const HANKELTRANSFORMTYPE& Htype);
     /// convert enums to string saves repeated code useful for YAML serializing
     std::string enum2String(const FIELDCALCULATIONS& Htype);
+    /// convert enums to string saves repeated code useful for YAML serializing
+    std::string enum2String(const WINDOWTYPE& Wtype);
 
     // other way around is a template, where template argument lets us know
     // which specialisation to use.

Modules/LemmaCore/include/lemma.h

         */
         enum FIELDCALCULATIONS {E, H, BOTH};
 
+        /** Windowing function type
+         */
+        enum WINDOWTYPE { HAMMING, /*!< A hamming window */
+                          HANNING, /*!< A hanning window */
+                          RECTANGULAR /*!< Rectangular window */
+        };
+
+
     }
 
 #endif // __Lemma_H

Modules/LemmaCore/src/CMakeLists.txt

 	${CMAKE_CURRENT_SOURCE_DIR}/LemmaObject.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/ASCIIParser.cpp                # fixed, key 
 	${CMAKE_CURRENT_SOURCE_DIR}/CubicSplineInterpolator.cpp    # fixed, key 
-	${CMAKE_CURRENT_SOURCE_DIR}/Data.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/DataReader.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/EarthModel.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/Instrument.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarth.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/Grid.cpp       
+	${CMAKE_CURRENT_SOURCE_DIR}/Grid.cpp                       # ABC, no key 
 	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGrid.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridReader.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridVTKExporter.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/Filter.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/WindowFilter.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/Filter.cpp                     # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/WindowFilter.cpp			   # fixed, key
+	${CMAKE_CURRENT_SOURCE_DIR}/EarthModel.cpp                 # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarth.cpp			   # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/Data.cpp                       # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/DataReader.cpp                 # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/Instrument.cpp                 # ABC, no key
 	PARENT_SCOPE
 )

Modules/LemmaCore/src/CubicSplineInterpolator.cpp

     //--------------------------------------------------------------------------------------
     //       Class:  CubicSplineInterpolator
     //      Method:  CubicSplineInterpolator
-    // Description:  constructor (protected)
+    // Description:  constructor (locked with ctor_key)
     //--------------------------------------------------------------------------------------
     CubicSplineInterpolator::CubicSplineInterpolator ( const ctor_key& ) : LemmaObject( ) {
 
     //--------------------------------------------------------------------------------------
     //       Class:  CubicSplineInterpolator
     //      Method:  CubicSplineInterpolator
-    // Description:  DeSerializing constructor (protected)
+    // Description:  DeSerializing constructor (locked with ctor_key)
     //--------------------------------------------------------------------------------------
     CubicSplineInterpolator::CubicSplineInterpolator (const YAML::Node& node, const ctor_key& ) : LemmaObject(node) {
     }  // -----  end of method CubicSplineInterpolator::CubicSplineInterpolator  (constructor)  -----
     // Description:  public constructor
     //--------------------------------------------------------------------------------------
     std::shared_ptr<CubicSplineInterpolator> CubicSplineInterpolator::NewSP() {
-        //std::shared_ptr<CubicSplineInterpolator> sp(new  CubicSplineInterpolator( CubicSplineInterpolator::ctor_key ), LemmaObjectDeleter() );
-        //return sp;
         return std::make_shared<CubicSplineInterpolator>( ctor_key() );
     }
 
         if (node.Tag() != "CubicSplineInterpolator") {
             throw  DeSerializeTypeMismatch( "CubicSplineInterpolator", node.Tag());
         }
-        //std::shared_ptr<CubicSplineInterpolator> Object(new  CubicSplineInterpolator(node), LemmaObjectDeleter() );
-        //return Object ;
         return std::make_shared<CubicSplineInterpolator>( node, ctor_key() );
     }
 

Modules/LemmaCore/src/Data.cpp

 	Data::Data(  ) : LemmaObject( ) {
 	}
 
+    Data::Data( const YAML::Node& node ) : LemmaObject( node ) {
+	}
+
 
 	Data::~Data() {
 	}

Modules/LemmaCore/src/DataReader.cpp

     }
 
 	DataReader::DataReader( ) : LemmaObject( ) {
+
+	}
+
+    DataReader::DataReader( const YAML::Node& node ) : LemmaObject( node ) {
+
 	}
 
 	DataReader::~DataReader() {
+
 	}
 
 }		// -----  end of Lemma  name  -----

Modules/LemmaCore/src/Filter.cpp

 
 namespace Lemma {
 
+    std::ostream &operator << (std::ostream &stream, const Filter &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  Filter
+    //      Method:  Filter
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
     Filter::Filter( ) : LemmaObject( ) { }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  Filter
+    //      Method:  ~Filter
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
     Filter::~Filter( ) { }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  Filter
+    //      Method:  Filter
+    // Description:  DeSerializing constructor (protected)
+    //--------------------------------------------------------------------------------------
+    Filter::Filter ( const YAML::Node& node ) : LemmaObject(node) {
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  Filter
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  Filter::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();;
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        return node;
+    }		// -----  end of method Filter::Serialize  -----
 }		// -----  end of Lemma  name  -----

Modules/LemmaCore/src/Grid.cpp

 	}
 
     YAML::Node Grid::Serialize() const {
-
         YAML::Node node = LemmaObject::Serialize();
         node.SetTag( this->GetName() );
         return node;
-
     }
 
 }

Modules/LemmaCore/src/Instrument.cpp

 	Instrument::Instrument( ) : LemmaObject() {
 	}
 
+    Instrument::Instrument( const YAML::Node& node ) : LemmaObject( node ) {
+	    // Fill in class specifics
+    }
+
 	Instrument::~Instrument() {
 	}
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  Instrument
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  Instrument::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();;
+        node.SetTag( GetName() );
+        // Fill in class specifics
+        return node;
+    }		// -----  end of method Instrument::Serialize  -----
+
 }		// -----  end of Lemma  name  -----

Modules/LemmaCore/src/LayeredEarth.cpp

 	LayeredEarth::~LayeredEarth() {
 	}
 
-    LayeredEarth::LayeredEarth(const YAML::Node& node) : EarthModel(node)
-    {
+    LayeredEarth::LayeredEarth(const YAML::Node& node) : EarthModel(node) {
         NumberOfLayers = node["NumberOfLayers"].as<int>();
         NumberOfInterfaces = node["NumberOfInterfaces"].as<int>();
         LayerThickness = node["LayerThickness"].as<VectorXr>();

Modules/LemmaCore/src/WindowFilter.cpp

 
 namespace Lemma {
 
-    // ====================  LIFECYCLE     =======================
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const WindowFilter &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
 
-    WindowFilter::WindowFilter( ) : Filter( ),
-        Width(0), SamplingRate(0), Bandwidth(0), Coefficients(),
-        Type(RECTANGULAR) {}
+    // ====================  LIFECYCLE     =======================
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  WindowFilter
+    // Description:  constructor (locked with ctor_key)
+    //--------------------------------------------------------------------------------------
+    WindowFilter::WindowFilter( const ctor_key& ) : Filter( ),
+        Width(0), SamplingRate(0), Bandwidth(0), Coefficients(), Type(RECTANGULAR)
+    {
+    }   // -----  end of method WindowFilter::WindowFilter  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  WindowFilter
+    // Description:  DeSerializing constructor (locked with ctor_key)
+    //--------------------------------------------------------------------------------------
+    WindowFilter::WindowFilter( const YAML::Node& node, const ctor_key& ) : Filter( node ),
+        Width(0), SamplingRate(0), Bandwidth(0), Coefficients(), Type(RECTANGULAR)
+    {
+        Width = node["Width"].as<int>( );
+        Nt = node["Nt"].as<int>( );
+        Nw = node["Nw"].as<int>( );
+        SamplingRate = node["SamplingRate"].as<Real>();
+        Bandwidth = node["Bandwidth"].as<Real>();
+        Coefficients = node["Coefficients"].as<VectorXr>();
+        Type = string2Enum<WINDOWTYPE>( node["WINDOWTYPE"].as<std::string>() );
+    } // -----  end of method WindowFilter::WindowFilter  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  NewSP()
+    // Description:  public constructor
+    //--------------------------------------------------------------------------------------
     std::shared_ptr< WindowFilter > WindowFilter::NewSP() {
-        std::shared_ptr<WindowFilter> sp(new  WindowFilter( ), LemmaObjectDeleter() );
-        return sp;
+        return std::make_shared< WindowFilter >( ctor_key() );
     }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  ~WindowFilter
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
     WindowFilter::~WindowFilter() {
     }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  WindowFilter::Serialize (  ) const {
+        YAML::Node node = Filter::Serialize();;
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        node["Width"] = Width;
+        node["Nt"] = Nt;
+        node["Nw"] = Nw;
+        node["SamplingRate"] = SamplingRate;
+        node["Bandwidth"] = Bandwidth;
+        node["Coefficients"] = Coefficients;
+        node["WINDOWTYPE"] = enum2String(Type);
+        return node;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<WindowFilter> WindowFilter::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() != "WindowFilter") {
+            throw  DeSerializeTypeMismatch( "WindowFilter", node.Tag());
+        }
+        return std::make_shared<WindowFilter>( node, ctor_key() );
+    }
 
     // ====================  OPERATIONS    =======================
 

Modules/LemmaCore/src/helper.cpp

     return t;
 }
 
+std::string enum2String( const WINDOWTYPE& Type ) {
+    std::string t;
+    switch (Type) {
+        case HAMMING:
+            return std::string("HAMMING");
+        case HANNING:
+            return  std::string("HANNING");
+        case RECTANGULAR:
+            return std::string("RECTANGULAR");
+        default:
+            throw( std::runtime_error( "In enum2String WINDOWTYPE, type not identified" ) );
+    }
+}
+
 template<>
 FREQUENCYUNITS string2Enum<FREQUENCYUNITS>( const std::string& str ) {
     if       (str ==  "HZ") return   HZ;
     }
 }
 
+template<>
+WINDOWTYPE string2Enum<WINDOWTYPE>( const std::string& str ) {
+    if      (str == "HAMMING")      return HAMMING;
+    if      (str == "HANNING")      return HANNING;
+    if      (str == "RECTANGULAR")  return RECTANGULAR;
+    else {
+        throw std::runtime_error("string not recognized as WindowType");
+    }
+}
+
 }		// -----  end of Lemma  name  -----
 

Modules/LemmaCore/testing/SerializeCheck.h

 {
     public:
 
-//     void testASCIIParser( void )
-//     {
-//         auto Obj = ASCIIParser::NewSP();
-//         YAML::Node node = Obj->Serialize();
-//         auto Obj2 = ASCIIParser::DeSerialize(node);
-//         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
-//     }
-
+    void testASCIIParser( void )
+    {
+        auto Obj = ASCIIParser::NewSP();
+        YAML::Node node = Obj->Serialize();
+        auto Obj2 = ASCIIParser::DeSerialize(node);
+        TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+    }
 
     void testCubicSplineInterpolator(void)
     {
         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
     }
 
+    void testWindowFilter( void )
+    {
+        auto Obj = WindowFilter::NewSP();
+        YAML::Node node = Obj->Serialize();
+        auto Obj2 = WindowFilter::DeSerialize(node);
+        TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+    }
+
 // /*
 //     void testRectilinearGridReader( void )
 //     {
 //         TS_ASSERT_EQUALS( Obj->GetName(), std::string("RectilinearGridVTKExporter") );
 //     }
 //
-//     void testWindowFilter( void )
-//     {
-//         auto Obj = WindowFilter::NewSP();
-//         TS_ASSERT_EQUALS( Obj->GetName(), std::string("WindowFilter") );
-//     }
+
 // */
 
 };

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
+"highlight cComment ctermfg=Green guifg=Green
+highlight cType ctermfg=Green guifg=Green
+syn keyword cType Real Complex VectorXr VectorXcr Vector3r Vector3Xr VectorXi Vector3cr Vector3Xcr MatrixXr MatrixXi MatrixXcr shared_ptr make_shared
 
+highlight constType ctermfg=Red guifg=Red
+syn keyword constType  PI EPSILON0 MU0 QPI  
+
+highlight eType ctermfg=Magenta guifg=Magenta
+syn keyword eType  MAGUNITS  TEMPUNITS  TIMEUNITS FREQUENCYUNITS FEMCOILORIENTATION ORIENTATION FIELDTYPE FIELDCOMPONENT SPATIALCOORDINANT HANKELTRANSFORMTYPE FIELDCALCULATIONS WINDOWTYPE 
+
+highlight eeType ctermfg=Cyan guifg=Cyan
+syn keyword eeType  TESLA NANOTESLA GAUSS CELCIUS KELVIN SEC MILLISEC MICROSEC NANOSEC PICOSEC HZ KHZ MHZ GHZ COAXIAL COPLANAR HFIELDREAL HFIELDIMAG EFIELDREAL EFIELDIMAG XCOMPONENT YCOMPONENT ZCOMPONENT XCOORD YCOORD ZCOORD X Y Z NX  NY  NZ ANDERSON801 CHAVE FHTKEY201 FHTKEY101 FHTKEY51 QWEKEY E H BOTH HAMMING HANNING RECTANGULAR
+
+" Namespaces
+highlight nspace ctermfg=Red guifg=Red
+syn keyword nspace Lemma YAML Eigen 
+
+" Lemma types
+highlight leType ctermfg=Yellow guifg=Yellow
+syn keyword leType HankelTransform KernelEm1D KernelEM1DManager DipoleSource EarthModel LayeredEarth LayeredEarthEM TEMSurvey TEMSurveyLine TEMSurveyLineRecord TEMInductiveReceiver PolygonalWireAntenna TEMTransmitter TEMReceiver Instrument InstrumentTem LemmaObject ReceiverPoints DCIPElectrode TEMSurveyData TEMSurveyLineData TEMSurveyLineRecordData  ASCIIParser CubicSplineInterpolator RectilinearGrid RectilinearGridReader RectilinearGridVTKExporter Filter WindowFilter DEMParticle DEMGrain Data DataReader
+
+" Deprecated Lemma Types
+highlight dleType ctermfg=Blue guifg=Blue 
+syn keyword dleType  ReferenceCountedObject 

vim/cpp.cpp.template

 
 	friend std::ostream &operator<<(std::ostream &stream, const |CLASSNAME| &ob);
 
+    /*
+     *  This key is used to lock the constructor.
+     */
+    struct ctor_key {};
+
 	public:
 
 	    // ====================  LIFECYCLE     =======================
 
-        /*
-         *  Factory method for generating concrete class.
-         *  @return a std::shared_ptr of type |CLASSNAME|
+        /**
+         * Default constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see |CLASSNAME|::NewSP
          */
-	    static std::shared_ptr< |CLASSNAME| > NewSP();
+        explicit |CLASSNAME| ( const ctor_key& );
+
+        /**
+         * DeSerializing constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see |CLASSNAME|::DeSerialize
+         */
+        |CLASSNAME| (const YAML::Node& node);
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficeint
+         *       make_shared constructor.
+         */
+        virtual ~|CLASSNAME| ();
 
         /**
          *  Uses YAML to serialize this object.
          *  @return a YAML::Node
-         *   @see |CLASSNAME|::DeSerialize
+         *  @see |CLASSNAME|::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type |CLASSNAME|
          */
-        YAML::Node Serialize() const;
+	    static std::shared_ptr< |CLASSNAME| > NewSP();
 
         /**
          *   Constructs an |CLASSNAME| object from a YAML::Node.
 
         // ====================  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  =========================
+    	// ====================  DATA MEMBERS  =========================
 
     private:
 
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "|CLASSNAME|";
+
 }; // -----  end of class  |CLASSNAME|  -----
 }  // -----  end of namespace Lemma ----