1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
|
/*-----------------------------------------------------------------------------+
Interval Container Library
Author: Joachim Faulhaber
Copyright (c) 2007-2009: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
/** Example std_transform.cpp \file std_transform.cpp
\brief Fill interval containers from user defined objects using std::transform.
Example std_transform shows how algorithm std::transform can be used to
fill interval containers from std::containers of objects of a user
defined class.
\include std_transform_/std_transform.cpp
*/
//[example_std_transform
#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/icl/split_interval_map.hpp>
#include <boost/icl/separate_interval_set.hpp>
using namespace std;
using namespace boost;
using namespace boost::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.
class MyObject
{
public:
MyObject(){}
MyObject(int from, int to, int value): _from(from), _to(to), _value(value){}
int from()const {return _from;}
int to()const {return _to;}
int value()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(const MyObject& myObj)
{
return std::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(const MyObject& myObj)
{
return discrete_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));
return object_vec;
}
// ... show_objects displays the sequence of input objects.
void show_objects(const vector<MyObject>& objects)
{
vector<MyObject>::const_iterator iter = objects.begin();
while(iter != objects.end())
{
cout << "([" << iter->from() << "," << iter->to() << "],"
<< iter->value() << ")";
++iter;
}
}
void std_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";
}
int main()
{
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();
return 0;
}
// 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]}
----------------------------------------------------------*/
//]
|