vctVarStrideVectorIterator.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: 2004-07-02
 
  (C) Copyright 2004-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 _vctVarStrideVectorIterator_h
#define _vctVarStrideVectorIterator_h

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

template<class _elementType>
class vctVarStrideVectorConstIterator
{
public:
    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    typedef vctVarStrideVectorConstIterator<_elementType> ThisType;

    typedef typename std::random_access_iterator_tag iterator_category;
 
protected:
    value_type * DataPtr;
 
    /* Stride between the elements of a vector. */
    difference_type Stride;
 
 
 
public:
    vctVarStrideVectorConstIterator():
        DataPtr(0),
        Stride(1)
        {}
 

    explicit vctVarStrideVectorConstIterator(value_type * dataPtr, difference_type stride = 1)
        : DataPtr(dataPtr), Stride(stride)
        {}
 

    explicit vctVarStrideVectorConstIterator(const value_type * dataPtr, difference_type stride = 1)
        : DataPtr(const_cast<value_type *>(dataPtr)), Stride(stride)
    {}
 

    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>
class vctVarStrideVectorIterator : public vctVarStrideVectorConstIterator<_elementType>
{
public:
    /* documented in base class */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    typedef vctVarStrideVectorIterator<_elementType> ThisType;
    typedef vctVarStrideVectorConstIterator<_elementType> BaseType;
    typedef typename BaseType::iterator_category iterator_category;

    vctVarStrideVectorIterator()
        : BaseType()
        {}
 

    explicit vctVarStrideVectorIterator(value_type * dataPtr, difference_type stride = 1)
        : BaseType(dataPtr, stride)
        {}
 

    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* () const {
        return *(this->DataPtr);
    }
};
 
 

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

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

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

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

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

template<class _elementType>
vctVarStrideVectorIterator<_elementType>
operator-(const vctVarStrideVectorIterator<_elementType> & iterator,
          typename vctVarStrideVectorIterator<_elementType>::difference_type difference)
{
    vctVarStrideVectorIterator<_elementType> result(iterator);
    return result -= difference;
}
 
 
#endif  // _vctVarStrideVectorIterator_h