vctDynamicNArrayRef.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-13

  (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 _vctDynamicNArrayRef_h
#define _vctDynamicNArrayRef_h

#include <cisstVector/vctDynamicNArrayBase.h>
#include <cisstVector/vctDynamicNArrayRefOwner.h>
#include <cisstVector/vctDynamicConstNArrayRef.h>

template <class _elementType, vct::size_type _dimension>
class vctDynamicNArrayRef:
    public vctDynamicNArrayBase<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 vctDynamicNArrayRef<_elementType, DIMENSION> ThisType;
    typedef vctDynamicNArrayRefOwner<_elementType, DIMENSION> NArrayOwnerType;
    typedef vctDynamicNArrayBase<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;


    vctDynamicNArrayRef()
    {
        this->SetRef(0, nsize_type(0), nstride_type(0));
    }

    vctDynamicNArrayRef(const ThisType & other):
        BaseType()
    {
        this->SetRef(const_cast<pointer>(other.Pointer()), other.sizes(), other.strides());
    }

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

    template <class __ownerType>
    inline vctDynamicNArrayRef(vctDynamicNArrayBase<__ownerType, _elementType, DIMENSION> & otherNArray)
    {
        this->SetRef(otherNArray);
    }

    template <class __ownerType>
    inline vctDynamicNArrayRef(vctDynamicConstVectorBase<__ownerType, _elementType> & vector)
    {
        this->SetRef(vector);
    }

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

    template <class __ownerType>
    inline vctDynamicNArrayRef(vctDynamicConstMatrixBase<__ownerType, _elementType> & matrix)
    {
        this->SetRef(matrix);
    }

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


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

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

    template <class __ownerType>
    inline void SubarrayOf(vctDynamicNArrayBase<__ownerType, _elementType, 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(vctDynamicNArrayBase<__ownerType, _elementType, 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(vctDynamicNArrayBase<__ownerType, _elementType, 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 vctDynamicNArrayBase<__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(vctDynamicConstVectorBase<__ownerType, _elementType> & 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(vctFixedSizeConstVectorBase<__size, __stride, _elementType, __dataPtrType> & vector)
    {
        this->SetRef( vector.Pointer(), nsize_type(__size), nstride_type(__stride) );
    }

    template <class __ownerType>
    inline void SetRef(vctDynamicConstMatrixBase<__ownerType, _elementType> & 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(vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & matrix)
    {
        this->SetRef(matrix.Pointer(),
                     nsize_type(__rows, __cols),
                     nstride_type(__rowStride, __colStride));
    }


    inline ThisType & operator = (const ThisType & other)
    {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    inline ThisType & operator = (const vctDynamicConstNArrayRef<_elementType, DIMENSION> & other)
    {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    template <class __nArrayOwnerType, typename __elementType>
    inline ThisType & operator = (const vctDynamicNArrayBase<__nArrayOwnerType, __elementType, DIMENSION> & other)
    {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    inline ThisType & operator = (const value_type & value)
    {
        this->SetAll(value);
        return *this;
    }

};


#endif // _vctDynamicNArrayRef_h