You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
243 lines
7.4 KiB
243 lines
7.4 KiB
// map standard header
|
|
#pragma once
|
|
#ifndef _MAP_
|
|
#define _MAP_
|
|
#include <xtree>
|
|
|
|
#pragma pack(push,8)
|
|
#pragma warning(push,3)
|
|
_STD_BEGIN
|
|
|
|
// TEMPLATE CLASS _Tmap_traits
|
|
template<class _Kty, // key type
|
|
class _Ty, // mapped type
|
|
class _Pr, // comparator predicate type
|
|
class _Alloc, // actual allocator type (should be value allocator)
|
|
bool _Mfl> // true if multiple equivalent keys are permitted
|
|
class _Tmap_traits
|
|
{ // traits required to make _Tree behave like a map
|
|
public:
|
|
typedef _Kty key_type;
|
|
typedef pair<const _Kty, _Ty> value_type;
|
|
typedef _Pr key_compare;
|
|
typedef typename _Alloc::_TEMPLATE_MEMBER rebind<value_type>::other
|
|
allocator_type;
|
|
typedef _POINTER_X(value_type, allocator_type) _ITptr;
|
|
typedef _REFERENCE_X(value_type, allocator_type) _IReft;
|
|
enum
|
|
{ // make multi parameter visible as an enum constant
|
|
_Multi = _Mfl};
|
|
|
|
_Tmap_traits()
|
|
: comp()
|
|
{ // construct with default comparator
|
|
}
|
|
|
|
_Tmap_traits(_Pr _Parg)
|
|
: comp(_Parg)
|
|
{ // construct with specified comparator
|
|
}
|
|
|
|
class value_compare
|
|
: public binary_function<value_type, value_type, bool>
|
|
{ // functor for comparing two element values
|
|
friend class _Tmap_traits<_Kty, _Ty, _Pr, _Alloc, _Mfl>;
|
|
|
|
public:
|
|
bool operator()(const value_type& _Left,
|
|
const value_type& _Right) const
|
|
{ // test if _Left precedes _Right by comparing just keys
|
|
return (comp(_Left.first, _Right.first));
|
|
}
|
|
|
|
value_compare(key_compare _Pred)
|
|
: comp(_Pred)
|
|
{ // construct with specified predicate
|
|
}
|
|
|
|
protected:
|
|
key_compare comp; // the comparator predicate for keys
|
|
};
|
|
|
|
static const _Kty& _Kfn(const value_type& _Val)
|
|
{ // extract key from element value
|
|
return (_Val.first);
|
|
}
|
|
|
|
_Pr comp; // the comparator predicate for keys
|
|
};
|
|
|
|
// TEMPLATE CLASS map
|
|
template<class _Kty,
|
|
class _Ty,
|
|
class _Pr = less<_Kty>,
|
|
class _Alloc = allocator<pair<const _Kty, _Ty> > >
|
|
class map
|
|
: public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> >
|
|
{ // ordered red-black tree of {key, mapped} values, unique keys
|
|
public:
|
|
typedef map<_Kty, _Ty, _Pr, _Alloc> _Myt;
|
|
typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> > _Mybase;
|
|
typedef _Kty key_type;
|
|
typedef _Ty mapped_type;
|
|
typedef _Ty referent_type; // retained
|
|
typedef _Pr key_compare;
|
|
typedef typename _Mybase::value_compare value_compare;
|
|
typedef typename _Mybase::allocator_type allocator_type;
|
|
typedef typename _Mybase::size_type size_type;
|
|
typedef typename _Mybase::difference_type difference_type;
|
|
typedef typename _Mybase::pointer pointer;
|
|
typedef typename _Mybase::const_pointer const_pointer;
|
|
typedef typename _Mybase::reference reference;
|
|
typedef typename _Mybase::const_reference const_reference;
|
|
typedef typename _Mybase::iterator iterator;
|
|
typedef typename _Mybase::const_iterator const_iterator;
|
|
typedef typename _Mybase::reverse_iterator reverse_iterator;
|
|
typedef typename _Mybase::const_reverse_iterator
|
|
const_reverse_iterator;
|
|
typedef typename _Mybase::value_type value_type;
|
|
|
|
map()
|
|
: _Mybase(key_compare(), allocator_type())
|
|
{ // construct empty map from defaults
|
|
}
|
|
|
|
explicit map(const key_compare& _Pred)
|
|
: _Mybase(_Pred, allocator_type())
|
|
{ // construct empty map from comparator
|
|
}
|
|
|
|
map(const key_compare& _Pred, const allocator_type& _Al)
|
|
: _Mybase(_Pred, _Al)
|
|
{ // construct empty map from comparator and allocator
|
|
}
|
|
|
|
template<class _Iter>
|
|
map(_Iter _First, _Iter _Last)
|
|
: _Mybase(key_compare(), allocator_type())
|
|
{ // construct map from [_First, _Last), defaults
|
|
for (; _First != _Last; ++_First)
|
|
this->insert(*_First);
|
|
}
|
|
|
|
template<class _Iter>
|
|
map(_Iter _First, _Iter _Last, const key_compare& _Pred)
|
|
: _Mybase(_Pred, allocator_type())
|
|
{ // construct map from [_First, _Last), comparator
|
|
for (; _First != _Last; ++_First)
|
|
this->insert(*_First);
|
|
}
|
|
|
|
template<class _Iter>
|
|
map(_Iter _First, _Iter _Last, const key_compare& _Pred,
|
|
const allocator_type& _Al)
|
|
: _Mybase(_Pred, _Al)
|
|
{ // construct map from [_First, _Last), comparator, and allocator
|
|
for (; _First != _Last; ++_First)
|
|
this->insert(*_First);
|
|
}
|
|
|
|
mapped_type& operator[](const key_type& _Keyval)
|
|
{ // find element matching _Keyval or insert with default mapped
|
|
iterator _Where =
|
|
insert(value_type(_Keyval, mapped_type())).first;
|
|
return ((*_Where).second);
|
|
}
|
|
};
|
|
|
|
// TEMPLATE CLASS multimap
|
|
template<class _Kty,
|
|
class _Ty,
|
|
class _Pr = less<_Kty>,
|
|
class _Alloc = allocator<pair<const _Kty, _Ty> > >
|
|
class multimap
|
|
: public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true> >
|
|
{ // ordered red-black tree of {key, mapped} values, non-unique keys
|
|
public:
|
|
typedef multimap<_Kty, _Ty, _Pr, _Alloc> _Myt;
|
|
typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true> > _Mybase;
|
|
typedef _Kty key_type;
|
|
typedef _Ty mapped_type;
|
|
typedef _Ty referent_type; // retained
|
|
typedef _Pr key_compare;
|
|
typedef typename _Mybase::value_compare value_compare;
|
|
typedef typename _Mybase::allocator_type allocator_type;
|
|
typedef typename _Mybase::size_type size_type;
|
|
typedef typename _Mybase::difference_type difference_type;
|
|
typedef typename _Mybase::pointer pointer;
|
|
typedef typename _Mybase::const_pointer const_pointer;
|
|
typedef typename _Mybase::reference reference;
|
|
typedef typename _Mybase::const_reference const_reference;
|
|
typedef typename _Mybase::iterator iterator;
|
|
typedef typename _Mybase::const_iterator const_iterator;
|
|
typedef typename _Mybase::reverse_iterator reverse_iterator;
|
|
typedef typename _Mybase::const_reverse_iterator
|
|
const_reverse_iterator;
|
|
typedef typename _Mybase::value_type value_type;
|
|
|
|
multimap()
|
|
: _Mybase(key_compare(), allocator_type())
|
|
{ // construct empty map from defaults
|
|
}
|
|
|
|
explicit multimap(const key_compare& _Pred)
|
|
: _Mybase(_Pred, allocator_type())
|
|
{ // construct empty map from comparator
|
|
}
|
|
multimap(const key_compare& _Pred, const allocator_type& _Al)
|
|
: _Mybase(_Pred, _Al)
|
|
{ // construct empty map from comparator and allocator
|
|
}
|
|
|
|
template<class _Iter>
|
|
multimap(_Iter _First, _Iter _Last)
|
|
: _Mybase(key_compare(), allocator_type())
|
|
{ // construct map from [_First, _Last), defaults
|
|
for (; _First != _Last; ++_First)
|
|
insert(*_First);
|
|
}
|
|
|
|
template<class _Iter>
|
|
multimap(_Iter _First, _Iter _Last, const key_compare& _Pred)
|
|
: _Mybase(_Pred, allocator_type())
|
|
{ // construct map from [_First, _Last), comparator
|
|
for (; _First != _Last; ++_First)
|
|
insert(*_First);
|
|
}
|
|
|
|
template<class _Iter>
|
|
multimap(_Iter _First, _Iter _Last, const key_compare& _Pred,
|
|
const allocator_type& _Al)
|
|
: _Mybase(_Pred, _Al)
|
|
{ // construct map from [_First, _Last), comparator, and allocator
|
|
for (; _First != _Last; ++_First)
|
|
insert(*_First);
|
|
}
|
|
|
|
iterator insert(const value_type& _Val)
|
|
{ // insert a {key, mapped} value
|
|
return (_Mybase::insert(_Val).first);
|
|
}
|
|
|
|
iterator insert(iterator _Where, const value_type& _Val)
|
|
{ // insert a {key, mapped} value, with hint
|
|
return (_Mybase::insert(_Where, _Val));
|
|
}
|
|
|
|
template<class _Iter>
|
|
void insert(_Iter _First, _Iter _Last)
|
|
{ // insert [_First, _Last), arbitrary iterators
|
|
for (; _First != _Last; ++_First)
|
|
insert(*_First);
|
|
}
|
|
};
|
|
_STD_END
|
|
#pragma warning(pop)
|
|
#pragma pack(pop)
|
|
|
|
#endif /* _MAP_ */
|
|
|
|
/*
|
|
* Copyright (c) 1992-2001 by P.J. Plauger. ALL RIGHTS RESERVED.
|
|
* Consult your license regarding permissions and restrictions.
|
|
V3.10:0009 */
|