STXXL  1.4.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
examples/stream/stream1.cpp

This example code is explain in the Tutorial for the Stream Package.

/***************************************************************************
* examples/stream/stream1.cpp
*
* This file contains the example snippets from the stream tutorial.
*
* Part of the STXXL. See http://stxxl.sourceforge.net
*
* Copyright (C) 2012-2013 Timo Bingmann <[email protected]>
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or copy at
* http://www.boost.org/LICENSE_1_0.txt)
**************************************************************************/
#include <stxxl/stream>
#include <stxxl/vector>
#include <stxxl/sorter>
#include <vector>
#include <climits>
struct counter_object
{
// This stream produces a sequence of integers.
typedef int value_type;
private:
// A class attribute to save the current value.
int m_current_value;
public:
// A constructor to set the initial value to 1.
counter_object()
: m_current_value(1)
{ }
// The retrieve operator returning the current value.
const value_type& operator * () const
{
return m_current_value;
}
// Increment operator advancing to the next integer.
counter_object& operator ++ ()
{
++m_current_value;
return *this;
}
// Empty indicator, which in this case can check the current value.
bool empty() const
{
return (m_current_value > 1000);
}
};
template <typename InputStream>
struct squaring_object
{
// This stream produces a sequence of integers.
typedef int value_type;
private:
// A reference to another stream of integers, which are our input.
InputStream& m_input_stream;
// A temporary value buffer to hold the current square in for retrieval.
value_type m_current_value;
public:
// A constructor taking another stream of integers as input.
squaring_object(InputStream& input_stream)
: m_input_stream(input_stream)
{
if (!m_input_stream.empty())
{
m_current_value = *m_input_stream;
m_current_value = m_current_value * m_current_value;
}
}
// The retrieve operator returning the square of the input stream.
const value_type& operator * () const
{
return m_current_value;
}
// Increment operator: handled by incrementing the input stream.
squaring_object& operator ++ ()
{
++m_input_stream;
if (!m_input_stream.empty())
{
m_current_value = *m_input_stream;
m_current_value = m_current_value * m_current_value;
}
return *this;
}
// Empty indicator: this stream is empty when the input stream is.
bool empty() const
{
return m_input_stream.empty();
}
};
// define comparator class: compare right-most decimal and then absolute value
struct CompareMod10
{
// comparison operator() returning true if (a < b)
inline bool operator () (int a, int b) const
{
if ((a % 10) == (b % 10))
return a < b;
else
return (a % 10) < (b % 10);
}
// smallest possible integer value
int min_value() const { return INT_MIN; }
// largest possible integer value
int max_value() const { return INT_MAX; }
};
int main()
{
{
counter_object counter;
while (!counter.empty())
{
std::cout << *counter << " ";
++counter;
}
std::cout << std::endl;
}
{
for (counter_object cnt; !cnt.empty(); ++cnt)
{
std::cout << *cnt << " ";
}
std::cout << std::endl;
}
{
counter_object counter;
squaring_object<counter_object> squares(counter);
while (!squares.empty())
{
std::cout << *squares << " ";
++squares;
}
std::cout << std::endl;
}
{
std::vector<int> intvector;
// (fill intvector)
// define stream class iterating over an integer vector
// instantiate the stream object, iterate from begin to end of intvector.
intstream_type intstream(intvector.begin(), intvector.end());
// plug in squaring object after vector iterator stream.
squaring_object<intstream_type> squares(intstream);
}
{
stxxl::vector<int> intvector;
// (fill intvector)
// define stream class iterating over an integer vector
// instantiate the stream object, iterate from begin to end of intvector.
intstream_type intstream(intvector.begin(), intvector.end());
// plug in squaring object after vector iterator stream.
squaring_object<intstream_type> squares(intstream);
}
{
// construct the squared counter stream
counter_object counter;
squaring_object<counter_object> squares(counter);
// allocate vector of 100 integers
std::vector<int> intvector(100);
// materialize 100 integers from stream and put into vector
stxxl::stream::materialize(squares, intvector.begin(), intvector.end());
}
{
// construct the squared counter stream
counter_object counter;
squaring_object<counter_object> squares(counter);
// allocate STXXL vector of 100 integers
stxxl::vector<int> intvector(100);
// materialize 100 integers from stream and put into STXXL vector
stxxl::stream::materialize(squares, intvector.begin(), intvector.end());
}
{
static const int ram_use = 10 * 1024 * 1024; // amount of memory to use in runs creation
counter_object counter; // the counter stream from first examples
// define a runs sorter for the counter stream which order by CompareMod10 object.
// instance of CompareMod10 comparator class
CompareMod10 comparemod10;
// instance of runs_creator which reads the counter stream.
rc_counter_type rc_counter(counter, comparemod10, ram_use);
// define a runs merger for the sorted runs from rc_counter.
// instance of runs_merger which merges sorted runs from rc_counter.
rm_counter_type rm_counter(rc_counter.result(), comparemod10, ram_use);
// read sorted stream: runs_merger also conforms to the stream interface.
while (!rm_counter.empty())
{
std::cout << *rm_counter << " ";
++rm_counter;
}
std::cout << std::endl;
}
{
static const int ram_use = 10 * 1024 * 1024; // amount of memory to use in runs creation
// define a runs sorter which accepts imperative push()s and orders by CompareMod10 object.
typedef stxxl::stream::runs_creator<stxxl::stream::use_push<int>, CompareMod10> rc_counter_type;
// instance of CompareMod10 comparator class.
CompareMod10 comparemod10;
// instance of runs_creator which waits for input.
rc_counter_type rc_counter(comparemod10, ram_use);
// write sequence of integers into runs
for (int i = 1; i <= 1000; ++i)
rc_counter.push(i);
// define a runs merger for the sorted runs from rc_counter.
// instance of runs_merger which merges sorted runs from rc_counter.
rm_counter_type rm_counter(rc_counter.result(), comparemod10, ram_use);
// read sorted stream: runs_merger also conforms to the stream interface.
while (!rm_counter.empty())
{
std::cout << *rm_counter << " ";
++rm_counter;
}
std::cout << std::endl;
}
{
static const int ram_use = 10 * 1024 * 1024; // amount of memory to use in runs creation
// define a runs sorter which accepts imperative push()s and orders by CompareMod10 object.
typedef stxxl::sorter<int, CompareMod10> sr_counter_type;
// instance of CompareMod10 comparator class.
CompareMod10 comparemod10;
// instance of sorter which waits for input.
sr_counter_type sr_counter(comparemod10, ram_use);
// write sequence of integers into sorter, which creates sorted runs
for (int i = 1; i <= 1000; ++i)
sr_counter.push(i);
// signal sorter that the input stream is finished and switch to output mode.
sr_counter.sort();
// read sorted stream: sorter also conforms to the stream interface.
while (!sr_counter.empty())
{
std::cout << *sr_counter << " ";
++sr_counter;
}
std::cout << std::endl;
}
}