23#ifndef _SHARED_MAP_HPP_
24#define _SHARED_MAP_HPP_
28#include <boost/shared_ptr.hpp>
38 class _Pr = std::less<keyT>,
39 class _Alloc = std::allocator<std::pair<const keyT, valueT> > >
44 typedef std::map<keyT, valueT, _Pr, _Alloc>
BaseType;
53 typedef typename BaseType::pointer
pointer;
63 boost::shared_ptr<BaseType>
_base;
78 for (; _First != _Last; ++_First)
87 for (; _First != _Last; ++_First)
96 for (; _First != _Last; ++_First)
104 {
return _base->get_allocator();}
108 {
return _base->begin();}
112 {
return _base->begin();}
116 {
return _base->end();}
120 {
return _base->end();}
124 {
return _base->rbegin();}
128 {
return _base->rbegin();}
132 {
return _base->rend();}
136 {
return _base->rend();}
140 {
_base =
x._base;
return *
this;}
156 {
return _base->empty();}
160 {
return _base->equal_range(
x);}
164 {
return _base->equal_range(
x);}
168 {
_base->erase(position);}
172 {
_base->erase(start, finish);}
188 {
return _base->insert(
x);}
192 {
return _base->insert(position,
x);}
195 template <
class InputIterator>
196 void insert(InputIterator start, InputIterator finish)
197 {
_base->insert(start, finish);}
201 {
return _base->key_comp();}
205 {
return _base->lower_bound(
x);}
209 {
return _base->lower_bound(
x);}
213 {
return _base->max_size();}
217 {
return _base->size();}
225 {
return _base->upper_bound(
x);}
229 {
return _base->upper_bound(
x);}
233 {
return _base->value_comp();}
KernelTraitsBase< Kernel >::space_type::abscissa_type x
copy semantics of shared_ptr<map<K,V> > with a std::map interface
iterator end()
Returns an iterator pointing to the last element stored in the map; in other words,...
reverse_iterator rbegin()
Returns a reverse_iterator pointing to the first element stored in the map. First is defined by the m...
BaseType::mapped_type mapped_type
size_type erase(const key_type &x)
Deletes the element with the key value x from the map, if one exists. Returns 1 if x existed in the m...
void clear()
Erases all elements from the self.
shared_map(_Iter _First, _Iter _Last, const key_compare &_Pred)
Constructs a map containing values in the range [_First, _Last). Creation of the new map is only guar...
std::pair< iterator, iterator > equal_range(const key_type &x)
Returns the pair (lower_bound(x), upper_bound(x)).
size_type size() const
Returns the number of elements in the map.
BaseType::value_compare value_compare
iterator upper_bound(const key_type &x)
Returns an iterator for the first entry with a key greater than x.
BaseType::key_compare key_compare
const_iterator lower_bound(const key_type &x) const
Same as lower_bound above but returns a const_iterator.
BaseType::const_pointer const_pointer
iterator begin()
Returns an iterator pointing to the first element stored in the map. First is defined by the map's co...
BaseType::allocator_type allocator_type
BaseType::const_reference const_reference
allocator_type get_allocator() const
Returns a copy of the allocator used by self for storage management.
BaseType::pointer pointer
const_iterator end() const
Returns a const_iterator pointing to the last element stored in the map.
mapped_type & operator[](const key_type &x)
If an element with the key x exists in the map, then a reference to its associated value is returned....
void insert(InputIterator start, InputIterator finish)
Copies of each element in the range [start, finish) that possess a unique key (one not already in the...
std::map< keyT, valueT, _Pr, _Alloc > BaseType
value_compare value_comp() const
Returns a function object capable of comparing pair<const Key, T> values using the comparison operati...
bool empty() const
Returns true if the map is empty, false otherwise.
const_iterator upper_bound(const key_type &x) const
Same as upper_bound above, but returns a const_iterator.
iterator insert(iterator position, const value_type &x)
If a value_type with the same key as x is not present in the map, then x is inserted into the map....
std::pair< iterator, bool > insert(const value_type &x)
If a value_type with the same key as x is not present in the map, then x is inserted into the map....
void erase(iterator position)
Deletes the map element pointed to by the iterator position.
shared_map(_Iter _First, _Iter _Last, const key_compare &_Pred, const allocator_type &_Al)
Constructs a map containing values in the range [_First, _Last). Creation of the new map is only guar...
BaseType::size_type size_type
const_iterator find(const key_type &x) const
Same as find above but returns a const_iterator.
size_type max_size() const
Returns the maximum possible size of the map. This size is only constrained by the number of unique k...
iterator find(const key_type &x)
Searches the map for a pair with the key value x and returns an iterator to that pair if it is found....
BaseType::difference_type difference_type
reverse_iterator rend()
Returns a reverse_iterator pointing to the last element stored in the map; in other words,...
BaseType::iterator iterator
void erase(iterator start, iterator finish)
If the iterators start and finish point to the same map and last is reachable from first,...
std::pair< const_iterator, const_iterator > equal_range(const key_type &x) const
Returns the pair (lower_bound(x), upper_bound(x)).
BaseType::reverse_iterator reverse_iterator
BaseType::const_reverse_iterator const_reverse_iterator
const_reverse_iterator rend() const
Returns a const_reverse_iterator pointing to the last element stored in the map.
const_iterator begin() const
Returns a const_iterator pointing to the first element stored in the map.
boost::shared_ptr< BaseType > _base
iterator lower_bound(const key_type &x)
Returns a reference to the first entry with a key greater than or equal to x.
void swap(shared_map< keyT, valueT, key_compare, allocator_type > &x)
Swaps the contents of the map x with the current map, *this.
BaseType::reference reference
BaseType::value_type value_type
shared_map(const key_compare &predicate=key_compare(), const allocator_type &allocator=allocator_type())
Constructs an empty map that uses the predicate _Pred to order keys, if it is supplied....
key_compare key_comp() const
Returns a function object capable of comparing key values using the comparison operation,...
BaseType::key_type key_type
shared_map(_Iter _First, _Iter _Last)
Constructs a map containing values in the range [_First, _Last). Creation of the new map is only guar...
size_type count(const key_type &x) const
Returns a 1 if a value with the key x exists in the map. Otherwise returns a 0.
const_reverse_iterator rbegin() const
Returns a const_reverse_iterator pointing to the first element stored in the map.
shared_map< keyT, valueT, key_compare, allocator_type > & operator=(const shared_map< keyT, valueT, key_compare, allocator_type > &x)
Replaces the contents of *this with a copy of the map x.
BaseType::const_iterator const_iterator