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

Various fixes for property maps (master)

AABB_tree/include/CGAL/AABB_triangulation_3_cell_primitive.h

@@ -58,8 +58,8 @@ 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)
+      get(Tet_from_cell_iterator_proprety_map<GeomTraits, Iterator>, key_type it)
       {
         typename GeomTraits::Construct_point_3 point;
         return value_type(point(it->vertex(0)->point()),

BGL/examples/BGL_arrangement_2/arrangement_dual.cpp

@@ -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&,
+  friend void put(const Extended_face_property_map&, key_type key, value_type val)
-                  key_type key, value_type val)
   { key->set_data(val); }
 };
 

BGL/examples/BGL_arrangement_2/primal.cpp

@@ -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);
 }

BGL/include/CGAL/boost/graph/Dual.h

@@ -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) )

BGL/include/CGAL/boost/graph/Graph_with_descriptor_with_graph.h

@@ -727,7 +727,7 @@ struct Graph_with_descriptor_with_graph_property_map {
   template <typename Descriptor>
   friend
   void
-  put(const Graph_with_descriptor_with_graph_property_map<Graph,PM>& gpm, const Descriptor& d,   const value_type& v)
+  put(const Graph_with_descriptor_with_graph_property_map<Graph,PM>& gpm, const Descriptor& d, const value_type& v)
   {
     CGAL_assertion(gpm.graph!=nullptr);
     CGAL_assertion(d.graph == gpm.graph);
@@ -747,9 +747,9 @@ 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);
+    return get(*this, k);
   }
 
   Graph_with_descriptor_with_graph_property_map()

BGL/include/CGAL/boost/graph/alpha_expansion_graphcut.h

@@ -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;

BGL/include/CGAL/boost/graph/named_params_helper.h

@@ -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:

BGL/include/CGAL/boost/graph/properties.h

@@ -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,
@@ -135,7 +136,7 @@ struct Point_accessor<Handle, ValueType, ConstReference, true>
   : boost::put_get_helper< ConstReference, Point_accessor<Handle, ValueType, ConstReference, true> >
 {
   typedef boost::lvalue_property_map_tag category;
-  typedef ConstReference                      reference;
+  typedef ConstReference                 reference;
   typedef ValueType                      value_type;
   typedef Handle                         key_type;
 
@@ -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,
+// 'lvalue_property_map_tag' is annoying, because the property map is allowed to be non-mutable,
-// but boost::lvalue_property_map_tag is defined as:
+// 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

BGL/include/CGAL/boost/graph/properties_OpenMesh.h

@@ -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()
@@ -66,19 +65,19 @@ public:
   }
 
   inline friend reference get(const OM_pmap<Mesh,Descriptor,Value>& pm,
-                         typename boost::graph_traits<Mesh>::face_descriptor k)
+                              typename boost::graph_traits<Mesh>::face_descriptor k)
   {
     return pm.mesh->property(pm.h,k);
   }
 
   inline friend reference get(const OM_pmap<Mesh,Descriptor,Value>& pm,
-                         typename boost::graph_traits<Mesh>::halfedge_descriptor k)
+                              typename boost::graph_traits<Mesh>::halfedge_descriptor k)
   {
     return pm.mesh->property(pm.h,k);
   }
 
   inline friend reference get(const OM_pmap<Mesh,Descriptor,Value>& pm,
-                         typename boost::graph_traits<Mesh>::edge_descriptor k)
+                              typename boost::graph_traits<Mesh>::edge_descriptor k)
   {
     typename Mesh::EdgeHandle eh(k.idx());
     return pm.mesh->property(pm.h,eh);
@@ -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,17 +148,19 @@ 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;
-  typedef unsigned int                      value_type;
+  typedef unsigned int                     value_type;
-  typedef unsigned int                      reference;
+  typedef unsigned int                     reference;
   typedef VEF                              key_type;
 
   OM_index_pmap()
@@ -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);

BGL/include/CGAL/boost/graph/property_maps.h

@@ -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;

BGL/include/CGAL/boost/graph/selection.h

@@ -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);

BGL/test/BGL/test_Face_filtered_graph.cpp

@@ -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)
 {

BGL/test/BGL/test_Properties.cpp

@@ -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];
   }

Classification/include/CGAL/Classification/Cluster.h

@@ -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;

Classification/include/CGAL/Classification/Point_set_neighborhood.h

@@ -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))); }
   };

Classification/include/CGAL/Classification/property_maps.h

@@ -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;
 

Hash_map/include/CGAL/Unique_hash_map.h

@@ -133,27 +133,29 @@ 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
+    friend
-  const value_type&
+    reference
-  get(const associative_property_map<C>& uhm, const key_type& key)
+    get(const associative_property_map<C>& uhm, const key_type& key)
-  {
+    {
-    return uhm[key];
+      return uhm[key];
-  }
+    }
 
-  friend
+    friend
-  void
+    void
-  put(associative_property_map<C>& uhm, const key_type& key, const value_type& val)
+    put(associative_property_map<C>& uhm, const key_type& key, const value_type& val)
-  {
+    {
-    uhm[key] = val;
+      uhm[key] = val;
-  }
+    }
 
   private:
     C* m_c;

Jet_fitting_3/examples/Jet_fitting_3/PolyhedralSurf.h

@@ -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;

Linear_cell_complex/include/CGAL/boost/graph/properties_Linear_cell_complex_for_combinatorial_map.h

@@ -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;
 };

Mesh_3/include/CGAL/Mesh_3/Sliver_perturber.h

@@ -489,8 +489,7 @@ private:
    * @class PVertex_id
    * relaxed heap
    */
-  class PVertex_id :
+  class PVertex_id
-  public boost::put_get_helper<typename PVertex::id_type, 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;

Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h

@@ -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 PolylineWithContext key_type;
-  typedef const typename PolylineWithContext::Bare_polyline& value_type;
+  typedef typename PolylineWithContext::Bare_polyline value_type;
-  typedef value_type reference;
+  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 PolylineWithContext key_type;
-  typedef const typename PolylineWithContext::Context::Patches_ids& value_type;
+  typedef typename PolylineWithContext::Context::Patches_ids value_type;
-  typedef value_type reference;
+  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>

Point_set_3/include/CGAL/Point_set_3.h

@@ -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();

Point_set_processing_3/include/CGAL/Point_set_processing_3/internal/Neighbor_query.h

@@ -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;
 

Point_set_processing_3/include/CGAL/Point_with_normal_3.h

@@ -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,13 +139,12 @@ 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();}
+  friend reference get(const Self&, const key_type& k) { return k.normal(); }
-  friend void put(const Self&,key_type& k, const value_type& v) {k.normal()=v;}
+  friend void put(const Self&, key_type& k, const value_type& v) { k.normal() = v; }
   /// @};}
 };
 

Point_set_processing_3/include/CGAL/estimate_scale.h

@@ -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)
+    Pmap_to_3d (PointMap point_map) : point_map (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
+      typename boost::property_traits<PointMap>::reference p2 = get(pmap.point_map, p);
-        p2 = get(pmap.point_map, p);
       return value_type (p2.x(), p2.y(), 0.);
     }
-
   };
 
   struct Sort_by_distance_to_point

Point_set_processing_3/include/CGAL/mst_orient_normals.h

@@ -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);
   }

Point_set_processing_3/include/CGAL/structure_point_set.h

@@ -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)
+    friend inline reference get (const My_point_property_map& ppmap, key_type i) { return ppmap[i]; }
-    { return ppmap[i]; }
   };
 
   struct Edge

Polygon_mesh_processing/examples/Polygon_mesh_processing/connected_components_example.cpp

@@ -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_;

Polygon_mesh_processing/examples/Polygon_mesh_processing/corefinement_OM_union.cpp

@@ -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;

Polygon_mesh_processing/examples/Polygon_mesh_processing/corefinement_consecutive_bool_op.cpp

@@ -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;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h

@@ -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;

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Isotropic_remeshing/remesh_impl.h

@@ -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
@@ -1181,9 +1181,9 @@ private:
 
   struct Patch_id_property_map
   {
-    typedef boost::readable_property_map_tag     category;
+    typedef boost::readable_property_map_tag       category;
-    typedef Patch_id                             value_type;
+    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(

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/locate.h

@@ -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));
   }
 

Polygon_mesh_processing/test/Polygon_mesh_processing/connected_component_surface_mesh.cpp

@@ -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;

Polygon_mesh_processing/test/Polygon_mesh_processing/remeshing_test.cpp

@@ -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
+  friend void put(Constraints_pmap& map, const key_type& e, const value_type is)
-                , const key_type& e, const value_type is)
   {
     CGAL_assertion(map.set_ptr_ != nullptr);
     if (is)                map.set_ptr_->insert(e);

Polygon_mesh_processing/test/Polygon_mesh_processing/triangulate_faces_test.cpp

@@ -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;
 

Polygonal_surface_reconstruction/examples/Polygonal_surface_reconstruction/polyfit_example_with_region_growing.cpp

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

Polyhedron/demo/Polyhedron/Plugins/AABB_tree/Cut_plugin.cpp

@@ -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)
   {

Polyhedron/demo/Polyhedron/Plugins/Point_set/Point_set_normal_estimation_plugin.cpp

@@ -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;

Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/Offset_meshing_plugin.cpp

@@ -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,8 +124,8 @@ 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)
+                          key_type polygon_it)
     {
       auto it = polygon_it->begin();
       CGAL_assertion(it != polygon_it->end());

Polyhedron/demo/Polyhedron/Plugins/Surface_mesh/Surface_mesh_approximation_plugin.cpp

@@ -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;

Polyhedron/demo/Polyhedron/Plugins/Surface_mesh_deformation/Scene_edit_polyhedron_item.cpp

@@ -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;
   }

Polyhedron/demo/Polyhedron/Plugins/Surface_mesh_deformation/Scene_edit_polyhedron_item.h

@@ -73,21 +73,24 @@ struct Array_based_vertex_point_map
 {
 public:
   typedef typename boost::graph_traits<Mesh>::vertex_descriptor     key_type;
-  typedef EPICK::Point_3                                           value_type;
+  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,
+get(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>::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>::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);

Polyhedron/demo/Polyhedron/Scene_polyhedron_selection_item.h

@@ -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)

Polyhedron/demo/Polyhedron/include/id_printing.h

@@ -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){
+  friend value_type get(const VKRingPMAP<Mesh>& map, const key_type& v){
-    return (*map.vec)[get(map.idmap, f)];
+    return (*map.vec)[get(map.idmap, v)];
   }
-  friend void put(VKRingPMAP<Mesh>& map, const key_type& f, const value_type i){
+  friend void put(VKRingPMAP<Mesh>& map, const key_type& v, const value_type i){
-    (*map.vec)[get(map.idmap, f)] = 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){
+  friend value_type get(const EdgeKRingPMAP<Mesh>& map, const key_type& e){
-    return (*map.vec)[get(map.idmap, halfedge(f, *map.poly))/2];
+    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){
+  friend void put(EdgeKRingPMAP<Mesh>& map, const key_type& e, const value_type i){
-    (*map.vec)[get(map.idmap, halfedge(f, *map.poly))/2] = 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;

Polyhedron/include/CGAL/boost/graph/properties_Polyhedron_3.h

@@ -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
+  FT operator[](const E& e) const {
-  operator[](const E& e) const {
+    return approximate_sqrt(CGAL::squared_distance(e.halfedge()->vertex()->point(),
-    return approximate_sqrt(CGAL::squared_distance(e.halfedge()->vertex()->point(), e.halfedge()->opposite()->vertex()->point()));
+                                                   e.halfedge()->opposite()->vertex()->point()));
+  }
+
+  friend inline
+  value_type get(const Wrap_squared& m, const key_type k)
+  {
+    return m[k];
   }
 };
 

Polyhedron/include/CGAL/boost/graph/properties_Polyhedron_3_features.h

@@ -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,
+void put(Polyhedron_face_patch_id_pmap<Patch_id>, Handle_type h, Patch_id pid)
-         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>

Polyhedron/include/CGAL/boost/graph/properties_Polyhedron_3_time_stamp.h

@@ -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,
+void put(Polyhedron_face_time_stamp_pmap, Handle_type h, std::size_t ts)
-         std::size_t ts)
 {
   h->set_time_stamp(ts);
 }

Polyline_simplification_2/include/CGAL/Polyline_simplification_2/simplify.h

@@ -93,18 +93,20 @@ 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;
     typedef value_type                       reference;
-    typedef Vertex_handle  key_type;
+    typedef Vertex_handle                    key_type;
 
 
-    reference operator[] ( key_type const& x ) const
+    value_type operator[](const key_type& x) const
     {
-        return x->ID;
+      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 ;

Property_map/include/CGAL/Dynamic_property_map.h

@@ -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>,
+  typedef boost::read_write_property_map_tag category;
-                                     boost::read_write_property_map_tag,
-                                     boost::lvalue_property_map_tag>::type  category;
 
   Dynamic_with_index()
     : m_values()

Property_map/include/CGAL/Index_property_map.h

@@ -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);
   }

Property_map/include/CGAL/property_map.h

@@ -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)
   {}
 };
 
@@ -76,14 +80,14 @@ class OR_property_map {
   {}
 
   inline friend
-    value_type
+  value_type
-    get(const OR_property_map& pm, const key_type& k)
+  get(const OR_property_map& pm, const key_type& k)
   {
     return get(pm.pm1,k) || get(pm.pm2,k);
   }
 
   inline friend
-    void
+  void
   put(OR_property_map& pm, const key_type& k, const value_type& v)
   {
     put(pm.pm1,k, v);
@@ -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,10 +114,16 @@ struct Property_map_binder{
   KeyMap key_map;
   ValueMap value_map;
 
-  Property_map_binder(const KeyMap& key_map, const ValueMap& value_map)
+  Property_map_binder(const KeyMap& key_map = KeyMap(),
-    : key_map(key_map)
+                      const ValueMap& value_map = ValueMap())
-    , value_map(value_map)
+    : 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
   reference get(const Property_map_binder& map, key_type k)
@@ -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,19 +203,21 @@ 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;}
+  friend reference get(const Self&, const key_type& k) { return k; }
-  friend void put(const Self&,key_type& k, const value_type& v) {k=v;}
+  friend void put(const Self&, key_type& k, const value_type& v) { k = v; }
   /// @}
 };
 
@@ -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,20 +257,21 @@ 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;}
+  friend reference get(const Self&, const key_type& k) { return k.first; }
-  friend void put(const Self&,key_type& k, const value_type& v) {k.first=v;}
+  friend void put(const Self&, key_type& k, const value_type& v) { k.first = v; }
   /// @}
 };
 
@@ -283,20 +297,21 @@ 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;}
+  friend reference get(const Self&, const key_type& k) { return k.second; }
-  friend void put(const Self&,key_type& k, const value_type& v) {k.second=v;}
+  friend void put(const Self&, key_type& k, const value_type& v) { k.second = v; }
   /// @}
 };
 
@@ -321,23 +336,25 @@ 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
+#ifdef DOXYGEN_RUNNING
   typedef unspecified_type value_type;  ///< typedef to the N-th type of the tuple
-  #else
+#else
   typedef typename boost::tuples::element<N,Tuple>::type value_type;
-  #endif
+#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>();}
+  friend reference get(const Self&, const key_type& k) { return k.template get<N>(); }
-  friend void put(const Self&,key_type& k, const value_type& v) {k.template get<N>()=v;}
+  friend void put(const Self&, key_type& k, const value_type& v) { k.template get<N>() = v; }
   /// @}
 };
 
@@ -345,16 +362,17 @@ 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 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; }
-  friend void put(const Self&,key_type& k, const value_type& v) {std::get<N>(k)=v;}
 };
 
 /// Free function to create a Nth_of_tuple_property_map property map.
@@ -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
+    return CGAL::Cartesian_converter<K1, K2>()(get(pm.vpm, k));
-     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)

Shape_detection/examples/Shape_detection/region_growing_with_custom_classes.cpp

@@ -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) :
+    Seed_map(const std::map<std::size_t, std::size_t>& objects_map)
-    m_objects_map(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(
+    friend value_type get(const Seed_map& seed_map,
-      const Seed_map& seed_map,
+                          const key_type& key)
-      const key_type key) {
+    {
-
       return seed_map[key];
     }
 

Shape_detection/include/CGAL/Shape_detection/Efficient_RANSAC/property_map.h

@@ -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);
     }

Shape_detection/include/CGAL/Shape_detection/Region_growing/internal/property_map.h

@@ -57,10 +57,8 @@ namespace internal {
       return get(m_property_map, key);
     }
 
-    friend inline reference get(
+    friend inline reference get(const Item_property_map& item_map,
-      const Item_property_map& item_map,
+                                const key_type key) {
-      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(
+    friend inline value_type get(const Item_to_index_property_map& item_to_index_map,
-      const Item_to_index_property_map& item_to_index_map,
+                                 const key_type& key) {
-      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(
+    Seed_property_map(const std::vector<std::size_t>& seeds)
-      const std::vector<std::size_t>& seeds) :
+      : m_seeds(seeds)
-    m_seeds(seeds)
     { }
 
     value_type operator[](const key_type key) const {
       return m_seeds[key];
     }
 
-    friend value_type get(
+    friend value_type get(const Seed_property_map& seed_map,
-      const Seed_property_map& seed_map,
+                          const key_type key) {
-      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(
+    Point_to_shape_index_map(const PointRange& points,
-      const PointRange& points,
+                             const std::vector< std::vector<std::size_t> >& regions)
-      const std::vector< std::vector<std::size_t> >& regions) :
+      : m_indices(new std::vector<int>(points.size(), -1))
-    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(
+    inline friend value_type get(const Point_to_shape_index_map& point_to_shape_index_map,
-      const Point_to_shape_index_map& point_to_shape_index_map,
+                                 const key_type key) {
-      const key_type key) {
-
       const auto& indices = *(point_to_shape_index_map.m_indices);
       return indices[key];
     }

Spatial_searching/benchmark/Spatial_searching/nearest_neighbor_searching_inplace_50.cpp

@@ -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){}
 

Spatial_searching/include/CGAL/Search_traits_adapter.h

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

Spatial_searching/test/Spatial_searching/Point_with_info.h

@@ -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];}
 };
 

Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h

@@ -32,14 +32,13 @@ 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:
   typedef boost::readable_property_map_tag                category;
   typedef typename CGAL::Kernel_traits<Point>::type::FT   value_type;
   typedef value_type                                      reference;
-  typedef typename SM::Edge_index                        key_type;
+  typedef typename SM::Edge_index                         key_type;
 
   SM_edge_weight_pmap(const CGAL::Surface_mesh<Point>& sm)
     : pm_(sm. template property_map<
@@ -54,15 +53,21 @@ 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::template Property_map< typename SM::Vertex_index,
-                                       typename SM::Point > pm_;
+                                      typename SM::Point > pm_;
   const SM& sm_;
 };
 
 
 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

Surface_mesh_deformation/include/CGAL/Surface_mesh_deformation.h

@@ -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;

Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_OpenMesh.cpp

@@ -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;

Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_constrain_sharp_edges.cpp

@@ -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); }
 

Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_constrained_border_polyhedron.cpp

@@ -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);
   }
 };

Surface_mesh_simplification/examples/Surface_mesh_simplification/edge_collapse_constrained_border_surface_mesh.cpp

@@ -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);
   }
 };

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/internal/Common.h

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

Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/internal/Edge_collapse.h

@@ -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;
   };
 

Tetrahedral_remeshing/examples/Tetrahedral_remeshing/tetrahedral_remeshing_with_features.cpp

@@ -52,7 +52,7 @@ public:
   }
 
   friend value_type get(const Constrained_edges_property_map& map,
-                              const key_type& k)
+                        const key_type& k)
   {
     CGAL_assertion(map.m_set_ptr != nullptr);
     CGAL_assertion(k.first < k.second);

Tetrahedral_remeshing/include/CGAL/Tetrahedral_remeshing/internal/tetrahedral_adaptive_remeshing_impl.h

@@ -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&) {
+  friend value_type get(No_constraint_pmap, key_type) { return false; }
-    return false;
+  friend void put(No_constraint_pmap, key_type, value_type) {}
-  }
-  friend void put(No_constraint_pmap&, const key_type&, const bool) {}
 };
 
 template<typename Triangulation

Tetrahedral_remeshing/test/Tetrahedral_remeshing/test_tetrahedral_remeshing_with_features.cpp

@@ -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);
@@ -57,7 +57,7 @@ public:
   }
 
   friend value_type get(const Constrained_edges_property_map& map,
-                              const key_type& k)
+                        const key_type& k)
   {
     CGAL_assertion(map.m_set_ptr != nullptr);
     CGAL_assertion(k.first < k.second);

Triangulation_2/include/CGAL/boost/graph/internal/properties_2D_triangulation.h

@@ -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;
 };

Triangulation_2/include/CGAL/boost/graph/properties_Triangulation_data_structure_2.h

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