songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6046 from MaelRL/PM-Fix_pmaps_reference_types_master-GF 

Various fixes for property maps (master)
This commit is contained in:
Sébastien Loriot 2021-10-29 17:40:15 +02:00
parent 3cf45cb83b d6a950078a
commit 9543deb304
71 changed files with 386 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AABB_tree/include/CGAL/AABB_triangulation_3_cell_primitive.h
View File

@ -58,7 +58,7 @@ namespace CGAL
typedef boost::readable_property_map_tag category;
inline friend
reference
value_type
get(Tet_from_cell_iterator_proprety_map<GeomTraits, Iterator>, key_type it)
{
typename GeomTraits::Construct_point_3 point;

6
BGL/examples/BGL_arrangement_2/arrangement_dual.cpp
View File

@ -17,7 +17,8 @@
// A property map that reads/writes the information to/from the extended
// face.
template <typename Arrangement, class Type> class Extended_face_property_map {
template <typename Arrangement, class Type>
class Extended_face_property_map {
public:
typedef typename Arrangement::Face_handle Face_handle;
@ -32,8 +33,7 @@ public:
{ return key->data(); }
// The put function is required by the property map concept.
friend void put(const Extended_face_property_map&,
key_type key, value_type val)
friend void put(const Extended_face_property_map&, key_type key, value_type val)
{ key->set_data(val); }
};

2
BGL/examples/BGL_arrangement_2/primal.cpp
View File

@ -42,7 +42,7 @@ public:
}
};
double get(Edge_length_func edge_length, Arrangement_2::Halfedge_handle e)
double get(const Edge_length_func& edge_length, Arrangement_2::Halfedge_handle e)
{
return edge_length(e);
}

4
BGL/include/CGAL/boost/graph/Dual.h
View File

@ -128,7 +128,7 @@ struct Dual_vertex_index_pmap{
typedef typename boost::graph_traits<G>::face_descriptor key_type;
typedef typename Property_map::value_type value_type;
typedef typename Property_map::reference reference;
typedef typename Property_map::category category;
typedef boost::readable_property_map_tag category;
Dual_vertex_index_pmap(const G& g)
: m_pmap( get(boost::face_index, g) )
@ -147,7 +147,7 @@ struct Dual_face_index_pmap{
typedef typename boost::graph_traits<G>::vertex_descriptor key_type;
typedef typename Property_map::value_type value_type;
typedef typename Property_map::reference reference;
typedef typename Property_map::category category;
typedef boost::readable_property_map_tag category;
Dual_face_index_pmap(const G& g)
: m_pmap( get(boost::vertex_index, g) )

2
BGL/include/CGAL/boost/graph/Graph_with_descriptor_with_graph.h
View File

@ -747,7 +747,7 @@ struct Graph_with_descriptor_with_graph_property_map<Graph, PM, boost::lvalue_pr
Graph* graph;
PM pm;
value_type& operator[](key_type& k) const
reference operator[](key_type& k) const
{
return get(*this, k);
}

3
BGL/include/CGAL/boost/graph/alpha_expansion_graphcut.h
View File

@ -68,7 +68,7 @@ struct Alpha_expansion_old_API_wrapper_graph
: cost_matrix (cost_matrix)
{ }
friend reference get (const Vertex_label_cost_map& pmap, key_type idx)
friend value_type get (const Vertex_label_cost_map& pmap, key_type idx)
{
std::vector<double> out;
out.reserve (pmap.cost_matrix->size());
@ -76,7 +76,6 @@ struct Alpha_expansion_old_API_wrapper_graph
out.push_back ((*pmap.cost_matrix)[i][idx]);
return out;
}
};
typedef CGAL::Pointer_property_map<double>::const_type Edge_cost_map;

8
BGL/include/CGAL/boost/graph/named_params_helper.h
View File

@ -291,7 +291,7 @@ CGAL_DEF_GET_INITIALIZED_INDEX_MAP(face, typename boost::graph_traits<Graph>::fa
typedef boost::readable_property_map_tag category;
typedef DummyNormalPmap Self;
friend reference get(const Self&, const key_type&) { return CGAL::NULL_VECTOR; }
friend value_type get(const Self&, const key_type&) { return CGAL::NULL_VECTOR; }
};
public:
@ -422,7 +422,7 @@ CGAL_DEF_GET_INITIALIZED_INDEX_MAP(face, typename boost::graph_traits<Graph>::fa
typedef boost::read_write_property_map_tag category;
typedef DummyNormalMap Self;
friend reference get(const Self&, const key_type&) { return CGAL::NULL_VECTOR; }
friend value_type get(const Self&, const key_type&) { return CGAL::NULL_VECTOR; }
friend void put(const Self&, const key_type&, const value_type&) { }
};
@ -466,7 +466,7 @@ CGAL_DEF_GET_INITIALIZED_INDEX_MAP(face, typename boost::graph_traits<Graph>::fa
typedef boost::readable_property_map_tag category;
typedef DummyPlaneIndexMap Self;
friend reference get(const Self&, const key_type&) { return -1; }
friend value_type get(const Self&, const key_type&) { return -1; }
};
public:
@ -489,7 +489,7 @@ CGAL_DEF_GET_INITIALIZED_INDEX_MAP(face, typename boost::graph_traits<Graph>::fa
typedef boost::readable_property_map_tag category;
typedef DummyConstrainedMap Self;
friend reference get(const Self&, const key_type&) { return false; }
friend value_type get(const Self&, const key_type&) { return false; }
};
public:

12
BGL/include/CGAL/boost/graph/properties.h
View File

@ -105,14 +105,15 @@ struct Index_accessor
template<typename Handle>
struct Edge_index_accessor
: boost::put_get_helper< std::size_t, Edge_index_accessor<Handle> >
{
typedef boost::readable_property_map_tag category;
typedef std::size_t reference;
typedef std::size_t value_type;
typedef Handle key_type;
reference operator[](Handle h) const { return h.id(); }
value_type operator[](Handle h) const { return h.id(); }
friend inline value_type get(const Edge_index_accessor& m, const key_type k) { return m[k]; }
};
template<typename Handle, typename ValueType, typename Reference,
@ -160,10 +161,11 @@ struct Is_writable_property_map<PropertyMap, boost::writable_property_map_tag> :
template <typename PropertyMap>
struct Is_writable_property_map<PropertyMap, boost::read_write_property_map_tag> : CGAL::Tag_true { };
// 'lvalue_pmap_tag' is annoying, because the property map is allowed to be non-mutable,
// but boost::lvalue_property_map_tag is defined as:
// 'lvalue_property_map_tag' is annoying, because the property map is allowed to be non-mutable,
// but boost::lvalue_property_map_tag is always defined as:
// struct lvalue_property_map_tag : public read_write_property_map_tag
// so we can't just check that 'writable_property_map_tag' is a base of the lvalue tag.
// whereas it should sometimes only be
// struct lvalue_property_map_tag : public readable_property_map_tag.
//
// This checks if the reference is non-const, which is not completely correct: map[key] returning
// a non-const reference doesn't mean that 'put(map, key, val)' exists, which is what a writable

17
BGL/include/CGAL/boost/graph/properties_OpenMesh.h
View File

@ -37,11 +37,10 @@ public:
OpenMesh::HPropHandleT<Value>,
OpenMesh::EPropHandleT<Value> >::type>::type>::type H;
typedef boost::read_write_property_map_tag category;
typedef boost::lvalue_property_map_tag category;
typedef Descriptor key_type;
typedef Value value_type;
typedef value_type& reference;
OM_pmap()
@ -133,7 +132,6 @@ public:
template <typename OpenMesh>
class OM_edge_weight_pmap
: public boost::put_get_helper<typename OpenMesh::Scalar , OM_edge_weight_pmap<OpenMesh> >
{
public:
typedef boost::readable_property_map_tag category;
@ -150,12 +148,14 @@ public:
return sm_.calc_edge_length(e.halfedge());
}
friend inline value_type get(const OM_edge_weight_pmap& m, const key_type& k) { return m[k]; }
private:
const OpenMesh& sm_;
};
template <typename K, typename VEF>
class OM_index_pmap : public boost::put_get_helper<unsigned int, OM_index_pmap<K,VEF> >
class OM_index_pmap
{
public:
typedef boost::readable_property_map_tag category;
@ -170,18 +170,21 @@ public:
{
return vd.idx();
}
friend inline value_type get(const OM_index_pmap& m, const key_type& k) { return m[k]; }
};
template<typename OpenMesh, typename P>
class OM_point_pmap //: public boost::put_get_helper<bool, OM_point_pmap<OpenMesh> >
class OM_point_pmap
{
public:
typedef boost::read_write_property_map_tag category;
#if defined(CGAL_USE_OM_POINTS)
typedef boost::lvalue_property_map_tag category;
typedef typename OpenMesh::Point value_type;
typedef const typename OpenMesh::Point& reference;
#else
typedef boost::read_write_property_map_tag category;
typedef P value_type;
typedef P reference;
#endif
@ -199,7 +202,7 @@ public:
: sm_(pm.sm_)
{}
value_type operator[](key_type v)
reference operator[](key_type v)
{
#if defined(CGAL_USE_OM_POINTS)
return sm_->point(v);

11
BGL/include/CGAL/boost/graph/property_maps.h
View File

@ -53,7 +53,7 @@ struct Triangle_from_face_descriptor_map{
//get function for property map
inline friend
reference
value_type
get(const Triangle_from_face_descriptor_map<TriangleMesh,VertexPointMap>& pmap,
key_type f)
{
@ -66,7 +66,7 @@ struct Triangle_from_face_descriptor_map{
}
inline friend
reference
value_type
get(const Triangle_from_face_descriptor_map<TriangleMesh,VertexPointMap>& pmap,
const std::pair<key_type, const TriangleMesh*>& f)
{
@ -111,7 +111,7 @@ struct Segment_from_edge_descriptor_map{
//get function for property map
inline friend
reference
value_type
get(const Segment_from_edge_descriptor_map<PolygonMesh,VertexPointMap>& pmap,
key_type h)
{
@ -120,7 +120,7 @@ struct Segment_from_edge_descriptor_map{
}
inline friend
reference
value_type
get(const Segment_from_edge_descriptor_map<PolygonMesh,VertexPointMap>& pmap,
const std::pair<key_type, const PolygonMesh*>& h)
{
@ -154,7 +154,7 @@ struct One_point_from_face_descriptor_map{
typedef typename boost::graph_traits<PolygonMesh>::face_descriptor key_type;
typedef typename boost::property_traits< VertexPointMap >::value_type value_type;
typedef typename boost::property_traits< VertexPointMap >::reference reference;
typedef boost::lvalue_property_map_tag category;
typedef boost::readable_property_map_tag category;
//get function for property map
inline friend
@ -196,6 +196,7 @@ struct Source_point_from_edge_descriptor_map{
typedef typename boost::property_traits< VertexPointMap >::reference reference;
typedef typename boost::graph_traits<PolygonMesh>::edge_descriptor key_type;
typedef boost::readable_property_map_tag category;
//data
typename boost::remove_const<PolygonMesh>::type* m_pm;
VertexPointMap m_vpm;

6
BGL/include/CGAL/boost/graph/selection.h
View File

@ -102,7 +102,7 @@ struct Regularization_graph
typedef vertex_descriptor key_type;
typedef std::size_t value_type;
typedef std::size_t& reference;
typedef boost::lvalue_property_map_tag category;
typedef boost::read_write_property_map_tag category;
Regularization_graph* rg;
@ -132,7 +132,7 @@ struct Regularization_graph
: rg (rg)
{ }
friend reference get (const Vertex_label_probability_map& pmap, key_type fd)
friend value_type get (const Vertex_label_probability_map& pmap, key_type fd)
{
double value = (1. - pmap.rg->weight) * pmap.rg->area (fd) / pmap.rg->total_area;
@ -167,7 +167,7 @@ struct Regularization_graph
Edge_cost_map (const Regularization_graph* rg)
: rg (rg) { }
friend reference get (const Edge_cost_map& pmap, key_type ed)
friend value_type get (const Edge_cost_map& pmap, key_type ed)
{
fg_vertex_descriptor esource = source(ed, pmap.rg->fg);
fg_vertex_descriptor etarget = target(ed, pmap.rg->fg);

6
BGL/test/BGL/test_Face_filtered_graph.cpp
View File

@ -355,7 +355,7 @@ test_graph_range(const std::vector<Graph>& graphs)
typedef SM::Point Point_3;
template<class Mesh, typename VertexPointPMap>
struct Constraint : public boost::put_get_helper<bool,Constraint<Mesh, VertexPointPMap> >
struct Constraint
{
typedef typename boost::graph_traits<Mesh>::edge_descriptor edge_descriptor;
typedef boost::readable_property_map_tag category;
@ -363,7 +363,6 @@ struct Constraint : public boost::put_get_helper<bool,Constraint<Mesh, VertexPoi
typedef bool reference;
typedef edge_descriptor key_type;
Constraint()
:g_(NULL)
{}
@ -406,9 +405,12 @@ struct Constraint : public boost::put_get_helper<bool,Constraint<Mesh, VertexPoi
return false;
}
friend inline value_type get(const Constraint& m, const key_type k) { return m[k]; }
const Mesh* g_;
VertexPointPMap vppmap;
};
template<class Mesh, class FCCMAP, class Adapter>
void test_mesh(Adapter fga)
{

6
BGL/test/BGL/test_Properties.cpp
View File

@ -13,12 +13,12 @@ struct Non_mutable_property_map
{
typedef Key key_type;
typedef Value value_type;
typedef value_type reference;
typedef const value_type& reference;
typedef boost::readable_property_map_tag category;
Non_mutable_property_map(const Container& c) : m_c(c) { }
friend reference get(const Non_mutable_property_map<Key, Value, Container>& pmap, key_type k)
friend reference get(const Non_mutable_property_map<Key, Value, Container>& pmap, const key_type& k)
{
return pmap.m_c.at(k);
}
@ -42,7 +42,7 @@ struct RW_property_map
pmap.m_c[k] = val;
}
friend reference get(RW_property_map<Key, Value, Container>& pmap, const key_type& k)
friend reference get(const RW_property_map<Key, Value, Container>& pmap, const key_type& k)
{
return pmap.m_c[k];
}

1
Classification/include/CGAL/Classification/Cluster.h
View File

@ -66,7 +66,6 @@ public:
public:
using argument_type = std::size_t;
using result_type = typename boost::property_traits<ItemMap>::reference;
using category = boost::readable_property_map_tag;
const ItemRange* m_range;
ItemMap m_item_map;

4
Classification/include/CGAL/Classification/Point_set_neighborhood.h
View File

@ -67,10 +67,12 @@ class Point_set_neighborhood
using value_type = typename boost::property_traits<PointMap>::value_type;
using reference = typename boost::property_traits<PointMap>::reference;
using key_type = std::uint32_t;
using category = typename boost::property_traits<PointMap>::category;
using category = boost::readable_property_map_tag;
My_point_property_map () { }
My_point_property_map (const PointRange *input, PointMap point_map)
: input (input), point_map (point_map) { }
friend reference get (const My_point_property_map& ppmap, key_type i)
{ return get(ppmap.point_map, *(ppmap.input->begin()+std::size_t(i))); }
};

4
Classification/include/CGAL/Classification/property_maps.h
View File

@ -67,7 +67,7 @@ public:
: m_mesh (mesh), m_vpm (vpm) { }
/// \cond SKIP_IN_MANUAL
inline friend reference get (const Face_descriptor_to_center_of_mass_map& map, key_type f)
inline friend value_type get (const Face_descriptor_to_center_of_mass_map& map, key_type f)
{
std::vector<Point_3> points;
@ -139,7 +139,7 @@ public:
: m_mesh (mesh), m_vpm (vpm) { }
/// \cond SKIP_IN_MANUAL
inline friend reference get (const Face_descriptor_to_face_descriptor_with_bbox_map& map, key_type f)
inline friend value_type get (const Face_descriptor_to_face_descriptor_with_bbox_map& map, key_type f)
{
CGAL::Bbox_3 bbox;

8
Hash_map/include/CGAL/Unique_hash_map.h
View File

@ -133,16 +133,18 @@ namespace boost {
public:
typedef KeyType key_type;
typedef ValueType value_type;
typedef const value_type& reference;
typedef value_type& reference;
typedef lvalue_property_map_tag category;
associative_property_map() : m_c(0) { }
associative_property_map(C& c) : m_c(&c) { }
value_type& operator[](const key_type& k) const {
reference operator[](const key_type& k) const {
return (*m_c)[k];
}
friend
const value_type&
reference
get(const associative_property_map<C>& uhm, const key_type& key)
{
return uhm[key];

6
Jet_fitting_3/examples/Jet_fitting_3/PolyhedralSurf.h
View File

@ -68,12 +68,12 @@ public:
template <class TPoly>
class Facet_PM :
public boost::put_get_helper<typename TPoly::Traits::Vector_3, Facet_PM<TPoly> >
public boost::put_get_helper<typename TPoly::Traits::Vector_3&, Facet_PM<TPoly> >
{
public:
//read_write
typedef boost::read_write_property_map_tag category;
typedef boost::lvalue_property_map_tag category;
typedef typename TPoly::Facet key_type;
typedef typename TPoly::Traits::Vector_3 value_type;
typedef typename TPoly::Traits::Vector_3& reference;
@ -121,8 +121,6 @@ class HEdge_PM :
public boost::put_get_helper<typename TPoly::Traits::FT&, HEdge_PM<TPoly> >//double
{
public:
//read_write or lvalue
//typedef boost::read_write_property_map_tag category;
typedef boost::lvalue_property_map_tag category;
typedef typename TPoly::Halfedge key_type;
typedef typename TPoly::Traits::FT value_type;

10
Linear_cell_complex/include/CGAL/boost/graph/properties_Linear_cell_complex_for_combinatorial_map.h
View File

@ -42,7 +42,6 @@ namespace CGAL {
template<typename LCC, typename FT>
struct Wrap_squared_lcc
: boost::put_get_helper< double, Wrap_squared_lcc<LCC, FT> >
{
typedef typename boost::graph_traits<LCC>::edge_descriptor Handle;
typedef FT value_type;
@ -54,12 +53,19 @@ struct Wrap_squared_lcc
{}
template<typename E>
FT operator[](const E& e) const
value_type operator[](const E& e) const
{
return approximate_sqrt(CGAL::squared_distance
(m_lcc.point(e.first_halfedge()),
m_lcc.point(e.second_halfedge())));
}
friend inline
value_type get(const Wrap_squared_lcc& m, const key_type& k)
{
return m[k];
}
private:
const LCC& m_lcc;
};

9
Mesh_3/include/CGAL/Mesh_3/Sliver_perturber.h
View File

@ -489,8 +489,7 @@ private:
* @class PVertex_id
* relaxed heap
*/
class PVertex_id :
public boost::put_get_helper<typename PVertex::id_type, PVertex_id>
class PVertex_id
{
public:
typedef boost::readable_property_map_tag category;
@ -499,6 +498,12 @@ private:
typedef PVertex key_type;
value_type operator[] (const key_type& pv) const { return pv.id(); }
friend inline
value_type get(const PVertex_id& m, const key_type& k)
{
return m[k];
}
};
typedef std::less<PVertex> less_PVertex;

24
Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h
View File

@ -1104,25 +1104,29 @@ add_features(InputIterator first, InputIterator end,
namespace details {
template <typename PolylineWithContext>
struct Get_content_from_polyline_with_context {
struct Get_content_from_polyline_with_context
{
typedef Get_content_from_polyline_with_context Self;
typedef const PolylineWithContext& key_type;
typedef const typename PolylineWithContext::Bare_polyline& value_type;
typedef value_type reference;
typedef PolylineWithContext key_type;
typedef typename PolylineWithContext::Bare_polyline value_type;
typedef const value_type& reference;
typedef boost::readable_property_map_tag category;
friend value_type get(const Self, key_type polyline) {
friend reference get(const Self&, const key_type& polyline) {
return polyline.polyline_content;
}
}; // end Get_content_from_polyline_with_context<PolylineWithContext>
template <typename PolylineWithContext>
struct Get_patches_id_from_polyline_with_context {
struct Get_patches_id_from_polyline_with_context
{
typedef Get_patches_id_from_polyline_with_context Self;
typedef const PolylineWithContext& key_type;
typedef const typename PolylineWithContext::Context::Patches_ids& value_type;
typedef value_type reference;
typedef PolylineWithContext key_type;
typedef typename PolylineWithContext::Context::Patches_ids value_type;
typedef const value_type& reference;
typedef boost::readable_property_map_tag category;
friend value_type get(const Self, key_type polyline) {
friend reference get(const Self&, const key_type& polyline) {
return polyline.context.adjacent_patches_ids;
}
}; // end Get_patches_id_from_polyline_with_context<PolylineWithContext>

4
Point_set_3/include/CGAL/Point_set_3.h
View File

@ -1110,7 +1110,7 @@ public:
typedef Index key_type;
typedef typename Property::value_type value_type;
typedef value_type& reference;
typedef boost::lvalue_property_map_tag category;
typedef boost::read_write_property_map_tag category;
Point_set* ps;
Property* prop;
@ -1121,7 +1121,7 @@ public:
Index ind=Index())
: ps(ps), prop(prop), ind(ind) {}
friend void put(const Push_property_map& pm, Index& i, reference t)
friend void put(const Push_property_map& pm, Index& i, const value_type& t)
{
if(pm.ps->size() <= (pm.ind))
pm.ps->insert();

2
Point_set_processing_3/include/CGAL/Point_set_processing_3/internal/Neighbor_query.h
View File

@ -57,7 +57,7 @@ public:
typedef input_iterator key_type;
typedef typename boost::property_traits<PointMap>::reference reference;
typedef typename boost::property_traits<PointMap>::value_type value_type;
typedef typename boost::property_traits<PointMap>::category category;
typedef typename boost::readable_property_map_tag category;
PointMap point_map;

5
Point_set_processing_3/include/CGAL/Point_with_normal_3.h
View File

@ -128,6 +128,8 @@ private:
template <class Gt>
struct Normal_of_point_with_normal_map
{
typedef Normal_of_point_with_normal_map<Gt> Self;
typedef Point_with_normal_3<Gt> Point_with_normal; ///< Position + normal
typedef typename Gt::Vector_3 Vector; /// normal
@ -137,9 +139,8 @@ struct Normal_of_point_with_normal_map
typedef boost::lvalue_property_map_tag category;
/// Access a property map element
value_type& operator[](key_type& pwn) const { return pwn.normal(); }
value_type& operator[](key_type& k) const { return k.normal(); }
typedef Normal_of_point_with_normal_map<Gt> Self;
/// \name Put/get free functions
/// @{
friend reference get(const Self&, const key_type& k) { return k.normal(); }

16
Point_set_processing_3/include/CGAL/estimate_scale.h
View File

@ -238,23 +238,21 @@ class Quick_multiscale_approximate_knn_distance<Kernel, typename Kernel::Point_2
template <typename PointMap>
struct Pmap_to_3d
{
PointMap point_map;
typedef typename Kernel::Point_3 value_type;
typedef const value_type& reference;
typedef value_type reference;
typedef typename Kernel::Point_2 key_type;
typedef boost::lvalue_property_map_tag category;
typedef boost::readable_property_map_tag category;
PointMap point_map;
Pmap_to_3d () { }
Pmap_to_3d (PointMap point_map)
: point_map (point_map) { }
Pmap_to_3d (PointMap point_map) : point_map (point_map) { }
friend inline value_type get (const Pmap_to_3d& pmap, key_type p)
friend inline value_type get (const Pmap_to_3d& pmap, const key_type& p)
{
typename boost::property_traits<PointMap>::reference
p2 = get(pmap.point_map, p);
typename boost::property_traits<PointMap>::reference p2 = get(pmap.point_map, p);
return value_type (p2.x(), p2.y(), 0.);
}
};
struct Sort_by_distance_to_point

2
Point_set_processing_3/include/CGAL/mst_orient_normals.h
View File

@ -133,7 +133,7 @@ public:
/// Free function to access the map elements.
friend inline
reference get(const Default_constrained_map& map, key_type p)
value_type get(const Default_constrained_map& map, const key_type& p)
{
return (p == *map.m_source_point);
}

5
Point_set_processing_3/include/CGAL/structure_point_set.h
View File

@ -102,10 +102,11 @@ private:
typedef const value_type& reference;
typedef std::size_t key_type;
typedef boost::lvalue_property_map_tag category;
My_point_property_map (const std::vector<Point>& pts) : points (pts) {}
reference operator[] (key_type k) const { return points[k]; }
friend inline reference get (const My_point_property_map& ppmap, key_type i)
{ return ppmap[i]; }
friend inline reference get (const My_point_property_map& ppmap, key_type i) { return ppmap[i]; }
};
struct Edge

10
Polygon_mesh_processing/examples/Polygon_mesh_processing/connected_components_example.cpp
View File

@ -20,7 +20,7 @@ typedef CGAL::Surface_mesh<Point> Mesh;
namespace PMP = CGAL::Polygon_mesh_processing;
template <typename G>
struct Constraint : public boost::put_get_helper<bool,Constraint<G> >
struct Constraint
{
typedef typename boost::graph_traits<G>::edge_descriptor edge_descriptor;
typedef boost::readable_property_map_tag category;
@ -36,7 +36,7 @@ struct Constraint : public boost::put_get_helper<bool,Constraint<G> >
: g_(&g), bound_(bound)
{}
bool operator[](edge_descriptor e) const
value_type operator[](edge_descriptor e) const
{
const G& g = *g_;
return compare_(g.point(source(e, g)),
@ -46,6 +46,12 @@ struct Constraint : public boost::put_get_helper<bool,Constraint<G> >
bound_) == CGAL::SMALLER;
}
friend inline
value_type get(const Constraint& m, const key_type k)
{
return m[k];
}
const G* g_;
Compare_dihedral_angle_3 compare_;
double bound_;

2
Polygon_mesh_processing/examples/Polygon_mesh_processing/corefinement_OM_union.cpp
View File

@ -22,8 +22,8 @@ struct Exact_vertex_point_map
// typedef for the property map
typedef boost::property_traits<Exact_point_map>::value_type value_type;
typedef boost::property_traits<Exact_point_map>::reference reference;
typedef boost::property_traits<Exact_point_map>::category category;
typedef boost::property_traits<Exact_point_map>::key_type key_type;
typedef boost::read_write_property_map_tag category;
// exterior references
Exact_point_map exact_point_map;

2
Polygon_mesh_processing/examples/Polygon_mesh_processing/corefinement_consecutive_bool_op.cpp
View File

@ -22,8 +22,8 @@ struct Exact_vertex_point_map
// typedef for the property map
typedef boost::property_traits<Exact_point_map>::value_type value_type;
typedef boost::property_traits<Exact_point_map>::reference reference;
typedef boost::property_traits<Exact_point_map>::category category;
typedef boost::property_traits<Exact_point_map>::key_type key_type;
typedef boost::read_write_property_map_tag category;
// exterior references
Exact_point_map exact_point_map;

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h
View File

@ -86,7 +86,7 @@ template<typename PatchIdMap,
typename ValueType = typename boost::property_traits<PatchIdMap>::value_type>
struct PatchIdMapWrapper
{
typedef typename boost::property_traits<PatchIdMap>::category category;
typedef typename boost::read_write_property_map_tag category;
typedef ValueType value_type;
typedef typename boost::property_traits<PatchIdMap>::reference reference;
typedef typename boost::property_traits<PatchIdMap>::key_type key_type;
@ -118,7 +118,7 @@ void put(PatchIdMapWrapper<PatchIdMap, Int>& map, Handle_type h,
template<typename PatchIdMap, typename Int>
struct PatchIdMapWrapper<PatchIdMap, std::pair<Int, Int> >
{
typedef typename boost::property_traits<PatchIdMap>::category category;
typedef typename boost::read_write_property_map_tag category;
typedef Int value_type;
typedef typename boost::property_traits<PatchIdMap>::reference reference;
typedef typename boost::property_traits<PatchIdMap>::key_type key_type;

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Isotropic_remeshing/remesh_impl.h
View File

@ -98,7 +98,7 @@ namespace internal {
public:
typedef edge_descriptor key_type;
typedef bool value_type;
typedef value_type& reference;
typedef value_type reference;
typedef boost::read_write_property_map_tag category;
Border_constraint_pmap()
@ -172,7 +172,7 @@ namespace internal {
public:
typedef face_descriptor key_type;
typedef Patch_id value_type;
typedef Patch_id& reference;
typedef Patch_id reference;
typedef boost::read_write_property_map_tag category;
//note pmesh is a non-const ref because properties are added and removed
@ -1183,7 +1183,7 @@ private:
{
typedef boost::readable_property_map_tag category;
typedef Patch_id value_type;
typedef Patch_id& reference;
typedef Patch_id reference;
typedef typename Triangle_list::const_iterator key_type;
const Self* remesher_ptr_;
@ -1193,7 +1193,7 @@ private:
Patch_id_property_map(const Self& remesher)
: remesher_ptr_(&remesher) {}
friend Patch_id get(const Patch_id_property_map& m, key_type tr_it)
friend value_type get(const Patch_id_property_map& m, key_type tr_it)
{
//tr_it is an iterator from triangles_
std::size_t id_in_vec = std::distance(

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/locate.h
View File

@ -1499,7 +1499,7 @@ public:
const VertexPointMap& vpm() const { return vpm_; }
// get function for property map
inline friend reference get(const Self& pmap, key_type v) {
inline friend value_type get(const Self& pmap, key_type v) {
return pmap.converter()(get(pmap.vpm(), v));
}

7
Polygon_mesh_processing/test/Polygon_mesh_processing/connected_component_surface_mesh.cpp
View File

@ -20,7 +20,6 @@ typedef CGAL::Surface_mesh<Point> Mesh;
template <typename G, typename GT>
struct Constraint
: public boost::put_get_helper<bool, Constraint<G, GT> >
{
typedef typename GT::FT FT;
@ -45,6 +44,12 @@ struct Constraint
bound) == CGAL::SMALLER;
}
friend inline
value_type get(const Constraint& m, const key_type k)
{
return m[k];
}
const G* g;
const GT* gt;
FT bound;

5
Polygon_mesh_processing/test/Polygon_mesh_processing/remeshing_test.cpp
View File

@ -124,7 +124,7 @@ struct Constraints_pmap
typedef edge_descriptor key_type;
typedef bool value_type;
typedef value_type& reference;
typedef value_type reference;
typedef boost::read_write_property_map_tag category;
public:
@ -141,8 +141,7 @@ public:
return !map.set_ptr_->empty()
&& map.set_ptr_->count(e);
}
friend void put(Constraints_pmap& map
, const key_type& e, const value_type is)
friend void put(Constraints_pmap& map, const key_type& e, const value_type is)
{
CGAL_assertion(map.set_ptr_ != nullptr);
if (is) map.set_ptr_->insert(e);

2
Polygon_mesh_processing/test/Polygon_mesh_processing/triangulate_faces_test.cpp
View File

@ -186,7 +186,7 @@ struct Dual_vpm
}
friend
Point get(Dual_vpm& map, key_type& f)
value_type get(Dual_vpm& map, key_type f)
{
std::vector<Point> face_points;

16
Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/polyfit_example_with_region_growing.cpp
View File

@ -57,20 +57,18 @@ public:
Index_map() { }
template<typename PointRange>
Index_map(
const PointRange& points,
const std::vector< std::vector<std::size_t> >& regions) :
m_indices(new std::vector<int>(points.size(), -1)) {
Index_map(const PointRange& points,
const std::vector< std::vector<std::size_t> >& regions)
: m_indices(new std::vector<int>(points.size(), -1))
{
for (std::size_t i = 0; i < regions.size(); ++i)
for (const std::size_t idx : regions[i])
(*m_indices)[idx] = static_cast<int>(i);
}
inline friend value_type get(
const Index_map& index_map,
const key_type key) {
inline friend value_type get(const Index_map& index_map,
const key_type key)
{
const auto& indices = *(index_map.m_indices);
return indices[key];
}

9
Polyhedron/demo/Polyhedron/Plugins/AABB_tree/Cut_plugin.cpp
View File

@ -204,14 +204,9 @@ struct PPMAP
typedef typename boost::property_map<Mesh, boost::vertex_point_t>::type VertexPointMap;
Mesh* _mesh;
PPMAP<Mesh>()
:_mesh(nullptr){}
PPMAP<Mesh>(Mesh* mesh)
:_mesh(mesh)
{
}
PPMAP() : _mesh(nullptr){}
PPMAP(Mesh* mesh) : _mesh(mesh) { }
friend reference get(const PPMAP<Mesh>&ppmap, key_type v)
{

5
Polyhedron/demo/Polyhedron/Plugins/Point_set/Point_set_normal_estimation_plugin.cpp
View File

@ -82,11 +82,10 @@ struct Vector_to_pmap
Vector_to_pmap (std::vector<bool>* vec = nullptr) : vec (vec) { }
friend inline
reference get(const Vector_to_pmap& map, key_type p)
value_type get(const Vector_to_pmap& map, key_type i)
{
return (*map.vec)[p];
return (*map.vec)[i];
}
};
using namespace CGAL::Three;

4
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/Offset_meshing_plugin.cpp
View File

@ -95,7 +95,7 @@ class Polygon_soup_offset_function {
public:
typedef Polygon_iterator key_type;
typedef EPICK::Point_3 value_type;
typedef value_type reference;
typedef const value_type& reference;
typedef boost::readable_property_map_tag category;
Polygon_soup_point_property_map() = default;
@ -124,7 +124,7 @@ class Polygon_soup_offset_function {
: points_vector_ptr(ptr)
{}
friend reference get(Polygon_soup_triangle_property_map map,
friend value_type get(Polygon_soup_triangle_property_map map,
key_type polygon_it)
{
auto it = polygon_it->begin();

2
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/Surface_mesh_approximation_plugin.cpp
View File

@ -37,7 +37,7 @@ class Polyhedron_demo_surface_mesh_approximation_plugin :
Q_PLUGIN_METADATA(IID "com.geometryfactory.PolyhedronDemo.PluginInterface/1.0")
typedef boost::property_map<SMesh, CGAL::face_patch_id_t<int> >::type Face_id_map;
struct Patch_id_pmap : public boost::put_get_helper<std::size_t, Patch_id_pmap>
struct Patch_id_pmap
{
public:
typedef boost::read_write_property_map_tag category;

11
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh_deformation/Scene_edit_polyhedron_item.cpp
View File

@ -441,10 +441,12 @@ struct ROI_faces_pmap<SMesh>
{
typedef sm_face_descriptor key_type;
typedef std::size_t value_type;
typedef std::size_t& reference;
typedef std::size_t reference;
typedef boost::read_write_property_map_tag category;
SMesh* mesh;
SMesh::Property_map<sm_face_descriptor,bool> irmap;
ROI_faces_pmap(std::map<key_type, value_type>*, SMesh* mesh)
:mesh(mesh)
{
@ -482,7 +484,8 @@ struct ROI_border_pmap
ROI_border_pmap(std::set<m_ed>* set_)
: m_set_ptr(set_)
{}
friend bool get(const ROI_border_pmap<Mesh>& map, const key_type& k)
friend value_type get(const ROI_border_pmap<Mesh>& map, const key_type& k)
{
CGAL_assertion(map.m_set_ptr != nullptr);
return map.m_set_ptr->count(k);
@ -528,8 +531,10 @@ struct Is_constrained_map<SMesh>
typedef bool value_type;
typedef bool reference;
typedef boost::read_write_property_map_tag category;
SMesh::Property_map<sm_vertex_descriptor,int> icmap;
SMesh* mesh;
Is_constrained_map()
{}
Is_constrained_map(std::vector<int>* vec, SMesh* mesh)
@ -544,7 +549,7 @@ struct Is_constrained_map<SMesh>
void clean(){ mesh->remove_property_map(icmap); }
friend bool get(const Is_constrained_map<SMesh>& map, const key_type& k)
friend value_type get(const Is_constrained_map<SMesh>& map, const key_type& k)
{
return map.icmap[k] != -1;
}

15
Polyhedron/demo/Polyhedron/Plugins/Surface_mesh_deformation/Scene_edit_polyhedron_item.h
View File

@ -76,18 +76,21 @@ public:
typedef EPICK::Point_3 value_type;
typedef const value_type& reference;
typedef boost::read_write_property_map_tag category;
std::vector<float>* positions;
Mesh* mesh;
Id_setter* id_setter;
Array_based_vertex_point_map(std::vector<float>* positions, Mesh* mesh, Id_setter* id_setter) : positions(positions), mesh(mesh), id_setter(id_setter) {}
Array_based_vertex_point_map(std::vector<float>* positions, Mesh* mesh, Id_setter* id_setter)
: positions(positions), mesh(mesh), id_setter(id_setter)
{}
};
template<typename Mesh> inline
typename Array_based_vertex_point_map<Mesh>::reference
get(Array_based_vertex_point_map<Mesh> map,
typename Array_based_vertex_point_map<Mesh>::key_type key) {
get(const Array_based_vertex_point_map<Mesh>& map,
typename Array_based_vertex_point_map<Mesh>::key_type key)
{
typedef typename boost::property_map<Mesh, boost::vertex_point_t>::type VertexPointMap;
VertexPointMap pmap = get(boost::vertex_point, *map.mesh);
return get(pmap, key);
@ -96,9 +99,9 @@ get(Array_based_vertex_point_map<Mesh> map,
template<typename Mesh> inline
void
put(Array_based_vertex_point_map<Mesh> map,
put(const Array_based_vertex_point_map<Mesh>& map,
typename Array_based_vertex_point_map<Mesh>::key_type key,
typename Array_based_vertex_point_map<Mesh>::value_type val)
const typename Array_based_vertex_point_map<Mesh>::value_type& val)
{
typedef typename boost::property_map<Mesh, boost::vertex_point_t>::type VertexPointMap;
VertexPointMap vpmap = get(boost::vertex_point, *map.mesh);

5
Polyhedron/demo/Polyhedron/Scene_polyhedron_selection_item.h
View File

@ -611,7 +611,8 @@ public:
Is_constrained_map(SelectionSet* set_)
: m_set_ptr(set_)
{}
friend bool get(const Is_constrained_map& map, const key_type& k)
friend value_type get(const Is_constrained_map& map, const key_type& k)
{
CGAL_assertion(map.m_set_ptr != nullptr);
return map.m_set_ptr->count(k);
@ -629,7 +630,7 @@ public:
{
typedef Handle key_type;
typedef std::size_t value_type;
typedef value_type& reference;
typedef value_type reference;
typedef boost::read_write_property_map_tag category;
friend value_type get(Index_map, Handle h)

22
Polyhedron/demo/Polyhedron/include/id_printing.h
View File

@ -7,7 +7,9 @@
#include <CGAL/Kernel_traits.h>
#include <CGAL/Polygon_mesh_processing/compute_normal.h>
#include <vector>
#define POINT_SIZE 11
template<class Mesh>
struct VKRingPMAP{
typedef typename boost::graph_traits<Mesh>::vertex_descriptor key_type;
@ -15,22 +17,22 @@ struct VKRingPMAP{
typedef value_type reference;
typedef boost::read_write_property_map_tag category;
typedef typename boost::property_map<Mesh, boost::vertex_index_t>::type IDmap;
std::vector<bool>* vec;
Mesh* poly;
IDmap idmap;
VKRingPMAP(std::vector<bool>* vec, Mesh* poly)
:vec(vec), poly(poly)
{
idmap = get(boost::vertex_index, *poly);
}
friend value_type get(const VKRingPMAP<Mesh>& map, const key_type& f){
return (*map.vec)[get(map.idmap, f)];
friend value_type get(const VKRingPMAP<Mesh>& map, const key_type& v){
return (*map.vec)[get(map.idmap, v)];
}
friend void put(VKRingPMAP<Mesh>& map, const key_type& f, const value_type i){
(*map.vec)[get(map.idmap, f)] = i;
friend void put(VKRingPMAP<Mesh>& map, const key_type& v, const value_type i){
(*map.vec)[get(map.idmap, v)] = i;
}
};
template<class Mesh>
@ -40,6 +42,7 @@ struct EdgeKRingPMAP{
typedef value_type reference;
typedef boost::read_write_property_map_tag category;
typedef typename boost::property_map<Mesh, boost::halfedge_index_t>::type IDmap;
std::vector<bool>* vec;
Mesh* poly;
IDmap idmap;
@ -50,11 +53,11 @@ struct EdgeKRingPMAP{
idmap = get(boost::halfedge_index, *poly);
}
friend value_type get(const EdgeKRingPMAP<Mesh>& map, const key_type& f){
return (*map.vec)[get(map.idmap, halfedge(f, *map.poly))/2];
friend value_type get(const EdgeKRingPMAP<Mesh>& map, const key_type& e){
return (*map.vec)[get(map.idmap, halfedge(e, *map.poly))/2];
}
friend void put(EdgeKRingPMAP<Mesh>& map, const key_type& f, const value_type i){
(*map.vec)[get(map.idmap, halfedge(f, *map.poly))/2] = i;
friend void put(EdgeKRingPMAP<Mesh>& map, const key_type& e, const value_type i){
(*map.vec)[get(map.idmap, halfedge(e, *map.poly))/2] = i;
}
};
template<class Mesh>
@ -64,6 +67,7 @@ struct FKRingPMAP{
typedef value_type reference;
typedef boost::read_write_property_map_tag category;
typedef typename boost::property_map<Mesh, boost::face_index_t>::type IDmap;
std::vector<bool>* vec;
Mesh* poly;
IDmap idmap;

19
Polyhedron/include/CGAL/boost/graph/properties_Polyhedron_3.h
View File

@ -52,12 +52,12 @@ private:
// Special case for edges.
template<class Polyhedron>
class Polyhedron_edge_index_map_external
: public boost::put_get_helper<std::size_t, Polyhedron_edge_index_map_external<Polyhedron> >
: public boost::put_get_helper<std::size_t&, Polyhedron_edge_index_map_external<Polyhedron> >
{
public:
typedef boost::readable_property_map_tag category;
typedef boost::lvalue_property_map_tag category;
typedef std::size_t value_type;
typedef std::size_t reference;
typedef std::size_t& reference;
typedef typename boost::graph_traits<Polyhedron>::edge_descriptor key_type;
private:
@ -80,7 +80,6 @@ private:
template<typename Handle, typename FT>
struct Wrap_squared
: boost::put_get_helper< double, Wrap_squared<Handle,FT> >
{
typedef FT value_type;
typedef FT reference;
@ -88,9 +87,15 @@ struct Wrap_squared
typedef boost::readable_property_map_tag category;
template<typename E>
FT
operator[](const E& e) const {
return approximate_sqrt(CGAL::squared_distance(e.halfedge()->vertex()->point(), e.halfedge()->opposite()->vertex()->point()));
FT operator[](const E& e) const {
return approximate_sqrt(CGAL::squared_distance(e.halfedge()->vertex()->point(),
e.halfedge()->opposite()->vertex()->point()));
}
friend inline
value_type get(const Wrap_squared& m, const key_type k)
{
return m[k];
}
};

6
Polyhedron/include/CGAL/boost/graph/properties_Polyhedron_3_features.h
View File

@ -50,8 +50,7 @@ Patch_id get(Polyhedron_face_patch_id_pmap<Patch_id>, Handle_type h)
}
template <typename Patch_id, typename Handle_type>
void put(Polyhedron_face_patch_id_pmap<Patch_id>, Handle_type h,
Patch_id pid)
void put(Polyhedron_face_patch_id_pmap<Patch_id>, Handle_type h, Patch_id pid)
{
h->set_patch_id(pid);
}
@ -199,11 +198,10 @@ struct Polyhedron_incident_patches_pmap {
typedef boost::lvalue_property_map_tag category;
template <typename Handle_type>
value_type& operator[](Handle_type h) const
reference operator[](Handle_type h) const
{
return get(*this, h);
}
};
template <typename Patch_id, typename Handle_type>

3
Polyhedron/include/CGAL/boost/graph/properties_Polyhedron_3_time_stamp.h
View File

@ -33,8 +33,7 @@ std::size_t get(Polyhedron_face_time_stamp_pmap, Handle_type h)
}
template <typename Handle_type>
void put(Polyhedron_face_time_stamp_pmap, Handle_type h,
std::size_t ts)
void put(Polyhedron_face_time_stamp_pmap, Handle_type h, std::size_t ts)
{
h->set_time_stamp(ts);
}

6
Polyline_simplification_2/include/CGAL/Polyline_simplification_2/simplify.h
View File

@ -93,7 +93,7 @@ public:
} ;
struct Id_map : public boost::put_get_helper<std::size_t, Id_map>
struct Id_map
{
typedef boost::readable_property_map_tag category;
typedef std::size_t value_type;
@ -101,10 +101,12 @@ public:
typedef Vertex_handle key_type;
reference operator[] ( key_type const& x ) const
value_type operator[](const key_type& x) const
{
return x->ID;
}
friend inline value_type get(const Id_map& m, const key_type k) { return m[k]; }
} ;
typedef CGAL::Modifiable_priority_queue<Vertex_handle,Compare_cost,Id_map> MPQ ;

6
Property_map/include/CGAL/Dynamic_property_map.h
View File

@ -96,7 +96,7 @@ struct Dynamic {
typedef typename PM::key_type key_type;
typedef typename PM::value_type value_type;
typedef typename PM::reference reference;
typedef typename PM::category category;
typedef boost::read_write_property_map_tag category;
typedef Dynamic_property_map_deleter<Mesh,PM> Deleter;
@ -130,9 +130,7 @@ struct Dynamic_with_index
typedef typename boost::mpl::if_< boost::is_same<bool, Value>,
value_type,
value_type&>::type reference;
typedef typename boost::mpl::if_< boost::is_same<bool, Value>,
boost::read_write_property_map_tag,
boost::lvalue_property_map_tag>::type category;
typedef boost::read_write_property_map_tag category;
Dynamic_with_index()
: m_values()

2
Property_map/include/CGAL/Index_property_map.h
View File

@ -121,7 +121,7 @@ public:
/// Free function to access the map elements.
friend inline
reference get(const Index_property_map& map, key_type p)
value_type get(const Index_property_map& map, key_type p)
{
return std::distance(map.m_first, p);
}

73
Property_map/include/CGAL/property_map.h
View File

@ -19,8 +19,6 @@
#include <boost/tuple/tuple.hpp>
#include <CGAL/tuple.h>
#include <utility> // defines std::pair
#include <CGAL/boost/iterator/counting_iterator.hpp>
#include <CGAL/boost/iterator/transform_iterator.hpp>
#include <CGAL/Iterator_range.h>
@ -28,6 +26,13 @@
#include <CGAL/Kernel_traits_fwd.h>
#include <CGAL/assertions.h>
#include <algorithm>
#include <iterator>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
namespace CGAL {
/// \cond SKIP_DOXYGEN
@ -43,7 +48,6 @@ public:
typedef boost::read_write_property_map_tag category;
public:
inline friend
value_type
get(Static_boolean_property_map, const key_type&)
@ -53,7 +57,7 @@ public:
inline friend
void
put(Static_boolean_property_map, const key_type&, const value_type&)
put(Static_boolean_property_map, const key_type&, value_type)
{}
};
@ -100,7 +104,8 @@ make_OR_property_map(const PM1& pm1, const PM2& pm2)
// A property map that uses the result of a property map as key.
template <class KeyMap, class ValueMap>
struct Property_map_binder{
struct Property_map_binder
{
typedef typename boost::property_traits<KeyMap>::key_type key_type;
typedef typename boost::property_traits<ValueMap>::value_type value_type;
typedef typename boost::property_traits<ValueMap>::reference reference;
@ -109,9 +114,15 @@ struct Property_map_binder{
KeyMap key_map;
ValueMap value_map;
Property_map_binder(const KeyMap& key_map, const ValueMap& value_map)
: key_map(key_map)
, value_map(value_map)
Property_map_binder(const KeyMap& key_map = KeyMap(),
const ValueMap& value_map = ValueMap())
: key_map(key_map), value_map(value_map)
{ }
template <typename VM>
Property_map_binder(const VM& value_map,
typename std::enable_if<!std::is_same<KeyMap, VM>::value>::type* = nullptr)
: value_map(value_map)
{ }
friend
@ -164,14 +175,14 @@ struct Dereference_property_map
{
typedef T* key_type; ///< typedef to 'T*'
typedef T value_type; ///< typedef to 'T'
typedef const value_type& reference; ///< typedef to 'T&'
typedef T& reference; ///< typedef to 'T&'
typedef boost::lvalue_property_map_tag category; ///< `boost::lvalue_property_map_tag`
/// Access a property map element.
///
/// @tparam Iter Type convertible to `key_type`.
template <class Iter>
value_type& operator[](Iter it) const { return reference(*it); }
value_type& operator[](Iter it) const { return *it; }
};
/// Free function to create a `Dereference_property_map` property map.
@ -192,15 +203,17 @@ make_dereference_property_map(Iter)
template <typename T>
struct Identity_property_map
{
typedef Identity_property_map<T> Self;
typedef T key_type; ///< typedef to `T`
typedef T value_type; ///< typedef to `T`
typedef const T& reference; ///< typedef to `T&`
typedef const T& reference; ///< typedef to `const T&`
typedef boost::lvalue_property_map_tag category; ///< `boost::lvalue_property_map_tag`
/// Access a property map element.
/// @param k a key which is returned as mapped value.
value_type& operator[](key_type& k) const { return k; }
const value_type& operator[](const key_type& k) const { return k; }
typedef Identity_property_map<T> Self;
/// \name Put/get free functions
/// @{
friend reference get(const Self&, const key_type& k) { return k; }
@ -220,7 +233,7 @@ struct Identity_property_map_no_lvalue
typedef Identity_property_map_no_lvalue<T> Self;
friend reference get(const Self&, const key_type& k) {return k;}
friend value_type get(const Self&, const key_type& k) {return k;}
};
/// \endcond
@ -244,16 +257,17 @@ Identity_property_map<T>
template <typename Pair>
struct First_of_pair_property_map
{
typedef First_of_pair_property_map<Pair> Self;
typedef Pair key_type; ///< typedef to `Pair`
typedef typename Pair::first_type value_type; ///< typedef to `Pair::first_type`
typedef const value_type& reference; ///< typedef to `value_type&`
typedef const value_type& reference; ///< typedef to `const value_type&`
typedef boost::lvalue_property_map_tag category; ///< boost::lvalue_property_map_tag
/// Access a property map element.
/// @param pair a key whose first item is accessed
value_type& operator[](key_type& pair) const { return pair.first; }
const value_type& operator[](const key_type& pair) const { return pair.first; }
typedef First_of_pair_property_map<Pair> Self;
/// \name Put/get free functions
/// @{
friend reference get(const Self&, const key_type& k) { return k.first; }
@ -283,16 +297,17 @@ First_of_pair_property_map<Pair>
template <typename Pair>
struct Second_of_pair_property_map
{
typedef Second_of_pair_property_map<Pair> Self;
typedef Pair key_type; ///< typedef to `Pair`
typedef typename Pair::second_type value_type; ///< typedef to `Pair::second_type`
typedef const value_type& reference; ///< typedef to `value_type&`
typedef const value_type& reference; ///< typedef to `const value_type&`
typedef boost::lvalue_property_map_tag category; ///< boost::lvalue_property_map_tag
/// Access a property map element.
/// @param pair a key whose second item is accessed
value_type& operator[](key_type& pair) const { return pair.second; }
const value_type& operator[](const key_type& pair) const { return pair.second; }
typedef Second_of_pair_property_map<Pair> Self;
/// \name Put/get free functions
/// @{
friend reference get(const Self&, const key_type& k) { return k.second; }
@ -321,19 +336,21 @@ Second_of_pair_property_map<Pair>
template <int N, typename Tuple>
struct Nth_of_tuple_property_map
{
typedef Nth_of_tuple_property_map<N,Tuple> Self;
typedef Tuple key_type; ///< typedef to `Tuple`
#ifdef DOXYGEN_RUNNING
typedef unspecified_type value_type; ///< typedef to the N-th type of the tuple
#else
typedef typename boost::tuples::element<N,Tuple>::type value_type;
#endif
typedef const value_type& reference; ///< typedef to `value_type&`
typedef const value_type& reference; ///< typedef to `const value_type&`
typedef boost::lvalue_property_map_tag category; ///< `boost::lvalue_property_map_tag`
/// Access a property map element.
/// @param tuple a key whose Nth item is accessed
value_type& operator[](key_type& tuple) const { return tuple.template get<N>(); }
const value_type& operator[](const key_type& tuple) const { return tuple.template get<N>(); }
typedef Nth_of_tuple_property_map<N,Tuple> Self;
/// \name Put/get free functions
/// @{
friend reference get(const Self&, const key_type& k) { return k.template get<N>(); }
@ -345,14 +362,15 @@ template <int N, typename ... T>
struct Nth_of_tuple_property_map<N,std::tuple<T...> >
{
typedef std::tuple<T...> Tuple;
typedef Nth_of_tuple_property_map<N,Tuple> Self;
typedef Tuple key_type;
typedef typename std::tuple_element<N,Tuple>::type value_type;
typedef const value_type& reference;
typedef boost::lvalue_property_map_tag category;
value_type& operator[](key_type& tuple) const { return get<N>(tuple); }
const value_type& operator[](const key_type& tuple) const { return get<N>(tuple); }
typedef Nth_of_tuple_property_map<N,Tuple> Self;
friend reference get(const Self&, const key_type& k) { return std::get<N>(k); }
friend void put(const Self&, key_type& k, const value_type& v) { std::get<N>(k) = v; }
};
@ -470,7 +488,7 @@ struct Constant_property_map
/// Free function that returns `pm.default_value`.
inline friend
const value_type& get (const Constant_property_map& pm, const key_type&) { return pm.default_value; }
reference get (const Constant_property_map& pm, const key_type&) { return pm.default_value; }
/// Free function that does nothing.
inline friend
@ -549,8 +567,7 @@ struct Cartesian_converter_property_map
friend value_type get(const Cartesian_converter_property_map<GeomObject, Vpm>& pm, const key_type& k)
{
return
CGAL::Cartesian_converter<K1, K2>()(get(pm.vpm, k));
return CGAL::Cartesian_converter<K1, K2>()(get(pm.vpm, k));
}
friend void put(Cartesian_converter_property_map<GeomObject, Vpm>& pm, const key_type& k, const value_type& v)

17
Shape_detection/examples/Shape_detection/region_growing_with_custom_classes.cpp
View File

@ -87,20 +87,21 @@ namespace Custom {
public:
using key_type = std::size_t;
using value_type = std::size_t;
using category = boost::lvalue_property_map_tag;
using reference = std::size_t;
using category = boost::readable_property_map_tag;
Seed_map(const std::map<std::size_t, std::size_t>& objects_map) :
m_objects_map(objects_map)
Seed_map(const std::map<std::size_t, std::size_t>& objects_map)
: m_objects_map(objects_map)
{ }
value_type operator[](const key_type key) const {
value_type operator[](const key_type& key) const
{
return m_objects_map.find(key)->second;
}
friend value_type get(
const Seed_map& seed_map,
const key_type key) {
friend value_type get(const Seed_map& seed_map,
const key_type& key)
{
return seed_map[key];
}

2
Shape_detection/include/CGAL/Shape_detection/Efficient_RANSAC/property_map.h
View File

@ -90,7 +90,7 @@ namespace Shape_detection {
typedef value_type reference;
typedef boost::read_write_property_map_tag category;
inline friend reference get (const Plane_map&, const key_type& k)
inline friend value_type get (const Plane_map&, const key_type& k)
{
return value_type(*k);
}

35
Shape_detection/include/CGAL/Shape_detection/Region_growing/internal/property_map.h
View File

@ -57,10 +57,8 @@ namespace internal {
return get(m_property_map, key);
}
friend inline reference get(
const Item_property_map& item_map,
friend inline reference get(const Item_property_map& item_map,
const key_type key) {
return item_map[key];
}
@ -79,8 +77,9 @@ namespace internal {
using Item = typename Iterator::value_type;
using value_type = std::size_t;
using reference = std::size_t;
using key_type = Item;
using category = boost::lvalue_property_map_tag;
using category = boost::readable_property_map_tag;
using Item_map = std::map<key_type, value_type>;
@ -105,10 +104,8 @@ namespace internal {
return value->second;
}
friend inline value_type get(
const Item_to_index_property_map& item_to_index_map,
friend inline value_type get(const Item_to_index_property_map& item_to_index_map,
const key_type& key) {
return item_to_index_map[key];
}
@ -122,21 +119,18 @@ namespace internal {
public:
using key_type = std::size_t;
using value_type = std::size_t;
using category = boost::lvalue_property_map_tag;
using category = boost::readable_property_map_tag;
Seed_property_map(
const std::vector<std::size_t>& seeds) :
m_seeds(seeds)
Seed_property_map(const std::vector<std::size_t>& seeds)
: m_seeds(seeds)
{ }
value_type operator[](const key_type key) const {
return m_seeds[key];
}
friend value_type get(
const Seed_property_map& seed_map,
friend value_type get(const Seed_property_map& seed_map,
const key_type key) {
return seed_map[key];
}
@ -159,20 +153,17 @@ namespace RG {
Point_to_shape_index_map() { }
template<typename PointRange>
Point_to_shape_index_map(
const PointRange& points,
const std::vector< std::vector<std::size_t> >& regions) :
m_indices(new std::vector<int>(points.size(), -1)) {
Point_to_shape_index_map(const PointRange& points,
const std::vector< std::vector<std::size_t> >& regions)
: m_indices(new std::vector<int>(points.size(), -1))
{
for (std::size_t i = 0; i < regions.size(); ++i)
for (const std::size_t idx : regions[i])
(*m_indices)[idx] = static_cast<int>(i);
}
inline friend value_type get(
const Point_to_shape_index_map& point_to_shape_index_map,
inline friend value_type get(const Point_to_shape_index_map& point_to_shape_index_map,
const key_type key) {
const auto& indices = *(point_to_shape_index_map.m_indices);
return indices[key];
}

2
Spatial_searching/benchmark/Spatial_searching/nearest_neighbor_searching_inplace_50.cpp
View File

@ -24,7 +24,7 @@ public:
typedef Point_3 value_type;
typedef const value_type& reference;
typedef Point key_type;
typedef boost::lvalue_property_map_tag category;
typedef boost::readable_property_map_tag category;
My_point_property_map(const std::vector<Point_3>& pts):points(pts){}

13
Spatial_searching/include/CGAL/Search_traits_adapter.h
View File

@ -232,17 +232,14 @@ public:
// Select type of iterator + construct class depending on whether
// point map is lvalue or not
typedef typename boost::mpl::if_
<boost::is_same
<boost::lvalue_property_map_tag,
typename boost::property_traits<PointPropertyMap>::category >,
typedef typename boost::mpl::if_<
boost::is_reference<typename boost::property_traits<PointPropertyMap>::reference>,
typename Base::Cartesian_const_iterator_d,
No_lvalue_iterator>::type
Cartesian_const_iterator_d;
typedef typename boost::mpl::if_
<boost::is_same
<boost::lvalue_property_map_tag,
typename boost::property_traits<PointPropertyMap>::category >,
typedef typename boost::mpl::if_<
boost::is_reference<typename boost::property_traits<PointPropertyMap>::reference>,
Construct_cartesian_const_iterator_d_lvalue,
Construct_cartesian_const_iterator_d_no_lvalue>::type
Construct_cartesian_const_iterator_d;

6
Spatial_searching/test/Spatial_searching/Point_with_info.h
View File

@ -22,12 +22,12 @@ template <class Point>
struct Point_property_map{
typedef Point value_type;
typedef const value_type& reference;
typedef const My_point_with_info<Point>& key_type;
typedef My_point_with_info<Point> key_type;
typedef boost::lvalue_property_map_tag category;
reference operator[](key_type k) const {return k.point();}
reference operator[](const key_type& k) const { return k.point(); }
friend reference get(const Point_property_map& ppmap, key_type i)
friend reference get(const Point_property_map& ppmap, const key_type& i)
{return ppmap[i];}
};

15
Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h
View File

@ -32,7 +32,6 @@ namespace CGAL {
template <typename Point>
class SM_edge_weight_pmap
: public boost::put_get_helper<typename CGAL::Kernel_traits<Point>::type::FT, SM_edge_weight_pmap<Point> >
{
typedef CGAL::Surface_mesh<Point> SM;
public:
@ -54,6 +53,12 @@ public:
pm_[target(e, sm_)]));
}
friend inline
value_type get(const SM_edge_weight_pmap& m, const key_type& k)
{
return m[k];
}
private:
typename SM::template Property_map< typename SM::Vertex_index,
typename SM::Point > pm_;
@ -62,7 +67,7 @@ private:
template <typename K, typename VEF>
class SM_index_pmap : public boost::put_get_helper<boost::uint32_t, SM_index_pmap<K,VEF> >
class SM_index_pmap
{
public:
typedef boost::readable_property_map_tag category;
@ -74,6 +79,12 @@ public:
{
return vd;
}
friend inline
value_type get(const SM_index_pmap& m, const key_type& k)
{
return m[k];
}
};
} // CGAL

4
Surface_mesh_deformation/include/CGAL/Surface_mesh_deformation.h
View File

@ -148,7 +148,9 @@ struct Types_selectors<TriangleMesh, CGAL::SRE_ARAP> {
// on the fly in order the deformation class to be used
// with points with minimal requirements
template <class Vertex_point_map>
struct SC_on_the_fly_pmap: public Vertex_point_map{
struct SC_on_the_fly_pmap
: public Vertex_point_map
{
typedef boost::readable_property_map_tag category;
typedef CGAL::Simple_cartesian<double>::Point_3 value_type;
typedef value_type reference;

2
Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_OpenMesh.cpp
View File

@ -30,7 +30,7 @@ public:
sm_.add_property(constraint);
}
inline friend reference get(const Constrained_edge_map& em, key_type e)
inline friend value_type get(const Constrained_edge_map& em, key_type e)
{
bool b = em.sm_.property(em.constraint,em.sm_.edge_handle(e.idx()));
return b;

5
Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_constrain_sharp_edges.cpp
View File

@ -25,7 +25,6 @@ namespace SMS = CGAL::Surface_mesh_simplification;
// BGL property map which indicates whether an edge is marked as non-removable
struct Constrained_edge_map
: public boost::put_get_helper<bool, Constrained_edge_map>
{
typedef boost::readable_property_map_tag category;
typedef bool value_type;
@ -36,7 +35,9 @@ struct Constrained_edge_map
: mConstraints(aConstraints)
{}
reference operator[](const key_type& e) const { return is_constrained(e); }
value_type operator[](const key_type& e) const { return is_constrained(e); }
friend inline value_type get(const Constrained_edge_map& m, const key_type& k) { return m[k]; }
bool is_constrained(const key_type& e) const { return mConstraints.is_defined(e); }

2
Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_constrained_border_polyhedron.cpp
View File

@ -34,7 +34,7 @@ struct Border_is_constrained_edge_map
Border_is_constrained_edge_map(const Surface_mesh& sm) : sm_ptr(&sm) {}
friend bool get(Border_is_constrained_edge_map m, const key_type& edge) {
friend value_type get(const Border_is_constrained_edge_map& m, const key_type& edge) {
return CGAL::is_border(edge, *m.sm_ptr);
}
};

2
Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_constrained_border_surface_mesh.cpp
View File

@ -36,7 +36,7 @@ struct Border_is_constrained_edge_map
Border_is_constrained_edge_map(const Surface_mesh& sm) : sm_ptr(&sm) {}
friend bool get(Border_is_constrained_edge_map m, const key_type& edge) {
friend value_type get(const Border_is_constrained_edge_map& m, const key_type& edge) {
return CGAL::is_border(edge, *m.sm_ptr);
}
};

2
Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/internal/Common.h
View File

@ -73,7 +73,7 @@ struct No_constrained_edge_map
typedef bool value_type;
typedef value_type reference;
typedef boost::readable_property_map_tag category;
friend bool get(No_constrained_edge_map, key_type) { return false; }
friend value_type get(No_constrained_edge_map, key_type) { return false; }
};
} // namespace Surface_mesh_simplification

3
Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/internal/Edge_collapse.h
View File

@ -157,7 +157,6 @@ public:
};
struct edge_id
: boost::put_get_helper<size_type, edge_id>
{
typedef boost::readable_property_map_tag category;
typedef size_type value_type;
@ -169,6 +168,8 @@ public:
size_type operator[](const halfedge_descriptor e) const { return m_algorithm->get_edge_id(e); }
friend inline value_type get(const edge_id& m, const key_type& k) { return m[k]; }
const Self* m_algorithm;
};

8
Tetrahedral_remeshing/include/CGAL/Tetrahedral_remeshing/internal/tetrahedral_adaptive_remeshing_impl.h
View File

@ -75,13 +75,11 @@ struct No_constraint_pmap
public:
typedef Primitive key_type;
typedef bool value_type;
typedef value_type& reference;
typedef value_type reference;
typedef boost::read_write_property_map_tag category;
friend bool get(const No_constraint_pmap&, const key_type&) {
return false;
}
friend void put(No_constraint_pmap&, const key_type&, const bool) {}
friend value_type get(No_constraint_pmap, key_type) { return false; }
friend void put(No_constraint_pmap, key_type, value_type) {}
};
template<typename Triangulation

2
Tetrahedral_remeshing/test/Tetrahedral_remeshing/test_tetrahedral_remeshing_with_features.cpp
View File

@ -48,7 +48,7 @@ public:
public:
friend void put(Constrained_edges_property_map& map,
const key_type& k,
const bool b)
const value_type b)
{
CGAL_assertion(map.m_set_ptr != nullptr);
CGAL_assertion(k.first < k.second);

16
Triangulation_2/include/CGAL/boost/graph/internal/properties_2D_triangulation.h
View File

@ -59,8 +59,6 @@ public:
template <typename Tr>
class T2_edge_weight_map
: public boost::put_get_helper<typename Tr::Geom_traits::FT,
T2_edge_weight_map<Tr> >
{
public:
typedef boost::readable_property_map_tag category;
@ -72,13 +70,14 @@ public:
value_type operator[](key_type e) const { return approximate_sqrt(tr.segment(e).squared_length()); }
friend inline value_type get(const T2_edge_weight_map& m, key_type k) { return m[k]; }
private:
const Tr& tr;
};
template <typename Tr>
class T2_vertex_id_map
: public boost::put_get_helper<int, T2_vertex_id_map<Tr> >
{
public:
typedef boost::readable_property_map_tag category;
@ -93,12 +92,13 @@ public:
return v->id();
}
friend inline value_type get(const T2_vertex_id_map& m, key_type k) { return m[k]; }
const Tr& tr;
};
template <typename Tr>
class T2_halfedge_id_map
: public boost::put_get_helper<int, T2_halfedge_id_map<Tr> >
{
public:
typedef boost::readable_property_map_tag category;
@ -128,13 +128,14 @@ public:
return 2*(f1->edge_id(h.second)) + 1;
}
friend inline value_type get(const T2_halfedge_id_map& m, key_type k) { return m[k]; }
private:
const Tr& tr;
};
template <typename Tr>
class T2_edge_id_map
: public boost::put_get_helper<int, T2_edge_id_map<Tr> >
{
public:
typedef boost::readable_property_map_tag category;
@ -157,13 +158,14 @@ public:
return f1->edge_id(e.second);
}
friend inline value_type get(const T2_edge_id_map& m, key_type k) { return m[k]; }
private:
const Tr& tr;
};
template <typename Tr>
class T2_face_id_map
: public boost::put_get_helper<int, T2_face_id_map<Tr> >
{
public:
typedef boost::readable_property_map_tag category;
@ -178,6 +180,8 @@ public:
return f->id();
}
friend inline value_type get(const T2_face_id_map& m, key_type k) { return m[k]; }
private:
const Tr& tr;
};

19
Triangulation_2/include/CGAL/boost/graph/properties_Triangulation_data_structure_2.h
View File

@ -33,13 +33,12 @@ public:
typedef typename CGAL::Triangulation_data_structure_2<VB,FB>::Vertex_handle key_type;
friend reference get(TDS2_vertex_point_map<VB,FB>, key_type vh) { return vh->point(); }
friend void put(TDS2_vertex_point_map<VB,FB>, key_type vh, reference v) { vh->point() = v; }
friend void put(TDS2_vertex_point_map<VB,FB>, key_type vh, const value_type& p) { vh->point() = p; }
reference operator[](key_type vh) const { return vh->point(); }
};
template <class VB, class FB>
class TDS2_edge_weight_map
: public boost::put_get_helper<typename VB::FT, TDS2_edge_weight_map<VB, FB> >
{
public:
typedef boost::readable_property_map_tag category;
@ -51,13 +50,14 @@ public:
value_type operator[](key_type e) const { return approximate_sqrt(tds.segment(e).squared_length()); }
friend inline value_type get(const TDS2_edge_weight_map& m, const key_type k) { return m[k]; }
private:
const CGAL::Triangulation_data_structure_2<VB,FB>& tds;
};
template <class VB, class FB>
class TDS2_vertex_id_map
: public boost::put_get_helper<int, TDS2_vertex_id_map<VB, FB> >
{
public:
typedef boost::readable_property_map_tag category;
@ -67,12 +67,13 @@ public:
TDS2_vertex_id_map() {}
long operator[](key_type vh) const { return vh->id(); }
value_type operator[](key_type vh) const { return vh->id(); }
friend inline value_type get(const TDS2_vertex_id_map& m, const key_type k) { return m[k]; }
};
template <class VB, class FB>
class TDS2_halfedge_id_map
: public boost::put_get_helper<int, TDS2_halfedge_id_map<VB, FB> >
{
typedef typename CGAL::Triangulation_data_structure_2<VB,FB> TDS;
@ -98,11 +99,12 @@ public:
else
return 2*(3 * f2->id() + f2->index(f1)) + 1;
}
friend inline value_type get(const TDS2_halfedge_id_map& m, const key_type k) { return m[k]; }
};
template <class VB, class FB>
class TDS2_edge_id_map
: public boost::put_get_helper<int, TDS2_edge_id_map<VB, FB> >
{
typedef typename CGAL::Triangulation_data_structure_2<VB,FB> TDS;
@ -126,11 +128,12 @@ public:
else
return 3 * f2->id() + f2->index(f1);
}
friend inline value_type get(const TDS2_edge_id_map& m, const key_type k) { return m[k]; }
};
template <class VB, class FB>
class TDS2_face_id_map
: public boost::put_get_helper<int, TDS2_face_id_map<VB, FB> >
{
typedef typename CGAL::Triangulation_data_structure_2<VB,FB> TDS;
@ -143,6 +146,8 @@ public:
TDS2_face_id_map() { }
value_type operator[](key_type f) const { return f->id(); }
friend inline value_type get(const TDS2_face_id_map& m, const key_type k) { return m[k]; }
};
template <class VB, class FB, class Tag>