vctFixedStrideMatrixIterator.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 _vctFixedStrideMatrixIterator_h
#define _vctFixedStrideMatrixIterator_h

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

template <class _elementType, vct::stride_type _columnStride, vct::size_type _numColumns, vct::stride_type _rowStride>
class vctFixedStrideMatrixConstIterator
{
public:
    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    typedef vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride> ThisType;

    typedef typename std::random_access_iterator_tag iterator_category;
 
    enum {COL_STRIDE = _columnStride, ROW_STRIDE = _rowStride};
    enum {NUM_COLUMNS = _numColumns};
 
protected:
    value_type * DataPtr;
    difference_type CurrentColumn;
 
    enum {ROW_FIRST_INDEX = (ROW_STRIDE >= NUM_COLUMNS * COL_STRIDE)};

    inline void WrapToRight() {
        if (CurrentColumn >= NUM_COLUMNS) {
            DataPtr += ROW_STRIDE - (COL_STRIDE * NUM_COLUMNS);
            CurrentColumn -= NUM_COLUMNS;
        }
    }
 

    inline void WrapToLeft() {
        if (CurrentColumn < 0) {
            DataPtr -= ROW_STRIDE - (COL_STRIDE * NUM_COLUMNS);
            CurrentColumn += NUM_COLUMNS;
        }
    }
 
 
public:
    vctFixedStrideMatrixConstIterator() {
        CMN_ASSERT(ROW_STRIDE * COL_STRIDE > 0);
    }
 

    explicit vctFixedStrideMatrixConstIterator(value_type * dataPtr,
                                               index_type initialColumn = 0)
        : DataPtr(dataPtr)
        , CurrentColumn(initialColumn) {
        CMN_ASSERT(ROW_STRIDE * COL_STRIDE > 0);
        CMN_ASSERT( initialColumn < NUM_COLUMNS );
    }
 

    explicit vctFixedStrideMatrixConstIterator(const value_type * dataPtr,
                                               index_type initialColumn = 0)
        : DataPtr(const_cast<value_type *>(dataPtr))
        , CurrentColumn(initialColumn) {
        CMN_ASSERT(ROW_STRIDE * COL_STRIDE > 0);
        CMN_ASSERT( initialColumn < NUM_COLUMNS );
    }
 

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

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

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

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

    ThisType & operator +=(difference_type difference) {
        DataPtr += (NUM_COLUMNS == 0) ? 0
            : (difference / NUM_COLUMNS) * ROW_STRIDE + (difference % NUM_COLUMNS) * COL_STRIDE;
        CurrentColumn += (NUM_COLUMNS == 0) ? 0 : difference % NUM_COLUMNS;
        if (difference >= 0)
            WrapToRight();
        else
            WrapToLeft();
        return *this;
    }
 

    ThisType & operator -=(difference_type difference) {
        DataPtr -= (NUM_COLUMNS == 0) ? 0
            : (difference / NUM_COLUMNS) * ROW_STRIDE + (difference % NUM_COLUMNS) * COL_STRIDE;
        CurrentColumn -= (NUM_COLUMNS == 0) ? 0 : difference % NUM_COLUMNS;
        if (difference >= 0)
            WrapToLeft();
        else
            WrapToRight();
        return *this;
    }
 

    difference_type operator-(const ThisType & other) const {
        const value_type * beginThisRow = DataPtr - CurrentColumn * COL_STRIDE;
        const value_type * beginThatRow = other.DataPtr - other.CurrentColumn * COL_STRIDE;
        const difference_type rowDiff = (beginThisRow - beginThatRow) / ROW_STRIDE;
        const difference_type colDiff = CurrentColumn - other.CurrentColumn;
        const difference_type result = rowDiff * NUM_COLUMNS + 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, vct::stride_type _columnStride, vct::index_type _numColumns, vct::stride_type _rowStride>
vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns,_rowStride>
operator+(const vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride> & iterator,
          typename vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride>::difference_type difference)
{
    vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride> result(iterator);
    return result += difference;
}

template <class _elementType, vct::stride_type _columnStride, vct::index_type _numColumns, vct::stride_type _rowStride>
vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride>
operator+(typename vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride>::difference_type difference,
          const vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride> & iterator)
{
    vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride> result(iterator);
    return result += difference;
}

template <class _elementType, vct::stride_type _columnStride, vct::index_type _numColumns, vct::stride_type _rowStride>
vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride>
operator-(const vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride> & iterator,
          typename vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns,_rowStride>::difference_type difference)
{
    vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns,_rowStride> result(iterator);
    return result -= difference;
}
 

template <class _elementType, vct::stride_type _columnStride, vct::index_type _numColumns, vct::stride_type _rowStride>
class vctFixedStrideMatrixIterator:
    public vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride>
{
public:
    /* documented in base class */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    typedef vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns, _rowStride> ThisType;
    typedef vctFixedStrideMatrixConstIterator<_elementType, _columnStride, _numColumns, _rowStride> BaseType;
    typedef typename BaseType::iterator_category iterator_category;

    vctFixedStrideMatrixIterator()
        : BaseType()
    {}
 

    explicit vctFixedStrideMatrixIterator(value_type * dataPtr,
                                          index_type initialColumn = 0)
        : BaseType(dataPtr, initialColumn)
    {}
 

    ThisType & operator++() {
        return reinterpret_cast<ThisType &>(BaseType::operator++());
    }
 

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

    ThisType & operator--() {
        return reinterpret_cast<ThisType &>(BaseType::operator--());
    }
 

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

    ThisType & operator+=(difference_type difference) {
        return reinterpret_cast<ThisType &>(BaseType::operator+=(difference));
    }
 

    ThisType & operator-=(difference_type difference) {
        return reinterpret_cast<ThisType &>(BaseType::operator-=(difference));
    }
 

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

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

template <class _elementType, vct::stride_type _columnStride, vct::index_type _numColumns, vct::stride_type _rowStride>
vctFixedStrideMatrixIterator<_elementType, _columnStride,_numColumns, _rowStride>
operator+(const vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns, _rowStride> & iterator,
          typename vctFixedStrideMatrixIterator<_elementType,_columnStride, _numColumns, _rowStride>::difference_type difference)
{
    vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns,_rowStride> result(iterator);
    return result += difference;
}

template <class _elementType, vct::stride_type _columnStride, vct::index_type _numColumns, vct::stride_type _rowStride>
vctFixedStrideMatrixIterator< _elementType, _columnStride, _numColumns, _rowStride>
operator+(typename vctFixedStrideMatrixIterator< _elementType, _columnStride, _numColumns, _rowStride>::difference_type difference,
          const vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns, _rowStride> & iterator)
{
    vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns, _rowStride> result(iterator);
    return result += difference;
}

template <class _elementType, vct::stride_type _columnStride, vct::index_type _numColumns, vct::stride_type _rowStride>
vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns, _rowStride>
operator-(const vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns, _rowStride> & iterator,
          typename vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns, _rowStride>::difference_type difference)
{
    vctFixedStrideMatrixIterator<_elementType, _columnStride, _numColumns,_rowStride> result(iterator);
    return result -= difference;
}
 
 
#endif // _vctFixedStrideMatrixIterator_h