vctDynamicVectorOwner.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-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 _vctDynamicVectorOwner_h
#define _vctDynamicVectorOwner_h

 
#include <cisstVector/vctFixedStrideVectorIterator.h>

template<class _elementType>
class vctDynamicVectorOwner
{
public:
    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    typedef vctDynamicVectorOwner<_elementType> ThisType;
 
    /* iterators are container specific */
    enum { DEFAULT_STRIDE = 1 };
#ifndef SWIG
    typedef vctFixedStrideVectorConstIterator<value_type, DEFAULT_STRIDE> const_iterator;
    typedef vctFixedStrideVectorConstIterator<value_type, -DEFAULT_STRIDE> const_reverse_iterator;
    typedef vctFixedStrideVectorIterator<value_type, DEFAULT_STRIDE> iterator;
    typedef vctFixedStrideVectorIterator<value_type, -DEFAULT_STRIDE> reverse_iterator;
#endif // SWIG
 
    vctDynamicVectorOwner()
        : Size(0)
        , Data(0)
    {}
 
    vctDynamicVectorOwner(size_type size):
        Size(0)
    {
        SetSize(size);
    }
 
    ~vctDynamicVectorOwner() {
        Disown();
    }
 
    size_type size(void) const {
        return Size;
    }
 
    stride_type stride(void) const
    {
        return DEFAULT_STRIDE;
    }
 
    pointer Pointer(index_type index = 0) {
        return Data + index;
    }
 
    const_pointer Pointer(index_type index = 0) const {
        return Data + index;
    }
 
    const_iterator begin(void) const {
        return const_iterator(Data);
    }
 
    const_iterator end(void) const {
        return const_iterator(Data + Size);
    }
 
    iterator begin(void) {
        return iterator(Data);
    }
 
    iterator end(void) {
        return iterator(Data + Size);
    }
 
    const_reverse_iterator rbegin(void) const {
        return const_reverse_iterator(Data + Size - 1);
    }
 
    const_reverse_iterator rend(void) const {
        return const_reverse_iterator(Data - 1);
    }
 
    reverse_iterator rbegin(void) {
        return reverse_iterator(Data + Size-1);
    }
 
    reverse_iterator rend(void) {
        return reverse_iterator(Data - 1);
    }

    void SetSize(size_type size) {
        if (size == Size) return;
        Disown();
        Own(size, (size == 0) ? 0 : new value_type[size]);
    }

    value_type * Release()
    {
        value_type * oldData = Data;
        Data = 0;
        Size = 0;
        return oldData;
    }

    value_type * Own(size_type size, value_type * data) {
        value_type * oldData = Data;
        Size = size;
        Data = data;
        return oldData;
    }

    void Disown(void) {
        delete[] Data;
        Size = 0;
        Data = 0;
    }
 
 
protected:
    size_type Size;
    value_type* Data;
 
private:
    // copy constructor private to prevent any call
    vctDynamicVectorOwner(const ThisType & CMN_UNUSED(other)) {};
 
};
 
 
#endif // _vctDynamicVectorOwner_h