CGAL 4.7 - STL Extensions for CGAL: CGAL::Inverse_index< IC > Class Template Reference

\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \) \( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \) \( \def\ccSum #1#2#3{ \sum_{#1}^{#2}{#3} } \def\ccProd #1#2#3{ \sum_{#1}^{#2}{#3} }\)

CGAL 4.7 - STL Extensions for CGAL

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
List of all members
CGAL::Inverse_index< IC > Class Template Reference
Iterators and Iterator/Circulator Adaptors

`#include <CGAL/iterator.h>`

## Definition

The class `Inverse_index` constructs an inverse index for a given range `[i,j)` of two iterators or circulators of type `IC`.

The first element `I` in the range `[i,j)` has the index 0. Consecutive elements are numbered incrementally. The inverse index provides a query for a given iterator or circulator `k` to retrieve its index number.

Precondition
  The iterator or circulator must be either of the random access category or the dereference operator must return stable and distinguishable addresses for the values, e.g. proxies or non-modifiable iterator with opaque values will not work.

Implementation

For random access iterators or circulators, it is done in constant time by subtracting `i`. For other iterator categories, an STL `map` is used, which results in a `log(j-i)` query time. The comparisons are done using the operator `operator<` on pointers.

See Also
  `CGAL::Random_access_adaptor<IC>`
  `CGAL::Random_access_value_adaptor<IC,T>`

## Creation

| Inverse_index ()
| invalid index.
| Inverse_index (const IC &i)
| empty inverse index initialized to start at `i`.
| Inverse_index (const IC &i, const IC &j)
| inverse index initialized with range `[i,j)`.

## Operations

std::size_t | operator[] (const IC &k)
| returns inverse index of `k`. More...
void | push_back (const IC &k)
| adds `k` at the end of the indices.

## Member Function Documentation

template<typename IC >

std::size_t CGAL::Inverse_index< IC >::operator[] | ( | const IC & | k) |  |

returns inverse index of `k`.

Precondition
  `k` has been stored in the inverse index.