Generic Image Library: RandomAccessNDLocatorConcept< Loc > Struct Template Reference

###  | #  |

Public Member Functions | Public Attributes | List of all members
RandomAccessNDLocatorConcept< Loc > Struct Template Reference
Pixel Locator » Concepts » RandomAccessNDLocatorConcept

N-dimensional locator over immutable values. More...

`#include <pixel_locator.hpp>`

## Public Member Functions
void | constraints ()

## Public Attributes
Loc | loc

## Detailed Description

template<typename Loc>
struct boost::gil::RandomAccessNDLocatorConcept< Loc >

N-dimensional locator over immutable values.

concept RandomAccessNDLocatorConcept<Regular Loc>
{
typename value_type; // value over which the locator navigates
typename reference; // result of dereferencing
typename difference_type; where PointNDConcept<difference_type>; // return value of operator-.
typename const_t; // same as Loc, but operating over immutable values
typename cached_location_t; // type to store relative location (for efficient repeated access)
typename point_t = difference_type;
static const size_t num_dimensions; // dimensionality of the locator
where num_dimensions = point_t::num_dimensions;
// The difference_type and iterator type along each dimension. The iterators may only differ in
// difference_type. Their value_type must be the same as Loc::value_type
template <size_t D>
struct axis
{
typename coord_t = point_t::axis<D>::coord_t;
typename iterator; where RandomAccessTraversalConcept<iterator>; // iterator along D-th axis.
where iterator::value_type == value_type;
};
// Defines the type of a locator similar to this type, except it invokes Deref upon dereferencing
template <PixelDereferenceAdaptorConcept Deref>
struct add_deref
{
typename type;
where RandomAccessNDLocatorConcept<type>;
static type make(const Loc& loc, const Deref& deref);
};
Loc& operator+=(Loc&, const difference_type&);
Loc& operator-=(Loc&, const difference_type&);
Loc operator+(const Loc&, const difference_type&);
Loc operator-(const Loc&, const difference_type&);
reference operator*(const Loc&);
reference operator[](const Loc&, const difference_type&);
// Storing relative location for faster repeated access and accessing it
cached_location_t Loc::cache_location(const difference_type&) const;
reference operator[](const Loc&,const cached_location_t&);
// Accessing iterators along a given dimension at the current location or at a given offset
template <size_t D> axis<D>::iterator& Loc::axis_iterator();
template <size_t D> axis<D>::iterator const& Loc::axis_iterator() const;
template <size_t D> axis<D>::iterator Loc::axis_iterator(const difference_type&) const;
};
boost::gil::PointNDConcept
N-dimensional point concept.
Definition concepts/point.hpp:62
boost::gil::RandomAccessNDLocatorConcept
N-dimensional locator over immutable values.
Definition pixel_locator.hpp:105
boost::gil::Regular
Concept for type regularity requirement.
Definition basic.hpp:142
boost::gil::type

The documentation for this struct was generated from the following file:

- pixel_locator.hpp