/usr/include/CGAL/Index_property_map.h is in libcgal-dev 4.11-2build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | // Copyright (c) 20009 INRIA Sophia-Antipolis (France).
// 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) : Laurent Saboret
#ifndef CGAL_INDEX_PROPERTY_MAP_H
#define CGAL_INDEX_PROPERTY_MAP_H
#include <CGAL/property_map.h>
#include <boost/shared_ptr.hpp>
#include <iterator>
#include <map>
namespace CGAL {
/// \cond SKIP_IN_MANUAL
// ----------------------------------------------------------------------------
// Private section
// ----------------------------------------------------------------------------
namespace internal {
/// Functor for operator< that compares iterators address.
template <typename Iterator>
struct Compare_iterator_address
{
bool operator()(const Iterator& lhs, const Iterator& rhs) const
{
return (&*lhs < &*rhs);
}
};
} /* namespace internal */
// ----------------------------------------------------------------------------
// Public section
// ----------------------------------------------------------------------------
/// Template class "index" property map, which associates a 0-based index (unsigned int)
/// to the `[first, beyond)` range of elements.
///
/// 2 specializations exist:
/// - if Iter is a random access iterator (typically vector and deque),
/// get() just calls std::distance() and is very efficient;
/// - else, the property map allocates a std::map to store indices
/// and get() requires a lookup in the map.
///
/// @heading Is Model for the Concepts:
/// Model of the `ReadablePropertyMap` concept.
///
/// @heading Parameters:
/// @param Iter iterator over input elements.
/// @param iterator_tag Iter's iterator category.
// This is the default variant that creates a temporary std::map<Iter,unsigned int>.
template <class Iter,
typename iterator_tag=typename std::iterator_traits<Iter>::iterator_category>
class Index_property_map
: public boost::associative_property_map< std::map<Iter,
unsigned int,
internal::Compare_iterator_address<Iter> > >
{
// std::map to store indices
typedef typename std::map<Iter,
unsigned int,
internal::Compare_iterator_address<Iter> >
Index_map;
// base class = property map
typedef typename boost::associative_property_map<Index_map>
Base;
public:
Index_property_map(
Iter first, ///< iterator over the first element (index 0)
Iter beyond) ///< past-the-end iterator over the elements
: m_index_map(new Index_map) // Allocate std::map
{
// Index elements in std::map
Iter it;
unsigned int index;
for (it = first, index = 0; it != beyond; it++, index++)
(*m_index_map)[it] = index;
// Wrap std::map in property map
(Base&)(*this) = *m_index_map;
}
private:
// Property maps must be lightweight classes => share std::map
boost::shared_ptr<Index_map> m_index_map;
};
/// @cond SKIP_IN_MANUAL
// This variant is optimized for a random access container.
template <class Iter>
class Index_property_map<Iter,
std::random_access_iterator_tag>
{
public:
// Property maps' required types
typedef boost::readable_property_map_tag category;
typedef std::size_t value_type;
typedef value_type reference;
typedef Iter key_type;
Index_property_map(
Iter first, ///< iterator over the first element (index 0)
Iter /*beyond*/) ///< past-the-end iterator over the elements
: m_first(first)
{}
/// Free function to access the map elements.
friend inline
reference get(const Index_property_map& map, key_type p)
{
return std::distance(map.m_first, p);
}
private:
Iter m_first; // iterator over the first element (index 0)
};
/// @endcond
/// Free function to create an Index_property_map property map.
///
/// @tparam Iter iterator over input elements.
///
/// @return an "index" property map, which associates a 0-based index (unsigned int)
/// to the `[first, beyond)` range of elements.
template <class Iter>
Index_property_map<Iter>
make_index_property_map(
Iter first, ///< iterator over the first element (index 0)
Iter beyond) ///< past-the-end iterator over the elements
{
return Index_property_map<Iter>(first, beyond);
}
/// \endcond
} // namespace CGAL
#endif // CGAL_INDEX_PROPERTY_MAP_H
|