CGAL 4.7 - STL Extensions for CGAL: STL Extensions for CGAL 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
Modules | Classes | Macros
STL Extensions for CGAL Reference

##

Michael Hoffmann, Lutz Kettner, Sylvain Pion, and Ron Wein
CGAL is designed in the spirit of the generic programming paradigm to work together with the Standard Template Library (STL). This package provides non-geometric STL-like algorithms and datastructures that are not in the STL standard, as well as functions to change the failure behaviour of assertions.

Introduced in: CGAL 1.0
BibTeX: cgal:hkpw-se-15b
License: LGPL

## Classified Reference Pages

## Doubly-Connected List Managing Items in Place

- `CGAL::In_place_list<T,bool>`
- `CGAL::In_place_list_base<T>`

## Compact Container

- `CGAL::Compact_container<T, Allocator>`
- `CGAL::Compact_container_traits<T>`
- `CGAL::Compact_container_base`

## Multiset with Extended Functionality

- `CGAL::Multiset<Type,Compare,Allocator>`

## Generic Algorithms

- `CGAL::cpp11::copy_n`
- `CGAL::copy_n`
- `CGAL::min_max_element`
- `CGAL::cpp11::next`
- `CGAL::cpp11::prev`
- `CGAL::predecessor`
- `CGAL::successor`

## Iterators and Iterator/Circulator Adaptors

- `CGAL::Dispatch_output_iterator<V,O>`
- `CGAL::Dispatch_or_drop_output_iterator<V,O>`
- `CGAL::Emptyset_iterator`
- `CGAL::Oneset_iterator<T>`
- `CGAL::Insert_iterator<Container>`
- `CGAL::Counting_iterator<Iterator, Value>`
- `CGAL::N_step_adaptor<I,int N>`
- `CGAL::Filter_iterator<Iterator, Predicate>`
- `CGAL::Join_input_iterator_1<Iterator, Creator>`
- `CGAL::Inverse_index<IC>`
- `CGAL::Random_access_adaptor<IC>`
- `CGAL::Random_access_value_adaptor<IC,T>`

## Ranges

- `CGAL::Iterator_range`

## Projection Function Objects

- `CGAL::Identity<Value>`
- `CGAL::Dereference<Value>`
- `CGAL::Get_address<Value>`
- `CGAL::Cast_function_object<Arg, Result>`
- `CGAL::Project_vertex<Node>`
- `CGAL::Project_facet<Node>`
- `CGAL::Project_point<Node>`
- `CGAL::Project_normal<Node>`
- `CGAL::Project_plane<Node>`
- `CGAL::Project_next<Node>`
- `CGAL::Project_prev<Node>`
- `CGAL::Project_next_opposite<Node>`
- `CGAL::Project_opposite_prev<Node>`

## Creator Function Objects

- `CGAL::Creator_1<Arg, Result>`
- `CGAL::Creator_2<Arg1, Arg2, Result>`
- `CGAL::Creator_3<Arg1, Arg2, Arg3, Result>`
- `CGAL::Creator_4<Arg1, Arg2, Arg3, Arg4, Result>`
- `CGAL::Creator_5<Arg1, Arg2, Arg3, Arg4, Arg5, Result>`
- `CGAL::Creator_uniform_2<Arg, Result>`
- `CGAL::Creator_uniform_3<Arg, Result>`
- `CGAL::Creator_uniform_4<Arg, Result>`
- `CGAL::Creator_uniform_5<Arg, Result>`
- `CGAL::Creator_uniform_6<Arg, Result>`
- `CGAL::Creator_uniform_7<Arg, Result>`
- `CGAL::Creator_uniform_8<Arg, Result>`
- `CGAL::Creator_uniform_9<Arg, Result>`
- `CGAL::Creator_uniform_d<Arg, Result>`

## Utilities

- `CGAL::Twotuple<T>`
- `CGAL::Threetuple<T>`
- `CGAL::Fourtuple<T>`
- `CGAL::Sixtuple<T>`
- `CGAL::Triple<T1, T2, T3>`
- `CGAL::Quadruple<T1, T2, T3, T4>`
- `CGAL::Boolean_tag<bool value>`
- `CGAL::Tag_true`
- `CGAL::Tag_false`
- `CGAL::Null_tag`
- `CGAL::Null_functor`
- `CGAL::Uncertain<T>`
- `CGAL::Default`
- `CGAL::Fast`
- `CGAL::Compact`
- `CGAL::Location_policy<Tag>`
- `CGAL::Fast_location`
- `CGAL::Compact_location`

## Modules

| Generic Algorithms
| Compact Container
| Projection Function Objects
| Creator Function Objects
| Doubly-Connected List Managing Items in Place
| Iterators and Iterator/Circulator Adaptors
| Concepts
| Utilities
| Assertions and Failure Behaviour

## Classes

class | CGAL::cpp11::array< T, int >
| An object of the class `cpp11::array` represents an array of elements of type `T`, the number of which is specified by the second template argument. More...
class | CGAL::CC_safe_handle< CC_iterator >
| The class `CC_safe_handle` is a helper class that stores an iterator on a `Compact_container` (or `Concurrent_compact_container`) and is able to know if the pointee has been erased after the creation of the `CC_safe_handle` instance. More...
class | CGAL::Concurrent_compact_container_traits< T >
| The traits class `Concurrent_compact_container_traits` provides the way to access the internal pointer required for `T` to be used in a `Concurrent_compact_container<T, Allocator>`. More...
class | CGAL::Default
| `Default` is a tag class. More...
class | CGAL::Iterator_range< I >
| `CGAL::Iterator_range` encapsulates two iterators so they fulfill the `ForwardRange` concept. More...
class | CGAL::Multiset< Type, Compare, Allocator >
class | CGAL::Object
| Some functions can return different types of objects. More...
struct | CGAL::cpp11::result_of< F >
| Alias to the tr1 implementation from boost of the `result_of` mechanism. More...
class | CGAL::Spatial_lock_grid_3< Grid_lock_tag >
| The class `Spatial_lock_grid_3` allows to lock points with coordinates (x, y, z) in a 3D grid. More...
class | CGAL::cpp11::tuple<>
| An object of the class `cpp11::tuple` represents a heterogeneous tuple of elements of the types specified in parameters, which are in variadic number. More...

## Macros

#define | CGAL_ALLOCATOR(T) std::allocator< T >
| A define for the allocator used by CGAL. More...

## Macro Definition Documentation

#define CGAL_ALLOCATOR | ( |  | T) |  | std::allocator< T >

A define for the allocator used by CGAL.

This is only defined if there is no user defined version before `memory.h` is included the first time.

`#include <CGAL/memory.h>`