diff options
Diffstat (limited to 'src/boost/libs/ptr_container/test/view_example.cpp')
| -rw-r--r-- | src/boost/libs/ptr_container/test/view_example.cpp | 180 |
1 files changed, 180 insertions, 0 deletions
diff --git a/src/boost/libs/ptr_container/test/view_example.cpp b/src/boost/libs/ptr_container/test/view_example.cpp new file mode 100644 index 00000000..e8ad5dfe --- /dev/null +++ b/src/boost/libs/ptr_container/test/view_example.cpp @@ -0,0 +1,180 @@ +// +// Boost.Pointer Container +// +// Copyright Thorsten Ottosen 2003-2005. Use, modification and +// distribution is subject to 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) +// +// For more information, see http://www.boost.org/libs/ptr_container/ +// + +// +// This example is intended to show you how to +// use the 'view_clone_manager'. The idea +// is that we have a container of non-polymorphic +// objects and want to keep then sorted by different +// criteria at the same time. +// + +// +// We'll go for 'ptr_vector' here. Using a node-based +// container would be a waste of space here. +// All container headers will also include +// the Clone Managers. +// +#include <boost/ptr_container/ptr_vector.hpp> +#include <boost/ptr_container/indirect_fun.hpp> + +#include <functional> // For 'binary_fnuction' +#include <cstdlib> // For 'rand()' +#include <algorithm> // For 'std::sort()' +#include <iostream> // For 'std::cout' + +using namespace std; + +// +// This is our simple example data-structure. It can +// be ordered in three ways. +// +struct photon +{ + photon() : color( rand() ), + direction( rand() ), + power( rand() ) + { } + + int color; + int direction; + int power; +}; + +// +// Our big container is a standard vector +// +typedef std::vector<photon> vector_type; + +// +// Now we define our view type by adding a second template argument. +// The 'view_clone_manager' will implements Cloning by taking address +// of objects. +// +// Notice the first template argument is 'photon' and not +// 'const photon' to allow the view container write access. +// +typedef boost::ptr_vector<photon,boost::view_clone_allocator> view_type; + +// +// Our first sort criterium +// +struct sort_by_color +{ + typedef photon first_argument_type; + typedef photon second_argument_type; + typedef bool result_type; + + bool operator()( const photon& l, const photon& r ) const + { + return l.color < r.color; + } +}; + +// +// Our second sort criterium +// +struct sort_by_direction +{ + typedef photon first_argument_type; + typedef photon second_argument_type; + typedef bool result_type; + + bool operator()( const photon& l, const photon& r ) const + { + return l.direction < r.direction; + } +}; + + +// +// Our third sort criterium +// +struct sort_by_power +{ + typedef photon first_argument_type; + typedef photon second_argument_type; + typedef bool result_type; + + bool operator()( const photon& l, const photon& r ) const + { + return l.power < r.power; + } +}; + +// +// This function inserts "Clones" into the +// the view. +// +// We need to pass the first argument +// as a non-const reference to be able to store +// 'T*' instead of 'const T*' objects. Alternatively, +// we might change the declaration of the 'view_type' +// to +// typedef boost::ptr_vector<const photon,boost::view_clone_manager> +// view_type; ^^^^^^ +// +void insert( vector_type& from, view_type& to ) +{ + to.insert( to.end(), + from.begin(), + from.end() ); +} + +int main() +{ + enum { sz = 10, count = 500 }; + + // + // First we create the main container and two views + // + std::vector<vector_type> photons; + view_type color_view; + view_type direction_view; + + // + // Then we fill the main container with some random data + // + for( int i = 0; i != sz; ++i ) + { + photons.push_back( vector_type() ); + + for( int j = 0; j != count; ++j ) + photons[i].push_back( photon() ); + } + + // + // Then we create the two views. + // + for( int i = 0; i != sz; ++i ) + { + insert( photons[i], color_view ); + insert( photons[i], direction_view ); + } + + // + // First we sort the original photons, using one of + // the view classes. This may sound trivial, but consider that + // the objects are scatered all around 'sz' different vectors; + // the view makes them act as one big vector. + // + std::sort( color_view.begin(), color_view.end(), sort_by_power() ); + + // + // And now we can sort the views themselves. Notice how + // we switch to different iterators and different predicates: + // + color_view.sort( sort_by_color() ); + + direction_view.sort( sort_by_direction() ); + + return 0; +} |