vctDynamicConstMatrixRef.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-01
 
  (C) Copyright 2004-2007 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 _vctDynamicConstMatrixRef_h
#define _vctDynamicConstMatrixRef_h

 
#include <cisstVector/vctDynamicConstMatrixBase.h>
#include <cisstVector/vctDynamicMatrixRefOwner.h>

template <class _elementType>
class vctDynamicConstMatrixRef :
    public vctDynamicConstMatrixBase<vctDynamicMatrixRefOwner<_elementType>, _elementType>
{
public:
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    enum {DIMENSION = 2};
    VCT_NARRAY_TRAITS_TYPEDEFS(DIMENSION);
 
    typedef vctDynamicConstMatrixRef<_elementType> ThisType;
    typedef vctDynamicMatrixRefOwner<_elementType> MatrixOwnerType;
    typedef vctDynamicConstMatrixBase<vctDynamicMatrixRefOwner<_elementType>, _elementType> BaseType;
    typedef typename MatrixOwnerType::iterator iterator;
    typedef typename MatrixOwnerType::const_iterator const_iterator;
    typedef typename MatrixOwnerType::reverse_iterator reverse_iterator;
    typedef typename MatrixOwnerType::const_reverse_iterator const_reverse_iterator;
 
 
    vctDynamicConstMatrixRef() {
        SetRef(0, 0, 1, 1, static_cast<pointer>(0));
    }

    vctDynamicConstMatrixRef(const ThisType & other):
        BaseType()
    {
        SetRef(other.sizes(), other.strides(), other.Pointer());
    }

    vctDynamicConstMatrixRef(size_type rows, size_type cols,
                             stride_type rowStride, stride_type colStride,
                             pointer dataPointer)
    {
        SetRef(rows, cols, rowStride, colStride, dataPointer);
    }
    vctDynamicConstMatrixRef(size_type rows, size_type cols,
                             stride_type rowStride, stride_type colStride,
                             const_pointer dataPointer)
    {
        SetRef(rows, cols, rowStride, colStride, dataPointer);
    }
 
    vctDynamicConstMatrixRef(const nsize_type & matrixSize, stride_type rowStride, stride_type colStride,
                             pointer dataPointer)
    {
        SetRef(matrixSize, rowStride, colStride, dataPointer);
    }
    vctDynamicConstMatrixRef(const nsize_type & matrixSize, stride_type rowStride, stride_type colStride,
                             const_pointer dataPointer)
    {
        SetRef(matrixSize, rowStride, colStride, dataPointer);
    }
 
    vctDynamicConstMatrixRef(const nsize_type & matrixSize, const nstride_type & matrixStride,
                             pointer dataPointer)
    {
        SetRef(matrixSize, matrixStride, dataPointer);
    }
    vctDynamicConstMatrixRef(const nsize_type & matrixSize, const nstride_type & matrixStride,
                             const_pointer dataPointer)
    {
        SetRef(matrixSize, matrixStride, dataPointer);
    }

 

    vctDynamicConstMatrixRef(size_type rows, size_type cols, pointer dataPointer,
                             bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        SetRef(rows, cols, dataPointer, storageOrder);
    }
    vctDynamicConstMatrixRef(size_type rows, size_type cols, const_pointer dataPointer,
                             bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        SetRef(rows, cols, dataPointer, storageOrder);
    }
 
    vctDynamicConstMatrixRef(const nsize_type & matrixSize, pointer dataPointer,
                             bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        SetRef(matrixSize, dataPointer, storageOrder);
    }
    vctDynamicConstMatrixRef(const nsize_type & matrixSize, const_pointer dataPointer,
                             bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        SetRef(matrixSize, dataPointer, storageOrder);
    }

 

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline vctDynamicConstMatrixRef(const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType>
                                    & otherMatrix)
    {
        SetRef(otherMatrix);
    }

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline vctDynamicConstMatrixRef(const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & otherMatrix,
                                    size_type startRow, size_type startCol, size_type rows, size_type cols)
    {
        SetRef(otherMatrix, startRow, startCol, rows, cols);
    }

    template <class __ownerType>
    inline vctDynamicConstMatrixRef(const vctDynamicConstMatrixBase<__ownerType, _elementType> & otherMatrix)
    {
        SetRef(otherMatrix);
    }

    template <class __ownerType>
    inline vctDynamicConstMatrixRef(const vctDynamicConstMatrixBase<__ownerType, _elementType> & otherMatrix,
                                    size_type startRow, size_type startCol, size_type rows, size_type cols)
    {
        SetRef(otherMatrix, startRow, startCol, rows, cols);
    }
 
    template <class __ownerType>
    inline vctDynamicConstMatrixRef(const vctDynamicConstMatrixBase<__ownerType, _elementType> & otherMatrix,
                                    const nsize_type & start, const nsize_type & matrixSize)
    {
        SetRef(otherMatrix, start, matrixSize);
    }


    void SetRef(size_type rows, size_type cols,
                stride_type rowStride, stride_type colStride,
                pointer dataPointer)
    {
        this->Matrix.SetRef(rows, cols, rowStride, colStride, dataPointer);
    }
    void SetRef(size_type rows, size_type cols,
                stride_type rowStride, stride_type colStride,
                const_pointer dataPointer)
    {
        this->Matrix.SetRef(rows, cols, rowStride, colStride, const_cast<pointer>(dataPointer));
    }
 
    void SetRef(const nsize_type & matrixSize,
                stride_type rowStride, stride_type colStride,
                pointer dataPointer) {
        this->Matrix.SetRef(matrixSize, rowStride, colStride, dataPointer);
    }
    void SetRef(const nsize_type & matrixSize,
                stride_type rowStride, stride_type colStride,
                const_pointer dataPointer) {
        this->Matrix.SetRef(matrixSize, rowStride, colStride, const_cast<pointer>(dataPointer));
    }
 
    void SetRef(const nsize_type & matrixSize,
                const nstride_type & matrixStride,
                pointer dataPointer) {
        this->Matrix.SetRef(matrixSize, matrixStride, dataPointer);
    }
    void SetRef(const nsize_type & matrixSize,
                const nstride_type & matrixStride,
                const_pointer dataPointer) {
        this->Matrix.SetRef(matrixSize, matrixStride, const_cast<pointer>(dataPointer));
    }

 

    void SetRef(size_type rows, size_type cols, pointer dataPointer, bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        this->Matrix.SetRef(rows, cols, dataPointer, storageOrder);
    }
    void SetRef(size_type rows, size_type cols, const_pointer dataPointer, bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        this->Matrix.SetRef(rows, cols, const_cast<pointer>(dataPointer), storageOrder);
    }
 
    void SetRef(const nsize_type & sizes, pointer dataPointer, bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        this->Matrix.SetRef(sizes, dataPointer, storageOrder);
    }
    void SetRef(const nsize_type & sizes, const_pointer dataPointer, bool storageOrder = VCT_DEFAULT_STORAGE)
    {
        this->Matrix.SetRef(sizes, const_cast<pointer>(dataPointer), storageOrder);
    }

 

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline void SetRef(const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType>
                       & otherMatrix)
    {
        SetRef(otherMatrix.rows(), otherMatrix.cols(), otherMatrix.row_stride(), otherMatrix.col_stride(),
               otherMatrix.Pointer());
    }
 

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline void SetRef(const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & otherMatrix,
                       size_type startRow, size_type startCol,
                       size_type rows, size_type cols)
    {
        if ( (startRow + rows > otherMatrix.rows()) || (startCol + cols > otherMatrix.cols()) ) {
            cmnThrow(std::out_of_range("vctDynamicConstMatrixRef SetRef out of range"));
        }
        SetRef(rows, cols, otherMatrix.row_stride(), otherMatrix.col_stride(), otherMatrix.Pointer(startRow, startCol));
    }

    template <class __ownerType>
    inline void SetRef( const vctDynamicConstMatrixBase<__ownerType, _elementType> & otherMatrix)
    {
        SetRef(otherMatrix.rows(), otherMatrix.cols(), otherMatrix.row_stride(), otherMatrix.col_stride(),
               otherMatrix.Pointer());
    }

    template <class __ownerType>
    inline void SetRef( const vctDynamicConstMatrixBase<__ownerType, _elementType> & otherMatrix,
                        size_type startRow, size_type startCol,
                        size_type rows, size_type cols)
    {
        if ( (startRow + rows > otherMatrix.rows()) || (startCol + cols > otherMatrix.cols()) ) {
            cmnThrow(std::out_of_range("vctDynamicConstMatrixRef SetRef out of range"));
        }
        SetRef(rows, cols, otherMatrix.row_stride(), otherMatrix.col_stride(),
               otherMatrix.Pointer(startRow, startCol));
    }
 
    template <class __ownerType>
    inline void SetRef(const vctDynamicConstMatrixBase<__ownerType, _elementType> & otherMatrix,
                       const nsize_type & start, const nsize_type & matrixSize)
    {
        SetRef(otherMatrix,
               start.Element(0), start.Element(1), matrixSize.Element(0), matrixSize.Element(1));
    }

};
 
 
#endif // _vctDynamicConstMatrixRef_h