CGAL 6.2 - Combinatorial Maps

Loading...
Searching...
No Matches
List of all members | Public Types
GenericMapItems Concept Reference
Reference Manual » Concepts

## Definition

The concept `GenericMapItems` allows to customize a dD generic map by choosing the information associated with darts, by enabling and disabling some attributes, and by choosing to use indices or handles. For that, it defines an inner class template named `Dart_wrapper`, with one template parameter, `Map`, a model of the `GenericMap` concept. This inner class can define the two types `Dart_info` and `Attributes`.

Has models
  `CGAL::Generic_map_min_items`

See also
  `GenericMap`

Example

The following examples show two possible models of the `GenericMapItems` concept: the first one for a generic map without dart information, nor enabled attributes, the second one for a generic map that uses std::uint16_t as indices, with a `double` associated with each dart, and edge attributes enabled, and associated with a `Cell_attribute` containing an `int`.

struct Example_Item_1
{
template < class CMap >
struct Dart_wrapper
{};
};
struct Example_Item_2
{
typedef CGAL::Tag_true Use_index; // CGAL::Tag_false by default
typedef std::uint16_t Index_type; // std::uint32_t by default
template < class GMap >
struct Dart_wrapper
{
typedef double Dart_info;
typedef CGAL::Cell_attribute<GMap, int> Edge_attrib;
typedef std::tuple<void,Edge_attrib> Attributes;
};
};
CGAL::Cell_attribute
The class Cell_attribute represents an attribute containing (or not) an information.
Definition: Cell_attribute.h:26
unspecified_type
CGAL::Boolean_tag

## Public Types
typedef unspecified_type | Use_index
| If `Use_index` is `CGAL::Tag_true`, uses indices as descriptors.
typedef unspecified_type | Index_type
| Number type used for indices when Use_index is CGAL::Tag_true.
template<typename Map >
using | Dart_wrapper = unspecified_type
| Wrapper class defining type of information associated with darts and types of attributes.

## Member Typedef Documentation

## ◆ Dart_wrapper

template<typename Map >

using GenericMapItems::Dart_wrapper = unspecified_type

Wrapper class defining type of information associated with darts and types of attributes.

The class `Dart_wrapper<Map>` must provide:

- `Dart_wrapper<Map>::Dart_info`, the type of information associated with darts. Not defined or equal to `void` to have no information.
- `Dart_wrapper<Map>::Attributes` The tuple of attributes, containing at most `Map::dimension+1` types (one for each possible cell of the generic map). Each type of the tuple must be either a model of the `CellAttribute` concept or `void`. The first type corresponds to 0-attributes, the second to 1-attributes and so on. If the \( i^{\mbox{th}}\) type in the tuple is `void`, (i-1)-attributes are disabled. Otherwise, (i-1)-attributes are enabled and have the given type. If the size of the tuple is k, with k<`Map::dimension`+1, \( \forall\)i: k \( \leq\)i \( \leq\)`Map::dimension`, i-attributes are disabled. If this type is not defined, all attributes are disabled.

Note
  It can be implemented using a nested template class.

## ◆ Index_type

typedef unspecified_type GenericMapItems::Index_type

Number type used for indices when Use_index is CGAL::Tag_true.

By default, use std::uint32_t.

## ◆ Use_index

typedef unspecified_type GenericMapItems::Use_index

If `Use_index` is `CGAL::Tag_true`, uses indices as descriptors.

Otherwise (if this type is not defined or different from `CGAL::Tag_true`), use handles.