vctVarStrideNArrayIterator.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Daniel Li, Ofri Sadowsky, Anton Deguet
  Created on: 2006-07-11

  (C) Copyright 2006-2013 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/

#pragma once
#ifndef _vctVarStrideNArrayIterator_h
#define _vctVarStrideNArrayIterator_h

#include <iterator>
#include <cisstVector/vctContainerTraits.h>
#include <cisstVector/vctDynamicNArrayOwner.h>
#include <cisstVector/vctVarStrideVectorIterator.h>
#include <iostream>


template<class _ownerType, bool _forward>
class vctVarStrideNArrayConstIterator:
    public std::iterator<std::random_access_iterator_tag,
                         typename _ownerType::value_type>
{
public:
    /* define most types from vctContainerOwnerTraits and vctNArrayTraits */
    enum {DIMENSION = _ownerType::DIMENSION};
    typedef typename _ownerType::value_type _elementType;
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    VCT_NARRAY_TRAITS_TYPEDEFS(DIMENSION);

    enum {DIRECTION = _forward ? +1 : -1};

    typedef vctVarStrideNArrayConstIterator<_ownerType, _forward> ThisType;

    typedef _ownerType OwnerType;

    typedef std::iterator<std::random_access_iterator_tag, value_type> BaseType;

    typedef typename BaseType::iterator_category iterator_category;

protected:
    const OwnerType * ContainerOwner;

    difference_type MetaIndex;

    value_type * ElementPointer;


    void UpdateElementPointer(void)
    {
        difference_type metaindex = MetaIndex;
        difference_type offset = 0;
        difference_type modulus;

        typename nstride_type::const_reverse_iterator stridesBegin = ContainerOwner->strides().rbegin();
        typename nsize_type::const_reverse_iterator sizesBegin = ContainerOwner->sizes().rbegin();
        typename nsize_type::const_reverse_iterator sizesEnd = ContainerOwner->sizes().rend();
        size_type sizes_value;
        for (; sizesBegin != sizesEnd;
             ++sizesBegin, ++stridesBegin) {
            sizes_value = (*sizesBegin == 0) ? 1 : *sizesBegin;
            modulus = metaindex % static_cast<difference_type>(sizes_value);
            offset += modulus * (*stridesBegin);
            metaindex /= static_cast<difference_type>(sizes_value);
        }

        offset += metaindex * ContainerOwner->sizes()[0] * ContainerOwner->strides()[0];

        value_type * pointer = const_cast<value_type *>( ContainerOwner->Pointer() );
        ElementPointer = pointer + offset;
    }


public:
    vctVarStrideNArrayConstIterator(void):
        ContainerOwner(0),
        MetaIndex(0),
        ElementPointer(0)
    {}


    vctVarStrideNArrayConstIterator(const OwnerType * container, difference_type index = 0):
        ContainerOwner(container),
        MetaIndex(index)
    {
        UpdateElementPointer();
    }


    vctVarStrideNArrayConstIterator(const ThisType & other):
        ContainerOwner(other.ContainerOwner),
        MetaIndex(other.MetaIndex),
        ElementPointer(other.ElementPointer)
    {}


    ThisType & operator = (const ThisType & other)
    {
        this->ContainerOwner = other.ContainerOwner;
        this->MetaIndex = other.MetaIndex;
        this->ElementPointer = other.ElementPointer;
        return *this;
    }


    ThisType & operator ++ (void)
    {
        MetaIndex += DIRECTION;
        UpdateElementPointer();
        return *this;
    }


    ThisType operator ++ (int)
    {
        ThisType tmp(*this);
        ++(*this);
        return tmp;
    }


    ThisType & operator -- (void)
    {
        MetaIndex -= DIRECTION;
        UpdateElementPointer();
        return *this;
    }


    ThisType operator -- (int)
    {
        ThisType tmp(*this);
        --(*this);
        return tmp;
    }


    ThisType & operator += (difference_type difference)
    {
        MetaIndex += difference * DIRECTION;
        UpdateElementPointer();
        return *this;
    }


    ThisType & operator -= (difference_type difference)
    {
        MetaIndex -= difference * DIRECTION;
        UpdateElementPointer();
        return *this;
    }


    difference_type operator - (const ThisType & other) const
    {
        return ( this->MetaIndex - other.MetaIndex );
    }


    const value_type & operator [] (difference_type index) const
    {
        difference_type metaindex = MetaIndex + index;
        difference_type offset = 0;
        difference_type modulus;

        typename nstride_type::const_reverse_iterator stridesBegin = ContainerOwner->strides().rbegin();
        typename nsize_type::const_reverse_iterator sizesBegin = ContainerOwner->sizes().rbegin();
        typename nsize_type::const_reverse_iterator sizesEnd = ContainerOwner->sizes().rend();
        size_type sizes_value;
        for (; sizesBegin != sizesEnd;
             ++sizesBegin, ++stridesBegin) {
            sizes_value = (*sizesBegin == 0) ? 1 : *sizesBegin;
            modulus = metaindex % static_cast<difference_type>(sizes_value);
            offset += modulus * (*stridesBegin);
            metaindex /= static_cast<difference_type>(sizes_value);
        }

        value_type * pointer = const_cast<value_type *>( ContainerOwner->Pointer() );
        value_type * elementPointer = pointer + offset;

        return *elementPointer;
    }


    const value_type & operator * (void) const
    {
        return *ElementPointer;
    }


    bool operator == (const ThisType & other) const
    {
        return
            ( this->ContainerOwner == other.ContainerOwner) &&
            ( this->MetaIndex == other.MetaIndex ) &&
            ( this->ElementPointer == other.ElementPointer );
    }


    bool operator != (const ThisType & other) const
    {
        return !( *this == other );
    }


    bool operator < (const ThisType & other) const
    {
        return ((*this) - other) < 0;
    }
    bool operator <= (const ThisType & other) const
    {
        return ((*this) < other) || ((*this) == other);
    }


    bool operator > (const ThisType & other) const
    {
        return other < (*this);
    }
    bool operator >= (const ThisType & other) const
    {
        return ((*this) > other) || ((*this) == other);
    }
};


template<class _ownerType, bool _forward>
class vctVarStrideNArrayIterator :
    public vctVarStrideNArrayConstIterator<_ownerType, _forward>
{
public:
    /* define most types from vctContainerOwnerTraits and vctNArrayTraits */
    enum {DIMENSION = _ownerType::DIMENSION};
    typedef typename _ownerType::value_type _elementType;
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    VCT_NARRAY_TRAITS_TYPEDEFS(DIMENSION);

    enum {DIRECTION = _forward ? +1 : -1};
    typedef vctVarStrideNArrayIterator<_ownerType, _forward> ThisType;
    typedef _ownerType OwnerType;
    typedef vctVarStrideNArrayConstIterator<_ownerType, _forward> BaseType;
    typedef typename BaseType::iterator_category iterator_category;


    vctVarStrideNArrayIterator():
        BaseType()
    {}


    vctVarStrideNArrayIterator(const OwnerType * container, difference_type index = 0):
        BaseType(container, index)
    {}


    vctVarStrideNArrayIterator(const ThisType & other):
        BaseType(other)
    {}


    ThisType & operator = (const ThisType & other)
    {
        this->ContainerOwner = other.ContainerOwner;
        this->MetaIndex = other.MetaIndex;
        this->ElementPointer = other.ElementPointer;
        return *this;
    }


    ThisType & operator ++ (void)
    {
        this->MetaIndex += DIRECTION;
        this->UpdateElementPointer();
        return *this;
    }


    ThisType operator ++ (int)
    {
        ThisType tmp(*this);
        ++(*this);
        return tmp;
    }


    ThisType & operator -- (void)
    {
        this->MetaIndex -= DIRECTION;
        this->UpdateElementPointer();
        return *this;
    }


    ThisType operator -- (int)
    {
        ThisType tmp(*this);
        --(*this);
        return tmp;
    }

    ThisType & operator += (difference_type difference)
    {
        this->MetaIndex += difference * DIRECTION;
        this->UpdateElementPointer();
        return *this;
    }


    ThisType & operator -= (difference_type difference)
    {
        this->MetaIndex -= difference * DIRECTION;
        this->UpdateElementPointer();
        return *this;
    }


    value_type & operator[](difference_type index)
    {
        difference_type metaindex = this->MetaIndex + index;
        difference_type offset = 0;
        difference_type modulus;

        typename nstride_type::const_reverse_iterator stridesBegin = this->ContainerOwner->strides().rbegin();
        typename nsize_type::const_reverse_iterator sizesBegin = this->ContainerOwner->sizes().rbegin();
        typename nsize_type::const_reverse_iterator sizesEnd = this->ContainerOwner->sizes().rend();
        size_type sizes_value;
        for (;
             sizesBegin != sizesEnd;
             ++sizesBegin, ++stridesBegin) {
            sizes_value = (*sizesBegin == 0) ? 1 : *sizesBegin;
            modulus = metaindex % static_cast<difference_type>(sizes_value);
            offset += modulus * (*stridesBegin);
            metaindex /= static_cast<difference_type>(sizes_value);
        }

        value_type * pointer = const_cast<value_type *>(this->ContainerOwner->Pointer());
        value_type * elementPointer = pointer + offset;

        return *elementPointer;
    }


    value_type & operator * (void)
    {
        return *(this->ElementPointer);
    }
};


template<class _ownerType, bool _forward>
vctVarStrideNArrayConstIterator<_ownerType, _forward>
operator + (const vctVarStrideNArrayConstIterator<_ownerType, _forward> & iterator,
            typename vctVarStrideNArrayConstIterator<_ownerType, _forward>::difference_type difference)
{
    vctVarStrideNArrayConstIterator<_ownerType, _forward> result(iterator);
    return result += difference;
}


template<class _ownerType, bool _forward>
vctVarStrideNArrayConstIterator<_ownerType, _forward>
operator + (typename vctVarStrideNArrayConstIterator<_ownerType, _forward>::difference_type difference,
            const vctVarStrideNArrayConstIterator<_ownerType, _forward> & iterator)
{
    vctVarStrideNArrayConstIterator<_ownerType, _forward> result(iterator);
    return result += difference;
}


template<class _ownerType, bool _forward>
vctVarStrideNArrayConstIterator<_ownerType, _forward>
operator - (const vctVarStrideNArrayConstIterator<_ownerType, _forward> & iterator,
            typename vctVarStrideNArrayConstIterator<_ownerType, _forward>::difference_type difference)
{
    vctVarStrideNArrayConstIterator<_ownerType, _forward> result(iterator);
    return result -= difference;
}


template<class _ownerType, bool _forward>
vctVarStrideNArrayIterator<_ownerType, _forward>
operator + (const vctVarStrideNArrayIterator<_ownerType, _forward> & iterator,
            typename vctVarStrideNArrayIterator<_ownerType, _forward>::difference_type difference)
{
    vctVarStrideNArrayIterator<_ownerType, _forward> result(iterator);
    return result += difference;

}


template<class _ownerType, bool _forward>
vctVarStrideNArrayIterator<_ownerType, _forward>
operator + (typename vctVarStrideNArrayIterator<_ownerType, _forward>::difference_type difference,
            const vctVarStrideNArrayIterator<_ownerType, _forward> & iterator)
{
    vctVarStrideNArrayIterator<_ownerType, _forward> result(iterator);
    return result += difference;
}


template<class _ownerType, bool _forward>
vctVarStrideNArrayIterator<_ownerType, _forward>
operator - (const vctVarStrideNArrayIterator<_ownerType, _forward> & iterator,
            typename vctVarStrideNArrayIterator<_ownerType, _forward>::difference_type difference)
{
    vctVarStrideNArrayIterator<_ownerType, _forward> result(iterator);
    return result -= difference;
}


#endif  // _vctVarStrideNArrayIterator_h