vctFixedStrideVectorIterator.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):  Ofri Sadowsky, Anton Deguet
  Created on: 2003-09-30
 
  (C) Copyright 2003-2025 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 _vctFixedStrideVectorIterator_h
#define _vctFixedStrideVectorIterator_h

 
#include <cisstCommon/cmnPortability.h>
#include <cisstVector/vctContainerTraits.h>
 
#include <iterator>

template <class _elementType, vct::stride_type _stride>
class vctFixedStrideVectorConstIterator
{
public:
    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    typedef vctFixedStrideVectorConstIterator<_elementType, _stride> ThisType;

    typedef typename std::random_access_iterator_tag iterator_category;
 
    /* Stride between the elements of a vector. */
    enum {STRIDE = _stride};
 
protected:
    value_type * DataPtr;
 
public:
    vctFixedStrideVectorConstIterator()
    {}
 

    explicit vctFixedStrideVectorConstIterator(value_type * dataPtr)
        : DataPtr(dataPtr)
    {}
 

    explicit vctFixedStrideVectorConstIterator(const value_type * dataPtr)
        : DataPtr(const_cast<value_type *>(dataPtr))
    {}
 

    ThisType & operator++() {
        DataPtr += STRIDE;
        return *this;
    }
 

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

    ThisType & operator--() {
        DataPtr -= STRIDE;
        return *this;
    }
 

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

    ThisType & operator+=(difference_type difference) {
        DataPtr += difference * STRIDE;
        return *this;
    }
 

    ThisType & operator-=(difference_type difference) {
        DataPtr -= difference * STRIDE;
        return *this;
    }
 

    difference_type operator-(const ThisType & other) const {
        return (DataPtr - other.DataPtr) / STRIDE;
    }
 

    const value_type & operator[](difference_type index) const {
        return *(DataPtr + index * STRIDE);
    }
 

    const value_type & operator* () const {
        return *DataPtr;
    }
 

    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 DataPtr == other.DataPtr;
    }
 

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

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

template<class _elementType, vct::stride_type _stride>
class vctFixedStrideVectorIterator : public vctFixedStrideVectorConstIterator<_elementType, _stride>
{
public:
    /* documented in base class */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    typedef vctFixedStrideVectorIterator<_elementType, _stride> ThisType;
    typedef vctFixedStrideVectorConstIterator<_elementType, _stride> BaseType;
    typedef typename BaseType::iterator_category iterator_category;

    vctFixedStrideVectorIterator()
        : BaseType()
        {}
 

    explicit vctFixedStrideVectorIterator(value_type * dataPtr)
        : BaseType(dataPtr)
        {}
 

    ThisType & operator++() {
        this->DataPtr += this->STRIDE;
        return *this;
    }
 

    ThisType operator++(int) {
        ThisType tmp(*this);
        this->DataPtr += this->STRIDE;
        return tmp;
    }
 

    ThisType & operator--() {
        this->DataPtr -= this->STRIDE;
        return *this;
    }
 

    ThisType operator--(int) {
        ThisType tmp(*this);
        this->DataPtr -= this->STRIDE;
        return tmp;
    }
 

    ThisType & operator+=(difference_type difference) {
        this->DataPtr += difference * this->STRIDE;
        return *this;
    }
 

    ThisType & operator-=(difference_type difference) {
        this->DataPtr -= difference * this->STRIDE;
        return *this;
    }
 

    value_type & operator[](difference_type index) const {
        return *(this->DataPtr + index * this->STRIDE);
    }
 

    value_type & operator* () {
        return *(this->DataPtr);
    }
 
    value_type & operator* () const {
        return *(this->DataPtr);
    }
};
 
 

template<class _elementType, vct::stride_type _stride>
vctFixedStrideVectorConstIterator<_elementType, _stride>
operator+(const vctFixedStrideVectorConstIterator<_elementType, _stride> & iterator,
          typename vctFixedStrideVectorConstIterator<_elementType, _stride>::difference_type difference)
{
    vctFixedStrideVectorConstIterator<_elementType, _stride> result(iterator);
    return result += difference;
}
 

template<class _elementType, vct::stride_type _stride>
vctFixedStrideVectorConstIterator<_elementType, _stride>
operator+(typename vctFixedStrideVectorConstIterator<_elementType, _stride>::difference_type difference,
          const vctFixedStrideVectorConstIterator<_elementType, _stride> & iterator)
{
    vctFixedStrideVectorConstIterator<_elementType, _stride> result(iterator);
    return result += difference;
}
 

template<class _elementType, vct::stride_type _stride>
vctFixedStrideVectorConstIterator<_elementType, _stride>
operator-(const vctFixedStrideVectorConstIterator<_elementType, _stride> & iterator,
          typename vctFixedStrideVectorConstIterator<_elementType,_stride>::difference_type difference)
{
    vctFixedStrideVectorConstIterator<_elementType, _stride> result(iterator);
    return result -= difference;
}
 

template<class _elementType, vct::stride_type _stride>
vctFixedStrideVectorIterator<_elementType, _stride>
operator+(const vctFixedStrideVectorIterator<_elementType, _stride> & iterator,
          typename vctFixedStrideVectorIterator<_elementType, _stride>::difference_type difference)
{
    vctFixedStrideVectorIterator<_elementType, _stride> result(iterator);
    return result += difference;
}
 

template<class _elementType, vct::stride_type _stride>
vctFixedStrideVectorIterator<_elementType, _stride>
operator+(typename vctFixedStrideVectorIterator<_elementType, _stride>::difference_type difference,
          const vctFixedStrideVectorIterator<_elementType, _stride> & iterator)
{
    vctFixedStrideVectorIterator<_elementType, _stride> result(iterator);
    return result += difference;
}
 

template<class _elementType, vct::stride_type _stride>
vctFixedStrideVectorIterator<_elementType, _stride>
operator-(const vctFixedStrideVectorIterator<_elementType, _stride> & iterator,
          typename vctFixedStrideVectorIterator<_elementType, _stride>::difference_type difference)
{
    vctFixedStrideVectorIterator<_elementType, _stride> result(iterator);
    return result -= difference;
}
 
 
#endif  // _vctFixedStrideVectorIterator_h