Addable, subractable and intersectable maps. More...

#include <map.hpp>

Inheritance diagram for boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >:

Collaboration diagram for boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >:

Public Types
typedef Alloc< typename std::pair< const DomainT, CodomainT > >	allocator_type

typedef icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >	type

typedef ICL_IMPL_SPACE::map < DomainT, CodomainT, ICL_COMPARE_DOMAIN(Compare, DomainT), allocator_type >	base_type

typedef Traits	traits

typedef DomainT	domain_type

typedef boost::call_traits < DomainT >::param_type	domain_param

typedef DomainT	key_type

typedef CodomainT	codomain_type

typedef CodomainT	mapped_type

typedef CodomainT	data_type

typedef std::pair< const DomainT, CodomainT >	element_type

typedef std::pair< const DomainT, CodomainT >	value_type

typedef domain_compare	key_compare

typedef inverse < codomain_combine >::type	inverse_codomain_combine

typedef mpl::if_ < has_set_semantics < codomain_type > , ICL_SECTION_CODOMAIN(Section, CodomainT), codomain_combine > ::type	codomain_intersect

typedef inverse < codomain_intersect >::type	inverse_codomain_intersect

typedef base_type::value_compare	value_compare

typedef ICL_IMPL_SPACE::set < DomainT, domain_compare, Alloc< DomainT > >	set_type

typedef set_type	key_object_type

typedef on_absorbtion< type, codomain_combine, Traits::absorbs_identities >	on_identity_absorbtion

typedef base_type::pointer	pointer

typedef base_type::const_pointer	const_pointer

typedef base_type::reference	reference

typedef base_type::const_reference	const_reference

typedef base_type::iterator	iterator

typedef base_type::const_iterator	const_iterator

typedef base_type::size_type	size_type

typedef base_type::difference_type	difference_type

typedef base_type::reverse_iterator	reverse_iterator

typedef base_type::const_reverse_iterator	const_reverse_iterator

Public Member Functions
typedef	ICL_COMPARE_DOMAIN (Compare, DomainT) domain_compare

typedef	ICL_COMBINE_CODOMAIN (Combine, CodomainT) codomain_combine

typedef	ICL_COMPARE_DOMAIN (Compare, element_type) element_compare

	BOOST_STATIC_CONSTANT (bool, _total=(Traits::is_total))

	BOOST_STATIC_CONSTANT (bool, _absorbs=(Traits::absorbs_identities))

	BOOST_STATIC_CONSTANT (bool, total_invertible=(mpl::and_< is_total< type >, has_inverse< codomain_type > >::value))

	BOOST_STATIC_CONSTANT (bool, is_total_invertible=(Traits::is_total &&has_inverse< codomain_type >::value))

	BOOST_STATIC_CONSTANT (int, fineness=4)

	map ()

	map (const key_compare &comp)

template<class InputIterator >
	map (InputIterator first, InputIterator past)

template<class InputIterator >
	map (InputIterator first, InputIterator past, const key_compare &comp)

	map (const map &src)

	map (const element_type &key_value_pair)

	map (map &&src)

map &	operator= (map src)

void	swap (map &src)

template<class SubObject >
bool	contains (const SubObject &sub) const

bool	within (const map &super) const

std::size_t	iterative_size () const
	`iterative_size()` yields the number of elements that is visited throu complete iteration. More...

codomain_type	operator() (const domain_type &key) const
	Total select function. More...

map &	add (const value_type &value_pair)
	`add` inserts `value_pair` into the map if it's key does not exist in the map. More...

iterator	add (iterator prior, const value_type &value_pair)
	`add` add `value_pair` into the map using `prior` as a hint to insert `value_pair` after the position `prior` is pointing to. More...

map &	subtract (const element_type &value_pair)
	If the `value_pair's` key value is in the map, it's data value is subtraced from the data value stored in the map. More...

map &	subtract (const domain_type &key)

std::pair< iterator, bool >	insert (const value_type &value_pair)

iterator	insert (iterator prior, const value_type &value_pair)

template<class Iterator >
iterator	insert (Iterator first, Iterator last)

map &	set (const element_type &key_value_pair)
	With `key_value_pair = (k,v)` set value `v` for key `k`. More...

size_type	erase (const element_type &key_value_pair)
	erase `key_value_pair` from the map. More...

void	add_intersection (map &section, const element_type &key_value_pair) const
	The intersection of `key_value_pair` and `*this` map is added to `section`. More...

map &	flip (const element_type &operand)

template<class Combiner >
map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > &	_add (const element_type &addend)

template<class Combiner >
map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > &	_subtract (const value_type &minuend)

Friends
struct	on_invertible< type, true >

struct	on_invertible< type, false >

struct	on_definedness< type, true >

struct	on_definedness< type, false >

struct	on_total_absorbable< type, true, true >

struct	on_total_absorbable< type, false, true >

struct	on_total_absorbable< type, true, false >

struct	on_total_absorbable< type, false, false >

Detailed Description

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>
class boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >

Addable, subractable and intersectable maps.

Member Typedef Documentation

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef Alloc<typename std::pair<const DomainT, CodomainT> > boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::allocator_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef ICL_IMPL_SPACE::map<DomainT, CodomainT, ICL_COMPARE_DOMAIN(Compare,DomainT), allocator_type> boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::base_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef mpl::if_<has_set_semantics<codomain_type> , ICL_SECTION_CODOMAIN(Section,CodomainT) , codomain_combine >::type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::codomain_intersect

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef CodomainT boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::codomain_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::const_iterator boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::const_iterator

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::const_pointer boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::const_pointer

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::const_reference boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::const_reference

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::const_reverse_iterator boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::const_reverse_iterator

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef CodomainT boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::data_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::difference_type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::difference_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef boost::call_traits<DomainT>::param_type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::domain_param

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef DomainT boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::domain_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef std::pair<const DomainT, CodomainT> boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::element_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef inverse<codomain_combine >::type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::inverse_codomain_combine

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef inverse<codomain_intersect>::type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::inverse_codomain_intersect

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::iterator boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::iterator

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef domain_compare boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::key_compare

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef set_type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::key_object_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef DomainT boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::key_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef CodomainT boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::mapped_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef on_absorbtion<type,codomain_combine,Traits::absorbs_identities> boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::on_identity_absorbtion

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::pointer boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::pointer

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::reference boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::reference

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::reverse_iterator boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::reverse_iterator

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef ICL_IMPL_SPACE::set<DomainT, domain_compare, Alloc<DomainT> > boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::set_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::size_type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::size_type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef Traits boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::traits

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef icl::map<DomainT,CodomainT,Traits, Compare,Combine,Section,Alloc> boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::type

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef base_type::value_compare boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::value_compare

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef std::pair<const DomainT, CodomainT> boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::value_type

Constructor & Destructor Documentation

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::map ( )

inline

References boost::BOOST_CONCEPT_ASSERT().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::map ( const key_compare & comp )

inline

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

template<class InputIterator >

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::map	(	InputIterator	first,
		InputIterator	past
	)

inline

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

template<class InputIterator >

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::map	(	InputIterator	first,
		InputIterator	past,
		const key_compare &	comp
	)

inline

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::map ( const map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > & src )

inline

References boost::BOOST_CONCEPT_ASSERT().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::map ( const element_type & key_value_pair )

inlineexplicit

References boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::insert().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::map ( map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > && src )

inline

References boost::BOOST_CONCEPT_ASSERT().

Member Function Documentation

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

template<class Combiner >

map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::_add ( const element_type & addend )

References boost::Combiner, boost::icl::erase(), boost::xpressive::insert, boost::it, and boost::detail::type.

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

template<class Combiner >

map<DomainT,CodomainT,Traits,Compare,Combine,Section,Alloc>& boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::_subtract ( const value_type & minuend )

References boost::Combiner, boost::end, boost::icl::erase(), boost::icl::find(), and boost::detail::type.

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

map& boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::add ( const value_type & value_pair )

inline

add inserts value_pair into the map if it's key does not exist in the map.

If value_pairs's key value exists in the map, it's data value is added to the data value already found in the map.

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

iterator boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::add	(	iterator	prior,
		const value_type &	value_pair
	)

inline

add add value_pair into the map using prior as a hint to insert value_pair after the position prior is pointing to.

References boost::prior().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

void boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::add_intersection	(	map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > &	section,
		const element_type &	key_value_pair
	)		const

inline

The intersection of key_value_pair and *this map is added to section.

References boost::icl::add_intersection().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::BOOST_STATIC_CONSTANT	(	bool	,
		_total	= `(Traits::is_total)`
	)

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::BOOST_STATIC_CONSTANT	(	bool	,
		_absorbs	= `(Traits::absorbs_identities)`
	)

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::BOOST_STATIC_CONSTANT	(	bool	,
		total_invertible	= `(mpl::and_< is_total< type >, has_inverse< codomain_type > >::value)`
	)

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::BOOST_STATIC_CONSTANT	(	bool	,
		is_total_invertible	= `(Traits::is_total &&has_inverse< codomain_type >::value)`
	)

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::BOOST_STATIC_CONSTANT	(	int	,
		fineness	= `4`
	)

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

template<class SubObject >

bool boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::contains ( const SubObject & sub ) const

inline

References boost::icl::contains().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

size_type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::erase ( const element_type & key_value_pair )

inline

erase key_value_pair from the map.

Erase only if, the exact value content val is stored for the given key.

References boost::icl::erase().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

map& boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::flip ( const element_type & operand )

inline

References boost::icl::flip().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::ICL_COMBINE_CODOMAIN	(	Combine	,
		CodomainT
	)

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::ICL_COMPARE_DOMAIN	(	Compare	,
		DomainT
	)

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

typedef boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::ICL_COMPARE_DOMAIN	(	Compare	,
		element_type
	)

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

std::pair<iterator,bool> boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::insert ( const value_type & value_pair )

inline

References boost::end, and boost::xpressive::insert.

Referenced by boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::insert(), and boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::map().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

iterator boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::insert	(	iterator	prior,
		const value_type &	value_pair
	)

inline

References boost::end, and boost::xpressive::insert.

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

template<class Iterator >

iterator boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::insert	(	Iterator	first,
		Iterator	last
	)

inline

References boost::end, boost::icl::first(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::insert(), boost::it, and boost::prior().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

std::size_t boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::iterative_size ( ) const

inline

iterative_size() yields the number of elements that is visited throu complete iteration.

For interval sets iterative_size() is different from size().

References boost::fusion::size().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

codomain_type boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::operator() ( const domain_type & key ) const

inline

Total select function.

References boost::end, boost::icl::find(), boost::it, and boost::icl::identity_element< Type >::value().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

map& boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::operator= ( map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > src )

inline

References boost::move(), and boost::multiprecision::backends::operator=().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

map& boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::set ( const element_type & key_value_pair )

inline

With key_value_pair = (k,v) set value v for key k.

References boost::icl::set_at().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

map& boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::subtract ( const element_type & value_pair )

inline

If the value_pair's key value is in the map, it's data value is subtraced from the data value stored in the map.

References boost::icl::subtract().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

map& boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::subtract ( const domain_type & key )

inline

References boost::icl::erase().

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

void boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::swap ( map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > & src )

inline

References boost::swap.

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

bool boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::within ( const map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc > & super ) const

inline

References boost::icl::contains().

Friends And Related Function Documentation

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

friend struct on_definedness< type, false >

friend

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

friend struct on_definedness< type, true >

friend

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

friend struct on_invertible< type, false >

friend

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

friend struct on_invertible< type, true >

friend

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

friend struct on_total_absorbable< type, false, false >

friend

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

friend struct on_total_absorbable< type, false, true >

friend

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

friend struct on_total_absorbable< type, true,false >

friend

template<typename DomainT, typename CodomainT, class Traits = icl::partial_absorber, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(ICL_COMPARE_DEFAULT, DomainT), ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, CodomainT), ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, CodomainT), ICL_ALLOC Alloc = std::allocator>

friend struct on_total_absorbable< type, true,true >

friend

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

boost_1_57_0/boost/icl/map.hpp

Public Types

Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation