Modules | Alphabetical List | Class List | Directories | File List | GIL Home Page

# RandomAccessNDLocatorConcept Struct Template Reference
[RandomAccessNDLocatorConcept]

`#include <gil_concept.hpp>`

List of all members.

## 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;
    };

## Public Member Functions

void | constraints ()

## Public Attributes

Loc | loc

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

- gil_concept.hpp