Updates for Lemma with shared_ptr, working again.

CMakeLists.txt

-if (LEMMA_VTK6_SUPPORT OR LEMMA_VTK7_SUPPORT)
+if (LEMMA_VTK7_SUPPORT OR LEMMA_VTK8_SUPPORT)
 	include_directories(${CMAKE_INSTALL_PREFIX}/include)
 
 	include_directories( "${CMAKE_CURRENT_SOURCE_DIR}/include" )
 	add_subdirectory("src")
-
+	
 	add_library( fem4ellipticpde ${FEMSOURCE} )  
-	target_link_libraries(fem4ellipticpde "lemmacore")
 
+	set_target_properties(fem4ellipticpde PROPERTIES 
+		VERSION  "${LEMMA_VERSION_NOQUOTES}"
+		SOVERSION "${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}"
+		PROJECT_LABEL "FDEM1D ${LABEL_SUFFIX}"
+    	CXX_STANDARD 14
+    	CXX_STANDARD_REQUIRED ON
+	)
+
+	target_link_libraries(fem4ellipticpde "lemmacore" "dcip")
 	install ( TARGETS fem4ellipticpde DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
 
 	if (LEMMA_BUILD_EXAMPLES)

examples/FEM4EllipticPDE_bhmag.cpp

 
     ////////////////////////////////////////////
     // Solve
-    FEM4EllipticPDE *Solver = FEM4EllipticPDE::New();
+    auto Solver = FEM4EllipticPDE::NewSP();
         //Solver->SetGFunction(implG);
         //Solver->SetGFunction(Magnet);
         //Solver->SetSigmaFunction(implSigma);
         Solver->Solve(argv[3]);
 
     // Clean up
-    Solver->Delete();
+    //Solver->Delete();
     GReader->Delete();
     //implG->Delete();
-
     exit(EXIT_SUCCESS);
 }
 

examples/LinearMag/Sphere.cpp

  * @copyright Copyright (c) 2016, Trevor Irons & Lemma Software, LLC
  */
 
-#include "Lemma"
+#include "LemmaCore"
 #include "LinearMag.h"
 
 using namespace Lemma;
         exit(EXIT_SUCCESS);
     }
 
-    LinearMag* Mag = LinearMag::New();
+    auto Mag = LinearMag::NewSP();
         Mag->SetInducingMagField( 55234., 0, 0, NANOTESLA );
         Mag->SetVTUGridFile( argv[1] );
         Mag->CalculateRHS( "kappa" );
     // Print out YAML serialization of class
     std::cout << *Mag << std::endl;
 
-    Mag->Delete();
     exit(EXIT_SUCCESS);
 }
 

examples/ResampleWithDataset.cpp

 #include <cmath>
 #include <Eigen/Core>
 
-
 int main(int argc, char**argv) {
 
-
     std::cout << "Mesh boundary assigment routine\n";
     if (argc<4) {
         std::cout << "usage:\n" << "./ResampleWithDataset  inMesh.vtu  boundaries.stl  outG.vtu" << std::endl;
 
     //std::cout << *Resample << std::endl;.
 
-   std::cout << "Resampled grid, ncells=" << Resample->GetOutput()->GetNumberOfCells()  
-             << " npoints=" << Resample->GetOutput()->GetNumberOfPoints() << std::endl; 
+   std::cout << "Resampled grid, ncells=" << Resample->GetOutput()->GetNumberOfCells()
+             << " npoints=" << Resample->GetOutput()->GetNumberOfPoints() << std::endl;
 
     vtkXMLUnstructuredGridWriter* Writer = vtkXMLUnstructuredGridWriter::New();
         Writer->SetInputData( Resample->GetOutput() );

examples/VTKDC.cpp

     std::ifstream ifstr(argv[2]);
     //std::vector<YAML::Node> nodes = YAML::LoadAll(ifstr);
     YAML::Node nodes = YAML::Load(ifstr);
-    DCSurvey* Survey = DCSurvey::DeSerialize(nodes);
+    auto Survey = DCSurvey::DeSerialize(nodes);
     //std::cout << *Survey << std::endl;
 
 
     ////////////////////////////////////////////
     // Solve
-    FEM4EllipticPDE *Solver = FEM4EllipticPDE::New();
+    auto Solver = FEM4EllipticPDE::NewSP();
         //Solver->SetGFunction(implG);
         //Solver->SetGFunction(Magnet);
         //Solver->SetSigmaFunction(implSigma);
         //Solver->SetBoundaryStep(.05);
 
         Solver->SetGrid(uGrid);
-        Solver->SetupDC(Survey, 0);
+        Solver->SetupDC( Survey.get(), 0 );
         Solver->Solve( argv[3] );
         //Solver->SetGrid(rGrid);
         //Solver->Solve(argv[3]);
 
-    Survey->Delete();
-    Solver->Delete();
-
     exit(EXIT_SUCCESS);
 }

include/FEM4EllipticPDE.h

             /** Returns a pointer to a new object of type FEM4EllipticPDE.
              * It allocates all necessary memory.
              */
-            static FEM4EllipticPDE* New();
+            static std::shared_ptr<FEM4EllipticPDE> NewSP();
 
-            /** Deletes this object. Delete also disconnects any
-             * attachments to this object.
+            /**
+             * Default locked constructor.
              */
-            void Delete();
+            explicit FEM4EllipticPDE (const ctor_key& key);
+
+            /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+            FEM4EllipticPDE (const YAML::Node& node, const ctor_key& key);
 
+            /** Default protected constructor. */
+            ~FEM4EllipticPDE ();
 
-            #ifdef HAVE_YAMLCPP
             /**
              *  Uses YAML to serialize this object.
              *  @return a YAML::Node
             /**
              *   Constructs an object from a YAML::Node.
              */
-            static FEM4EllipticPDE* DeSerialize(const YAML::Node& node);
-            #endif
+            static std::shared_ptr<FEM4EllipticPDE> 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.
-            FEM4EllipticPDE (const std::string& cname);
-
-            #ifdef HAVE_YAMLCPP
-            /** Protected DeDerializing constructor, use factory DeSerialize  method*/
-            FEM4EllipticPDE (const YAML::Node& node);
-            #endif
-
-            /** Default protected constructor. */
-            ~FEM4EllipticPDE ();
-
-            /**
-             * @copybrief LemmaObject::Release()
-             * @copydetails LemmaObject::Release()
-             */
-            void Release();
-
             // ====================  OPERATIONS    =======================
 
             /** Used internally to construct stiffness matrix, A
 
         private:
 
+            static constexpr auto CName = "FEM4EllipticPDE";
+
     }; // -----  end of class  FEM4EllipticPDE  -----
 
     /*! @} */

include/LinearMag.h

      */
     class LinearMag : public FEM4EllipticPDE {
 
-        friend std::ostream &operator<<(std::ostream &stream,
-                const LinearMag &ob);
+        friend std::ostream &operator << (std::ostream &stream, const LinearMag &ob);
 
         public:
 
         // ====================  LIFECYCLE     =======================
 
         /**
-         * @copybrief LemmaObject::New()
-         * @copydetails LemmaObject::New()
+         * @copybrief LemmaObject::NewSP()
+         * @copydetails LemmaObject::NewSP()
          */
-        static LinearMag* New();
+        static std::shared_ptr<LinearMag> NewSP();
 
-        /**
-         *  @copybrief   LemmaObject::Delete()
-         *  @copydetails LemmaObject::Delete()
-         */
-        void Delete();
+        /** Default protected constructor, use New */
+        LinearMag (const ctor_key& key);
+
+        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+        LinearMag (const YAML::Node& node, const ctor_key& key);
+
+        /** Default protected destructor, use Delete */
+        ~LinearMag ();
 
-#ifdef HAVE_YAMLCPP
         /**
          *  Uses YAML to serialize this object.
          *  @return a YAML::Node
         /**
          *   Constructs an object from a YAML::Node.
          */
-        static LinearMag* DeSerialize(const YAML::Node& node);
-#endif
+        static std::shared_ptr<LinearMag> 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 */
-        LinearMag (const std::string& name);
-
-#ifdef HAVE_YAMLCPP
-        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
-        LinearMag (const YAML::Node& node);
-#endif
-
-        /** Default protected destructor, use Delete */
-        ~LinearMag ();
-
-        /**
-         *  @copybrief   LemmaObject::Release()
-         *  @copydetails LemmaObject::Release()
-         */
-        void Release();
-
         private:
 
         // ====================  DATA MEMBERS  =========================
 
         Vector3r    B0;
 
-
         /**
          *   Used internally to scale mag units into Tesla
          */
         void ScaleB0 ( const MAGUNITS& U);
 
+        static constexpr auto CName = "LinearMag";
+
     }; // -----  end of class  LinearMag  -----
 
     /*! @} */ // End of group

src/FEM4EllipticPDE.cpp

   @file
   @author   Trevor Irons
   @date     08/16/12
-  @version   0.0
  **/
 
 #include "FEM4EllipticPDE.h"
 
 namespace Lemma {
 
-#ifdef HAVE_YAMLCPP
     std::ostream &operator << (std::ostream &stream, const FEM4EllipticPDE &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
-#else
-	std::ostream &operator<<(std::ostream &stream,
-				const FEM4EllipticPDE &ob) {
-		stream << *(LemmaObject*)(&ob);
-		return stream;
-	}
-#endif
-
 
 	// ====================  LIFECYCLE     =======================
 
-	FEM4EllipticPDE::FEM4EllipticPDE(const std::string&name) :
-			LemmaObject(name), BndryH(10), BndrySigma(10),
+	FEM4EllipticPDE::FEM4EllipticPDE( const ctor_key& key ) :
+			LemmaObject(key), BndryH(10), BndrySigma(10),
             vtkSigma(nullptr), vtkG(nullptr), vtkGrid(nullptr), gFcn3(nullptr) {
 	}
 
-    #ifdef HAVE_YAMLCPP
     //--------------------------------------------------------------------------------------
     //       Class:  FEM4EllipticPDE
     //      Method:  FEM4EllipticPDE
     // Description:  DeSerializing constructor (protected)
     //--------------------------------------------------------------------------------------
-    FEM4EllipticPDE::FEM4EllipticPDE (const YAML::Node& node) : LemmaObject(node) {
+    FEM4EllipticPDE::FEM4EllipticPDE (const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
         // TODO impliment
         throw std::runtime_error("FEM4ELLIPTICPDE YAML CONSTRUCTOR NOT IMPLIMENTED!");
     }  // -----  end of method FEM4EllipticPDE::FEM4EllipticPDE  (constructor)  -----
-    #endif
 
 	FEM4EllipticPDE::~FEM4EllipticPDE() {
 	}
 
-    void FEM4EllipticPDE::Release() {
-        delete this;
-    }
-
-    FEM4EllipticPDE* FEM4EllipticPDE::New( ) {
-        FEM4EllipticPDE* Obj = new FEM4EllipticPDE("FEM4EllipticPDE");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<FEM4EllipticPDE> FEM4EllipticPDE::NewSP( ) {
+        return std::make_shared<FEM4EllipticPDE>( ctor_key() );
     }
 
-    void FEM4EllipticPDE::Delete() {
-        this->DetachFrom(this);
-    }
-
-#ifdef HAVE_YAMLCPP
     //--------------------------------------------------------------------------------------
     //       Class:  FEM4EllipticPDE
     //      Method:  Serialize
     //--------------------------------------------------------------------------------------
     YAML::Node  FEM4EllipticPDE::Serialize (  ) const {
-        YAML::Node node = LemmaObject::Serialize();;
-        node.SetTag( this->Name );
-        // FILL IN CLASS SPECIFICS HERE
+        YAML::Node node = LemmaObject::Serialize();
+        node.SetTag( this->GetName() );
+        // node["thing"] = value;
         return node;
     }		// -----  end of method FEM4EllipticPDE::Serialize  -----
 
-
     //--------------------------------------------------------------------------------------
     //       Class:  FEM4EllipticPDE
     //      Method:  DeSerialize
     //--------------------------------------------------------------------------------------
-    FEM4EllipticPDE* FEM4EllipticPDE::DeSerialize ( const YAML::Node& node  ) {
-        FEM4EllipticPDE* Object = new FEM4EllipticPDE(node);
-        Object->AttachTo(Object);
-        DESERIALIZECHECK( node, Object )
-            return Object ;
+    std::shared_ptr<FEM4EllipticPDE> FEM4EllipticPDE::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() != "FEM4EllipticPDE") {
+            throw DeSerializeTypeMismatch( "FEM4EllipticPDE", node.Tag() );
+        }
+        return std::make_shared<FEM4EllipticPDE> (node, ctor_key());
     }		// -----  end of method FEM4EllipticPDE::DeSerialize  -----
-#endif
 
     // ====================  OPERATIONS    =======================
 

src/LinearMag.cpp

 /**
  * @file
  * @date      03/21/2016 02:10:08 PM
- * @version   $Id$
  * @author    Trevor Irons (ti)
  * @email     tirons@egi.utah.edu
  * @copyright Copyright (c) 2016, University of Utah
 namespace Lemma {
 
 // ====================  FRIEND METHODS  =====================
-#ifdef HAVE_YAMLCPP
 std::ostream &operator << (std::ostream &stream, const LinearMag &ob) {
-    stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapsulate thingy
+    stream << ob.Serialize()  << "\n";
     return stream;
 }
-#else
-std::ostream &operator<<(std::ostream &stream, const LinearMag& ob) {
-    stream << *(FEM4EllipticPDE*)(&ob);
-    return stream;
-}
-#endif
 
 // ====================  LIFECYCLE     =======================
 
 //      Method:  LinearMag
 // Description:  constructor (protected)
 //--------------------------------------------------------------------------------------
-LinearMag::LinearMag (const std::string& name) : FEM4EllipticPDE(name) {
+LinearMag::LinearMag (const ctor_key& key) : FEM4EllipticPDE(key) {
 
 }  // -----  end of method LinearMag::LinearMag  (constructor)  -----
 
-#ifdef HAVE_YAMLCPP
 //--------------------------------------------------------------------------------------
 //       Class:  LinearMag
 //      Method:  LinearMag
 // Description:  DeSerializing constructor (protected)
 //--------------------------------------------------------------------------------------
-LinearMag::LinearMag (const YAML::Node& node) : FEM4EllipticPDE(node) {
+LinearMag::LinearMag (const YAML::Node& node, const ctor_key& key) : FEM4EllipticPDE(node, key) {
 
 }  // -----  end of method LinearMag::LinearMag  (constructor)  -----
-#endif
 
 //--------------------------------------------------------------------------------------
 //       Class:  LinearMag
 //      Method:  New()
 // Description:  public constructor
 //--------------------------------------------------------------------------------------
-LinearMag* LinearMag::New() {
-    LinearMag*  Obj = new LinearMag("LinearMag");
-    Obj->AttachTo(Obj);
-    return Obj;
+std::shared_ptr<LinearMag> LinearMag::NewSP() {
+    return std::make_shared<LinearMag>( ctor_key() );
 }
 
 //--------------------------------------------------------------------------------------
 
 //--------------------------------------------------------------------------------------
 //       Class:  LinearMag
-//      Method:  Delete
-// Description:  public destructor
-//--------------------------------------------------------------------------------------
-void LinearMag::Delete() {
-    this->DetachFrom(this);
-}
-
-//--------------------------------------------------------------------------------------
-//       Class:  LinearMag
-//      Method:  Release
-// Description:  destructor (protected)
-//--------------------------------------------------------------------------------------
-void LinearMag::Release() {
-    delete this;
-}
-
-
-#ifdef HAVE_YAMLCPP
-//--------------------------------------------------------------------------------------
-//       Class:  LinearMag
 //      Method:  Serialize
 //--------------------------------------------------------------------------------------
 YAML::Node  LinearMag::Serialize (  ) const {
     YAML::Node node = FEM4EllipticPDE::Serialize();;
-    node.SetTag( this->Name );
+    node.SetTag( this->GetName() );
     // FILL IN CLASS SPECIFICS HERE
     node["B0"] = B0;
     return node;
 //       Class:  LinearMag
 //      Method:  DeSerialize
 //--------------------------------------------------------------------------------------
-LinearMag* LinearMag::DeSerialize ( const YAML::Node& node  ) {
-    LinearMag* Object = new LinearMag(node);
-    Object->AttachTo(Object);
-    DESERIALIZECHECK( node, Object )
-        return Object ;
+std::shared_ptr<LinearMag> LinearMag::DeSerialize ( const YAML::Node& node ) {
+    if ( node.Tag() != "LinearMag") {
+        throw DeSerializeTypeMismatch( "LinearMag", node.Tag() );
+    }
+    return std::make_shared<LinearMag>( node, ctor_key() );
 }		// -----  end of method LinearMag::DeSerialize  -----
-#endif
-
-
 
 //--------------------------------------------------------------------------------------
 //       Class:  LinearMag
     G->SetName("G");
     //g.resize(vtkGrid->GetNumberOfPoints());
     VectorXr GG = VectorXr::Zero( vtkGrid->GetNumberOfPoints() );
-    
+
     // Iterate over all the points or all of the cells?
     for (int ic=0; ic < vtkGrid->GetNumberOfCells(); ++ic) {