stl_bids.h

Go to the documentation of this file.

// This is the STL wrapper for classlib/arrays.h from Borland's web site
// It has been modified to be compatible with vc++ (Paul Branann 5/7/98)
 
#pragma once
 
#ifdef _MSC_VER
#pragma warning(disable: 4786)
#endif
 
// #include <vector.h>
// #include <algo.h>
#include <vector>
#include <algorithm>
//#include <limits.h>
using namespace std;
 
template <class T>
class TArrayAsVector : public vector<T> {
private:
    const unsigned int growable;
    typedef size_t size_type;
    typedef typename vector<T>::const_iterator const_iterator;
    const size_type lowerbound;
public:
    TArrayAsVector(size_type upper,
        size_type lower = 0,
        int delta = 0) :
    vector<T>( ),
        growable(delta),
        lowerbound(lower)
    { vector<T>::reserve(upper-lower + 1);}
 
    ~TArrayAsVector( )
    { // This call is unnecessary?  (Paul Brannan 5/7/98)
        // vector<T>::~vector( );
    }
 
    int Add(const T& item)
    { if(!growable && vector<T>::size( ) == vector<T>::capacity( ))
    return 0;
    else
        vector<T>::insert(vector<T>::end( ), item);
    return 1; }
 
    int AddAt(const T& item, size_type index)
    { if(!growable &&
    ((vector<T>::size( ) == vector<T>::capacity( )) ||
    (ZeroBase(index > vector<T>::capacity( )) )))
    return 0;
    if(ZeroBase(index) > vector<T>::capacity( )) // out of bounds
    { vector<T>::insert(vector<T>::end( ),
    ZeroBase(index) - vector<T>::size( ), T( ));
    vector<T>::insert(vector<T>::end( ), item); }
    else
    { vector<T>::insert(vector<T>::begin( ) + ZeroBase(index), item); }
    return 1;
    }
 
    size_type ArraySize( )
    { return vector<T>::capacity( ); }
 
    size_type BoundBase(size_type location) const
    { if(location == UINT_MAX)
    return INT_MAX;
    else
        return location + lowerbound; }
    void Detach(size_type index)
    { vector<T>::erase(vector<T>::begin( ) + ZeroBase(index)); }
 
    void Detach(const T& item)
    { Destroy(Find(item)); }
 
    void Destroy(size_type index)
    { vector<T>::erase(vector<T>::begin( ) + ZeroBase(index)); }
 
    void Destroy(const T& item)
    { Destroy(Find(item)); }
 
    size_type Find(const T& item) const
    { const_iterator location = find(vector<T>::begin( ),
    vector<T>::end( ), item);
    if(location != vector<T>::end( ))
        return BoundBase(size_type(location -
        vector<T>::begin( )));
    else
        return INT_MAX; }
 
    size_type GetItemsInContainer( )
    { return vector<T>::size( ); }
 
    void Grow(size_type index)
    { if( index < lowerbound )
    Reallocate(ArraySize( ) + (index -
    lowerbound));
    else if( index >= BoundBase(vector<T>::size( )))
        Reallocate(ZeroBase(index) ); }
 
    int HasMember(const T& item)
    { if(Find(item) != INT_MAX)
    return 1;
    else
        return 0; }
 
    int IsEmpty( )
    { return vector<T>::empty( ); }
 
    int IsFull( )
    { if(growable)
    return 0;
    if(vector<T>::size( ) == vector<T>::capacity( ))
        return 1;
    else
        return 0; }
 
    size_type LowerBound( )
    { return lowerbound; }
 
    T& operator[] (size_type index)
    { return vector<T>::
	operator[](ZeroBase(index)); }
 
    const T& operator[] (size_type index) const
    { return vector<T>::
	operator[](ZeroBase(index)); }
 
    void Flush( )
    {
        vector<T>::clear();
    }
 
    void Reallocate(size_type sz,
        size_type offset = 0)
    { if(offset)
    vector<T>::insert(vector<T>::begin( ), offset, T( ));
    vector<T>::reserve(sz);
    vector<T>::erase(vector<T>::end( ) - offset, vector<T>::end( )); }
 
    void RemoveEntry(size_type index)
    { Detach(index); }
 
    void SetData(size_type index, const T& item)
    { (*this)[index] = item; }
 
    size_type UpperBound( )
    { return BoundBase(vector<T>::capacity( )) - 1; }
 
    size_type ZeroBase(size_type index) const
    { return index - lowerbound; }
 
    // The assignment operator is not inherited (Paul Brannan 5/25/98)
    TArrayAsVector& operator=(const TArrayAsVector& v) {
        vector<T>::operator=(v);
        // should growable and lowerbound be copied as well?
        return *this;
    }
 
};