// Copyright (c) 2008-2009 GeometryFactory and INRIA // All rights reserved. // // This file is part of CGAL (www.cgal.org); you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public License as // published by the Free Software Foundation; either version 3 of the License, // or (at your option) any later version. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $URL$ // $Id$ // // Author(s) : Andreas Fabri and Laurent Saboret #ifndef CGAL_POINT_SET_PROPERTY_MAP_H #define CGAL_POINT_SET_PROPERTY_MAP_H #include #include #if BOOST_VERSION >= 104000 #include #else #include #include #endif #include #include // defines std::pair namespace CGAL { /// \cond SKIP_DOXYGEN template class OR_property_map { typedef typename PM1::key_type key_type; typedef typename PM1::value_type value_type; typedef typename PM1::reference reference; typedef boost::read_write_property_map_tag category; PM1 pm1; PM2 pm2; public: OR_property_map(PM1 pm1, PM2 pm2) : pm1(pm1),pm2(pm2) {} inline friend value_type get(const OR_property_map& pm, const key_type& k) { return get(pm.pm1,k) || get(pm.pm2,k); } inline friend void put(OR_property_map& pm, const key_type& k, const value_type& v) { put(pm.pm1,k, v); put(pm.pm2,k, v); } }; /// Property map that accesses a value from an iterator /// /// \cgalModels `ReadablePropertyMap` /// /// \tparam InputIterator an input iterator /// \endcond template struct Input_iterator_property_map{ typedef InputIterator key_type; typedef typename std::iterator_traits::value_type value_type; typedef typename std::iterator_traits::reference reference; typedef boost::readable_property_map_tag category; /// Free function to use a get the value from an iterator using Input_iterator_property_map. inline friend reference get(Input_iterator_property_map,InputIterator it){ return *it; } }; /// \ingroup PkgProperty_map /// Property map that converts a `T*` pointer (or in general an iterator /// over `T` elements) to the `T` object. /// /// \cgalModels `LvaluePropertyMap` template struct Dereference_property_map : public boost::put_get_helper > { typedef T* key_type; ///< typedef to 'T*' typedef T value_type; ///< typedef to 'T' typedef const value_type& 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 value_type& operator[](Iter it) const { return reference(*it); } }; /// Free function to create a `Dereference_property_map` property map. /// /// \relates Dereference_property_map template // Type convertible to `key_type` Dereference_property_map::type> make_dereference_property_map(Iter) { // value_type_traits is a workaround as back_insert_iterator's `value_type` is void return Dereference_property_map::type>(); } /// \ingroup PkgProperty_map /// A `LvaluePropertyMap` property map mapping a key to itself (by reference). /// /// \cgalModels `LvaluePropertyMap` template struct Identity_property_map { typedef T key_type; ///< typedef to `T` typedef T value_type; ///< typedef to `T` typedef const T& reference; ///< typedef to `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; } typedef Identity_property_map Self; /// \name Put/get free functions /// @{ 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;} /// @} }; /// Free function to create a `Identity_property_map` property map. /// /// \relates Identity_property_map template // Key and value type Identity_property_map make_identity_property_map(T) { return Identity_property_map(); } /// \ingroup PkgProperty_map /// Property map that accesses the first item of a `std::pair`. /// \tparam Pair Instance of `std::pair`. /// \cgalModels `LvaluePropertyMap` /// /// \sa `CGAL::Second_of_pair_property_map` template struct First_of_pair_property_map { 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 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; } typedef First_of_pair_property_map Self; /// \name Put/get free functions /// @{ 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;} /// @} }; /// Free function to create a `First_of_pair_property_map` property map. /// /// \relates First_of_pair_property_map template // Pair type First_of_pair_property_map make_first_of_pair_property_map(Pair) { return First_of_pair_property_map(); } /// \ingroup PkgProperty_map /// /// Property map that accesses the second item of a `std::pair`. /// /// \tparam Pair Instance of `std::pair`. /// /// \cgalModels `LvaluePropertyMap` /// /// \sa `CGAL::First_of_pair_property_map` template struct Second_of_pair_property_map { typedef Pair key_type; ///< typedef to `Pair` typedef typename Pair::second_type value_type; ///< typedef to `Pair::first_type` typedef const value_type& reference; ///< typedef to `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; } typedef Second_of_pair_property_map Self; /// \name Put/get free functions /// @{ 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;} /// @} }; /// Free function to create a Second_of_pair_property_map property map. /// /// \relates Second_of_pair_property_map template // Pair type Second_of_pair_property_map make_second_of_pair_property_map(Pair) { return Second_of_pair_property_map(); } /// \ingroup PkgProperty_map /// /// Property map that accesses the Nth item of a `boost::tuple`. /// /// \tparam N %Index of the item to access. /// \tparam Tuple Instance of `boost::tuple`. /// /// \cgalModels `LvaluePropertyMap` template struct Nth_of_tuple_property_map { typedef Tuple key_type; ///< typedef to `Tuple` typedef typename boost::tuples::element::type value_type; ///< typedef to `boost::tuples::element::%type` typedef const value_type& reference; ///< typedef to `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(); } typedef Nth_of_tuple_property_map Self; /// \name Put/get free functions /// @{ friend reference get(const Self&,const key_type& k) {return k.template get();} friend void put(const Self&,key_type& k, const value_type& v) {k.template get()=v;} /// @} }; /// Free function to create a Nth_of_tuple_property_map property map. /// /// \relates Nth_of_tuple_property_map template // Tuple type Nth_of_tuple_property_map make_nth_of_tuple_property_map(Tuple) { return Nth_of_tuple_property_map(); } /// \ingroup PkgProperty_map /// Struct that turns a property map into a unary functor with /// `operator()(key k)` calling the get function with `k` template struct Property_map_to_unary_function{ typedef typename boost::property_traits::key_type argument_type; typedef typename boost::property_traits::reference result_type; PropertyMap map; Property_map_to_unary_function(PropertyMap m=PropertyMap()) : map(m) {} template result_type operator()(const KeyType& a) const { return get(map,a); } }; /// \ingroup PkgProperty_map /// Utility class providing shortcuts to property maps based on raw pointers template struct Pointer_property_map{ typedef boost::iterator_property_map< T*, boost::typed_identity_property_map, T, T&> type; ///< mutable `LvaluePropertyMap` typedef boost::iterator_property_map< const T*, boost::typed_identity_property_map, T, const T&> const_type; ///< non-mutable `LvaluePropertyMap` }; /// \ingroup PkgProperty_map /// Starting from boost 1.55, the use of raw pointers as property maps has been deprecated. /// This function is a shortcut to the recommanded replacement: /// `boost::make_iterator_property_map(, boost::typed_identity_property_map())` /// Note that the property map is a mutable `LvaluePropertyMap` with `std::size_t` as key. template inline typename Pointer_property_map::type make_property_map(T* pointer) { return typename Pointer_property_map::type(pointer); } /// \ingroup PkgProperty_map /// equivalent to `make_property_map(&v[0])` /// Note that `v` must not be modified while using the property map created template inline typename Pointer_property_map::type make_property_map(std::vector& v) { return make_property_map(&v[0]); } /// \ingroup PkgProperty_map /// Non-mutable version template inline typename Pointer_property_map::const_type make_property_map(const T* pointer) { return typename Pointer_property_map::const_type(pointer); } /// \ingroup PkgProperty_map /// equivalent to `make_property_map(&v[0])` /// Note that `v` must not be modified while using the property map created template inline typename Pointer_property_map::const_type make_property_map(const std::vector& v) { return make_property_map(&v[0]); } } // namespace CGAL #endif // CGAL_POINT_SET_PROPERTY_MAP_H