tvector.h

#ifndef _tvector_h
#define _tvector_h

#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
#include <iostream>
#include <cstdlib> /* abort() */
#ifndef _COREDEBUG_STR
#define _COREDEBUG_STR "To debug the core, use this command:\n"\
"    gdb -c core /path/to/executable             (gdb) bt"
#endif
#endif

template <class T>
class tvector
{
public:
    typedef T* iterator;

    typedef const T* const_iterator;

private:
    T* x;
    unsigned max;
    unsigned n;

public:
    tvector() {
        x = 0;
        max = 0;
        n = 0;
    }

    tvector(unsigned n) {
//      if(n < 0)
//          n = 0;
        this->n = max = n;
        if(n > 0) {
            x = new T[n];
            fill(begin(), begin() + n, T());
        } else {
            x = 0;
        }
    }

    tvector(unsigned n, const T& value);

    tvector(const tvector& a) {
        n = max = a.n;
        if(n > 0) {
            x = new T[n];
            a.copyInto(x);
        } else {
            x = 0;
        }
    }

    ~tvector() {
       if(x != 0) {
            delete [] x;
       }
    }

    unsigned size() const {
        return n;
    }

    unsigned capacity() const {
        return max;
    }

    operator T*() {
        return x;
    }

    operator const T*() const {
        return x;
    }

    tvector& operator =(const tvector& a) {
        if(n != a.n) {
            resize_nofill(a.n);
        }
        a.copyInto(x);
        return *this;
    }

    void clear() {
        delete[] x;
        x = 0;
        n = max = 0;
    }

    void erase(iterator first) {
        erase(first, first + 1);
    }

    void erase(iterator first, iterator last);

    void erase(const T& x);

    void resize(unsigned n) {
        resize(n, T());
    }

    void resize(unsigned n, const T& value) {
        unsigned prev = this->n;
        resize_nofill(n);
        if(this->n > prev) {
            fill(begin() + prev, begin() + this->n, value);
        }
    }

    void insert(iterator p, const T& value);

    void insert(iterator p, const T* first, const T* last);

    void push_back(const T& value) {
        if(n < max) {
            x[n++] = value;
        } else {
            resize_nofill(n + 1);
            x[n - 1] = value;
        }
    }

    void pop_back() {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(n == 0) {
            std::cerr << "Fatal error: pop_back() called for empty tvector\n"
                 _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        --n;
    }

    T& operator [](int k) {
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(k < 0 || k >= (int)n) {
            std::cerr << "Fatal error: tvector index " << k
                 << " out of range [0, "
                 << n << "[\n" _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
        return x[k];
    }

// method commented out because of gcc 3.3.3 compilation error:
// In member function `virtual gromit::TwoBodyInter*
// gromit_interactions_impl::CollisionTableImp::getInteraction(int, int) const':
// error: ISO C++ says that `const T& tvector<T>::operator[](int) const [with
// T = gromit::TwoBodyInter*]' and `operator[]' are ambiguous even though the
// worst conversion for the former is better than the worst conversion for the
// latter (06/22/2004 cspeter)
//    /** Gets the kth element. */
//    const T& operator [](int k) const {
//#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
//      if(k < 0 || k >= (int)n) {
//          std::cerr << "Fatal error: tvector index " << k
//               << " out of range [0, "
//               << n << "[\n" << _COREDEBUG_STR << std::endl;
//          ::abort();
//      }
//#endif
//      return x[k];
//    }

    T& front() {
        return *begin();
    }

    const T& front() const {
        return *begin();
    }

    T& back() {
        return *(end() - 1);
    }

    const T& back() const {
        return *(end() - 1);
    }

    iterator begin() {
        return x;
    }

    const_iterator begin() const {
        return x;
    }

    iterator end() {
        return x+n;
    }

    const_iterator end() const {
        return x+n;
    }

    void sort();

private:
    void resize_nofill(unsigned _n);

    void copyInto(T* y) const {
        for(unsigned i = 0; i < n; ++i) {
            y[i] = x[i];
        }
    }

    void fill(iterator begin, iterator end, const T& value);

    void sort(int lo, int hi);
};

template <class T> tvector<T>::tvector(unsigned _n, const T& value)
{
//    if(_n < 0)
//      _n = 0;
    n = max = _n;
    if(n > 0) {
        x = new T[n];
        fill(begin(), begin() + n, value);
    } else {
        x = 0;
    }
}

template <class T> void tvector<T>::erase(iterator first, iterator last)
{
    int d = last - first;
    if(d <= 0) {
        return;
    }
    for(unsigned i = last - x; i < n; ++i) {
        x[i - d] = x[i];
    }
    n -= d;
}

template <class T> void tvector<T>::erase(const T& v)
{
    for(int i = n - 1; i >= 0; --i) {
        if(x[i] == v) {
            erase(begin() + i);
        }
    }
}
 
template <class T> void tvector<T>::insert(iterator p, const T& value)
{
    unsigned k = p - x;
    if(n < max) {
        for(unsigned i = n; i > k; --i) {
            x[i] = x[i - 1];
        }
        x[k] = value;
    } else {
        max = 2*(n + 1);
        T* y = new T[max];
        for(unsigned i = 0; i < k; ++i) {
            y[i] = x[i];
        }
        for(unsigned i = k; i < n; ++i) {
            y[i + 1] = x[i];
        }
        y[k] = value;
        delete [] x;
        x = y;
    }
    ++n;
}
 
template <class T> void tvector<T>::insert(iterator p,
                                           const T* first, const T* last)
{
    int delta = last - first + 1;
#if defined(DEBUG) || defined(ARRAY_BOUNDS_CHECK)
        if(delta < 1) {
            std::cerr << "Fatal error: cannot insert zero or less elements "
                    "into tvector\n"
                 _COREDEBUG_STR << std::endl;
            ::abort();
        }
#endif
    int k = p - x;
    int k_plus_delta = k + delta;
    if(n + delta <= max) {
        for(int i = n - 1; i >= k; --i) {
            x[i + delta] = x[i];
        }
        for(int i = k; i < k_plus_delta; ++i) {
            x[i] = *(first++);
        }
    } else {
        max = 2*(n + delta);
        T* y = new T[max];
        for(int i = 0; i < k; ++i) {
            y[i] = x[i];
        }
        for(int i = n - 1; i >= k; --i) {
            y[i + delta] = x[i];
        }
        for(int i = k; i < k_plus_delta; ++i) {
            y[i] = *(first++);
        }
        delete [] x;
        x = y;
    }
    n += delta;
}

template <class T> void tvector<T>::resize_nofill(unsigned _n)
{
//    if(_n < 0) {
//      n = 0;
//    } else
    if(_n <= max) {
        n = _n;
    } else {
        for(max = 1; max < _n; max <<= 1);
        T* y = new T[max];
        copyInto(y);
        delete [] x;
        x = y;
        n = _n;
    }
}

template <class T> void tvector<T>::fill(iterator p, iterator end, const T& val)
{
    while(p != end) {
        *(p++) = val;
    }
}

// quicksort the contend of the vector, T must define operator <
template <class T> void tvector<T>::sort()
{
    sort(0, n-1);
}

// quicksort the contend of the vector, T must define operator <
template <class T> void tvector<T>::sort(int lo, int hi)
{
    if(lo>=hi) return;
    T ref= x[(lo+hi)/2];
    int left= lo, right= hi;
    while(left <= right) {
        while(left < hi && x[left] < ref) left++;
        while(right > lo && ref < x[right]) right--;
        if(left < right) {
            T tmp= x[left];
            x[left]= x[right];
            x[right]= tmp;
            left++; right--;
        } else if(left== right) {
            left++; right--;
        }
    }
    sort(lo, right);
    sort(left, hi);
}

#ifdef DEBUG
template <class T>
inline std::ostream& operator <<(std::ostream& out, const tvector<T>& x)
{
    for(unsigned i = 0; i < x.size(); ++i) {
        out << x[i];
        if(i+1 < x.size() ) {
            out << ", ";
        }
    }
    return out;
}
#endif /* DEBUG */

#endif /* _tvector_h */