ofstd/include/dcmtk/ofstd/ofvector.h

/*
 *
 *  Copyright (C) 2010, OFFIS e.V.
 *  All rights reserved.  See COPYRIGHT file for details.
 *
 *  This software and supporting documentation were developed by
 *
 *    OFFIS e.V.
 *    R&D Division Health
 *    Escherweg 2
 *    D-26121 Oldenburg, Germany
 *
 *
 *  Module:  ofstd
 *
 *  Author:  Uli Schlachter
 *
 *  Purpose: Defines a template vector class based on the STL vector class
 *
 *  Last Update:      $Author: joergr $
 *  Update Date:      $Date: 2010-10-14 13:15:51 $
 *  CVS/RCS Revision: $Revision: 1.3 $
 *  Status:           $State: Exp $
 *
 *  CVS/RCS Log at end of file
 *
 */

#ifndef OFVECTOR_H
#define OFVECTOR_H

#include "dcmtk/config/osconfig.h"    /* make sure OS specific configuration is included first */

#ifndef HAVE_CLASS_TEMPLATE
#error Your C++ compiler cannot handle class templates:
#endif

#if defined(HAVE_STL) || defined(HAVE_STL_VECTOR)

// Use the standard template library (STL) vector class.
#include <vector>

#ifdef HAVE_STD_NAMESPACE
#define OFVector std::vector
#else
#define OFVector vector
#endif

#else

#define INCLUDE_CASSERT          /* for assert() */
#define INCLUDE_CSTDLIB          /* for NULL */
#include "dcmtk/ofstd/ofstdinc.h"
#include "dcmtk/ofstd/oftypes.h" /* for OFBool */

template<typename T>
class OFVector
{
public:
    typedef T        value_type;
    typedef size_t   size_type;
    typedef T*       iterator;
    typedef const T* const_iterator;

protected:

    T* values_;

    size_type allocated_;

    size_type size_;

public:

    OFVector() : values_(NULL), allocated_(0), size_(0)
    {
        reserve(0);
    }

    OFVector(const OFVector& other) : values_(NULL), allocated_(0), size_(0)
    {
        reserve(other.size());
        for (const_iterator it = other.begin(); it != other.end(); ++it)
            push_back(*it);
    }

    explicit OFVector(size_type n, const T& v = T()) : values_(NULL), allocated_(0), size_(0)
    {
        if (n > 0)
            resize(n, v);
        else
            // Make sure that values_ never is a NULL pointer
            reserve(0);
    }

    OFVector(const_iterator from, const_iterator to) : values_(NULL), allocated_(0), size_(0)
    {
        reserve(to - from);
        while (from != to)
            push_back(*(from++));
    }

    ~OFVector()
    {
        delete[] values_;
    }

    OFVector& operator=(const OFVector& other)
    {
        clear();
        reserve(other.size());
        for (const_iterator it = other.begin(); it != other.end(); ++it)
            push_back(*it);
        return *this;
    }

    void swap(OFVector& other)
    {
        T* tmp_val = values_;
        size_type tmp_all = allocated_;
        size_type tmp_size = size_;

        values_ = other.values_;
        allocated_ = other.allocated_;
        size_ = other.size_;

        other.values_ = tmp_val;
        other.allocated_ = tmp_all;
        other.size_ = tmp_size;
    }

    iterator begin() { return &values_[0]; }

    const_iterator begin() const { return &values_[0]; }

    iterator end() { return &values_[size_]; }

    const_iterator end() const { return &values_[size_]; }

    size_type size() const { return size_; }

    OFBool empty() const { return size_ == 0; }

    void clear()
    {
        delete[] values_;
        values_ = NULL;
        size_ = 0;
        allocated_ = 0;
        // We must never have values_ == NULL
        reserve(0);
    }

    void erase(iterator it)
    {
        size_type idx = it - begin();
        for (size_type i = idx + 1; i < size_; i++) {
            values_[i - 1] = values_[i];
        }
        size_--;
    }

    iterator insert(iterator it, const T& v)
    {
        size_type idx = it - begin();
        reserve(size_ + 1);
        if (idx < size_)
            for (size_type i = size_; i > idx; i--) {
                values_[i] = values_[i - 1];
            }
        values_[idx] = v;
        size_++;
        return &values_[idx];
    }

    template<class InputIterator>
    void insert(iterator it, InputIterator from, InputIterator to)
    {
        while (from != to)
        {
            it = insert(it, *from);
            it++;
            from++;
        }
    }

    void push_back(const T& v)
    {
        insert(end(), v);
    }

    void pop_back()
    {
        erase(end() - 1);
    }

    T& operator[](size_type i)
    {
        return values_[i];
    }

    const T& operator[](size_type i) const
    {
        return values_[i];
    }

    T& at(size_type i)
    {
        assert(i < size_);
        return (*this)[i];
    }

    const T& at(size_type i) const
    {
        assert(i < size_);
        return (*this)[i];
    }

    void resize(size_type n, T v = T())
    {
        if (n > size_)
        {
            reserve(n);
            // Set up the new elements
            for (size_t i = size_; i < n; i++)
                values_[i] = v;
        }
        size_ = n;
    }

    void reserve(size_type n)
    {
        T* old_values = values_;
        T* new_values;

        if (n == 0)
            n = 1;
        if (n <= allocated_)
            return;

        // While we are at it, let's reserve some extra space
        n += 10;

        new_values = new T[n];
        if (old_values)
        {
            for (size_type i = 0; i < size_; i++)
                new_values[i] = old_values[i];
            delete[] old_values;
        }

        values_ = new_values;
        allocated_ = n;
    }
};

#endif

#endif


/*
 * CVS/RCS Log:
 * $Log: ofvector.h,v $
 * Revision 1.3  2010-10-14 13:15:51  joergr
 * Updated copyright header. Added reference to COPYRIGHT file.
 *
 * Revision 1.2  2010-10-08 13:25:33  uli
 * Implement OFVector.
 *
 * Revision 1.1  2010-04-26 11:57:35  joergr
 * Added initial definitions for using the STL vector class. Please note that
 * there is currently no alternative implementation to this standard class.
 *
 *
 */

---

Generated on 6 Jan 2011 for OFFIS DCMTK Version 3.6.0 by Doxygen 1.5.1