Instead of writing loops, the standard algorithm std::transform
can be used to fill interval containers from std containers of user defined
objects. We need a function, that maps the user defined object
into the segement type of an interval map or the interval
type of an interval set. Based on that we can use std::transform
with an icl::inserter or icl::adder
to transform the user objects into interval containers.

#include<iostream>#include<vector>#include<algorithm>#include<boost/icl/split_interval_map.hpp>#include<boost/icl/separate_interval_set.hpp>usingnamespacestd;usingnamespaceboost;usingnamespaceboost::icl;// Suppose we are working with a class called MyObject, containing some
// information about interval bounds e.g. _from, _to and some data members
// that carry associated information like e.g. _value.
classMyObject{public:MyObject(){}MyObject(intfrom,intto,intvalue):_from(from),_to(to),_value(value){}intfrom()const{return_from;}intto()const{return_to;}intvalue()const{return_value;}private:int_from;int_to;int_value;};// ... in order to use the std::transform algorithm to fill
// interval maps with MyObject data we need a function
// 'to_segment' that maps an object of type MyObject into
// the value type to the interval map we want to tranform to ...
pair<discrete_interval<int>,int>to_segment(constMyObject&myObj){returnstd::pair<discrete_interval<int>,int>(discrete_interval<int>::closed(myObj.from(),myObj.to()),myObj.value());}// ... there may be another function that returns the interval
// of an object only
discrete_interval<int>to_interval(constMyObject&myObj){returndiscrete_interval<int>::closed(myObj.from(),myObj.to());}// ... make_object computes a sequence of objects to test.
vector<MyObject>make_objects(){vector<MyObject>object_vec;object_vec.push_back(MyObject(2,3,1));object_vec.push_back(MyObject(4,4,1));object_vec.push_back(MyObject(1,2,1));returnobject_vec;}// ... show_objects displays the sequence of input objects.
voidshow_objects(constvector<MyObject>&objects){vector<MyObject>::const_iteratoriter=objects.begin();while(iter!=objects.end()){cout<<"(["<<iter->from()<<","<<iter->to()<<"],"<<iter->value()<<")";++iter;}}voidstd_transform(){// This time we want to transform objects into a splitting interval map:
split_interval_map<int,int>segmap;vector<MyObject>myObjects=make_objects();// Display the input
cout<<"input sequence: ";show_objects(myObjects);cout<<"\n\n";// Use an icl::inserter to fill the interval map via inserts
std::transform(myObjects.begin(),myObjects.end(),icl::inserter(segmap,segmap.end()),to_segment);cout<<"icl::inserting: "<<segmap<<endl;segmap.clear();// In order to compute aggregation results on associated values, we
// usually want to use an icl::adder instead of an std or icl::inserter
std::transform(myObjects.begin(),myObjects.end(),icl::adder(segmap,segmap.end()),to_segment);cout<<"icl::adding : "<<segmap<<"\n\n";separate_interval_set<int>segset;std::transform(myObjects.begin(),myObjects.end(),icl::adder(segset,segset.end()),// could be a icl::inserter(segset, segset.end()), here: same effect
to_interval);cout<<"Using std::transform to fill a separate_interval_set:\n\n";cout<<"icl::adding : "<<segset<<"\n\n";}intmain(){cout<<">> Interval Container Library: Example std_transform.cpp <<\n";cout<<"------------------------------------------------------------\n";cout<<"Using std::transform to fill a split_interval_map:\n\n";std_transform();return0;}// Program output:
/*----------------------------------------------------------
>> Interval Container Library: Example std_transform.cpp <<
------------------------------------------------------------
Using std::transform to fill a split_interval_map:
input sequence: ([2,3],1)([4,4],1)([1,2],1)
icl::inserting: {([1,2)->1)([2,3]->1)([4,4]->1)}
icl::adding : {([1,2)->1)([2,2]->2)((2,3]->1)([4,4]->1)}
Using std::transform to fill a separate_interval_set:
icl::adding : {[1,3][4,4]}
----------------------------------------------------------*/

To get clear about the different behaviors of interval containers in the
example, you may want to refer to the section about interval
combining styles that uses the same data.