Merge branch 'entity-tag-refactor' into 'master'

Refactor using Entity tags

See merge request !52

src/OpenVolumeMesh/Attribs/StatusAttrib.hh

@@ -108,12 +108,12 @@ public:
     }
 
     const OpenVolumeMeshStatus& mesh_status() const {
-        OpenVolumeMeshHandle h(0);
+        MeshHandle h(0);
         return m_status_[h];
     }
 
     OpenVolumeMeshStatus& mesh_status() {
-        OpenVolumeMeshHandle h(0);
+        MeshHandle h(0);
         return m_status_[h];
     }
 

src/OpenVolumeMesh/Core/Entities.hh

+#pragma once
+
+#include <type_traits>
+
+namespace OpenVolumeMesh {
+
+namespace Entity {
+    struct Vertex   {};
+    struct Edge     {};
+    struct HalfEdge {};
+    struct Face     {};
+    struct HalfFace {};
+    struct Cell     {};
+    struct Mesh     {};
+}
+
+template<typename T>
+struct is_entity : std::false_type {};
+
+template<> struct is_entity<Entity::Vertex>   : std::true_type {};
+template<> struct is_entity<Entity::Edge>     : std::true_type {};
+template<> struct is_entity<Entity::HalfEdge> : std::true_type {};
+template<> struct is_entity<Entity::Face>     : std::true_type {};
+template<> struct is_entity<Entity::HalfFace> : std::true_type {};
+template<> struct is_entity<Entity::Cell>     : std::true_type {};
+template<> struct is_entity<Entity::Mesh>     : std::true_type {};
+
+} // namespace OpenVolumeMesh

src/OpenVolumeMesh/Core/ForwardDeclarations.hh

+#pragma once
+#include "Entities.hh"
+
+namespace OpenVolumeMesh {
+
+class BaseProperty;
+
+template <class T>
+class OpenVolumeMeshPropertyT;
+
+template <class E, typename >
+class PropHandleT;
+
+template <class PropT, class HandleT>
+class PropertyPtr;
+
+template<typename T, typename Entity>
+class PropertyTT;
+
+template<typename T> using VertexPropertyT   = PropertyTT<T, Entity::Vertex>;
+template<typename T> using EdgePropertyT     = PropertyTT<T, Entity::Edge>;
+template<typename T> using HalfEdgePropertyT = PropertyTT<T, Entity::HalfEdge>;
+template<typename T> using FacePropertyT     = PropertyTT<T, Entity::Face>;
+template<typename T> using HalfFacePropertyT = PropertyTT<T, Entity::HalfFace>;
+template<typename T> using CellPropertyT     = PropertyTT<T, Entity::Cell>;
+template<typename T> using MeshPropertyT     = PropertyTT<T, Entity::Mesh>;
+
+} // namespace OVM

src/OpenVolumeMesh/Core/OpenVolumeMeshHandle.cc

@@ -32,14 +32,6 @@
  *                                                                           *
 \*===========================================================================*/
 
-/*===========================================================================*\
- *                                                                           *
- *   $Revision: 36 $                                                         *
- *   $Date: 2012-01-10 18:00:06 +0100 (Di, 10 Jan 2012) $                    *
- *   $LastChangedBy: kremer $                                                *
- *                                                                           *
-\*===========================================================================*/
-
 #include <istream>
 
 #include "OpenVolumeMeshHandle.hh"

src/OpenVolumeMesh/Core/OpenVolumeMeshHandle.hh

@@ -32,21 +32,13 @@
  *                                                                           *
 \*===========================================================================*/
 
-/*===========================================================================*\
- *                                                                           *
- *   $Revision$                                                         *
- *   $Date$                    *
- *   $LastChangedBy$                                                *
- *                                                                           *
-\*===========================================================================*/
-
-#ifndef OPENVOLUMEMESHHANDLE_HH_
-#define OPENVOLUMEMESHHANDLE_HH_
+#pragma once
 
 #include <algorithm>
 #include <iosfwd>
 #include <vector>
 
+#include "Entities.hh"
 #include "../System/FunctionalInclude.hh"
 #include "../System/Deprecation.hh"
 
@@ -95,14 +87,25 @@ private:
 	int idx_;
 };
 
+
+template<typename EntityTag,
+    typename = typename std::enable_if<is_entity<EntityTag>::value>::type>
+class HandleT : public OpenVolumeMeshHandle
+{
+public:
+    using Entity = EntityTag;
+    explicit HandleT(int _idx = -1) : OpenVolumeMeshHandle(_idx) {}
+};
+
 // Default entity handles
 
-class VertexHandle   : public OpenVolumeMeshHandle { public: explicit VertexHandle(int _idx = -1)   : OpenVolumeMeshHandle(_idx) {} };
-class EdgeHandle     : public OpenVolumeMeshHandle { public: explicit EdgeHandle(int _idx = -1)     : OpenVolumeMeshHandle(_idx) {} };
-class FaceHandle     : public OpenVolumeMeshHandle { public: explicit FaceHandle(int _idx = -1)     : OpenVolumeMeshHandle(_idx) {} };
-class CellHandle     : public OpenVolumeMeshHandle { public: explicit CellHandle(int _idx = -1)     : OpenVolumeMeshHandle(_idx) {} };
-class HalfEdgeHandle : public OpenVolumeMeshHandle { public: explicit HalfEdgeHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} };
-class HalfFaceHandle : public OpenVolumeMeshHandle { public: explicit HalfFaceHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} };
+using VertexHandle   = HandleT<Entity::Vertex>;
+using HalfEdgeHandle = HandleT<Entity::HalfEdge>;
+using EdgeHandle     = HandleT<Entity::Edge>;
+using HalfFaceHandle = HandleT<Entity::HalfFace>;
+using FaceHandle     = HandleT<Entity::Face>;
+using CellHandle     = HandleT<Entity::Cell>;
+using MeshHandle     = HandleT<Entity::Mesh>;
 
 // Helper class that is used to decrease all handles
 // exceeding a certain threshold
@@ -176,4 +179,3 @@ std::istream& operator>>(std::istream& _istr, OpenVolumeMeshHandle& _handle);
 
 } // Namespace OpenVolumeMesh
 
-#endif /* OPENVOLUMEMESHHANDLE_HH_ */

src/OpenVolumeMesh/Core/OpenVolumeMeshProperty.hh

@@ -32,16 +32,7 @@
  *                                                                           *
 \*===========================================================================*/
 
-/*===========================================================================*\
- *                                                                           *
- *   $Revision$                                                         *
- *   $Date$                    *
- *   $LastChangedBy$                                                *
- *                                                                           *
-\*===========================================================================*/
-
-#ifndef OPENVOLUMEMESHPROPERTY_HH
-#define OPENVOLUMEMESHPROPERTY_HH
+#pragma once
 
 //== INCLUDES =================================================================
 
@@ -520,6 +511,3 @@ private:
 
 } // Namespace OpenVolumeMesh
 
-//=============================================================================
-#endif // OPENVOLUMEMESHPROPERTY_HH defined
-//=============================================================================

src/OpenVolumeMesh/Core/PropertyDefines.cc

@@ -32,13 +32,6 @@
  *                                                                           *
 \*===========================================================================*/
 
-/*===========================================================================*\
- *                                                                           *
- *   $Revision$                                                         *
- *   $Date$                    *
- *   $LastChangedBy$                                                *
- *                                                                           *
-\*===========================================================================*/
 
 #include "PropertyDefines.hh"
 
@@ -60,4 +53,13 @@ template <> const std::string typeName<std::vector<double> >(){ return "vector_d
 template <> const std::string typeName<std::vector<VertexHandle> >(){ return "vector_vh"; }
 template <> const std::string typeName<std::vector<HalfFaceHandle> >(){ return "vector_hfh"; }
 template <> const std::string typeName<std::vector<std::vector<HalfFaceHandle> > >(){ return "vector_vector_hfh"; }
+
+template <> const std::string entityTypeName<Entity::Vertex>()  { return "VProp";  }
+template <> const std::string entityTypeName<Entity::HalfEdge>(){ return "HEProp"; }
+template <> const std::string entityTypeName<Entity::Edge>()    { return "EProp";  }
+template <> const std::string entityTypeName<Entity::Face>()    { return "FProp";  }
+template <> const std::string entityTypeName<Entity::HalfFace>(){ return "HFProp"; }
+template <> const std::string entityTypeName<Entity::Cell>()    { return "CProp";  }
+template <> const std::string entityTypeName<Entity::Mesh>()    { return "MProp";  }
+
 } // Namespace OpenVolumeMesh

src/OpenVolumeMesh/Core/PropertyDefines.hh

@@ -32,22 +32,14 @@
  *                                                                           *
 \*===========================================================================*/
 
-/*===========================================================================*\
- *                                                                           *
- *   $Revision$                                                         *
- *   $Date$                    *
- *   $LastChangedBy$                                                *
- *                                                                           *
-\*===========================================================================*/
-
-#ifndef PROPERTYDEFINES_HH_
-#define PROPERTYDEFINES_HH_
+#pragma once
 
 #include <iosfwd>
 #include <stdexcept>
 #include <string>
 #include <typeinfo>
 
+#include "Entities.hh"
 #include "PropertyHandles.hh"
 #include "PropertyPtr.hh"
 
@@ -78,103 +70,43 @@ template <>  const std::string typeName<std::vector<VertexHandle> >();
 template <>  const std::string typeName<std::vector<HalfFaceHandle> >();
 template <>  const std::string typeName<std::vector<std::vector<HalfFaceHandle> > >();
 
-/// Property classes for the different entity types
-template<class T>
-class VertexPropertyT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle> {
-public:
-    VertexPropertyT(const std::string& _name, ResourceManager& _resMan, VertexPropHandle _handle, const T _def = T());
-    virtual ~VertexPropertyT() {}
-    virtual BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const;
-    virtual void serialize(std::ostream& _ostr) const;
-    virtual void deserialize(std::istream& _istr);
-    virtual const std::string entityType() const { return "VProp"; }
-    virtual const std::string typeNameWrapper() const { return typeName<T>(); }
-private:
-    VertexPropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, VertexPropHandle _handle);
-};
-template<class T>
-class EdgePropertyT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, EdgePropHandle> {
-public:
-    EdgePropertyT(const std::string& _name, ResourceManager& _resMan, EdgePropHandle _handle, const T _def = T());
-    virtual ~EdgePropertyT() {}
-    virtual BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const;
-    virtual void serialize(std::ostream& _ostr) const;
-    virtual void deserialize(std::istream& _istr);
-    virtual const std::string entityType() const { return "EProp"; }
-    virtual const std::string typeNameWrapper() const { return typeName<T>(); }
-private:
-    EdgePropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, EdgePropHandle _handle);
-};
-template<class T>
-class HalfEdgePropertyT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfEdgePropHandle> {
-public:
-    HalfEdgePropertyT(const std::string& _name, ResourceManager& _resMan, HalfEdgePropHandle _handle, const T _def = T());
-    virtual ~HalfEdgePropertyT() {}
-    virtual BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const;
-    virtual void serialize(std::ostream& _ostr) const;
-    virtual void deserialize(std::istream& _istr);
-    virtual const std::string entityType() const { return "HEProp"; }
-    virtual const std::string typeNameWrapper() const { return typeName<T>(); }
-private:
-    HalfEdgePropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, HalfEdgePropHandle _handle);
-};
-template<class T>
-class FacePropertyT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, FacePropHandle> {
-public:
-    FacePropertyT(const std::string& _name, ResourceManager& _resMan, FacePropHandle _handle, const T _def = T());
-    virtual ~FacePropertyT() {}
-    virtual BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const;
-    virtual void serialize(std::ostream& _ostr) const;
-    virtual void deserialize(std::istream& _istr);
-    virtual const std::string entityType() const { return "FProp"; }
-    virtual const std::string typeNameWrapper() const { return typeName<T>(); }
-private:
-    FacePropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, FacePropHandle _handle);
-};
-template<class T>
-class HalfFacePropertyT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfFacePropHandle> {
-public:
-    HalfFacePropertyT(const std::string& _name, ResourceManager& _resMan, HalfFacePropHandle _handle, const T _def = T());
-    virtual ~HalfFacePropertyT() {}
-    virtual BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const;
-    virtual void serialize(std::ostream& _ostr) const;
-    virtual void deserialize(std::istream& _istr);
-    virtual const std::string entityType() const { return "HFProp"; }
-    virtual const std::string typeNameWrapper() const { return typeName<T>(); }
-private:
-    HalfFacePropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, HalfFacePropHandle _handle);
-};
-template<class T>
-class CellPropertyT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, CellPropHandle> {
-public:
-    CellPropertyT(const std::string& _name, ResourceManager& _resMan, CellPropHandle _handle, const T _def = T());
-    virtual ~CellPropertyT() {}
-    virtual BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const;
-    virtual void serialize(std::ostream& _ostr) const;
-    virtual void deserialize(std::istream& _istr);
-    virtual const std::string entityType() const { return "CProp"; }
-    virtual const std::string typeNameWrapper() const { return typeName<T>(); }
-private:
-    CellPropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, CellPropHandle _handle);
-};
-template<class T>
-class MeshPropertyT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, MeshPropHandle> {
+template<typename Entity>
+const std::string entityTypeName();
+
+template <> const std::string entityTypeName<Entity::Vertex>();
+template <> const std::string entityTypeName<Entity::HalfEdge>();
+template <> const std::string entityTypeName<Entity::Edge>();
+template <> const std::string entityTypeName<Entity::Face>();
+template <> const std::string entityTypeName<Entity::HalfFace>();
+template <> const std::string entityTypeName<Entity::Cell>();
+template <> const std::string entityTypeName<Entity::Mesh>();
+
+template<typename T, typename Entity>
+class PropertyTT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, PropHandleT<Entity>> {
 public:
-    MeshPropertyT(const std::string& _name, ResourceManager& _resMan, MeshPropHandle _handle, const T _def = T());
-    virtual ~MeshPropertyT() {}
+    using PropertyHandleT = OpenVolumeMesh::PropHandleT<Entity>;
+    PropertyTT(const std::string& _name, ResourceManager& _resMan, PropertyHandleT _handle, const T _def = T());
+    virtual ~PropertyTT() = default;
     virtual BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const;
     virtual void serialize(std::ostream& _ostr) const;
     virtual void deserialize(std::istream& _istr);
-    virtual const std::string entityType() const { return "MProp"; }
+    virtual const std::string entityType() const { return entityTypeName<Entity>(); }
     virtual const std::string typeNameWrapper() const { return typeName<T>(); }
 private:
-    MeshPropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, MeshPropHandle _handle);
+    PropertyTT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, PropertyHandleT _handle);
 };
 
+template<typename T> using VertexPropertyT   = PropertyTT<T, Entity::Vertex>;
+template<typename T> using EdgePropertyT     = PropertyTT<T, Entity::Edge>;
+template<typename T> using HalfEdgePropertyT = PropertyTT<T, Entity::HalfEdge>;
+template<typename T> using FacePropertyT     = PropertyTT<T, Entity::Face>;
+template<typename T> using HalfFacePropertyT = PropertyTT<T, Entity::HalfFace>;
+template<typename T> using CellPropertyT     = PropertyTT<T, Entity::Cell>;
+template<typename T> using MeshPropertyT     = PropertyTT<T, Entity::Mesh>;
+
+
 } // Namespace OpenVolumeMesh
 
 #if defined(INCLUDE_TEMPLATES) && !defined(PROPERTYDEFINEST_CC)
 #include "PropertyDefinesT_impl.hh"
 #endif
-
-#endif /* PROPERTYDEFINES_HH_ */

src/OpenVolumeMesh/Core/PropertyDefinesT_impl.hh

@@ -49,205 +49,36 @@
 
 namespace OpenVolumeMesh {
 
-/// Property classes for the different entity types
-template<class T>
-VertexPropertyT<T>::VertexPropertyT(const std::string& _name, ResourceManager& _resMan, VertexPropHandle _handle, const T _def) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
+template<typename T, typename Entity>
+PropertyTT<T,Entity>::PropertyTT(const std::string& _name, ResourceManager& _resMan, PropertyHandleT _handle, const T _def) :
+        PropertyPtr<OpenVolumeMeshPropertyT<T>, PropertyHandleT>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
 
 }
 
-template<class T>
-VertexPropertyT<T>::VertexPropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, VertexPropHandle _handle) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle>(_prop, _resMan, _handle)
+template<typename T, typename Entity>
+PropertyTT<T,Entity>::PropertyTT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, PropertyHandleT _handle) :
+        PropertyPtr<OpenVolumeMeshPropertyT<T>, PropertyHandleT>(_prop, _resMan, _handle)
 {
 }
 
-template<class T>
-BaseProperty *VertexPropertyT<T>::clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const
+template<typename T, typename Entity>
+BaseProperty *PropertyTT<T,Entity>::clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const
 {
     auto prop_clone = ptr::shared_ptr<OpenVolumeMeshPropertyT<T>>::get()->clone();
-    return new VertexPropertyT<T>(prop_clone, _resMan, VertexPropHandle(_handle.idx()));
+    return new PropertyTT<T, Entity>(prop_clone, _resMan, PropertyHandleT(_handle.idx()));
 }
 
-template<class T>
-void VertexPropertyT<T>::serialize(std::ostream& _ostr) const {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle>::get()->serialize(_ostr);
+template<typename T, typename Entity>
+void PropertyTT<T,Entity>::serialize(std::ostream& _ostr) const {
+    PropertyPtr<OpenVolumeMeshPropertyT<T>, PropertyHandleT>::get()->serialize(_ostr);
 }
 
-template<class T>
-void VertexPropertyT<T>::deserialize(std::istream& _istr) {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle>::get()->deserialize(_istr);
+template<typename T, typename Entity>
+void PropertyTT<T,Entity>::deserialize(std::istream& _istr) {
+    PropertyPtr<OpenVolumeMeshPropertyT<T>, PropertyHandleT>::get()->deserialize(_istr);
 }
 
-template<class T>
-EdgePropertyT<T>::EdgePropertyT(const std::string& _name, ResourceManager& _resMan, EdgePropHandle _handle, const T _def) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, EdgePropHandle>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
-
-}
-template<class T>
-EdgePropertyT<T>::EdgePropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, EdgePropHandle _handle) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, EdgePropHandle>(_prop, _resMan, _handle)
-{
-}
-
-template<class T>
-BaseProperty *EdgePropertyT<T>::clone(ResourceManager &_resMan, const OpenVolumeMeshHandle _handle) const
-{
-    auto prop_clone = ptr::shared_ptr<OpenVolumeMeshPropertyT<T>>::get()->clone();
-    return new EdgePropertyT<T>(prop_clone, _resMan, EdgePropHandle(_handle.idx()));
-}
-
-template<class T>
-void EdgePropertyT<T>::serialize(std::ostream& _ostr) const {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, EdgePropHandle>::get()->serialize(_ostr);
-}
-
-template<class T>
-void EdgePropertyT<T>::deserialize(std::istream& _istr) {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, EdgePropHandle>::get()->deserialize(_istr);
-}
-
-template<class T>
-HalfEdgePropertyT<T>::HalfEdgePropertyT(const std::string& _name, ResourceManager& _resMan, HalfEdgePropHandle _handle, const T _def) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfEdgePropHandle>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
-
-}
-template<class T>
-HalfEdgePropertyT<T>::HalfEdgePropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, HalfEdgePropHandle _handle) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfEdgePropHandle>(_prop, _resMan, _handle)
-{
-}
-
-template<class T>
-BaseProperty *HalfEdgePropertyT<T>::clone(ResourceManager &_resMan, const OpenVolumeMeshHandle _handle) const
-{
-    auto prop_clone = ptr::shared_ptr<OpenVolumeMeshPropertyT<T>>::get()->clone();
-    return new HalfEdgePropertyT<T>(prop_clone, _resMan, HalfEdgePropHandle(_handle.idx()));
-}
-
-template<class T>
-void HalfEdgePropertyT<T>::serialize(std::ostream& _ostr) const {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfEdgePropHandle>::get()->serialize(_ostr);
-}
-
-template<class T>
-void HalfEdgePropertyT<T>::deserialize(std::istream& _istr) {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfEdgePropHandle>::get()->deserialize(_istr);
-}
-
-template<class T>
-FacePropertyT<T>::FacePropertyT(const std::string& _name, ResourceManager& _resMan, FacePropHandle _handle, const T _def) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, FacePropHandle>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
-
-}
-template<class T>
-FacePropertyT<T>::FacePropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, FacePropHandle _handle) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, FacePropHandle>(_prop, _resMan, _handle)
-{
-}
-
-template<class T>
-BaseProperty *FacePropertyT<T>::clone(ResourceManager &_resMan, const OpenVolumeMeshHandle _handle) const
-{
-    auto prop_clone = ptr::shared_ptr<OpenVolumeMeshPropertyT<T>>::get()->clone();
-    return new FacePropertyT<T>(prop_clone, _resMan, FacePropHandle(_handle.idx()));
-}
-
-template<class T>
-void FacePropertyT<T>::serialize(std::ostream& _ostr) const {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, FacePropHandle>::get()->serialize(_ostr);
-}
-
-template<class T>
-void FacePropertyT<T>::deserialize(std::istream& _istr) {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, FacePropHandle>::get()->deserialize(_istr);
-}
-
-template<class T>
-HalfFacePropertyT<T>::HalfFacePropertyT(const std::string& _name, ResourceManager& _resMan, HalfFacePropHandle _handle, const T _def) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfFacePropHandle>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
-
-}
-template<class T>
-HalfFacePropertyT<T>::HalfFacePropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, HalfFacePropHandle _handle) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfFacePropHandle>(_prop, _resMan, _handle)
-{
-}
-
-template<class T>
-BaseProperty *HalfFacePropertyT<T>::clone(ResourceManager &_resMan, const OpenVolumeMeshHandle _handle) const
-{
-    auto prop_clone = ptr::shared_ptr<OpenVolumeMeshPropertyT<T>>::get()->clone();
-    return new HalfFacePropertyT<T>(prop_clone, _resMan, HalfFacePropHandle(_handle.idx()));
-}
-
-template<class T>
-void HalfFacePropertyT<T>::serialize(std::ostream& _ostr) const {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfFacePropHandle>::get()->serialize(_ostr);
-}
-
-template<class T>
-void HalfFacePropertyT<T>::deserialize(std::istream& _istr) {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, HalfFacePropHandle>::get()->deserialize(_istr);
-}
-
-template<class T>
-CellPropertyT<T>::CellPropertyT(const std::string& _name, ResourceManager& _resMan, CellPropHandle _handle, const T _def) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, CellPropHandle>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
-
-}
-template<class T>
-CellPropertyT<T>::CellPropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, CellPropHandle _handle) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, CellPropHandle>(_prop, _resMan, _handle)
-{
-}
-
-template<class T>
-BaseProperty *CellPropertyT<T>::clone(ResourceManager &_resMan, const OpenVolumeMeshHandle _handle) const
-{
-    auto prop_clone = ptr::shared_ptr<OpenVolumeMeshPropertyT<T>>::get()->clone();
-    return new CellPropertyT<T>(prop_clone, _resMan, CellPropHandle(_handle.idx()));
-}
-
-template<class T>
-void CellPropertyT<T>::serialize(std::ostream& _ostr) const {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, CellPropHandle>::get()->serialize(_ostr);
-}
-
-template<class T>
-void CellPropertyT<T>::deserialize(std::istream& _istr) {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, CellPropHandle>::get()->deserialize(_istr);
-}
-
-template<class T>
-MeshPropertyT<T>::MeshPropertyT(const std::string& _name, ResourceManager& _resMan, MeshPropHandle _handle, const T _def) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, MeshPropHandle>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
-
-}
-template<class T>
-MeshPropertyT<T>::MeshPropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, MeshPropHandle _handle) :
-        PropertyPtr<OpenVolumeMeshPropertyT<T>, MeshPropHandle>(_prop, _resMan, _handle)
-{
-}
-
-template<class T>
-BaseProperty *MeshPropertyT<T>::clone(ResourceManager &_resMan, const OpenVolumeMeshHandle _handle) const
-{
-    auto prop_clone = ptr::shared_ptr<OpenVolumeMeshPropertyT<T>>::get()->clone();
-    return new MeshPropertyT<T>(prop_clone, _resMan, MeshPropHandle(_handle.idx()));
-}
-
-template<class T>
-void MeshPropertyT<T>::serialize(std::ostream& _ostr) const {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, MeshPropHandle>::get()->serialize(_ostr);
-}
-
-template<class T>
-void MeshPropertyT<T>::deserialize(std::istream& _istr) {
-    PropertyPtr<OpenVolumeMeshPropertyT<T>, MeshPropHandle>::get()->deserialize(_istr);
-}
-
-template <class T>
+template<typename T>
 const std::string typeName() {
     throw std::runtime_error("Serialization is not supported for these data types!");
 }

src/OpenVolumeMesh/Core/PropertyHandles.hh

@@ -32,59 +32,30 @@
  *                                                                           *
 \*===========================================================================*/
 
-/*===========================================================================*\
- *                                                                           *
- *   $Revision$                                                         *
- *   $Date$                    *
- *   $LastChangedBy$                                                *
- *                                                                           *
-\*===========================================================================*/
 
-#ifndef PROPERTYHANDLES_HH_
-#define PROPERTYHANDLES_HH_
+#pragma once
 
 #include "OpenVolumeMeshHandle.hh"
+#include "Entities.hh"
 
 namespace OpenVolumeMesh {
 
-// Defines for property handles
-class VertexPropHandle      : public OpenVolumeMeshHandle {
-public:
-    using OpenVolumeMeshHandle::OpenVolumeMeshHandle;
-    using EntityHandleT = VertexHandle;
-};
-class EdgePropHandle        : public OpenVolumeMeshHandle {
-public:
-    using OpenVolumeMeshHandle::OpenVolumeMeshHandle;
-    using EntityHandleT = EdgeHandle;
-};
-class HalfEdgePropHandle    : public OpenVolumeMeshHandle {
-public:
-    using OpenVolumeMeshHandle::OpenVolumeMeshHandle;
-    using EntityHandleT = HalfEdgeHandle;
-};
-class FacePropHandle        : public OpenVolumeMeshHandle {
-public:
-    using OpenVolumeMeshHandle::OpenVolumeMeshHandle;
-    using EntityHandleT = FaceHandle;
-};
-class HalfFacePropHandle    : public OpenVolumeMeshHandle {
-public:
-    using OpenVolumeMeshHandle::OpenVolumeMeshHandle;
-    using EntityHandleT = HalfFaceHandle;
-};
-class CellPropHandle        : public OpenVolumeMeshHandle {
-public:
-    using OpenVolumeMeshHandle::OpenVolumeMeshHandle;
-    using EntityHandleT = CellHandle;
-};
-class MeshPropHandle        : public OpenVolumeMeshHandle
+template<typename EntityTag,
+    typename = typename std::enable_if<is_entity<EntityTag>::value>::type>
+class PropHandleT : public OpenVolumeMeshHandle
 {
 public:
+    using Entity = EntityTag;
     using OpenVolumeMeshHandle::OpenVolumeMeshHandle;
-    using EntityHandleT = OpenVolumeMeshHandle;
 };
 
+using VertexPropHandle   = PropHandleT<Entity::Vertex>;
+using EdgePropHandle     = PropHandleT<Entity::Edge>;
+using HalfEdgePropHandle = PropHandleT<Entity::HalfEdge>;
+using FacePropHandle     = PropHandleT<Entity::Face>;
+using HalfFacePropHandle = PropHandleT<Entity::HalfFace>;
+using CellPropHandle     = PropHandleT<Entity::Cell>;
+using MeshPropHandle     = PropHandleT<Entity::Mesh>;
+
 } // Namespace OpenVolumeMesh
 
-#endif /* PROPERTYHANDLES_HH_ */

src/OpenVolumeMesh/Core/PropertyPtr.hh

@@ -32,16 +32,8 @@
  *                                                                           *