BCP_vector.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef _BCP_VECTOR_GENERAL_H
#define _BCP_VECTOR_GENERAL_H

// This file is fully docified.


#include <memory>
#include <cstddef>
#include <cstring>

template <class T> class BCP_vec {
public:
        typedef size_t size_type;
        typedef T value_type;
        typedef T* iterator;
        typedef const T* const_iterator;
        typedef T& reference;
        typedef const T& const_reference;
private:
        inline void destroy(iterator pos);
        inline void destroy_range(iterator first, iterator last);
        inline void construct(iterator pos);
        inline void construct(iterator pos, const_reference x);

protected:
        inline iterator allocate(size_t len);
        inline void deallocate();
        void insert_aux(iterator position, const_reference x);
protected:
        iterator start;
        iterator finish;
        iterator end_of_storage;
public:
        BCP_vec();
        BCP_vec(const BCP_vec<T>& x);
        BCP_vec(const size_t n, const_reference value = T());
        BCP_vec(const_iterator first, const_iterator last);
        BCP_vec(const T* x, const size_t num);
        virtual ~BCP_vec() { deallocate(); }
        iterator begin()                           { return start; }
        const_iterator begin() const               { return start; }

        iterator end()                             { return finish; }
        const_iterator end() const                 { return finish; }

        iterator entry(const int i)                { return start + i; }
        const_iterator entry(const int i) const    { return start + i; }

        size_t index(const_iterator pos) const     { return size_t(pos - start); }
        size_t size() const                        { return finish - start; }
        size_t capacity() const                    { return end_of_storage - start;}
        bool empty() const                         { return start == finish; }

        reference operator[](const size_t i)       { return *(start + i); }
        const_reference operator[](const size_t i) const { return *(start + i); }

        reference front()                          { return *start; }
        const_reference front() const              { return *start; }
        reference back()                           { return *(finish - 1); }
        const_reference back() const               { return *(finish - 1); }
        void reserve(const size_t n);
        inline void swap(BCP_vec<T>& x);

        BCP_vec<T>& operator=(const BCP_vec<T>& x);

        void assign(const void* x, const size_t num);
        void insert(iterator position, const void* first, const size_t num);
   
        void insert(iterator position, const_iterator first, const_iterator last);
        void insert(iterator position, const size_t n, const_reference x);
        iterator insert(iterator position, const_reference x);

        void append(const BCP_vec<T>& x) {
                insert(end(), x.begin(), x.end()); }
        void append(const_iterator first, const_iterator last) {
                insert(end(), first, last); }

        inline void push_back(const_reference x);
        inline void unchecked_push_back(const_reference x);
        inline void pop_back();

        inline void clear();

        inline void update(const BCP_vec<int>& positions,
                                           const BCP_vec<T>& values);
        inline void unchecked_update(const BCP_vec<int>& positions,
                                                                 const BCP_vec<T>& values);

        //--------------------------------------------------------------------------

        inline void keep(iterator pos);
        inline void keep(iterator first, iterator last);
        inline void keep_by_index(const BCP_vec<int>& positions);
        inline void unchecked_keep_by_index(const BCP_vec<int>& positions);
        inline void keep_by_index(const int * firstpos, const int * lastpos);
        void unchecked_keep_by_index(const int * firstpos, const int * lastpos);
        //-------------------------------------------------------------------------

        inline void erase(iterator pos);
        inline void erase(iterator first, iterator last);
        inline void erase_by_index(const BCP_vec<int>& positions);
        inline void unchecked_erase_by_index(const BCP_vec<int>& positions);
        inline void erase_by_index(const int * firstpos, const int * lastpos);
        void unchecked_erase_by_index(const int * firstpos, const int * lastpos);
};

//##############################################################################

template <class T>
bool operator==(const BCP_vec<T>& x, const BCP_vec<T>& y)
{
        return x.size() == y.size() && equal(x.begin(), x.end(), y.begin());
}

template <class T>
bool operator< (BCP_vec<T>& x, BCP_vec<T>& y)
{
        return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
}

//#############################################################################

template <class T> void purge_ptr_vector(BCP_vec<T*>& pvec,
                                                                                 typename BCP_vec<T*>::iterator first,
                                                                                 typename BCP_vec<T*>::iterator last)
{
        typename BCP_vec<T*>::iterator origfirst = first;
        while (first != last) {
                delete *first;
                *first = 0;
                ++first;
        }
        pvec.erase(origfirst, last);
}


template <class T> void purge_ptr_vector(BCP_vec<T*>& pvec)
{
        purge_ptr_vector(pvec, pvec.begin(), pvec.end());
}


template <class T>
void purge_ptr_vector_by_index(BCP_vec<T*>& pvec,
                                                           typename BCP_vec<int>::const_iterator first,
                                                           typename BCP_vec<int>::const_iterator last)
{
        BCP_vec<int>::const_iterator origfirst = first;
        while (first != last) {
                delete pvec[*first];
                pvec[*first] = 0;
                ++first;
        }
        pvec.erase_by_index(origfirst, last);
}


template <class T>
void keep_ptr_vector_by_index(BCP_vec<T*>& pvec,
                                                          typename BCP_vec<int>::const_iterator first,
                                                          typename BCP_vec<int>::const_iterator last)
{
        BCP_vec<int>::const_iterator origfirst = first;
        const int pvec_size = pvec.size();
        int i;

        for (i = 0;  i < pvec_size && first != last; ++i) {
                if (i != *first) {
                        delete pvec[i];
                        pvec[i] = 0;
                } else {
                        ++first;
                }
        }

        for ( ; i < pvec_size; ++i) {
                delete pvec[i];
                pvec[i] = 0;
        }
        pvec.keep_by_index(origfirst, last);
}

/* Now include the implementation of the methods so the compiler could
   instantiate any requested vector class */

#include <algorithm>

#include "BCP_vector_sanity.hpp"
#include "BCP_error.hpp"

#include "BCP_vector_bool.hpp"
#include "BCP_vector_char.hpp"
#include "BCP_vector_short.hpp"
#include "BCP_vector_int.hpp"
#include "BCP_vector_double.hpp"

#include "BCP_vector_general.hpp"

#endif