copy semantics of shared_ptr<map<K,V> > with a std::map interface More...

#include <shared_map.hpp>

Public Types
typedef std::map< keyT, valueT, _Pr, _Alloc >	BaseType
typedef BaseType::allocator_type	allocator_type
typedef BaseType::key_type	key_type
typedef BaseType::value_type	value_type
typedef BaseType::key_compare	key_compare
typedef BaseType::value_compare	value_compare
typedef BaseType::size_type	size_type
typedef BaseType::mapped_type	mapped_type
typedef BaseType::difference_type	difference_type
typedef BaseType::pointer	pointer
typedef BaseType::const_pointer	const_pointer
typedef BaseType::reference	reference
typedef BaseType::const_reference	const_reference
typedef BaseType::iterator	iterator
typedef BaseType::const_iterator	const_iterator
typedef BaseType::reverse_iterator	reverse_iterator
typedef BaseType::const_reverse_iterator	const_reverse_iterator

Public Member Functions
	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. The map uses the allocator _Alloc for all storage management, if it is supplied.
template<class _Iter >
	shared_map (_Iter _First, _Iter _Last)
	Constructs a map containing values in the range [_First, _Last). Creation of the new map is only guaranteed to succeed if the iterators start and finish return values of type pair<class Key, class Value> and all values of Key in the range [_First, _Last) are unique. The map uses the predicate _Pred to order keys, and the allocator _Alloc for all storage management.
template<class _Iter >
	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 guaranteed to succeed if the iterators start and finish return values of type pair<class Key, class Value> and all values of Key in the range [_First, _Last) are unique. The map uses the predicate _Pred to order keys, and the allocator _Alloc for all storage management.
template<class _Iter >
	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 guaranteed to succeed if the iterators start and finish return values of type pair<class Key, class Value> and all values of Key in the range [_First, _Last) are unique. The map uses the predicate _Pred to order keys, and the allocator _Alloc for all storage management.
	~shared_map ()
allocator_type	get_allocator () const
	Returns a copy of the allocator used by self for storage management.
iterator	begin ()
	Returns an iterator pointing to the first element stored in the map. First is defined by the map's comparison operator, Compare.
const_iterator	begin () const
	Returns a const_iterator pointing to the first element stored in the map.
iterator	end ()
	Returns an iterator pointing to the last element stored in the map; in other words, to the off-the-end value.
const_iterator	end () const
	Returns a const_iterator pointing to the last element stored in the map.
reverse_iterator	rbegin ()
	Returns a reverse_iterator pointing to the first element stored in the map. First is defined by the map's comparison operator, Compare.
const_reverse_iterator	rbegin () const
	Returns a const_reverse_iterator pointing to the first element stored in the map.
reverse_iterator	rend ()
	Returns a reverse_iterator pointing to the last element stored in the map; in other words, to the off-the-end value).
const_reverse_iterator	rend () const
	Returns a const_reverse_iterator pointing to the last 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.
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. Otherwise the pair x,T() is inserted into the map and a reference to the default object T() is returned.
void	clear ()
	Erases all elements from the self.
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.
bool	empty () const
	Returns true if the map is empty, false otherwise.
std::pair< iterator, iterator >	equal_range (const key_type &x)
	Returns the pair (lower_bound(x), upper_bound(x)).
std::pair< const_iterator, const_iterator >	equal_range (const key_type &x) const
	Returns the pair (lower_bound(x), upper_bound(x)).
void	erase (iterator position)
	Deletes the map element pointed to by the iterator position.
void	erase (iterator start, iterator finish)
	If the iterators start and finish point to the same map and last is reachable from first, all elements in the range [start, finish) are deleted from the map.
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 map, 0 otherwise.
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. If such a pair is not found the value end() is returned.
const_iterator	find (const key_type &x) const
	Same as find above but returns a const_iterator.
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. Otherwise, the pair is not inserted. A position may be supplied as a hint regarding where to do the insertion. If the insertion is done right after position, then it takes amortized constant time. Otherwise it takes O(log N) time.
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. Otherwise, the pair is not inserted. A position may be supplied as a hint regarding where to do the insertion. If the insertion is done right after position, then it takes amortized constant time. Otherwise it takes O(log N) time.
template<class InputIterator >
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 map) are inserted into the map. The iterators start and finish must return values of type pair<T1,T2>. This operation takes approximately O(N*log(size()+N)) time.
key_compare	key_comp () const
	Returns a function object capable of comparing key values using the comparison operation, Compare, of the current map.
iterator	lower_bound (const key_type &x)
	Returns a reference to the first entry with a key greater than or equal to x.
const_iterator	lower_bound (const key_type &x) const
	Same as lower_bound 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 keys that can be represented by the type Key.
size_type	size () const
	Returns the number of elements in the map.
void	swap (shared_map< keyT, valueT, key_compare, allocator_type > &x)
	Swaps the contents of the map x with the current map, *this.
iterator	upper_bound (const key_type &x)
	Returns an iterator for the first entry with a key greater than x.
const_iterator	upper_bound (const key_type &x) const
	Same as upper_bound above, but returns a const_iterator.
value_compare	value_comp () const
	Returns a function object capable of comparing pair<const Key, T> values using the comparison operation, Compare, of the current map. This function is identical to key_comp for sets.

Private Attributes
boost::shared_ptr< BaseType >	_base

Detailed Description

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>
class pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >

copy semantics of shared_ptr<map<K,V> > with a std::map interface

Definition at line 40 of file shared_map.hpp.

Member Typedef Documentation

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef std::map<keyT, valueT, _Pr, _Alloc> pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::BaseType

Definition at line 44 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::allocator_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::allocator_type

Definition at line 45 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::key_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::key_type

Definition at line 46 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::value_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::value_type

Definition at line 47 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::key_compare pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::key_compare

Definition at line 48 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::value_compare pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::value_compare

Definition at line 49 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::size_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::size_type

Definition at line 50 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::mapped_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::mapped_type

Definition at line 51 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::difference_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::difference_type

Definition at line 52 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::pointer pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::pointer

Definition at line 53 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::const_pointer pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::const_pointer

Definition at line 54 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::reference pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::reference

Definition at line 55 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::const_reference pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::const_reference

Definition at line 56 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::iterator

Definition at line 57 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::const_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::const_iterator

Definition at line 58 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::reverse_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::reverse_iterator

Definition at line 59 of file shared_map.hpp.

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

typedef BaseType::const_reverse_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::const_reverse_iterator

Definition at line 60 of file shared_map.hpp.

Constructor & Destructor Documentation

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::shared_map	(	const key_compare &	predicate = `key_compare()`,
		const allocator_type &	allocator = `allocator_type()`
	)

inlineexplicit

Constructs an empty map that uses the predicate _Pred to order keys, if it is supplied. The map uses the allocator _Alloc for all storage management, if it is supplied.

Definition at line 68 of file shared_map.hpp.

        : _base(new BaseType(predicate, allocator))
    {
    }

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

template<class _Iter >

pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::shared_map	(	_Iter	_First,
		_Iter	_Last
	)

inline

Constructs a map containing values in the range [_First, _Last). Creation of the new map is only guaranteed to succeed if the iterators start and finish return values of type pair<class Key, class Value> and all values of Key in the range [_First, _Last) are unique. The map uses the predicate _Pred to order keys, and the allocator _Alloc for all storage management.

Definition at line 75 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::insert().

        : _base(new BaseType(key_compare(), allocator_type()))
    {
        for (; _First != _Last; ++_First)
            this->insert(*_First);
    }

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

template<class _Iter >

pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::shared_map	(	_Iter	_First,
		_Iter	_Last,
		const key_compare &	_Pred
	)

inline

Constructs a map containing values in the range [_First, _Last). Creation of the new map is only guaranteed to succeed if the iterators start and finish return values of type pair<class Key, class Value> and all values of Key in the range [_First, _Last) are unique. The map uses the predicate _Pred to order keys, and the allocator _Alloc for all storage management.

Definition at line 84 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::insert().

        : _base(new BaseType(_Pred, allocator_type()))
    {
        for (; _First != _Last; ++_First)
            this->insert(*_First);
    }

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

template<class _Iter >

pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::shared_map	(	_Iter	_First,
		_Iter	_Last,
		const key_compare &	_Pred,
		const allocator_type &	_Al
	)

inline

Constructs a map containing values in the range [_First, _Last). Creation of the new map is only guaranteed to succeed if the iterators start and finish return values of type pair<class Key, class Value> and all values of Key in the range [_First, _Last) are unique. The map uses the predicate _Pred to order keys, and the allocator _Alloc for all storage management.

Definition at line 93 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::insert().

        : _base(new BaseType(_Pred, _Al))
    {
        for (; _First != _Last; ++_First)
            this->insert(*_First);
    }

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::~shared_map ( )

inline

Definition at line 100 of file shared_map.hpp.

{}

Member Function Documentation

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

allocator_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::get_allocator ( ) const

inline

Returns a copy of the allocator used by self for storage management.

Definition at line 103 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->get_allocator();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::begin ( )

inline

Returns an iterator pointing to the first element stored in the map. First is defined by the map's comparison operator, Compare.

Definition at line 107 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->begin();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

const_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::begin ( ) const

inline

Returns a const_iterator pointing to the first element stored in the map.

Definition at line 111 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->begin();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::end ( )

inline

Returns an iterator pointing to the last element stored in the map; in other words, to the off-the-end value.

Definition at line 115 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->end();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

const_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::end ( ) const

inline

Returns a const_iterator pointing to the last element stored in the map.

Definition at line 119 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->end();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

reverse_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::rbegin ( )

inline

Returns a reverse_iterator pointing to the first element stored in the map. First is defined by the map's comparison operator, Compare.

Definition at line 123 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->rbegin();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

const_reverse_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::rbegin ( ) const

inline

Returns a const_reverse_iterator pointing to the first element stored in the map.

Definition at line 127 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->rbegin();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

reverse_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::rend ( )

inline

Returns a reverse_iterator pointing to the last element stored in the map; in other words, to the off-the-end value).

Definition at line 131 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->rend();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

const_reverse_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::rend ( ) const

inline

Returns a const_reverse_iterator pointing to the last element stored in the map.

Definition at line 135 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->rend();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

shared_map<keyT, valueT, key_compare, allocator_type>& pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::operator= ( const shared_map< keyT, valueT, key_compare, allocator_type > & x )

inline

Replaces the contents of *this with a copy of the map x.

Definition at line 139 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{_base = x._base; return *this;}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

mapped_type& pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::operator[] ( const key_type & x )

inline

If an element with the key x exists in the map, then a reference to its associated value is returned. Otherwise the pair x,T() is inserted into the map and a reference to the default object T() is returned.

Definition at line 143 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base, and x.

{return (*_base)[x];}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

void pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::clear ( )

inline

Erases all elements from the self.

Definition at line 147 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{_base->clear();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

size_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::count ( const key_type & x ) const

inline

Returns a 1 if a value with the key x exists in the map. Otherwise returns a 0.

Definition at line 151 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->count(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

bool pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::empty ( ) const

inline

Returns true if the map is empty, false otherwise.

Definition at line 155 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->empty();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

std::pair<iterator, iterator> pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::equal_range ( const key_type & x )

inline

Returns the pair (lower_bound(x), upper_bound(x)).

Definition at line 159 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->equal_range(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

std::pair<const_iterator,const_iterator> pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::equal_range ( const key_type & x ) const

inline

Returns the pair (lower_bound(x), upper_bound(x)).

Definition at line 163 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->equal_range(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

void pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::erase ( iterator position )

inline

Deletes the map element pointed to by the iterator position.

Definition at line 167 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{_base->erase(position);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

void pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::erase	(	iterator	start,
		iterator	finish
	)

inline

If the iterators start and finish point to the same map and last is reachable from first, all elements in the range [start, finish) are deleted from the map.

Definition at line 171 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{_base->erase(start, finish);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

size_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::erase ( const key_type & x )

inline

Deletes the element with the key value x from the map, if one exists. Returns 1 if x existed in the map, 0 otherwise.

Definition at line 175 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->erase(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::find ( const key_type & x )

inline

Searches the map for a pair with the key value x and returns an iterator to that pair if it is found. If such a pair is not found the value end() is returned.

Definition at line 179 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->find(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

const_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::find ( const key_type & x ) const

inline

Same as find above but returns a const_iterator.

Definition at line 183 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->find(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

std::pair<iterator, bool> pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::insert ( const value_type & x )

inline

If a value_type with the same key as x is not present in the map, then x is inserted into the map. Otherwise, the pair is not inserted. A position may be supplied as a hint regarding where to do the insertion. If the insertion is done right after position, then it takes amortized constant time. Otherwise it takes O(log N) time.

Definition at line 187 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

Referenced by pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::shared_map().

{return _base->insert(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::insert	(	iterator	position,
		const value_type &	x
	)

inline

If a value_type with the same key as x is not present in the map, then x is inserted into the map. Otherwise, the pair is not inserted. A position may be supplied as a hint regarding where to do the insertion. If the insertion is done right after position, then it takes amortized constant time. Otherwise it takes O(log N) time.

Definition at line 191 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->insert(position, x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

template<class InputIterator >

void pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::insert	(	InputIterator	start,
		InputIterator	finish
	)

inline

Copies of each element in the range [start, finish) that possess a unique key (one not already in the map) are inserted into the map. The iterators start and finish must return values of type pair<T1,T2>. This operation takes approximately O(N*log(size()+N)) time.

Definition at line 196 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{_base->insert(start, finish);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

key_compare pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::key_comp ( ) const

inline

Returns a function object capable of comparing key values using the comparison operation, Compare, of the current map.

Definition at line 200 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->key_comp();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::lower_bound ( const key_type & x )

inline

Returns a reference to the first entry with a key greater than or equal to x.

Definition at line 204 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->lower_bound(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

const_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::lower_bound ( const key_type & x ) const

inline

Same as lower_bound above but returns a const_iterator.

Definition at line 208 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->lower_bound(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

size_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::max_size ( ) const

inline

Returns the maximum possible size of the map. This size is only constrained by the number of unique keys that can be represented by the type Key.

Definition at line 212 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->max_size();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

size_type pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::size ( ) const

inline

Returns the number of elements in the map.

Definition at line 216 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->size();}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

void pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::swap ( shared_map< keyT, valueT, key_compare, allocator_type > & x )

inline

Swaps the contents of the map x with the current map, *this.

Definition at line 220 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{_base->swap(x._base);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::upper_bound ( const key_type & x )

inline

Returns an iterator for the first entry with a key greater than x.

Definition at line 224 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->upper_bound(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

const_iterator pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::upper_bound ( const key_type & x ) const

inline

Same as upper_bound above, but returns a const_iterator.

Definition at line 228 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->upper_bound(x);}

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

value_compare pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::value_comp ( ) const

inline

Returns a function object capable of comparing pair<const Key, T> values using the comparison operation, Compare, of the current map. This function is identical to key_comp for sets.

Definition at line 232 of file shared_map.hpp.

References pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base.

{return _base->value_comp();}

Member Data Documentation

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>

boost::shared_ptr<BaseType> pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >::_base

private

Definition at line 63 of file shared_map.hpp.

The documentation for this class was generated from the following file:

/Users/parag/_Research/pwiz/svn/trunk/pwiz/pwiz/utility/misc/shared_map.hpp

Public Types

Public Member Functions

Private Attributes

Detailed Description

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >> class pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class keyT, class valueT, class _Pr = std::less<keyT>, class _Alloc = std::allocator<std::pair<const keyT, valueT> >>
class pwiz::util::shared_map< keyT, valueT, _Pr, _Alloc >