vctDynamicVectorRef.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-2015 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 _vctDynamicVectorRef_h
#define _vctDynamicVectorRef_h

#include <cisstCommon/cmnDeSerializer.h>

#include<cisstVector/vctDynamicVectorBase.h>
#include<cisstVector/vctDynamicVectorRefOwner.h>
#include<cisstVector/vctDynamicConstVectorRef.h>

template <class _elementType>
class vctDynamicVectorRef: public vctDynamicVectorBase<vctDynamicVectorRefOwner<_elementType>, _elementType>
{
public:
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    typedef vctDynamicVectorRef<_elementType> ThisType;
    typedef vctDynamicVectorRefOwner<_elementType> VectorOwnerType;
    typedef vctDynamicVectorBase<vctDynamicVectorRefOwner<_elementType>, _elementType> BaseType;
    typedef typename BaseType::CopyType CopyType;
    typedef typename VectorOwnerType::iterator iterator;
    typedef typename VectorOwnerType::const_iterator const_iterator;
    typedef typename VectorOwnerType::reverse_iterator reverse_iterator;
    typedef typename VectorOwnerType::const_reverse_iterator const_reverse_iterator;

    vctDynamicVectorRef()
    {}

    vctDynamicVectorRef(const ThisType & other):
        BaseType()
    {
        this->SetRef(other.size(), const_cast<pointer>(other.Pointer()), other.stride());
    }

    vctDynamicVectorRef(size_type size, value_type* data, stride_type stride = 1)
    {
        this->SetRef(size, data, stride);
    }

    template <size_type __size, stride_type __stride, class __dataPtrType>
    vctDynamicVectorRef(vctFixedSizeVectorBase<__size, __stride, _elementType, __dataPtrType> & otherVector,
                        size_type startPosition = 0)
    {
        this->SetRef(otherVector, startPosition);
    }

    template <size_type __size, stride_type __stride, class __dataPtrType>
    vctDynamicVectorRef(vctFixedSizeVectorBase<__size, __stride, _elementType, __dataPtrType> & otherVector,
                        size_type startPosition, size_type length)
    {
        this->SetRef(otherVector, startPosition, length);
    }

    template <class __vectorOwnerType>
    vctDynamicVectorRef(vctDynamicVectorBase<__vectorOwnerType, _elementType> & otherVector)
    {
        this->SetRef(otherVector);
    }

    template <class __vectorOwnerType>
    vctDynamicVectorRef(vctDynamicVectorBase<__vectorOwnerType, _elementType> & otherVector,
                        size_type startPosition, size_type length)
    {
        this->SetRef(otherVector, startPosition, length);
    }

    void SetRef(size_type size, pointer data, stride_type stride = 1)
    {
        this->Vector.SetRef(size, data, stride);
    }

    template <size_type __size, stride_type __stride, class __dataPtrType>
    void SetRef(vctFixedSizeVectorBase<__size, __stride, _elementType, __dataPtrType> & otherVector,
                size_type startPosition = 0)
    {
        SetRef(otherVector.size() - startPosition, otherVector.Pointer(startPosition),
               otherVector.stride());
    }

    template <size_type __size, stride_type __stride, class __dataPtrType>
    void SetRef(vctFixedSizeVectorBase<__size, __stride, _elementType, __dataPtrType> & otherVector,
                size_type startPosition, size_type length) throw(std::out_of_range)
    {
        if (startPosition + length > otherVector.size()) {
            cmnThrow(std::out_of_range("vctDynamicVectorRef SetRef out of range"));
        }
        SetRef(length, otherVector.Pointer(startPosition), otherVector.stride());
    }

    template <class __vectorOwnerType>
    void SetRef(vctDynamicVectorBase<__vectorOwnerType, _elementType> & otherVector)
    {
        SetRef(otherVector.size(), otherVector.Pointer(), otherVector.stride());
    }

    template <class __vectorOwnerType>
    void SetRef(vctDynamicVectorBase<__vectorOwnerType, _elementType> & otherVector,
                size_type startPosition, size_type length) throw(std::out_of_range)
    {
        if (startPosition + length > otherVector.size()) {
            cmnThrow(std::out_of_range("vctDynamicVectorRef SetRef out of range"));
        }
        SetRef(length, otherVector.Pointer(startPosition), otherVector.stride());
    }


#ifndef _cisstVectorPython_EXPORTS
    /* Equivalent to Assign.  Please note that this operator performs a data
      copy, not an object copy as understood with a C++ copy constructor.  If
      the size of operands don't match an exception will be thrown. */
    inline ThisType & operator = (const ThisType & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }
#endif // _cisstVectorPython_EXPORTS

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

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

    template <size_type __size, stride_type __stride, class __elementType, class __dataPtrType>
    inline ThisType & operator =
    (const vctFixedSizeConstVectorBase<__size, __stride, __elementType, __dataPtrType> & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

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

    void DeSerializeRaw(std::istream & inputStream) throw(std::runtime_error)
    {
        // get and set size
        size_type mySize;
        cmnDeSerializeRaw(inputStream, mySize);

        if (mySize != this->size()) {
            cmnThrow(std::runtime_error("vctDynamicVectorRef::DeSerializeRaw: Sizes of vectors don't match"));
        }

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

};

#endif // _vctDynamicVectorRef_h