106 lines
4.0 KiB
C++
106 lines
4.0 KiB
C++
/*-----------------------------------------------------------------------------+
|
|
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_copy.cpp \file std_copy.cpp
|
|
\brief Fill interval containers using std::copy.
|
|
|
|
Example std_copy shows how algorithm std::copy can be used to
|
|
fill interval containers from other std::containers and how copying
|
|
to interval containers differs from other uses of std::copy.
|
|
|
|
\include std_copy_/std_copy.cpp
|
|
*/
|
|
//[example_std_copy
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <boost/icl/interval_map.hpp>
|
|
|
|
using namespace std;
|
|
using namespace boost;
|
|
using namespace boost::icl;
|
|
|
|
// 'make_segments' returns a vector of interval value pairs, which
|
|
// are not sorted. The values are taken from the minimal example
|
|
// in section 'interval combining styles'.
|
|
vector<pair<discrete_interval<int>, int> > make_segments()
|
|
{
|
|
vector<pair<discrete_interval<int>, int> > segment_vec;
|
|
segment_vec.push_back(make_pair(discrete_interval<int>::right_open(2,4), 1));
|
|
segment_vec.push_back(make_pair(discrete_interval<int>::right_open(4,5), 1));
|
|
segment_vec.push_back(make_pair(discrete_interval<int>::right_open(1,3), 1));
|
|
return segment_vec;
|
|
}
|
|
|
|
// 'show_segments' displays the source segements.
|
|
void show_segments(const vector<pair<discrete_interval<int>, int> >& segments)
|
|
{
|
|
vector<pair<discrete_interval<int>, int> >::const_iterator iter = segments.begin();
|
|
while(iter != segments.end())
|
|
{
|
|
cout << "(" << iter->first << "," << iter->second << ")";
|
|
++iter;
|
|
}
|
|
}
|
|
|
|
void std_copy()
|
|
{
|
|
// So we have some segments stored in an std container.
|
|
vector<pair<discrete_interval<int>, int> > segments = make_segments();
|
|
// Display the input
|
|
cout << "input sequence: "; show_segments(segments); cout << "\n\n";
|
|
|
|
// We are going to 'std::copy' those segments into an interval_map:
|
|
interval_map<int,int> segmap;
|
|
|
|
// Use an 'icl::inserter' from <boost/icl/iterator.hpp> to call
|
|
// insertion on the interval container.
|
|
std::copy(segments.begin(), segments.end(),
|
|
icl::inserter(segmap, segmap.end()));
|
|
cout << "icl::inserting: " << segmap << endl;
|
|
segmap.clear();
|
|
|
|
// When we are feeding data into interval_maps, most of the time we are
|
|
// intending to compute an aggregation result. So we are not interested
|
|
// the std::insert semantincs but the aggregating icl::addition semantics.
|
|
// To achieve this there is an icl::add_iterator and an icl::adder function
|
|
// provided in <boost/icl/iterator.hpp>.
|
|
std::copy(segments.begin(), segments.end(),
|
|
icl::adder(segmap, segmap.end())); //Aggregating associated values
|
|
cout << "icl::adding : " << segmap << endl;
|
|
|
|
// In this last case, the semantics of 'std::copy' transforms to the
|
|
// generalized addition operation, that is implemented by operator
|
|
// += or + on itl maps and sets.
|
|
}
|
|
|
|
int main()
|
|
{
|
|
cout << ">> Interval Container Library: Example std_copy.cpp <<\n";
|
|
cout << "-----------------------------------------------------------\n";
|
|
cout << "Using std::copy to fill an interval_map:\n\n";
|
|
|
|
std_copy();
|
|
return 0;
|
|
}
|
|
|
|
// Program output:
|
|
/*---------------------------------------------------------
|
|
>> Interval Container Library: Example std_copy.cpp <<
|
|
-----------------------------------------------------------
|
|
Using std::copy to fill an interval_map:
|
|
|
|
input sequence: ([2,4),1)([4,5),1)([1,3),1)
|
|
|
|
icl::inserting: {([1,5)->1)}
|
|
icl::adding : {([1,2)->1)([2,3)->2)([3,5)->1)}
|
|
---------------------------------------------------------*/
|
|
//]
|