vctDynamicConstNArrayRef.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):  Daniel Li, Ofri Sadowsky, Anton Deguet
  Created on: 2006-07-03
 
  (C) Copyright 2006-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 _vctDynamicConstNArrayRef_h
#define _vctDynamicConstNArrayRef_h

 
#include <cisstVector/vctDynamicConstNArrayBase.h>
#include <cisstVector/vctDynamicNArrayRefOwner.h>

template <class _elementType, vct::size_type _dimension>
class vctDynamicConstNArrayRef :
    public vctDynamicConstNArrayBase<vctDynamicNArrayRefOwner<_elementType, _dimension>, _elementType, _dimension>
{
public:
    /* define most types from vctContainerTraits and vctNArrayTraits */
    enum {DIMENSION = _dimension};
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    VCT_NARRAY_TRAITS_TYPEDEFS(DIMENSION);
 
    /* documented in base class */
    typedef vctDynamicConstNArrayRef<_elementType, DIMENSION> ThisType;
    typedef vctDynamicNArrayRefOwner<_elementType, DIMENSION> NArrayOwnerType;
    typedef vctDynamicConstNArrayBase<vctDynamicNArrayRefOwner<_elementType, DIMENSION>, _elementType, DIMENSION> BaseType;
    typedef typename NArrayOwnerType::iterator iterator;
    typedef typename NArrayOwnerType::const_iterator const_iterator;
    typedef typename NArrayOwnerType::reverse_iterator reverse_iterator;
    typedef typename NArrayOwnerType::const_reverse_iterator const_reverse_iterator;
 
 
    vctDynamicConstNArrayRef()
    {
        this->SetRef(0, nsize_type(0), nstride_type(0));
    }

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

    vctDynamicConstNArrayRef(const_pointer dataPointer, const nsize_type & sizes, const nstride_type & strides)
    {
        this->SetRef(dataPointer, sizes, strides);
    }

    vctDynamicConstNArrayRef(pointer dataPointer, const nsize_type & sizes, const nstride_type & strides)
    {
        this->SetRef(dataPointer, sizes, strides);
    }

    template <class __ownerType>
    inline vctDynamicConstNArrayRef(const vctDynamicConstNArrayBase<__ownerType, value_type, DIMENSION> & otherNArray)
    {
        this->SetRef(otherNArray);
    }

    template <class __ownerType>
    inline vctDynamicConstNArrayRef(const vctDynamicConstVectorBase<__ownerType, value_type> & vector)
    {
        this->SetRef(vector);
    }

    template <size_type __size, stride_type __stride, typename __dataPtrType>
    inline vctDynamicConstNArrayRef(const vctFixedSizeConstVectorBase<__size, __stride, value_type, __dataPtrType> & vector)
    {
        this->SetRef(vector);
    }

    template <class __ownerType>
    inline vctDynamicConstNArrayRef(const vctDynamicConstMatrixBase<__ownerType, value_type> & matrix)
    {
        this->SetRef(matrix);
    }

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline vctDynamicConstNArrayRef(const vctFixedSizeConstMatrixBase<__rows, __cols,
                                                                      __rowStride, __colStride,
                                                                      value_type, __dataPtrType>
                                    & matrix)
    {
        this->SetRef(matrix);
    }
 

    void SetRef(const_pointer dataPointer, const nsize_type & sizes, const nstride_type & strides)
    {
        this->NArray.SetRef( const_cast<pointer>(dataPointer), sizes, strides );
    }

    template <class __ownerType>
    inline void SetRef(const vctDynamicConstNArrayBase<__ownerType, value_type, DIMENSION> & otherNArray)
    {
        this->SetRef( otherNArray.Pointer(), otherNArray.sizes(), otherNArray.strides() );
    }

    template <class __ownerType>
    inline void SubarrayOf(const vctDynamicConstNArrayBase<__ownerType, value_type, DIMENSION> & otherNArray,
                           const nsize_type & startPosition,
                           const nsize_type & lengths)
    {
        CMN_ASSERT((startPosition + lengths).LesserOrEqual(otherNArray.sizes()));
        this->SetRef(otherNArray.Pointer(startPosition), lengths, otherNArray.strides());
    }

    template <class __ownerType>
    inline void PermutationOf(const vctDynamicConstNArrayBase<__ownerType, value_type, DIMENSION> & otherNArray,
                              const ndimension_type & dimensions)
    {
        nsize_type sizes;
        nstride_type strides;
 
        const typename ndimension_type::const_iterator dimensionsBegin = dimensions.begin();
        const typename ndimension_type::const_iterator dimensionsEnd = dimensions.end();
        typename ndimension_type::const_iterator dimensionsIter;
        typename nsize_type::iterator sizesIter = sizes.begin();
        typename nstride_type::iterator stridesIter = strides.begin();
        for (dimensionsIter = dimensionsBegin;
             dimensionsIter != dimensionsEnd;
             ++dimensionsIter, ++sizesIter, ++stridesIter) {
            *sizesIter = otherNArray.size(*dimensionsIter);
            *stridesIter = otherNArray.stride(*dimensionsIter);
        }
 
        this->SetRef(otherNArray.Pointer(), sizes, strides);
    }

    template <class __ownerType>
    inline void SliceOf(const vctDynamicConstNArrayBase<__ownerType, value_type, DIMENSION + 1> & otherNArray,
                        dimension_type dimension,
                        size_type index)
    {
        // set up local sizes and strides
        nsize_type sizes;
        nstride_type strides;
        size_type i;
 
        typedef vctDynamicConstNArrayBase<__ownerType, value_type, DIMENSION + 1> OtherArrayType;
        typedef typename OtherArrayType::nsize_type other_nsize_type;
        typedef typename OtherArrayType::nstride_type other_nstride_type;
 
        // set up iterators
        const typename other_nsize_type::const_iterator otherSizesBegin = otherNArray.sizes().begin();
        typename other_nsize_type::const_iterator otherSizesIter;
        const typename other_nstride_type::const_iterator otherStridesBegin = otherNArray.strides().begin();
        typename other_nstride_type::const_iterator otherStridesIter;
        const typename nsize_type::iterator sizesBegin = sizes.begin();
        const typename nsize_type::iterator sizesEnd = sizes.end();
        typename nsize_type::iterator sizesIter;
        const typename nstride_type::iterator stridesBegin = strides.begin();
        typename nstride_type::iterator stridesIter;
 
        // copy sizes and strides in every dimension except the one specified
        otherSizesIter = otherSizesBegin;
        otherStridesIter = otherStridesBegin;
        sizesIter = sizesBegin;
        stridesIter = stridesBegin;
        i = 0;
        while (sizesIter != sizesEnd) {
            if (i == dimension) {
                ++otherSizesIter;
                ++otherStridesIter;
                ++i;
            } else {
                *sizesIter = *otherSizesIter;
                *stridesIter = *otherStridesIter;
 
                ++otherSizesIter;
                ++otherStridesIter;
                ++sizesIter;
                ++stridesIter;
                ++i;
            }
        }
 
        // set start position
        other_nsize_type startPosition(static_cast<size_type>(0));
        startPosition[dimension] = index;
        this->SetRef(otherNArray.Pointer(startPosition), sizes, strides);
    }

    template <class __ownerType>
    inline void SetRef(const vctDynamicConstVectorBase<__ownerType, value_type> & vector)
    {
        this->SetRef( vector.Pointer(), nsize_type(vector.size()), nstride_type(vector.stride()) );
    }

    template <size_type __size, stride_type __stride, typename __dataPtrType>
    inline void SetRef(const vctFixedSizeConstVectorBase<__size, __stride, value_type, __dataPtrType> & vector)
    {
        this->SetRef( vector.Pointer(), nsize_type(__size), nstride_type(__stride) );
    }

    template <class __ownerType>
    inline void SetRef(const vctDynamicConstMatrixBase<__ownerType, value_type> & matrix)
    {
        this->SetRef(matrix.Pointer(),
                     nsize_type(matrix.rows(), matrix.cols()),
                     nstride_type(matrix.row_stride(), matrix.col_stride()));
    }

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, typename __dataPtrType>
    inline void SetRef(const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix)
    {
        this->SetRef(matrix.Pointer(),
                     nsize_type(__rows, __cols),
                     nstride_type(__rowStride, __colStride));
    }
};
 
 
#endif // _vctDynamicConstNArrayRef_h