#ifndef VP_INTEGER_MAP_H_14112001
#define VP_INTEGER_MAP_H_14112001

#include <vector>
#include <cstdlib>
#include <memory>

#include <boost/property_map.hpp>

namespace boost {

    /** Implements [0, max_int] -> T mapping. What is implemented is 
        conceptually what is said. It is mapping from all the integers to
        T, where mapped value is initially T(). It does not conforms to
        any of SGI STL concepts.
    */
    template<class T, class A = std::allocator<T> >
    class integer_map {
    public:
        // All but one of Container typedef are not defined.
        typedef typename std::vector<T, A>::size_type size_type;
        // Associative Container has not much do offer, too.
        typedef typename std::vector<T, A>::size_type key_type;
        // Pair Associative Container -- likewise.
        typedef T data_type;

                
        data_type& operator[](key_type k);
        const data_type& operator[](key_type k) const;                

        void swap(integer_map& other);
    private:
        mutable std::vector<T> data;        
    };

    template<class T, class A>
    class property_traits< integer_map<T, A> > {
        typedef T value_type;
        // Is it OK? Seems like property_map concept don't support
        // const/nonconst [].
        typedef const T& reference;
        typedef typename integer_map<T, A>::key_type key_type;
        typedef lvalue_property_map_tag category;
    };

    template<class T, class A>
    integer_map<T, A>::data_type&
    integer_map<T, A>::operator[](key_type k)
    {
        if (k >= data.size())
            data.resize(std::max(data.size()*2, k+1));
        return data[k];
    }

    template<class T, class A>
    const integer_map<T, A>::data_type&
    integer_map<T, A>::operator[](key_type k) const
    {
        if (k >= data.size())
            data.resize(std::max(data.size()*2, k+1));
        return data[k];
    }
    
    template<class T, class A>
    void 
    integer_map<T, A>::swap(integer_map& other)
    {
        this->data.swap(other.data);
    }

    template<class T, class A>
    typename property_traits< integer_map<T, A> >::reference
    get(const integer_map<T, A>& pmap, 
        typename integer_map<T, A>::key_type key)
    {
        return pmap[key];
    }

    template<class T, class A>
    void
    put(integer_map<T, A>& pmap, 
        typename integer_map<T, A>::key_type key,
        const typename integer_map<T, A>::data_type& value)
    {
        pmap[key] = value;
    }

}

#endif