vctVarStrideMatrixIterator.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 _vctVarStrideMatrixIterator_h
#define _vctVarStrideMatrixIterator_h

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

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

    typedef vctVarStrideMatrixConstIterator<_elementType> ThisType;

    typedef typename std::random_access_iterator_tag iterator_category;
 
protected:
    value_type * DataPtr;
 
    /* Strides between the elements of a matrix. */
    stride_type ColumnStride;
    difference_type NumColumns;
    stride_type RowStride;
    difference_type CurrentColumn;

    inline void WrapToRight() {
        if (CurrentColumn >= NumColumns) {
            DataPtr += RowStride - (ColumnStride * NumColumns);
            CurrentColumn -= NumColumns;
        }
    }
 

    inline void WrapToLeft() {
        if (CurrentColumn < 0) {
            DataPtr -= RowStride - (ColumnStride * NumColumns);
            CurrentColumn += NumColumns;
        }
    }
 
 
public:
    vctVarStrideMatrixConstIterator():
        DataPtr(0),
        ColumnStride(1),
        NumColumns(0),
        RowStride(1),
        CurrentColumn(0)
        {}
 

    vctVarStrideMatrixConstIterator(value_type * dataPtr, stride_type columnStride,
                                    size_type numColumns, stride_type rowStride,
                                    size_type initialColumn = 0):
        DataPtr(dataPtr),
        ColumnStride(columnStride),
        NumColumns(numColumns),
        RowStride(rowStride),
        CurrentColumn(initialColumn)
        {}
 

    vctVarStrideMatrixConstIterator(const value_type * dataPtr, difference_type columnStride,
                                    size_type numColumns, stride_type rowStride,
                                    size_type initialColumn = 0):
        DataPtr(const_cast<value_type *>(dataPtr)),
        ColumnStride(columnStride),
        NumColumns(numColumns),
        RowStride(rowStride),
        CurrentColumn(initialColumn)
    {}
 

    ThisType & operator++() {
        DataPtr += ColumnStride;
        ++CurrentColumn;
        WrapToRight();
        return *this;
    }
 

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

    ThisType & operator--() {
        DataPtr -= ColumnStride;
        --CurrentColumn;
        WrapToLeft();
        return *this;
    }
 

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

    ThisType & operator +=(difference_type difference) {
        DataPtr += (difference / NumColumns) * RowStride + (difference % NumColumns) * ColumnStride;
        CurrentColumn += difference % NumColumns;
        if (difference >= 0)
            WrapToRight();
        else
            WrapToLeft();
        return *this;
    }
 

    ThisType & operator -=(difference_type difference) {
        DataPtr -= (difference / NumColumns) * RowStride + (difference % NumColumns) * ColumnStride;
        CurrentColumn -= difference % NumColumns;
        if (difference >= 0)
            WrapToLeft();
        else
            WrapToRight();
        return *this;
    }
 

    difference_type operator-(const ThisType & other) const {
        const value_type * beginThisRow = DataPtr - CurrentColumn * ColumnStride;
        const value_type * beginThatRow = other.DataPtr - other.CurrentColumn * ColumnStride;
        const difference_type rowDiff = (beginThisRow - beginThatRow) / RowStride;
        const difference_type colDiff = CurrentColumn - other.CurrentColumn;
        const difference_type result = rowDiff * NumColumns + colDiff;
        return result;
    }
 

    const value_type & operator[](difference_type index) const {
        ThisType ptrCalc(*this);
        ptrCalc += index;
        return *ptrCalc;
    }
 

    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) && (CurrentColumn == other.CurrentColumn);
    }
 

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

    vctVarStrideMatrixIterator():
        BaseType()
        {}

    vctVarStrideMatrixIterator(value_type * dataPtr, stride_type columnStride,
                               size_type numColumns, stride_type rowStride,
                               size_type initialColumn = 0):
        BaseType(dataPtr, columnStride, numColumns, rowStride, initialColumn)
        {}
 

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

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

    ThisType & operator--() {
        this->DataPtr -= this->ColumnStride;
        --(this->CurrentColumn);
        this->WrapToLeft();
        return *this;
    }
 

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

    ThisType & operator+=(difference_type difference) {
        if (this->NumColumns == 0)
            return *this;
        this->DataPtr += (difference / this->NumColumns) * this->RowStride + (difference % this->NumColumns) * this->ColumnStride;
        this->CurrentColumn += difference % this->NumColumns;
        if (difference >= 0)
            this->WrapToRight();
        else
            this->WrapToLeft();
        return *this;
    }
 

    ThisType & operator-=(difference_type difference) {
        if (this->NumColumns == 0)
            return *this;
        this->DataPtr -= (difference / this->NumColumns) * this->RowStride + (difference % this->NumColumns) * this->ColumnStride;
        this->CurrentColumn -= difference % this->NumColumns;
        if (difference >= 0)
            this->WrapToLeft();
        else
            this->WrapToRight();
        return *this;
    }
 

    value_type & operator[](difference_type index) const {
        ThisType ptrCalc(*this);
        ptrCalc += index;
        return *ptrCalc;
    }
 

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

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

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

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

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

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

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