Refactor properties using entity tags

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/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

@@ -53,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

@@ -39,6 +39,7 @@
 #include <string>
 #include <typeinfo>
 
+#include "Entities.hh"
 #include "PropertyHandles.hh"
 #include "PropertyPtr.hh"
 
@@ -69,99 +70,41 @@ 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)

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/ResourceManager.hh

@@ -32,16 +32,7 @@
  *                                                                           *
 \*===========================================================================*/
 
-/*===========================================================================*\
- *                                                                           *
- *   $Revision$                                                         *
- *   $Date$                    *
- *   $LastChangedBy$                                                *
- *                                                                           *
-\*===========================================================================*/
-
-#ifndef RESOURCEMANAGER_HH_
-#define RESOURCEMANAGER_HH_
+#pragma once
 
 #ifndef NDEBUG
 #include <iostream>
@@ -51,27 +42,12 @@
 
 #include "OpenVolumeMeshProperty.hh"
 #include "PropertyHandles.hh"
+#include "ForwardDeclarations.hh"
 
 namespace OpenVolumeMesh {
 
 // Forward declarations
 class BaseProperty;
-template <class T>
-class VertexPropertyT;
-template <class T>
-class EdgePropertyT;
-template <class T>
-class HalfEdgePropertyT;
-template <class T>
-class FacePropertyT;
-template <class T>
-class HalfFacePropertyT;
-template <class T>
-class CellPropertyT;
-template <class T>
-class MeshPropertyT;
-template <class PropT, class HandleT>
-class PropertyPtr;
 
 class ResourceManager {
 public:
@@ -364,4 +340,3 @@ private:
 #include "ResourceManagerT_impl.hh"
 #endif
 
-#endif /* RESOURCEMANAGER_HH_ */