---

oscl_map.h

Go to the documentation of this file.

// -*- c++ -*-
// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

//                     O S C L _ M A P

// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

#ifndef OSCL_MAP_H_INCLUDED
#define OSCL_MAP_H_INCLUDED

#ifndef OSCL_BASE_H_INCLUDED
#include "oscl_base.h"
#endif

#ifndef OSCL_TREE_H_INCLUDED
#include "oscl_tree.h"
#endif

#define OSCL_DISABLE_WARNING_TRUNCATE_DEBUG_MESSAGE
#include "osclconfig_compiler_warnings.h"

template <class T>
struct Oscl_Less
{
    bool operator()(const T& x, const T& y) const
    {
        return x < y ? true : false ;
    }
};

template <class V, class U>
struct Oscl_Select1st
{
    const U& operator()(const V& x) const
    {
        return x.first;
    }
};

template < class Key, class T, class Alloc, class Compare = Oscl_Less<Key> >
class Oscl_Map
{

    public:
        typedef Key key_type;
        typedef Compare key_compare;
        typedef Oscl_Pair<const Key, T> value_type;
        typedef Oscl_Map<Key, T, Alloc, Compare> self;

    private:
        typedef Oscl_Rb_Tree < key_type, value_type,
        Oscl_Select1st<value_type, key_type>,
        key_compare, Alloc > rep_type;
        rep_type t;  // red-black tree representing map

    public:
        typedef typename rep_type::pointer pointer;
        typedef typename rep_type::reference reference;
        typedef typename rep_type::const_reference const_reference;
        typedef typename rep_type::iterator iterator;
        typedef typename rep_type::const_iterator const_iterator;
        typedef typename rep_type::size_type size_type;

        class value_compare
        {
                friend class Oscl_Map<Key, T, Alloc, Compare>;
            protected :
                Compare comp;
                value_compare(Compare c) : comp(c) {}
            public:
                bool operator()(const value_type& x, const value_type& y) const
                {
                    return comp(x.first, y.first);
                }
        };

    public:

        Oscl_Map(const Compare& comp = Compare()) : t(comp) {}
//    Oscl_Map(const value_type* first, const value_type* last,
//        const Compare& comp = Compare()) : t(first, last, comp, false) {}

        Oscl_Map(const self& x) : t(x.t) {}
        self& operator=(const self& x)
        {
            t = x.t;
            return *this;
        }
        key_compare key_comp() const
        {
            return t.key_comp();
        }
        value_compare value_comp() const
        {
            return value_compare(t.key_comp());
        }
        iterator begin()
        {
            return t.begin();
        }
        const_iterator begin() const
        {
            return t.begin();
        }
        iterator end()
        {
            return t.end();
        }
        const_iterator end() const
        {
            return t.end();
        }
        bool empty() const
        {
            return t.empty();
        }
        size_type size() const
        {
            return t.size();
        }
        size_type max_size() const
        {
            return t.max_size();
        }
        T& operator[](const key_type& k)
        {
            return (*((insert(value_type(k, T()))).first)).second;
        }
//    void swap(map<Key, T, Compare>& x) { t.swap(x.t); }


        typedef Oscl_Pair<iterator, bool> pair_iterator_bool;
        pair_iterator_bool insert(const value_type& x)
        {
            return t.insert_unique(x);
        }
        iterator insert(iterator position, const value_type& x)
        {
            return t.insert_unique(position, x);
        }
        void insert(const value_type* first, const value_type* last)
        {
            t.insert_unique(first, last);
        }
        void erase(iterator position)
        {
            t.erase(position);
        }
        size_type erase(const key_type& x)
        {
            return t.erase(x);
        }
        void erase(iterator first, iterator last)
        {
            t.erase(first, last);
        }
        void clear()
        {
            t.clear();
        }
        iterator find(const key_type& x)
        {
            return t.find(x);
        }
        const_iterator find(const key_type& x) const
        {
            return t.find(x);
        }
        size_type count(const key_type& x) const
        {
            return t.count(x);
        }
        iterator lower_bound(const key_type& x)
        {
            return t.lower_bound(x);
        }
        const_iterator lower_bound(const key_type& x) const
        {
            return t.lower_bound(x);
        }
        iterator upper_bound(const key_type& x)
        {
            return t.upper_bound(x);
        }
        const_iterator upper_bound(const key_type& x) const
        {
            return t.upper_bound(x);
        }
        typedef Oscl_Pair<iterator, iterator> pair_iterator_iterator;
        pair_iterator_iterator equal_range(const key_type& x)
        {
            return t.equal_range(x);
        }
        typedef Oscl_Pair<const_iterator, const_iterator> pair_citerator_citerator;
        pair_citerator_citerator equal_range(const key_type& x) const
        {
            return t.equal_range(x);
        }

    private:

};

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

//template <class Key, class T, class Compare>
//inline bool operator<(const map<Key, T, Compare>& x,
//                      const map<Key, T, Compare>& y) {
//    return lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
//}


#endif

---