html/reference/structboost_1_1gil_1_1_random_access_n_d_locator_concept.html

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;

};