Commit 9ec8ccad authored by Jan Möbius's avatar Jan Möbius
Browse files

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

Refactor using Entity tags

See merge request !52
parents 17447afd 52b5f70d
Pipeline #8867 passed with stage
in 6 minutes and 30 seconds
...@@ -108,12 +108,12 @@ public: ...@@ -108,12 +108,12 @@ public:
} }
const OpenVolumeMeshStatus& mesh_status() const { const OpenVolumeMeshStatus& mesh_status() const {
OpenVolumeMeshHandle h(0); MeshHandle h(0);
return m_status_[h]; return m_status_[h];
} }
OpenVolumeMeshStatus& mesh_status() { OpenVolumeMeshStatus& mesh_status() {
OpenVolumeMeshHandle h(0); MeshHandle h(0);
return m_status_[h]; return m_status_[h];
} }
......
#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
#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
...@@ -32,14 +32,6 @@ ...@@ -32,14 +32,6 @@
* * * *
\*===========================================================================*/ \*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 36 $ *
* $Date: 2012-01-10 18:00:06 +0100 (Di, 10 Jan 2012) $ *
* $LastChangedBy: kremer $ *
* *
\*===========================================================================*/
#include <istream> #include <istream>
#include "OpenVolumeMeshHandle.hh" #include "OpenVolumeMeshHandle.hh"
......
...@@ -32,21 +32,13 @@ ...@@ -32,21 +32,13 @@
* * * *
\*===========================================================================*/ \*===========================================================================*/
/*===========================================================================*\ #pragma once
* *
* $Revision$ *
* $Date$ *
* $LastChangedBy$ *
* *
\*===========================================================================*/
#ifndef OPENVOLUMEMESHHANDLE_HH_
#define OPENVOLUMEMESHHANDLE_HH_
#include <algorithm> #include <algorithm>
#include <iosfwd> #include <iosfwd>
#include <vector> #include <vector>
#include "Entities.hh"
#include "../System/FunctionalInclude.hh" #include "../System/FunctionalInclude.hh"
#include "../System/Deprecation.hh" #include "../System/Deprecation.hh"
...@@ -95,14 +87,25 @@ private: ...@@ -95,14 +87,25 @@ private:
int idx_; 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 // Default entity handles
class VertexHandle : public OpenVolumeMeshHandle { public: explicit VertexHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} }; using VertexHandle = HandleT<Entity::Vertex>;
class EdgeHandle : public OpenVolumeMeshHandle { public: explicit EdgeHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} }; using HalfEdgeHandle = HandleT<Entity::HalfEdge>;
class FaceHandle : public OpenVolumeMeshHandle { public: explicit FaceHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} }; using EdgeHandle = HandleT<Entity::Edge>;
class CellHandle : public OpenVolumeMeshHandle { public: explicit CellHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} }; using HalfFaceHandle = HandleT<Entity::HalfFace>;
class HalfEdgeHandle : public OpenVolumeMeshHandle { public: explicit HalfEdgeHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} }; using FaceHandle = HandleT<Entity::Face>;
class HalfFaceHandle : public OpenVolumeMeshHandle { public: explicit HalfFaceHandle(int _idx = -1) : OpenVolumeMeshHandle(_idx) {} }; using CellHandle = HandleT<Entity::Cell>;
using MeshHandle = HandleT<Entity::Mesh>;
// Helper class that is used to decrease all handles // Helper class that is used to decrease all handles
// exceeding a certain threshold // exceeding a certain threshold
...@@ -176,4 +179,3 @@ std::istream& operator>>(std::istream& _istr, OpenVolumeMeshHandle& _handle); ...@@ -176,4 +179,3 @@ std::istream& operator>>(std::istream& _istr, OpenVolumeMeshHandle& _handle);
} // Namespace OpenVolumeMesh } // Namespace OpenVolumeMesh
#endif /* OPENVOLUMEMESHHANDLE_HH_ */
...@@ -32,16 +32,7 @@ ...@@ -32,16 +32,7 @@
* * * *
\*===========================================================================*/ \*===========================================================================*/
/*===========================================================================*\ #pragma once
* *
* $Revision$ *
* $Date$ *
* $LastChangedBy$ *
* *
\*===========================================================================*/
#ifndef OPENVOLUMEMESHPROPERTY_HH
#define OPENVOLUMEMESHPROPERTY_HH
//== INCLUDES ================================================================= //== INCLUDES =================================================================
...@@ -520,6 +511,3 @@ private: ...@@ -520,6 +511,3 @@ private:
} // Namespace OpenVolumeMesh } // Namespace OpenVolumeMesh
//=============================================================================
#endif // OPENVOLUMEMESHPROPERTY_HH defined
//=============================================================================
...@@ -32,13 +32,6 @@ ...@@ -32,13 +32,6 @@
* * * *
\*===========================================================================*/ \*===========================================================================*/
/*===========================================================================*\
* *
* $Revision$ *
* $Date$ *
* $LastChangedBy$ *
* *
\*===========================================================================*/
#include "PropertyDefines.hh" #include "PropertyDefines.hh"
...@@ -60,4 +53,13 @@ template <> const std::string typeName<std::vector<double> >(){ return "vector_d ...@@ -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<VertexHandle> >(){ return "vector_vh"; }
template <> const std::string typeName<std::vector<HalfFaceHandle> >(){ return "vector_hfh"; } 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 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 } // Namespace OpenVolumeMesh
...@@ -32,22 +32,14 @@ ...@@ -32,22 +32,14 @@
* * * *
\*===========================================================================*/ \*===========================================================================*/
/*===========================================================================*\ #pragma once
* *
* $Revision$ *
* $Date$ *
* $LastChangedBy$ *
* *
\*===========================================================================*/
#ifndef PROPERTYDEFINES_HH_
#define PROPERTYDEFINES_HH_
#include <iosfwd> #include <iosfwd>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <typeinfo> #include <typeinfo>
#include "Entities.hh"
#include "PropertyHandles.hh" #include "PropertyHandles.hh"
#include "PropertyPtr.hh" #include "PropertyPtr.hh"
...@@ -78,103 +70,43 @@ template <> const std::string typeName<std::vector<VertexHandle> >(); ...@@ -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<HalfFaceHandle> >();
template <> const std::string typeName<std::vector<std::vector<HalfFaceHandle> > >(); template <> const std::string typeName<std::vector<std::vector<HalfFaceHandle> > >();
/// Property classes for the different entity types template<typename Entity>
template<class T> const std::string entityTypeName();
class VertexPropertyT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle> {
public: template <> const std::string entityTypeName<Entity::Vertex>();
VertexPropertyT(const std::string& _name, ResourceManager& _resMan, VertexPropHandle _handle, const T _def = T()); template <> const std::string entityTypeName<Entity::HalfEdge>();
virtual ~VertexPropertyT() {} template <> const std::string entityTypeName<Entity::Edge>();
virtual BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const; template <> const std::string entityTypeName<Entity::Face>();
virtual void serialize(std::ostream& _ostr) const; template <> const std::string entityTypeName<Entity::HalfFace>();
virtual void deserialize(std::istream& _istr); template <> const std::string entityTypeName<Entity::Cell>();
virtual const std::string entityType() const { return "VProp"; } template <> const std::string entityTypeName<Entity::Mesh>();
virtual const std::string typeNameWrapper() const { return typeName<T>(); }
private: template<typename T, typename Entity>
VertexPropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager& _resMan, VertexPropHandle _handle); class PropertyTT : public PropertyPtr<OpenVolumeMeshPropertyT<T>, PropHandleT<Entity>> {
};
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> {
public: public:
MeshPropertyT(const std::string& _name, ResourceManager& _resMan, MeshPropHandle _handle, const T _def = T()); using PropertyHandleT = OpenVolumeMesh::PropHandleT<Entity>;
virtual ~MeshPropertyT() {} 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 BaseProperty* clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const;
virtual void serialize(std::ostream& _ostr) const; virtual void serialize(std::ostream& _ostr) const;
virtual void deserialize(std::istream& _istr); 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>(); } virtual const std::string typeNameWrapper() const { return typeName<T>(); }
private: 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 } // Namespace OpenVolumeMesh
#if defined(INCLUDE_TEMPLATES) && !defined(PROPERTYDEFINEST_CC) #if defined(INCLUDE_TEMPLATES) && !defined(PROPERTYDEFINEST_CC)
#include "PropertyDefinesT_impl.hh" #include "PropertyDefinesT_impl.hh"
#endif #endif
#endif /* PROPERTYDEFINES_HH_ */
...@@ -49,205 +49,36 @@ ...@@ -49,205 +49,36 @@
namespace OpenVolumeMesh { namespace OpenVolumeMesh {
/// Property classes for the different entity types template<typename T, typename Entity>
template<class T> PropertyTT<T,Entity>::PropertyTT(const std::string& _name, ResourceManager& _resMan, PropertyHandleT _handle, const T _def) :
VertexPropertyT<T>::VertexPropertyT(const std::string& _name, ResourceManager& _resMan, VertexPropHandle _handle, const T _def) : PropertyPtr<OpenVolumeMeshPropertyT<T>, PropertyHandleT>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle>(new OpenVolumeMeshPropertyT<T>(_name, _def), _resMan, _handle) {
} }
template<class T> template<typename T, typename Entity>
VertexPropertyT<T>::VertexPropertyT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, VertexPropHandle _handle) : PropertyTT<T,Entity>::PropertyTT(OpenVolumeMeshPropertyT<T> *_prop, ResourceManager &_resMan, PropertyHandleT _handle) :
PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle>(_prop, _resMan, _handle) PropertyPtr<OpenVolumeMeshPropertyT<T>, PropertyHandleT>(_prop, _resMan, _handle)
{ {
} }
template<class T> template<typename T, typename Entity>
BaseProperty *VertexPropertyT<T>::clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const BaseProperty *PropertyTT<T,Entity>::clone(ResourceManager &_resMan, OpenVolumeMeshHandle _handle) const
{ {
auto prop_clone = ptr::shared_ptr<OpenVolumeMeshPropertyT<T>>::get()->clone(); 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> template<typename T, typename Entity>
void VertexPropertyT<T>::serialize(std::ostream& _ostr) const { void PropertyTT<T,Entity>::serialize(std::ostream& _ostr) const {
PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle>::get()->serialize(_ostr); PropertyPtr<OpenVolumeMeshPropertyT<T>, PropertyHandleT>::get()->serialize(_ostr);
} }
template<class T> template<typename T, typename Entity>
void VertexPropertyT<T>::deserialize(std::istream& _istr) { void PropertyTT<T,Entity>::deserialize(std::istream& _istr) {
PropertyPtr<OpenVolumeMeshPropertyT<T>, VertexPropHandle>::get()->deserialize(_istr); PropertyPtr<OpenVolumeMeshPropertyT<T>, PropertyHandleT>::get()->deserialize(_istr);
} }
template<class T> template<typename 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) :