Home  Libraries  People  FAQ  More 
While addition and
subtraction on Sets
are implemented as set union and set
difference, for Maps
we want to implement aggregation
on the associated values for the case of collision (of key elements) or overlap
(of key intervals), which has been refered to as aggregate
on overlap above. This kind of Addability
and Subtractability
allows
to compute a lot of useful aggregation results on an interval_map's
associated values, just by adding and subtracting value pairs. Various examples
of aggregate on overlap
are given in section examples.
In addition, this concept of Addability
and Subtractability
contains
the classical Insertability
and Erasability
of key value
pairs as a special case so it provides a broader new semantics without loss
of the classical one.
Aggregation is implemented for functions add
and subtract
by propagating
a Combiner
functor to combine
associated values of type CodomainT
.
The standard Combiner
is
set as default template parameter template<class>class Combine = inplace_plus
, which is again generically
implemented by operator +=
for all Addable types.
For Combine
functors, the
Icl provides an inverse
functor.












The meta function inverse
is mutually implemented for all but the default functor Functor
such that e.g. inverse<inplace_minus<T> >::type
yields inplace_plus<T>
.
Not in every case, e.g. max/min
, does
the inverse
functor invert
the effect of it's antetype. But for the default it does:




Instance 


Inversion 
adds 
subtracts 
As already mentioned aggregating Addability
and Subtractability
on Maps
contains the classical
Insertability
and Erasability
of key value pairs as a special
case:
aggregating function 
equivalent classical function 





The aggregating member function templates _add
and _subtract
are not in
the public interface of interval_maps
,
because the Combine
functor
is intended to be an invariant of interval_map's
template instance to avoid, that clients spoil the aggregation by accidentally
calling varying aggregation functors. But you could instantiate an interval_map
to have insert/erase
semantics this way:
interval_map<int,int,partial_absorber, std::less, inplace_identity //Combine parameter specified > m; interval<int>::type itv = interval<int>::rightopen(2,7); m.add(make_pair(itv,42)); //same as insert m.subtract(make_pair(itv,42)); //same as erase
This is, of course, only a clarifying example. Member functions insert
and erase
are available in interval_map's
interface so they can be called directly.