Skip to content
GitLab
Menu
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
OpenVolumeMesh
OpenVolumeMesh
Commits
9ec8ccad
Commit
9ec8ccad
authored
Feb 26, 2019
by
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
Changes
14
Pipelines
1
Hide whitespace changes
Inline
Side-by-side
src/OpenVolumeMesh/Attribs/StatusAttrib.hh
View file @
9ec8ccad
...
...
@@ -108,12 +108,12 @@ public:
}
const
OpenVolumeMeshStatus
&
mesh_status
()
const
{
OpenVolume
MeshHandle
h
(
0
);
MeshHandle
h
(
0
);
return
m_status_
[
h
];
}
OpenVolumeMeshStatus
&
mesh_status
()
{
OpenVolume
MeshHandle
h
(
0
);
MeshHandle
h
(
0
);
return
m_status_
[
h
];
}
...
...
src/OpenVolumeMesh/Core/Entities.hh
0 → 100644
View file @
9ec8ccad
#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
0 → 100644
View file @
9ec8ccad
#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
View file @
9ec8ccad
...
...
@@ -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
View file @
9ec8ccad
...
...
@@ -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
View file @
9ec8ccad
...
...
@@ -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
View file @
9ec8ccad
...
...
@@ -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
View file @
9ec8ccad
...
...
@@ -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:
Mesh
PropertyT
(
OpenVolumeMeshPropertyT
<
T
>
*
_prop
,
ResourceManager
&
_resMan
,
Mesh
PropHandle
_handle
);
PropertyT
T
(
OpenVolumeMeshPropertyT
<
T
>
*
_prop
,
ResourceManager
&
_resMan
,
Prop
erty
Handle
T
_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
View file @
9ec8ccad
...
...
@@ -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
>
Vertex
PropertyT
<
T
>::
Vertex
PropertyT
(
OpenVolumeMeshPropertyT
<
T
>
*
_prop
,
ResourceManager
&
_resMan
,
Vertex
PropHandle
_handle
)
:
PropertyPtr
<
OpenVolumeMeshPropertyT
<
T
>
,
Vertex
PropHandle
>
(
_prop
,
_resMan
,
_handle
)
template
<
typename
T
,
typename
Entity
>
PropertyT
T
<
T
,
Entity
>::
PropertyT
T
(
OpenVolumeMeshPropertyT
<
T
>
*
_prop
,
ResourceManager
&
_resMan
,
Prop
erty
Handle
T
_handle
)
:
PropertyPtr
<
OpenVolumeMeshPropertyT
<
T
>
,
Prop
erty
Handle
T
>
(
_prop
,
_resMan
,
_handle
)
{
}
template
<
class
T
>
BaseProperty
*
Vertex
PropertyT
<
T
>::
clone
(
ResourceManager
&
_resMan
,
OpenVolumeMeshHandle
_handle
)
const
template
<
typename
T
,
typename
Entity
>
BaseProperty
*
PropertyT
T
<
T
,
Entity
>::
clone
(
ResourceManager
&
_resMan
,
OpenVolumeMeshHandle
_handle
)
const
{
auto
prop_clone
=
ptr
::
shared_ptr
<
OpenVolumeMeshPropertyT
<
T
>>::
get
()
->
clone
();
return
new
Vertex
PropertyT
<
T
>
(
prop_clone
,
_resMan
,
Vertex
PropHandle
(
_handle
.
idx
()));
return
new
PropertyT
T
<
T
,
Entity
>
(
prop_clone
,
_resMan
,
Prop
erty
Handle
T
(
_handle
.
idx
()));
}
template
<
class
T
>
void
Vertex
PropertyT
<
T
>::
serialize
(
std
::
ostream
&
_ostr
)
const
{
PropertyPtr
<
OpenVolumeMeshPropertyT
<
T
>
,
Vertex
PropHandle
>::
get
()
->
serialize
(
_ostr
);
template
<
typename
T
,
typename
Entity
>
void
PropertyT
T
<
T
,
Entity
>::
serialize
(
std
::
ostream
&
_ostr
)
const
{
PropertyPtr
<
OpenVolumeMeshPropertyT
<
T
>
,
Prop
erty
Handle
T
>::
get
()
->
serialize
(
_ostr
);
}
template
<
class
T
>
void
Vertex
PropertyT
<
T
>::
deserialize
(
std
::
istream
&
_istr
)
{
PropertyPtr
<
OpenVolumeMeshPropertyT
<
T
>
,
Vertex
PropHandle
>::
get
()
->
deserialize
(
_istr
);
template
<
typename
T
,
typename
Entity
>
void
PropertyT
T
<
T
,
Entity
>::
deserialize
(
std
::
istream
&
_istr
)
{
PropertyPtr
<
OpenVolumeMeshPropertyT
<
T
>
,
Prop
erty
Handle
T
>::
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
()));