42 #ifndef PROPERTYMANAGER_HH_
43 #define PROPERTYMANAGER_HH_
70 template<
typename PROPTYPE,
typename MeshT>
72 #if __cplusplus > 199711L or __GXX_EXPERIMENTAL_CXX0X__
104 PropertyManager(MeshT &mesh,
const char *propname,
bool existing =
false) : mesh_(&mesh), retain_(existing), name_(propname) {
106 if (!mesh_->get_property_handle(prop_, propname)) {
107 std::ostringstream oss;
108 oss <<
"Requested property handle \"" << propname <<
"\" does not exist.";
109 throw std::runtime_error(oss.str());
112 mesh_->add_property(prop_, propname);
123 void swap(PropertyManager &rhs) {
124 std::swap(mesh_, rhs.mesh_);
125 std::swap(prop_, rhs.prop_);
126 std::swap(retain_, rhs.retain_);
127 std::swap(name_, rhs.name_);
130 static bool propertyExists(MeshT &mesh,
const char *propname) {
132 return mesh.get_property_handle(dummy, propname);
135 bool isValid()
const {
return mesh_ != 0; }
136 operator bool()
const {
return isValid(); }
138 const PROPTYPE &getRawProperty()
const {
return prop_; }
140 const std::string &getName()
const {
return name_; }
142 MeshT &getMesh()
const {
return *mesh_; }
144 #if __cplusplus > 199711L or __GXX_EXPERIMENTAL_CXX0X__
148 PropertyManager(PropertyManager &&rhs) : mesh_(rhs.mesh_), prop_(rhs.prop_), retain_(rhs.retain_), name_(rhs.name_) {
155 PropertyManager &operator=(PropertyManager &&rhs) {
161 retain_ = rhs.retain_;
175 PropertyManager pm(mesh, propname, mesh.get_property_handle(dummy_prop, propname));
177 return std::move(pm);
181 PropertyManager duplicate(
const char *clone_name) {
182 PropertyManager pm(*mesh_, clone_name,
false);
183 pm.mesh_->property(pm.prop_) = mesh_->property(prop_);
184 return std::move(pm);
190 PropertyManager move() {
191 return std::move(*
this);
197 Proxy(MeshT *mesh_, PROPTYPE prop_,
bool retain_,
const std::string &name_) :
198 mesh_(mesh_), prop_(prop_), retain_(retain_), name_(name_) {}
208 Proxy p(mesh_, prop_, retain_, name_);
218 PropertyManager(Proxy p) : mesh_(p.mesh_), prop_(p.prop_), retain_(p.retain_), name_(p.name_) {}
220 PropertyManager &operator=(Proxy p) {
221 PropertyManager(p).swap(*
this);
232 PropertyManager pm(mesh, propname, mesh.get_property_handle(dummy_prop, propname));
237 Proxy duplicate(
const char *clone_name) {
239 pm.mesh_->property(pm.prop_) = mesh_->property(prop_);
250 inline void retain(
bool doRetain =
true) {
275 template<
typename HandleType>
276 inline typename PROPTYPE::reference
operator[] (
const HandleType &handle) {
277 return mesh_->property(prop_, handle);
287 template<
typename HandleType>
288 inline typename PROPTYPE::const_reference
operator[] (
const HandleType &handle)
const {
289 return mesh_->property(prop_, handle);
316 template<
typename HandleTypeIterator>
317 void set_range(HandleTypeIterator begin, HandleTypeIterator end,
318 typename PROPTYPE::const_reference value) {
319 for (; begin != end; ++begin)
320 (*
this)[*begin] = value;
337 template<
typename HandleTypeIterator,
typename PROPTYPE_2,
338 typename MeshT_2,
typename HandleTypeIterator_2>
339 void copy_to(HandleTypeIterator begin, HandleTypeIterator end,
341 HandleTypeIterator_2 dst_begin, HandleTypeIterator_2 dst_end)
const {
343 for (; begin != end && dst_begin != dst_end; ++begin, ++dst_begin) {
344 dst_propmanager[*dst_begin] = (*this)[*begin];
348 template<
typename RangeType,
typename PROPTYPE_2,
349 typename MeshT_2,
typename RangeType_2>
350 void copy_to(
const RangeType &range,
352 const RangeType_2 &dst_range)
const {
353 copy_to(range.begin(), range.end(), dst_propmanager,
354 dst_range.begin(), dst_range.end());
371 template<
typename RangeType,
typename MeshT_2,
typename RangeType_2>
372 static void copy(
const char *prop_name,
373 MeshT &src_mesh,
const RangeType &src_range,
374 MeshT_2 &dst_mesh,
const RangeType_2 &dst_range) {
377 DstPM dst(DstPM::createIfNotExists(dst_mesh, prop_name));
380 SrcPM src(src_mesh, prop_name,
true);
382 src.copy_to(src_range, dst, dst_range);
386 void deleteProperty() {
388 mesh_->remove_property(prop_);
static void copy(const char *prop_name, MeshT &src_mesh, const RangeType &src_range, MeshT_2 &dst_mesh, const RangeType_2 &dst_range)
Copy the values of a property from a source range to a target range.
Definition: PropertyManager.hh:372
PROPTYPE::reference operator[](const HandleType &handle)
Enables convenient access to the encapsulated property.
Definition: PropertyManager.hh:276
This class is intended to manage the lifecycle of properties.
Definition: PropertyManager.hh:71
void copy_to(HandleTypeIterator begin, HandleTypeIterator end, PropertyManager< PROPTYPE_2, MeshT_2 > &dst_propmanager, HandleTypeIterator_2 dst_begin, HandleTypeIterator_2 dst_end) const
Conveniently transfer the values managed by one property manager onto the values managed by a differe...
Definition: PropertyManager.hh:339
PropertyManager(MeshT &mesh, const char *propname, bool existing=false)
Constructor.
Definition: PropertyManager.hh:104
void set_range(HandleTypeIterator begin, HandleTypeIterator end, typename PROPTYPE::const_reference value)
Conveniently set the property for an entire range of values.
Definition: PropertyManager.hh:317
Definition: PropertyManager.hh:195
void retain(bool doRetain=true)
Disable lifecycle management for this property.
Definition: PropertyManager.hh:250
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:56
PROPTYPE & operator*()
Access the encapsulated property.
Definition: PropertyManager.hh:257
static Proxy createIfNotExists(MeshT &mesh, const char *propname)
Create a property manager for the supplied property and mesh.
Definition: PropertyManager.hh:230