vctDynamicNArray.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-10

  (C) Copyright 2006-2009 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 _vctDynamicNArray_h
#define _vctDynamicNArray_h

#include <cisstVector/vctDynamicNArrayBase.h>
#include <cisstVector/vctDynamicNArrayOwner.h>
#include <cisstVector/vctDynamicNArrayRef.h>

template<class _elementType, vct::size_type _dimension>
class vctDynamicNArray :
    public vctDynamicNArrayBase<vctDynamicNArrayOwner<_elementType, _dimension>, _elementType, _dimension>
{

    friend class vctReturnDynamicNArray<_elementType, _dimension>;

public:
    /* define most types from vctContainerTraits and vctNArrayTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    VCT_NARRAY_TRAITS_TYPEDEFS(_dimension);

    typedef vctDynamicNArrayBase<vctDynamicNArrayOwner<_elementType, _dimension>, _elementType, _dimension> BaseType;
    typedef vctDynamicNArray<_elementType, _dimension> ThisType;

    vctDynamicNArray()
        // The default initialization of vctDynamicNArrayOwner is empty.
    {}

    vctDynamicNArray(const nsize_type & sizes)
    {
        this->NArray.SetSize(sizes);
    }

    vctDynamicNArray(const nsize_type & sizes, value_type value)
    {
        this->NArray.SetSize(sizes);
        SetAll(value);
    }

    vctDynamicNArray(const vctReturnDynamicNArray<value_type, _dimension> & otherNArray);


    vctDynamicNArray(const ThisType & otherNArray):
        BaseType()
    {
        SetSize(otherNArray.sizes());
        this->Assign(otherNArray);
    }
    template <class _otherNArrayOwnerType>
    vctDynamicNArray(const vctDynamicConstNArrayBase<_otherNArrayOwnerType, value_type, _dimension> & otherNArray)
    {
        SetSize(otherNArray.sizes());
        this->Assign(otherNArray);
    }

    template <class _otherNArrayOwnerType, typename _otherNArrayElementType>
    explicit vctDynamicNArray(const vctDynamicConstNArrayBase<_otherNArrayOwnerType, _otherNArrayElementType, _dimension> & otherNArray)
    {
        SetSize(otherNArray.sizes());
        this->Assign(otherNArray);
    }


    template <class __nArrayOwnerType, typename __elementType>
    ThisType & operator = (const vctDynamicConstNArrayBase<__nArrayOwnerType, __elementType, _dimension> & otherNArray)
    {
        SetSize(otherNArray.sizes());
        this->Assign(otherNArray);
        return *this;
    }

    ThisType & operator = (const ThisType & otherNArray)
    {
        SetSize(otherNArray.sizes());
        this->Assign(otherNArray);
        return *this;
    }


    ThisType & operator = (const vctReturnDynamicNArray<value_type, _dimension> & otherNArray);

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

    // documented in base class
    template <class __nArrayOwnerType, typename __elementType>
    inline ThisType & ForceAssign(const vctDynamicConstNArrayBase<__nArrayOwnerType, __elementType, _dimension> & other) {
        this->SetSize(other.size());
        return this->Assign(other);
    }

    void SetSize(const nsize_type & sizes)
    {
        this->NArray.SetSize(sizes);
    }
};


template <class _elementType, vct::size_type _dimension>
class vctReturnDynamicNArray : public vctDynamicNArray<_elementType, _dimension>
{
public:
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    VCT_NARRAY_TRAITS_TYPEDEFS(_dimension);

    typedef vctDynamicNArray<_elementType, _dimension> BaseType;

    explicit vctReturnDynamicNArray(const BaseType & other)
    {
        BaseType & nonConstOther = const_cast<BaseType &>(other);
        // if we don't save it in a variable, it will be destroyed in the Release operation

        const nsize_type sizes = other.sizes();
        this->NArray.Own(sizes, nonConstOther.NArray.Release());
    }
};


// implementation of the special copy constructor of vctDynamicNArray
template <class _elementType, vct::size_type _dimension>
vctDynamicNArray<_elementType, _dimension>::vctDynamicNArray(const vctReturnDynamicNArray<_elementType, _dimension> & other)
{
    vctReturnDynamicNArray<_elementType, _dimension> & nonConstOther =
        const_cast< vctReturnDynamicNArray<_elementType, _dimension> & >(other);
    // if we don't save it in a variable, it will be destroyed in the Release operation

    const nsize_type sizes = other.sizes();
    this->NArray.Own(sizes, nonConstOther.NArray.Release());
}


// implementation of the special assignment operator from vctReturnDynamicNArray to vctDynamicNArray
template <class _elementType, vct::size_type _dimension>
vctDynamicNArray<_elementType, _dimension> &
vctDynamicNArray<_elementType, _dimension>::operator = (const vctReturnDynamicNArray<_elementType, _dimension> & other)
{
    vctReturnDynamicNArray<_elementType, _dimension> & nonConstOther =
        const_cast< vctReturnDynamicNArray<_elementType, _dimension> & >(other);
    // if we don't save it in a variable, it will be destroyed in the Release operation

    const nsize_type sizes = other.sizes();
    this->NArray.clear();
    this->NArray.Own(sizes, nonConstOther.NArray.Release());
    return *this;
}


template <class _nArrayOwnerType1, class _nArrayOwnerType2, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator + (const vctDynamicConstNArrayBase<_nArrayOwnerType1, _elementType, _dimension> & inputNArray1,
            const vctDynamicConstNArrayBase<_nArrayOwnerType2, _elementType, _dimension> & inputNArray2)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray1);
    resultStorage.Add(inputNArray2);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented above */
template <class _nArrayOwnerType1, class _nArrayOwnerType2, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator - (const vctDynamicConstNArrayBase<_nArrayOwnerType1, _elementType, _dimension> & inputNArray1,
            const vctDynamicConstNArrayBase<_nArrayOwnerType2, _elementType, _dimension> & inputNArray2)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray1);
    resultStorage.Subtract(inputNArray2);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}



template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator + (const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray,
            const _elementType & inputScalar)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray);
    resultStorage.Add(inputScalar);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented above */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator - (const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray,
            const _elementType & inputScalar)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray);
    resultStorage.Subtract(inputScalar);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented above */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator * (const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray,
            const _elementType & inputScalar)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray);
    resultStorage.Multiply(inputScalar);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented above */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator / (const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray,
            const _elementType & inputScalar)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray);
    resultStorage.Divide(inputScalar);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}



template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator + (const _elementType & inputScalar,
            const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray.sizes());
    resultStorage.SumOf(inputScalar, inputNArray);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented above */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator - (const _elementType & inputScalar,
            const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray.sizes());
    resultStorage.DifferenceOf(inputScalar, inputNArray);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented above */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator * (const _elementType & inputScalar,
            const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray.sizes());
    resultStorage.ProductOf(inputScalar, inputNArray);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented above */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator / (const _elementType & inputScalar,
            const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray.sizes());
    resultStorage.RatioOf(inputScalar, inputNArray);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}


template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator - (const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & inputNArray)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray.sizes());
    resultStorage.NegationOf(inputNArray);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}



#ifndef DOXYGEN
template <class _nArrayOwnerType1, class _nArrayOwnerType2, class _elementType, vct::size_type _dimension>
vctReturnDynamicNArray<_elementType, _dimension>
operator * (const vctDynamicConstNArrayBase<_nArrayOwnerType1, _elementType, _dimension> & inputNArray1,
            const vctDynamicConstNArrayBase<_nArrayOwnerType2, _elementType, _dimension> & inputNArray2)
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(inputNArray1.sizes());
    resultStorage.ProductOf(inputNArray1, inputNArray2);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}


/*
  Methods declared previously and implemented here because they require vctReturnDynamicNArray
*/


/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::NArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::Abs(void) const
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(this->sizes());
    vctDynamicNArrayLoopEngines<_dimension>::template
        NoNi<typename vctUnaryOperations<value_type>::AbsValue>::
        Run(resultStorage, *this);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::NArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::Negation(void) const
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(this->sizes());
    vctDynamicNArrayLoopEngines<_dimension>::template
        NoNi<typename vctUnaryOperations<value_type>::Negation>::
        Run(resultStorage, *this);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::NArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::Floor(void) const
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(this->sizes());
    vctDynamicNArrayLoopEngines<_dimension>::template
        NoNi<typename vctUnaryOperations<value_type>::Floor>::
        Run(resultStorage, *this);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::NArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::Ceil(void) const
{
    typedef _elementType value_type;
    vctDynamicNArray<value_type, _dimension> resultStorage(this->sizes());
    vctDynamicNArrayLoopEngines<_dimension>::template
        NoNi<typename vctUnaryOperations<value_type>::Ceil>::
        Run(resultStorage, *this);
    return vctReturnDynamicNArray<value_type, _dimension>(resultStorage);
}

/* Documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class __nArrayOwnerType, class _elementType,
         class _elementOperationType, vct::size_type _dimension>
inline vctReturnDynamicNArray<bool, _dimension>
vctDynamicNArrayElementwiseCompareNArray(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray1,
                                         const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray2)
{
    vctDynamicNArray<bool, _dimension> result(nArray1.sizes());
    vctDynamicNArrayLoopEngines<_dimension>::template
        NoNiNi<_elementOperationType>::Run(result, nArray1, nArray2);
    return vctReturnDynamicNArray<bool, _dimension>(result);
}

/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType, class _elementOperationType, vct::size_type _dimension>
inline vctReturnDynamicNArray<bool, _dimension>
vctDynamicNArrayElementwiseCompareScalar(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray,
                                         const _elementType & scalar)
{
    vctDynamicNArray<bool, _dimension> result(nArray.sizes());
    vctDynamicNArrayLoopEngines<_dimension>::template
        NoNiSi<_elementOperationType>::Run(result, nArray, scalar);
    return vctReturnDynamicNArray<bool, _dimension>(result);
}


/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline vctDynamicNArrayRef<_elementType, _dimension - 1>
vctDynamicNArrayNArraySlice(vctDynamicNArrayBase<_nArrayOwnerType, _elementType, _dimension> & input,
                            vct::size_type dimension,
                            vct::index_type index)
{
    vctDynamicNArrayRef<_elementType, _dimension - 1> slice;
    slice.SliceOf(input, dimension, index);
    return slice;
}

/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType>
inline _elementType &
vctDynamicNArrayElementSlice(vctDynamicNArrayBase<_nArrayOwnerType, _elementType, 1> & input,
                             vct::index_type index)
{
    return input.Element(vctFixedSizeVector<vct::index_type, 1>(index));
}

/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline vctDynamicConstNArrayRef<_elementType, _dimension - 1>
vctDynamicNArrayConstNArraySlice(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & input,
                                 vct::size_type dimension,
                                 vct::index_type index)
{
    vctDynamicConstNArrayRef<_elementType, _dimension - 1> slice;
    slice.SliceOf(input, dimension, index);
    return slice;
}

/* documented in class vctDynamicConstNArrayBase */
template <class _nArrayOwnerType, class _elementType>
inline const _elementType &
vctDynamicNArrayConstElementSlice(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, 1> & input,
                                  vct::index_type index)
{
    return input.Element(vctFixedSizeVector<vct::index_type, 1>(index));
}

#endif // DOXYGEN


#endif // _vctDynamicNArray_h