windows-xp/Source/XPSP1/NT/net/config/inc/stlmap.h

#pragma once
#ifndef _STLMAP_H_
#define _STLMAP_H_
//#include <functional>
//#include <xtree>

#include <stlfunc.h>
#include <stlxtree.h>
#include <stlxutil.h>

#ifdef  _MSC_VER
#pragma pack(push,8)
#endif  /* _MSC_VER */

_STD_BEGIN

// TEMPLATE CLASS map
template<class _K, class _Ty, class _Pr = less<_K>, class _A = allocator<_Ty> >
class map
{
public:
    typedef map<_K, _Ty, _Pr, _A> _Myt;
    typedef pair<const _K, _Ty> value_type;
    struct _Kfn : public unary_function<value_type, _K>
    {
        const _K& operator()(const value_type& _X) const
        {
            return (_X.first);
        }
    };
    class value_compare
    : public binary_function<value_type, value_type, bool>
    {
        friend class map<_K, _Ty, _Pr, _A>;
    public:
        bool operator()(const value_type& _X,
                        const value_type& _Y) const
        {
            return (comp(_X.first, _Y.first));
        }
        _PROTECTED:
        value_compare(_Pr _Pred)
        : comp(_Pred)
        {

        }
        _Pr comp;
    };
    typedef _K key_type;
    typedef _Ty referent_type;
    typedef _Pr key_compare;
    typedef _A allocator_type;
    typedef _A::reference _Tref;
    typedef _Tree<_K, value_type, _Kfn, _Pr, _A> _Imp;
    typedef _Imp::size_type size_type;
    typedef _Imp::difference_type difference_type;
    typedef _Imp::reference reference;
    typedef _Imp::const_reference const_reference;
    typedef _Imp::iterator iterator;
    typedef _Imp::const_iterator const_iterator;
    typedef _Imp::reverse_iterator reverse_iterator;
    typedef _Imp::const_reverse_iterator const_reverse_iterator;
    typedef pair<iterator, bool> _Pairib;
    typedef pair<iterator, iterator> _Pairii;
    typedef pair<const_iterator, const_iterator> _Paircc;
    explicit map(const _Pr& _Pred = _Pr(), const _A& _Al = _A())
    : _Tr(_Pred, false, _Al)
    {

    }
    typedef const value_type *_It;
    map(_It _F, _It _L, const _Pr& _Pred = _Pr(),
        const _A& _Al = _A())
    : _Tr(_Pred, false, _Al)
    {
        for (; _F != _L; ++_F)
            _Tr.insert(*_F);
    }
    iterator begin()
    {
        return (_Tr.begin());
    }
    const_iterator begin() const
    {
        return (_Tr.begin());
    }
    iterator end()
    {
        return (_Tr.end());
    }
    const_iterator end() const
    {
        return (_Tr.end());
    }
    reverse_iterator rbegin()
    {
        return (_Tr.rbegin());
    }
    const_reverse_iterator rbegin() const
    {
        return (_Tr.rbegin());
    }
    reverse_iterator rend()
    {
        return (_Tr.rend());
    }
    const_reverse_iterator rend() const
    {
        return (_Tr.rend());
    }
    size_type size() const
    {
        return (_Tr.size());
    }
    size_type max_size() const
    {
        return (_Tr.max_size());
    }
    bool empty() const
    {
        return (_Tr.empty());
    }
    _A get_allocator() const
    {
        return (_Tr.get_allocator());
    }
    _Tref operator[](const key_type& _Kv)
    {
        iterator _P = insert(value_type(_Kv, _Ty())).first;
        return ((*_P).second);
    }
    _Pairib insert(const value_type& _X)
    {
        _Imp::_Pairib _Ans = _Tr.insert(_X);
        return (_Pairib(_Ans.first, _Ans.second));
    }
    iterator insert(iterator _P, const value_type& _X)
    {
        return (_Tr.insert((_Imp::iterator&)_P, _X));
    }
    void insert(_It _F, _It _L)
    {
        for (; _F != _L; ++_F)
            _Tr.insert(*_F);
    }
    iterator erase(iterator _P)
    {
        return (_Tr.erase((_Imp::iterator&)_P));
    }
    iterator erase(iterator _F, iterator _L)
    {
        return (_Tr.erase((_Imp::iterator&)_F,
                          (_Imp::iterator&)_L));
    }
    size_type erase(const _K& _Kv)
    {
        return (_Tr.erase(_Kv));
    }
    void clear()
    {
        _Tr.clear();
    }
    void swap(_Myt& _X)
    {
        std::swap(_Tr, _X._Tr);
    }
    friend void swap(_Myt& _X, _Myt& _Y)
    {
        _X.swap(_Y);
    }
    key_compare key_comp() const
    {
        return (_Tr.key_comp());
    }
    value_compare value_comp() const
    {
        return (value_compare(_Tr.key_comp()));
    }
    iterator find(const _K& _Kv)
    {
        return (_Tr.find(_Kv));
    }
    const_iterator find(const _K& _Kv) const
    {
        return (_Tr.find(_Kv));
    }
    size_type count(const _K& _Kv) const
    {
        return (_Tr.count(_Kv));
    }
    iterator lower_bound(const _K& _Kv)
    {
        return (_Tr.lower_bound(_Kv));
    }
    const_iterator lower_bound(const _K& _Kv) const
    {
        return (_Tr.lower_bound(_Kv));
    }
    iterator upper_bound(const _K& _Kv)
    {
        return (_Tr.upper_bound(_Kv));
    }
    const_iterator upper_bound(const _K& _Kv) const
    {
        return (_Tr.upper_bound(_Kv));
    }
    _Pairii equal_range(const _K& _Kv)
    {
        return (_Tr.equal_range(_Kv));
    }
    _Paircc equal_range(const _K& _Kv) const
    {
        return (_Tr.equal_range(_Kv));
    }
protected:
    _Imp _Tr;
};
// map TEMPLATE OPERATORS
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator==(const map<_K, _Ty, _Pr, _A>& _X,
                const map<_K, _Ty, _Pr, _A>& _Y)
{
    return (_X.size() == _Y.size()
            && equal(_X.begin(), _X.end(), _Y.begin()));
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator!=(const map<_K, _Ty, _Pr, _A>& _X,
                const map<_K, _Ty, _Pr, _A>& _Y)
{
    return (!(_X == _Y));
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator<(const map<_K, _Ty, _Pr, _A>& _X,
               const map<_K, _Ty, _Pr, _A>& _Y)
{
    return (lexicographical_compare(_X.begin(), _X.end(),
                                    _Y.begin(), _Y.end()));
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator>(const map<_K, _Ty, _Pr, _A>& _X,
               const map<_K, _Ty, _Pr, _A>& _Y)
{
    return (_Y < _X);
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator<=(const map<_K, _Ty, _Pr, _A>& _X,
                const map<_K, _Ty, _Pr, _A>& _Y)
{
    return (!(_Y < _X));
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator>=(const map<_K, _Ty, _Pr, _A>& _X,
                const map<_K, _Ty, _Pr, _A>& _Y)
{
    return (!(_X < _Y));
}
// TEMPLATE CLASS multimap
template<class _K, class _Ty, class _Pr = less<_K>,
class _A = allocator<_Ty> >
class multimap
{
public:
    typedef multimap<_K, _Ty, _Pr, _A> _Myt;
    typedef pair<const _K, _Ty> value_type;
    struct _Kfn : public unary_function<value_type, _K>
    {
        const _K& operator()(const value_type& _X) const
        {
            return (_X.first);
        }
    };
    class value_compare
    : public binary_function<value_type, value_type, bool>
    {
        friend class map<_K, _Ty, _Pr, _A>;
    public:
        bool operator()(const value_type& _X,
                        const value_type& _Y) const
        {
            return (comp(_X.first, _Y.first));
        }
        _PROTECTED:
        value_compare(_Pr _Pred)
        : comp(_Pred)
        {

        }
        _Pr comp;
    };
    typedef _K key_type;
    typedef _Ty referent_type;
    typedef _Pr key_compare;
    typedef _A allocator_type;
    typedef _Tree<_K, value_type, _Kfn, _Pr, _A> _Imp;
    typedef _Imp::size_type size_type;
    typedef _Imp::difference_type difference_type;
    typedef _Imp::reference reference;
    typedef _Imp::const_reference const_reference;
    typedef _Imp::iterator iterator;
    typedef _Imp::const_iterator const_iterator;
    typedef _Imp::reverse_iterator reverse_iterator;
    typedef _Imp::const_reverse_iterator const_reverse_iterator;
    typedef pair<iterator, iterator> _Pairii;
    typedef pair<const_iterator, const_iterator> _Paircc;
    explicit multimap(const _Pr& _Pred = _Pr(),
                      const _A& _Al = _A())
    : _Tr(_Pred, true, _Al)
    {

    }
    typedef const value_type *_It;
    multimap(_It _F, _It _L, const _Pr& _Pred = _Pr(),
             const _A& _Al = _A())
    : _Tr(_Pred, true, _Al)
    {
        for (; _F != _L; ++_F)
            _Tr.insert(*_F);
    }
    iterator begin()
    {
        return (_Tr.begin());
    }
    const_iterator begin() const
    {
        return (_Tr.begin());
    }
    iterator end()
    {
        return (_Tr.end());
    }
    const_iterator end() const
    {
        return (_Tr.end());
    }
    reverse_iterator rbegin()
    {
        return (_Tr.rbegin());
    }
    const_reverse_iterator rbegin() const
    {
        return (_Tr.rbegin());
    }
    reverse_iterator rend()
    {
        return (_Tr.rend());
    }
    const_reverse_iterator rend() const
    {
        return (_Tr.rend());
    }
    size_type size() const
    {
        return (_Tr.size());
    }
    size_type max_size() const
    {
        return (_Tr.max_size());
    }
    bool empty() const
    {
        return (_Tr.empty());
    }
    _A get_allocator() const
    {
        return (_Tr.get_allocator());
    }
    iterator insert(const value_type& _X)
    {
        return (_Tr.insert(_X).first);
    }
    iterator insert(iterator _P, const value_type& _X)
    {
        return (_Tr.insert((_Imp::iterator&)_P, _X));
    }
    void insert(_It _F, _It _L)
    {
        for (; _F != _L; ++_F)
            _Tr.insert(*_F);
    }
    iterator erase(iterator _P)
    {
        return (_Tr.erase((_Imp::iterator&)_P));
    }
    iterator erase(iterator _F, iterator _L)
    {
        return (_Tr.erase((_Imp::iterator&)_F,
                          (_Imp::iterator&)_L));
    }
    size_type erase(const _K& _Kv = _K())
    {
        return (_Tr.erase(_Kv));
    }
    void clear()
    {
        _Tr.clear();
    }
    void swap(_Myt& _X)
    {
        std::swap(_Tr, _X._Tr);
    }
    friend void swap(_Myt& _X, _Myt& _Y)
    {
        _X.swap(_Y);
    }
    key_compare key_comp() const
    {
        return (_Tr.key_comp());
    }
    value_compare value_comp() const
    {
        return (value_compare(_Tr.key_comp()));
    }
    iterator find(const _K& _Kv)
    {
        return (_Tr.find(_Kv));
    }
    const_iterator find(const _K& _Kv) const
    {
        return (_Tr.find(_Kv));
    }
    size_type count(const _K& _Kv) const
    {
        return (_Tr.count(_Kv));
    }
    iterator lower_bound(const _K& _Kv)
    {
        return (_Tr.lower_bound(_Kv));
    }
    const_iterator lower_bound(const _K& _Kv) const
    {
        return (_Tr.lower_bound(_Kv));
    }
    iterator upper_bound(const _K& _Kv)
    {
        return (_Tr.upper_bound(_Kv));
    }
    const_iterator upper_bound(const _K& _Kv) const
    {
        return (_Tr.upper_bound(_Kv));
    }
    _Pairii equal_range(const _K& _Kv)
    {
        return (_Tr.equal_range(_Kv));
    }
    _Paircc equal_range(const _K& _Kv) const
    {
        return (_Tr.equal_range(_Kv));
    }
protected:
    _Imp _Tr;
};
// multimap TEMPLATE OPERATORS
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator==(const multimap<_K, _Ty, _Pr, _A>& _X,
                const multimap<_K, _Ty, _Pr, _A>& _Y)
{
    return (_X.size() == _Y.size()
            && equal(_X.begin(), _X.end(), _Y.begin()));
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator!=(const multimap<_K, _Ty, _Pr, _A>& _X,
                const multimap<_K, _Ty, _Pr, _A>& _Y)
{
    return (!(_X == _Y));
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator<(const multimap<_K, _Ty, _Pr, _A>& _X,
               const multimap<_K, _Ty, _Pr, _A>& _Y)
{
    return (lexicographical_compare(_X.begin(), _X.end(),
                                    _Y.begin(), _Y.end()));
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator>(const multimap<_K, _Ty, _Pr, _A>& _X,
               const multimap<_K, _Ty, _Pr, _A>& _Y)
{
    return (_Y < _X);
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator<=(const multimap<_K, _Ty, _Pr, _A>& _X,
                const multimap<_K, _Ty, _Pr, _A>& _Y)
{
    return (!(_Y < _X));
}
template<class _K, class _Ty, class _Pr, class _A> inline
bool operator>=(const multimap<_K, _Ty, _Pr, _A>& _X,
                const multimap<_K, _Ty, _Pr, _A>& _Y)
{
    return (!(_X < _Y));
}

_STD_END

#ifdef  _MSC_VER
#pragma pack(pop)
#endif  /* _MSC_VER */

#endif /* _STLMAP_H_ */

/*
 * Copyright (c) 1995 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
 */

/*
 * This file is derived from software bearing the following
 * restrictions:
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this
 * software and its documentation for any purpose is hereby
 * granted without fee, provided that the above copyright notice
 * appear in all copies and that both that copyright notice and
 * this permission notice appear in supporting documentation.
 * Hewlett-Packard Company makes no representations about the
 * suitability of this software for any purpose. It is provided
 * "as is" without express or implied warranty.
 */