vctDynamicVector.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-2012 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 _vctDynamicVector_h
#define _vctDynamicVector_h

#include <cisstCommon/cmnDeSerializer.h>

#include <cisstVector/vctDynamicVectorBase.h>
#include <cisstVector/vctDynamicVectorOwner.h>
#include <cisstVector/vctDynamicVectorRef.h>

template <class _elementType>
class vctDynamicVector : public vctDynamicVectorBase<vctDynamicVectorOwner<_elementType>, _elementType>
{

    friend class vctReturnDynamicVector<_elementType>;

public:
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    typedef vctDynamicVector<_elementType> ThisType;
    typedef vctDynamicVectorBase<vctDynamicVectorOwner<_elementType>, _elementType> BaseType;
    typedef typename BaseType::CopyType CopyType;
    typedef typename BaseType::TypeTraits TypeTraits;
    typedef typename BaseType::ElementVaArgPromotion ElementVaArgPromotion;

    vctDynamicVector()
        // The default initialization of vctDynamicVectorOwner is empty.
    {}


    explicit vctDynamicVector(size_type size) {
        this->SetSize(size);
    }

    vctDynamicVector(size_type size, value_type value) {
        this->SetSize(size);
        this->SetAll(value);
    }

    vctDynamicVector(size_type size, value_type element0, value_type element1, ...) throw(std::runtime_error) {
        if (size < 2) {
            cmnThrow(std::runtime_error("vctDynamicVector: Constructor from va_list requires size >= 2"));
        }
        this->SetSize(size);
        this->at(0) = element0;
        this->at(1) = element1;
        va_list nextArg;
        va_start(nextArg, element1);
        for (index_type i = 2; i < size; ++i) {
            this->at(i) = value_type( va_arg(nextArg, ElementVaArgPromotion) );
        }
        va_end(nextArg);
    }

    vctDynamicVector(size_type size, const value_type * values) {
        this->SetSize(size);
        this->Assign(values);
    }

    vctDynamicVector(const vctReturnDynamicVector<value_type> & otherVector);


    vctDynamicVector(const ThisType & otherVector):
        BaseType()
    {
        this->SetSize(otherVector.size());
        this->Assign(otherVector);
    }


    template <class _otherVectorOwnerType>
    vctDynamicVector(const vctDynamicConstVectorBase<_otherVectorOwnerType, value_type> & otherVector) {
        this->SetSize(otherVector.size());
        this->Assign(otherVector);
    }


    template <class _otherVectorOwnerType, typename _otherVectorElementType>
    explicit vctDynamicVector(const vctDynamicConstVectorBase<_otherVectorOwnerType, _otherVectorElementType> & otherVector) {
        this->SetSize(otherVector.size());
        this->Assign(otherVector);
    }

    template <size_type __size, stride_type __stride, class __elementType, class __dataPtrType>
    explicit vctDynamicVector(const vctFixedSizeConstVectorBase<__size, __stride, __elementType, __dataPtrType> & fixedVector) {
        this->SetSize(__size);
        this->Assign(fixedVector);
    }

    template <class __vectorOwnerType, typename __elementType>
    ThisType & operator = (const vctDynamicConstVectorBase<__vectorOwnerType, __elementType> & otherVector) {
        this->SetSize(otherVector.size());
        this->Assign(otherVector);
        return *this;
    }


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

    ThisType & operator = (const vctReturnDynamicVector<value_type> & other);

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

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

    // documented in base class
    template <size_type __size, stride_type __stride, class __elementType, class __dataPtrType>
    inline ThisType & ForceAssign(const vctFixedSizeConstVectorBase<__size, __stride, __elementType, __dataPtrType>
                                  & other) {
        this->SetSize(other.size());
        this->Assign(other);
        return *this;
    }

    void resize(size_type size) {
        const size_type oldSize = this->size();
        if (oldSize == size)
            return;
        ThisType newData(size);
        size_type minSizes = std::min(size, oldSize);
        const size_type corner = 0;
        vctDynamicConstVectorRef<value_type> myDataMinSpaceRef(*this, corner, minSizes);
        vctDynamicVectorRef<value_type> newDataMinSpaceRef(newData, corner, minSizes);
        newDataMinSpaceRef.Assign(myDataMinSpaceRef);
        this->Vector.Disown();
        this->Vector.Own(size, newData.Vector.Release());
    }

    void SetSize(size_type size) {
        this->Vector.SetSize(size);
    }

    bool FromStreamRaw(std::istream & inputStream, const char delimiter = ' ')
    {
        size_type size = this->size();
        _elementType *temp = new _elementType[size];
        size_type index;
        bool valid = true;
        for (index = 0; index < size; index++) {
            inputStream >> temp[index];  // assumes that operator >> is defined for _elementType
            if (inputStream.fail()) {
                valid = false;
                inputStream.clear();
                break;
            }
            // Now, look for the delimiter
            if (!isspace(delimiter)) {
                if (index < size-1) {
                    char c;
                    inputStream >> c;
                    if (c != delimiter) {
                        valid = false;
                        break;
                    }
                }
            }
        }
        if (valid) {
            // Only update the object if the parsing was successful for all elements.
            for (index = 0; index < size; index++)
                (*this)[index] = temp[index];
        }
        delete [] temp;
        return valid;
    }

    void DeSerializeRaw(std::istream & inputStream)
    {
        // get and set size
        size_type mySize = 0;
        cmnDeSerializeSizeRaw(inputStream, mySize);
        this->SetSize(mySize);

        // get data
        size_type index;
        for (index = 0; index < mySize; ++index) {
            cmnDeSerializeRaw(inputStream, this->Element(index));
        }
    }

};


template <class _elementType>
class vctReturnDynamicVector : public vctDynamicVector<_elementType> {
public:
    typedef vctDynamicVector<_elementType> BaseType;
    explicit vctReturnDynamicVector(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 vct::size_type size = other.size();
        this->Vector.Own(size, nonConstOther.Vector.Release());
    }
};


// implementation of the special copy constuctor of vctDynamicVector
template <class _elementType>
vctDynamicVector<_elementType>::vctDynamicVector(const vctReturnDynamicVector<_elementType> & other) {
    vctReturnDynamicVector<_elementType> & nonConstOther =
        const_cast< vctReturnDynamicVector<_elementType> & >(other);
    // if we don't save it in a variable, it will be destroyed in the Release operation
    const size_type size = other.size();
    this->Vector.Own(size, nonConstOther.Vector.Release());
}


// implementation of the special assignment operator from vctReturnDynamicVector to vctDynamicVector
template <class _elementType>
vctDynamicVector<_elementType> &
vctDynamicVector<_elementType>::operator = (const vctReturnDynamicVector<_elementType> & other) {
    vctReturnDynamicVector<_elementType> & nonConstOther =
        const_cast< vctReturnDynamicVector<_elementType> & >(other);
    // if we don't save it in a variable, it will be destroyed in the Release operation
    const vct::size_type size = other.size();
    this->Vector.Disown();
    this->Vector.Own(size, nonConstOther.Vector.Release());
    return *this;
}


template <class _vectorOwnerType1, class _vectorOwnerType2, class _elementType>
vctReturnDynamicVector<_elementType>
operator + (const vctDynamicConstVectorBase<_vectorOwnerType1, _elementType> & inputVector1,
            const vctDynamicConstVectorBase<_vectorOwnerType2, _elementType> & inputVector2) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector1);
    resultStorage.Add(inputVector2);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented above */
template <class _vectorOwnerType1, class _vectorOwnerType2, class _elementType>
vctReturnDynamicVector<_elementType>
operator - (const vctDynamicConstVectorBase<_vectorOwnerType1, _elementType> & inputVector1,
            const vctDynamicConstVectorBase<_vectorOwnerType2, _elementType> & inputVector2) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector1);
    resultStorage.Subtract(inputVector2);
    return vctReturnDynamicVector<value_type>(resultStorage);
}


template <class _vectorOwnerType1, class _vectorOwnerType2, class _elementType>
vctReturnDynamicVector<_elementType>
operator % (const vctDynamicConstVectorBase<_vectorOwnerType1, _elementType> & inputVector1,
            const vctDynamicConstVectorBase<_vectorOwnerType2, _elementType> & inputVector2) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(3);
    resultStorage.CrossProductOf(inputVector1, inputVector2);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

template <class _vectorOwnerType1, class _vectorOwnerType2, class _elementType>
vctReturnDynamicVector<_elementType>
vctCrossProduct(const vctDynamicConstVectorBase<_vectorOwnerType1, _elementType> & inputVector1,
                const vctDynamicConstVectorBase<_vectorOwnerType2, _elementType> & inputVector2) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(3);
    resultStorage.CrossProductOf(inputVector1, inputVector2);
    return vctReturnDynamicVector<value_type>(resultStorage);
}



template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator + (const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector,
            const _elementType & inputScalar) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector);
    resultStorage.Add(inputScalar);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented above */
template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator - (const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector,
            const _elementType & inputScalar) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector);
    resultStorage.Subtract(inputScalar);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented above */
template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator * (const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector,
            const _elementType & inputScalar) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector);
    resultStorage.Multiply(inputScalar);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented above */
template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator / (const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector,
            const _elementType & inputScalar) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector);
    resultStorage.Divide(inputScalar);
    return vctReturnDynamicVector<value_type>(resultStorage);
}



template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator + (const _elementType & inputScalar,
            const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector.size());
    resultStorage.SumOf(inputScalar, inputVector);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented above */
template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator - (const _elementType & inputScalar,
            const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector.size());
    resultStorage.DifferenceOf(inputScalar, inputVector);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented above */
template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator * (const _elementType & inputScalar,
            const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector.size());
    resultStorage.ProductOf(inputScalar, inputVector);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented above */
template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator / (const _elementType & inputScalar,
            const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector.size());
    resultStorage.RatioOf(inputScalar, inputVector);
    return vctReturnDynamicVector<value_type>(resultStorage);
}


template <class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator - (const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputVector.size());
    resultStorage.NegationOf(inputVector);
    return vctReturnDynamicVector<value_type>(resultStorage);
}



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

#ifndef DOXYGEN
/* documented in class vctDynamicConstVectorBase */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::VectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::Abs(void) const {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(this->size());
    vctDynamicVectorLoopEngines::
        VoVi<typename vctUnaryOperations<value_type>::AbsValue>::
        Run(resultStorage, *this);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented in class vctDynamicConstVectorBase */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::VectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::Negation(void) const {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(this->size());
    vctDynamicVectorLoopEngines::
        VoVi<typename vctUnaryOperations<value_type>::Negation>::
        Run(resultStorage, *this);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented in class vctDynamicConstVectorBase */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::VectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::Floor(void) const {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(this->size());
    vctDynamicVectorLoopEngines::
        VoVi<typename vctUnaryOperations<value_type>::Floor>::
        Run(resultStorage, *this);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented in class vctDynamicConstVectorBase */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::VectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::Ceil(void) const {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(this->size());
    vctDynamicVectorLoopEngines::
        VoVi<typename vctUnaryOperations<value_type>::Ceil>::
        Run(resultStorage, *this);
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented in class vctDynamicConstVectorBase */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::VectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::Normalized(void) const throw(std::runtime_error) {
    vctDynamicVector<value_type> resultStorage(*this);
    resultStorage.NormalizedSelf();
    return vctReturnDynamicVector<value_type>(resultStorage);
}

/* documented in class vctDynamicConstVectorBase */
template <class _vectorOwnerType, class __vectorOwnerType, class _elementType,
          class _elementOperationType>
inline vctReturnDynamicVector<bool>
vctDynamicVectorElementwiseCompareVector(const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector1,
                                         const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector2) {
    vctDynamicVector<bool> result(vector1.size());
    vctDynamicVectorLoopEngines::
        VoViVi<_elementOperationType>::Run(result, vector1, vector2);
    return vctReturnDynamicVector<bool>(result);
}

/* documented in class vctDynamicConstVectorBase */
template <class _vectorOwnerType, class _elementType, class _elementOperationType>
inline vctReturnDynamicVector<bool>
vctDynamicVectorElementwiseCompareScalar(const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector,
                                         const _elementType & scalar) {
    vctDynamicVector<bool> result(vector.size());
    vctDynamicVectorLoopEngines::
        VoViSi<_elementOperationType>::Run(result, vector, scalar);
    return vctReturnDynamicVector<bool>(result);
}

#endif // DOXYGEN

#endif // _vctDynamicVector_h