|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r56771 - in sandbox/async/boost/range: . adaptor algorithm algorithm_ext detail detail/vc6
From: vicente.botet_at_[hidden]
Date: 2009-10-13 03:03:54
Author: viboes
Date: 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
New Revision: 56771
URL: http://svn.boost.org/trac/boost/changeset/56771
Log:
TBoost.Async:
* Added range library
Added:
sandbox/async/boost/range/
sandbox/async/boost/range/adaptor/
sandbox/async/boost/range/adaptor/adjacent_filtered.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/argument_fwd.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/copied.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/filtered.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/indexed.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/indirected.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/map.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/replaced.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/replaced_if.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/reversed.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/sliced.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/strided.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/tokenized.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/transformed.hpp (contents, props changed)
sandbox/async/boost/range/adaptor/uniqued.hpp (contents, props changed)
sandbox/async/boost/range/adaptors.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/
sandbox/async/boost/range/algorithm.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/adjacent_find.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/binary_search.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/copy.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/copy_backward.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/count.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/count_if.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/equal.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/equal_range.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/fill.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/find.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/find_end.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/find_first_of.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/find_if.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/for_each.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/generate.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/heap_algorithm.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/inplace_merge.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/lexicographical_compare.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/lower_bound.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/max_element.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/merge.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/min_element.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/mismatch.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/nth_element.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/partial_sort.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/partition.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/permutation.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/random_shuffle.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/remove.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/remove_if.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/replace.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/replace_if.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/reverse.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/rotate.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/search.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/set_algorithm.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/sort.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/stable_partition.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/stable_sort.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/transform.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/unique.hpp (contents, props changed)
sandbox/async/boost/range/algorithm/upper_bound.hpp (contents, props changed)
sandbox/async/boost/range/algorithm_ext/
sandbox/async/boost/range/algorithm_ext.hpp (contents, props changed)
sandbox/async/boost/range/algorithm_ext/erase.hpp (contents, props changed)
sandbox/async/boost/range/algorithm_ext/for_each.hpp (contents, props changed)
sandbox/async/boost/range/algorithm_ext/insert.hpp (contents, props changed)
sandbox/async/boost/range/algorithm_ext/overwrite.hpp (contents, props changed)
sandbox/async/boost/range/algorithm_ext/push_back.hpp (contents, props changed)
sandbox/async/boost/range/algorithm_ext/push_front.hpp (contents, props changed)
sandbox/async/boost/range/as_array.hpp (contents, props changed)
sandbox/async/boost/range/as_literal.hpp (contents, props changed)
sandbox/async/boost/range/atl.hpp (contents, props changed)
sandbox/async/boost/range/begin.hpp (contents, props changed)
sandbox/async/boost/range/category.hpp (contents, props changed)
sandbox/async/boost/range/combine.hpp (contents, props changed)
sandbox/async/boost/range/concepts.hpp (contents, props changed)
sandbox/async/boost/range/config.hpp (contents, props changed)
sandbox/async/boost/range/const_iterator.hpp (contents, props changed)
sandbox/async/boost/range/const_reverse_iterator.hpp (contents, props changed)
sandbox/async/boost/range/counting_range.hpp (contents, props changed)
sandbox/async/boost/range/detail/
sandbox/async/boost/range/detail/as_literal.hpp (contents, props changed)
sandbox/async/boost/range/detail/begin.hpp (contents, props changed)
sandbox/async/boost/range/detail/collection_traits.hpp (contents, props changed)
sandbox/async/boost/range/detail/collection_traits_detail.hpp (contents, props changed)
sandbox/async/boost/range/detail/common.hpp (contents, props changed)
sandbox/async/boost/range/detail/const_iterator.hpp (contents, props changed)
sandbox/async/boost/range/detail/detail_str.hpp (contents, props changed)
sandbox/async/boost/range/detail/difference_type.hpp (contents, props changed)
sandbox/async/boost/range/detail/empty.hpp (contents, props changed)
sandbox/async/boost/range/detail/end.hpp (contents, props changed)
sandbox/async/boost/range/detail/extract_optional_type.hpp (contents, props changed)
sandbox/async/boost/range/detail/implementation_help.hpp (contents, props changed)
sandbox/async/boost/range/detail/iterator.hpp (contents, props changed)
sandbox/async/boost/range/detail/microsoft.hpp (contents, props changed)
sandbox/async/boost/range/detail/range_return.hpp (contents, props changed)
sandbox/async/boost/range/detail/remove_extent.hpp (contents, props changed)
sandbox/async/boost/range/detail/sfinae.hpp (contents, props changed)
sandbox/async/boost/range/detail/size.hpp (contents, props changed)
sandbox/async/boost/range/detail/size_type.hpp (contents, props changed)
sandbox/async/boost/range/detail/sizer.hpp (contents, props changed)
sandbox/async/boost/range/detail/str_types.hpp (contents, props changed)
sandbox/async/boost/range/detail/value_type.hpp (contents, props changed)
sandbox/async/boost/range/detail/vc6/
sandbox/async/boost/range/detail/vc6/end.hpp (contents, props changed)
sandbox/async/boost/range/detail/vc6/size.hpp (contents, props changed)
sandbox/async/boost/range/difference_type.hpp (contents, props changed)
sandbox/async/boost/range/distance.hpp (contents, props changed)
sandbox/async/boost/range/empty.hpp (contents, props changed)
sandbox/async/boost/range/end.hpp (contents, props changed)
sandbox/async/boost/range/functions.hpp (contents, props changed)
sandbox/async/boost/range/istream_range.hpp (contents, props changed)
sandbox/async/boost/range/iterator.hpp (contents, props changed)
sandbox/async/boost/range/iterator_range.hpp (contents, props changed)
sandbox/async/boost/range/iterator_range_core.hpp (contents, props changed)
sandbox/async/boost/range/iterator_range_io.hpp (contents, props changed)
sandbox/async/boost/range/metafunctions.hpp (contents, props changed)
sandbox/async/boost/range/mfc.hpp (contents, props changed)
sandbox/async/boost/range/mutable_iterator.hpp (contents, props changed)
sandbox/async/boost/range/numeric.hpp (contents, props changed)
sandbox/async/boost/range/pointer.hpp (contents, props changed)
sandbox/async/boost/range/rbegin.hpp (contents, props changed)
sandbox/async/boost/range/reference.hpp (contents, props changed)
sandbox/async/boost/range/rend.hpp (contents, props changed)
sandbox/async/boost/range/result_iterator.hpp (contents, props changed)
sandbox/async/boost/range/reverse_iterator.hpp (contents, props changed)
sandbox/async/boost/range/reverse_result_iterator.hpp (contents, props changed)
sandbox/async/boost/range/size.hpp (contents, props changed)
sandbox/async/boost/range/size_type.hpp (contents, props changed)
sandbox/async/boost/range/sub_range.hpp (contents, props changed)
sandbox/async/boost/range/unbounded_range.hpp (contents, props changed)
sandbox/async/boost/range/value_type.hpp (contents, props changed)
Added: sandbox/async/boost/range/adaptor/adjacent_filtered.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/adjacent_filtered.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,266 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_ADJACENT_FILTER_IMPL_HPP
+#define BOOST_RANGE_ADAPTOR_ADJACENT_FILTER_IMPL_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_MSVC
+#pragma warning( push )
+#pragma warning( disable : 4355 )
+#endif
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/next_prior.hpp>
+
+
+namespace boost
+{
+
+ namespace range_detail
+ {
+ template< class Iter, class R >
+ class skip_iterator
+ : public boost::iterator_adaptor< skip_iterator<Iter,R>, Iter >
+ {
+ private:
+ typedef boost::iterator_adaptor< skip_iterator<Iter,R>, Iter >
+ base_t;
+
+ R* range;
+
+ public:
+ typedef Iter wrapped_iter_t;
+
+ //
+ // The iterators are bound to the lifetime of the
+ // range and may not exist on their own. Hence it makes no
+ // sense to e.g. wrap them in reverse_iterators
+ // (that can OTOH be done in advance).
+ //
+ typedef std::input_iterator_tag iterator_category;
+
+ //
+ // @todo: the constructor needs to
+ // call increment to get to the firdt valid element.
+ //
+ /*
+ skip_iterator( Iter i )
+ : base(i), range(0) {}
+ */
+ explicit skip_iterator( R* r, Iter i )
+ : base_t(i), range(r) {}
+
+ template< class OtherIter, class R2>
+ skip_iterator( const skip_iterator<OtherIter,R2>& other )
+ : base_t( other.base() ) {}
+
+ R* get_range() const { return range; }
+
+ private:
+ friend class boost::iterator_core_access;
+
+ void increment()
+ {
+ BOOST_ASSERT( range != 0 );
+ range->increment_impl( this->base_reference() );
+ }
+
+ //
+ // Not needed ... just apply a reverse_iterator
+ //
+ void decrement()
+ {
+ BOOST_ASSERT( false && "you can't decrement an adjacent_filter_iterator" );
+ }
+ //
+ // @todo: simply wrap the underlying iterator in reverse-iterators:
+ //
+ // increment( make_reverse_iterator(*this), ... );
+ //
+
+ template< class D >
+ void advance( D n )
+ {
+ BOOST_ASSERT( false );
+ }
+
+ };
+
+ template< class P, class R >
+ struct adjacent_filter_range
+ : iterator_range< skip_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
+ adjacent_filter_range<P,R>
+ >
+ >
+ {
+ private:
+ typedef skip_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
+ adjacent_filter_range<P,R>
+ >
+ skip_iter;
+ typedef iterator_range<skip_iter>
+ base_range;
+
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<R>::type raw_iterator;
+
+ P bi_pred;
+
+ // Get the first element in the half-open range that
+ // passes the filter predicate.
+ // The adjacent_filter_range must only contain values that pass
+ // through the filter.
+ static raw_iterator to_valid(raw_iterator it, raw_iterator last, const P& bi_pred, bool default_pass)
+ {
+ if (it != last)
+ {
+ if (default_pass)
+ {
+ raw_iterator nxt = next(it);
+ while (nxt != last && !bi_pred(*it, *nxt))
+ {
+ ++it;
+ ++nxt;
+ }
+ }
+ else
+ {
+ raw_iterator nxt = next(it);
+ for(; nxt != last; ++it, ++nxt)
+ {
+ if (bi_pred(*it, *nxt))
+ {
+ break;
+ }
+ }
+ if (nxt == last)
+ {
+ it = last;
+ }
+ }
+ }
+ return it;
+ }
+
+ public:
+ adjacent_filter_range( const P& p, R& r, bool default_pass )
+ : base_range( skip_iter( this, to_valid(boost::begin(r), boost::end(r), p, default_pass)),
+ skip_iter( this, boost::end(r) ) ),
+ bi_pred( p ),
+ _default_pass(default_pass)
+ {
+ }
+
+ void increment_impl( raw_iterator& current )
+ {
+ BOOST_ASSERT( current != this->end().base() );
+
+ current = to_valid(next(current), this->end().base(), bi_pred, _default_pass);
+ }
+
+ private:
+ bool _default_pass;
+ };
+
+ template< class T >
+ struct adjacent_holder : holder<T>
+ {
+ adjacent_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ template< class T >
+ struct adjacent_excl_holder : holder<T>
+ {
+ adjacent_excl_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ template< class ForwardRng, class BinPredicate >
+ inline adjacent_filter_range<BinPredicate, ForwardRng>
+ operator|( ForwardRng& r,
+ const adjacent_holder<BinPredicate>& f )
+ {
+ return adjacent_filter_range<BinPredicate, ForwardRng>( f.val, r, true );
+ }
+
+ template< class ForwardRng, class BinPredicate >
+ inline adjacent_filter_range<BinPredicate, const ForwardRng>
+ operator|( const ForwardRng& r,
+ const adjacent_holder<BinPredicate>& f )
+ {
+ return adjacent_filter_range<BinPredicate,
+ const ForwardRng>( f.val, r, true );
+ }
+
+ template< class ForwardRng, class BinPredicate >
+ inline adjacent_filter_range<BinPredicate, ForwardRng>
+ operator|( ForwardRng& r,
+ const adjacent_excl_holder<BinPredicate>& f )
+ {
+ return adjacent_filter_range<BinPredicate, ForwardRng>( f.val, r, false );
+ }
+
+ template< class ForwardRng, class BinPredicate >
+ inline adjacent_filter_range<BinPredicate, ForwardRng>
+ operator|( const ForwardRng& r,
+ const adjacent_excl_holder<BinPredicate>& f )
+ {
+ return adjacent_filter_range<BinPredicate,
+ const ForwardRng>( f.val, r, false );
+ }
+
+ } // 'range_detail'
+
+ // Bring adjacent_filter_range into the boost namespace so that users of
+ // this library may specify the return type of the '|' operator and
+ // make_adjacent_filtered_range()
+ using range_detail::adjacent_filter_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder<range_detail::adjacent_holder>
+ adjacent_filtered =
+ range_detail::forwarder<range_detail::adjacent_holder>();
+
+ const range_detail::forwarder<range_detail::adjacent_excl_holder>
+ adjacent_filtered_excl =
+ range_detail::forwarder<range_detail::adjacent_excl_holder>();
+ }
+ }
+
+ template<class ForwardRng, class BinPredicate>
+ inline adjacent_filter_range<BinPredicate, ForwardRng>
+ make_adjacent_filtered_range(ForwardRng& rng, BinPredicate filter_pred)
+ {
+ return rng | adaptors::adjacent_filtered(filter_pred);
+ }
+
+ template<class ForwardRng, class BinPredicate>
+ inline adjacent_filter_range<BinPredicate, const ForwardRng>
+ make_adjacent_filtered_range(const ForwardRng& rng, BinPredicate filter_pred)
+ {
+ return rng | adaptors::adjacent_filtered(filter_pred);
+ }
+}
+
+#ifdef BOOST_MSVC
+#pragma warning( pop )
+#endif
+
+#endif
Added: sandbox/async/boost/range/adaptor/argument_fwd.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/argument_fwd.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,80 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_ARGUMENT_FWD_HPP
+#define BOOST_RANGE_ADAPTOR_ARGUMENT_FWD_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable : 4512) // assignment operator could not be generated
+#endif
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class T >
+ struct holder
+ {
+ T val;
+ holder( T t ) : val(t)
+ { }
+ };
+
+ template< class T >
+ struct holder2
+ {
+ T val1, val2;
+ holder2( T t, T u ) : val1(t), val2(u)
+ { }
+ };
+
+ template< template<class> class Holder >
+ struct forwarder
+ {
+ template< class T >
+ Holder<T> operator()( T t ) const
+ {
+ return Holder<T>(t);
+ }
+ };
+
+ template< template<class> class Holder >
+ struct forwarder2
+ {
+ template< class T >
+ Holder<T> operator()( T t, T u ) const
+ {
+ return Holder<T>(t,u);
+ }
+ };
+
+ template< template<class,class> class Holder >
+ struct forwarder2TU
+ {
+ template< class T, class U >
+ Holder<T, U> operator()( T t, U u ) const
+ {
+ return Holder<T, U>(t, u);
+ }
+ };
+
+
+ }
+
+}
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif
Added: sandbox/async/boost/range/adaptor/copied.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/copied.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,62 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_COPIED_HPP
+#define BOOST_RANGE_ADAPTOR_COPIED_HPP
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/adaptor/sliced.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class T >
+ struct copy_holder
+ : holder2<std::size_t>
+ {
+ copy_holder( std::size_t t, std::size_t u )
+ : holder2<std::size_t>(t,u)
+ { }
+ };
+
+ template< class CopyableRandomAccessRng, class Int >
+ inline CopyableRandomAccessRng
+ operator|( const CopyableRandomAccessRng& r, const copy_holder<Int>& f )
+ {
+ iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<const
+ CopyableRandomAccessRng>::type >
+ temp( sliced_impl( r, f ) );
+ return CopyableRandomAccessRng( temp.begin(), temp.end() );
+ }
+
+ } // 'range_detail'
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder2<range_detail::copy_holder>
+ copied = range_detail::forwarder2<range_detail::copy_holder>();
+ }
+ }
+
+ template<class CopyableRandomAccessRng>
+ inline CopyableRandomAccessRng
+ make_copied_range(const CopyableRandomAccessRng& rng, std::size_t t, std::size_t u)
+ {
+ return rng | adaptors::copied(t, u);
+ }
+}
+
+#endif
Added: sandbox/async/boost/range/adaptor/filtered.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/filtered.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,101 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_FILTERED_HPP
+#define BOOST_RANGE_ADAPTOR_FILTERED_HPP
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/iterator/filter_iterator.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class P, class R >
+ struct filter_range :
+ boost::iterator_range<
+ boost::filter_iterator< P,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef boost::iterator_range<
+ boost::filter_iterator< P,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ base;
+ public:
+ filter_range( P p, R& r )
+ : base( make_filter_iterator( p, boost::begin(r), boost::end(r) ),
+ make_filter_iterator( p, boost::end(r), boost::end(r) ) )
+ { }
+ };
+
+ template< class T >
+ struct filter_holder : holder<T>
+ {
+ filter_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ template< class InputRng, class Predicate >
+ inline filter_range<Predicate, InputRng>
+ operator|( InputRng& r,
+ const filter_holder<Predicate>& f )
+ {
+ return filter_range<Predicate, InputRng>( f.val, r );
+ }
+
+ template< class InputRng, class Predicate >
+ inline filter_range<Predicate, const InputRng>
+ operator|( const InputRng& r,
+ const filter_holder<Predicate>& f )
+ {
+ return filter_range<Predicate, const InputRng>( f.val, r );
+ }
+
+ } // 'range_detail'
+
+ // Unusual use of 'using' is intended to bring filter_range into the boost namespace
+ // while leaving the mechanics of the '|' operator in range_detail and maintain
+ // argument dependent lookup.
+ // filter_range logically needs to be in the boost namespace to allow user of
+ // the library to define the return type for make_filtered_range()
+ using range_detail::filter_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder<range_detail::filter_holder>
+ filtered =
+ range_detail::forwarder<range_detail::filter_holder>();
+ }
+ }
+
+ template<class InputRng, class Predicate>
+ inline filter_range<Predicate, InputRng>
+ make_filtered_range(InputRng& rng, Predicate filter_pred)
+ {
+ return rng | adaptors::filtered(filter_pred);
+ }
+
+ template<class InputRng, class Predicate>
+ inline filter_range<Predicate, const InputRng>
+ make_filtered_range(const InputRng& rng, Predicate filter_pred)
+ {
+ return rng | adaptors::filtered(filter_pred);
+ }
+}
+
+#endif
Added: sandbox/async/boost/range/adaptor/indexed.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/indexed.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,172 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_INDEXED_IMPL_HPP
+#define BOOST_RANGE_ADAPTOR_INDEXED_IMPL_HPP
+
+#include <boost/config.hpp>
+#ifdef BOOST_MSVC
+#pragma warning( push )
+#pragma warning( disable : 4355 )
+#endif
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+
+
+
+namespace boost
+{
+
+ namespace range_detail
+ {
+ template< class Iter >
+ class indexed_iterator
+ : public boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
+ {
+ private:
+ typedef boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
+ base;
+
+ typedef BOOST_DEDUCED_TYPENAME base::difference_type index_type;
+
+ index_type index_;
+
+ public:
+ explicit indexed_iterator( Iter i, index_type index )
+ : base(i), index_(index)
+ {
+ BOOST_ASSERT( index_ >= 0 && "Indexed Iterator out of bounds" );
+ }
+
+ index_type index() const
+ {
+ return index_;
+ }
+
+ private:
+ friend class boost::iterator_core_access;
+
+ void increment()
+ {
+ ++index_;
+ ++(this->base_reference());
+ }
+
+
+ void decrement()
+ {
+ BOOST_ASSERT( index_ > 0 && "Indexed Iterator out of bounds" );
+ --index_;
+ --(this->base_reference());
+ }
+
+ void advance( index_type n )
+ {
+ index_ += n;
+ BOOST_ASSERT( index_ >= 0 && "Indexed Iterator out of bounds" );
+ this->base_reference() += n;
+ }
+ };
+
+ template< class Rng >
+ struct indexed_range :
+ iterator_range< indexed_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> >
+ {
+ private:
+ typedef indexed_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type>
+ iter_type;
+ typedef iterator_range<iter_type>
+ base;
+ public:
+ template< class Index >
+ indexed_range( Index i, Rng& r )
+ : base( iter_type(boost::begin(r), i), iter_type(boost::end(r),i) )
+ { }
+ };
+
+
+ template< class T >
+ struct index_holder : holder<T>
+ {
+ index_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ struct index_forwarder
+ {
+ template< class T >
+ index_holder<T> operator()( T r ) const
+ {
+ return r;
+ }
+
+ index_holder<int> operator()( int r = 0 ) const
+ {
+ return r;
+ }
+ };
+
+ template< class SinglePassRange >
+ inline indexed_range<SinglePassRange>
+ operator|( SinglePassRange& r,
+ const index_holder<typename range_difference<SinglePassRange>::type>& f )
+ {
+ return indexed_range<SinglePassRange>( f.val, r );
+ }
+
+ template< class SinglePassRange >
+ inline indexed_range<const SinglePassRange>
+ operator|( const SinglePassRange& r,
+ const index_holder<typename range_difference<SinglePassRange>::type>& f )
+ {
+ return indexed_range<const SinglePassRange>( f.val, r );
+ }
+
+ } // 'range_detail'
+
+ // Make this available to users of this library. It will sometimes be
+ // required since it is the return type of operator '|' and
+ // make_indexed_range().
+ using range_detail::indexed_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder<range_detail::index_holder>
+ indexed =
+ range_detail::forwarder<range_detail::index_holder>();
+ }
+ }
+
+ template<class SinglePassRange, class Index>
+ inline indexed_range<SinglePassRange>
+ make_indexed_range(SinglePassRange& rng, Index index)
+ {
+ return rng | adaptors::indexed(index);
+ }
+
+ template<class SinglePassRange, class Index>
+ inline indexed_range<const SinglePassRange>
+ make_indexed_range(const SinglePassRange& rng, Index index)
+ {
+ return rng | adaptors::indexed(index);
+ }
+}
+
+#ifdef BOOST_MSVC
+#pragma warning( pop )
+#endif
+
+#endif
Added: sandbox/async/boost/range/adaptor/indirected.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/indirected.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,87 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_INDIRECTED_HPP
+#define BOOST_RANGE_ADAPTOR_INDIRECTED_HPP
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/iterator/indirect_iterator.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class R >
+ struct indirect_range :
+ public boost::iterator_range<
+ boost::indirect_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef boost::iterator_range<
+ boost::indirect_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ base;
+
+ public:
+ indirect_range( R& r )
+ : base( r )
+ { }
+ };
+
+ struct indirect_forwarder {};
+
+ template< class InputRng >
+ inline indirect_range<InputRng>
+ operator|( InputRng& r, indirect_forwarder )
+ {
+ return indirect_range<InputRng>( r );
+ }
+
+ template< class InputRng >
+ inline indirect_range<const InputRng>
+ operator|( const InputRng& r, indirect_forwarder )
+ {
+ return indirect_range<const InputRng>( r );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::indirect_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::indirect_forwarder indirected =
+ range_detail::indirect_forwarder();
+ }
+ }
+
+ template<class InputRng>
+ inline indirect_range<InputRng>
+ make_indirected_range(InputRng& rng)
+ {
+ return rng | adaptors::indirected;
+ }
+
+ template<class InputRng>
+ inline indirect_range<const InputRng>
+ make_indirected_range(const InputRng& rng)
+ {
+ return rng | adaptors::indirected;
+ }
+}
+
+#endif
Added: sandbox/async/boost/range/adaptor/map.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/map.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,184 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_MAP_HPP
+#define BOOST_RANGE_ADAPTOR_MAP_HPP
+
+#include <boost/range/adaptor/transformed.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ struct map_keys_forwarder {};
+ struct map_values_forwarder {};
+
+ template< class Map >
+ struct select_first
+ {
+ typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
+ typedef const BOOST_DEDUCED_TYPENAME pair_t::first_type&
+ result_type;
+
+ result_type operator()( const pair_t& r ) const
+ {
+ return r.first;
+ }
+ };
+
+ template< class Map >
+ struct select_second_mutable
+ {
+ typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
+ typedef BOOST_DEDUCED_TYPENAME pair_t::second_type& result_type;
+
+ result_type operator()( pair_t& r ) const
+ {
+ return r.second;
+ }
+ };
+
+ template< class Map >
+ struct select_second_const
+ {
+ typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
+ typedef const BOOST_DEDUCED_TYPENAME pair_t::second_type&
+ result_type;
+
+ result_type operator()( const pair_t& r ) const
+ {
+ return r.second;
+ }
+ };
+
+ template<class StdPairRng>
+ class select_first_range
+ : public transform_range<
+ select_first<StdPairRng>,
+ const StdPairRng>
+ {
+ typedef transform_range<select_first<StdPairRng>, const StdPairRng> base;
+ public:
+ typedef select_first<StdPairRng> transform_fn_type;
+ typedef const StdPairRng source_range_type;
+
+ select_first_range(transform_fn_type fn, source_range_type& rng)
+ : base(fn, rng)
+ {
+ }
+
+ select_first_range(const base& other) : base(other) {}
+ };
+
+ template<class StdPairRng>
+ class select_second_mutable_range
+ : public transform_range<
+ select_second_mutable<StdPairRng>,
+ StdPairRng>
+ {
+ typedef transform_range<select_second_mutable<StdPairRng>, StdPairRng> base;
+ public:
+ typedef select_second_mutable<StdPairRng> transform_fn_type;
+ typedef StdPairRng source_range_type;
+
+ select_second_mutable_range(transform_fn_type fn, source_range_type& rng)
+ : base(fn, rng)
+ {
+ }
+
+ select_second_mutable_range(const base& other) : base(other) {}
+ };
+
+ template<class StdPairRng>
+ class select_second_const_range
+ : public transform_range<
+ select_second_const<StdPairRng>,
+ const StdPairRng>
+ {
+ typedef transform_range<select_second_const<StdPairRng>, const StdPairRng> base;
+ public:
+ typedef select_second_const<StdPairRng> transform_fn_type;
+ typedef const StdPairRng source_range_type;
+
+ select_second_const_range(transform_fn_type fn, source_range_type& rng)
+ : base(fn, rng)
+ {
+ }
+
+ select_second_const_range(const base& other) : base(other) {}
+ };
+
+ template< class StdPairRng >
+ inline select_first_range<StdPairRng>
+ operator|( const StdPairRng& r, map_keys_forwarder )
+ {
+ return operator|( r,
+ boost::adaptors::transformed( select_first<StdPairRng>() ) );
+ }
+
+ template< class StdPairRng >
+ inline select_second_mutable_range<StdPairRng>
+ operator|( StdPairRng& r, map_values_forwarder )
+ {
+ return operator|( r,
+ boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
+ }
+
+ template< class StdPairRng >
+ inline select_second_const_range<StdPairRng>
+ operator|( const StdPairRng& r, map_values_forwarder )
+ {
+ return operator|( r,
+ boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::select_first_range;
+ using range_detail::select_second_mutable_range;
+ using range_detail::select_second_const_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::map_keys_forwarder map_keys =
+ range_detail::map_keys_forwarder();
+
+ const range_detail::map_values_forwarder map_values =
+ range_detail::map_values_forwarder();
+ }
+ }
+
+ template<class StdPairRng>
+ inline select_first_range<StdPairRng>
+ make_map_key_range(const StdPairRng& rng)
+ {
+ return rng | adaptors::map_keys;
+ }
+
+ template<class StdPairRng>
+ inline select_second_mutable_range<StdPairRng>
+ make_map_value_range(StdPairRng& rng)
+ {
+ return rng | adaptors::map_values;
+ }
+
+ template<class StdPairRng>
+ inline select_second_const_range<StdPairRng>
+ make_map_value_range(const StdPairRng& rng)
+ {
+ return rng | adaptors::map_values;
+ }
+}
+
+#endif
Added: sandbox/async/boost/range/adaptor/replaced.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/replaced.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,133 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2007. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_REPLACED_IMPL_HPP_INCLUDED
+#define BOOST_RANGE_ADAPTOR_REPLACED_IMPL_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class Value >
+ class replace_value
+ {
+ public:
+ typedef const Value& result_type;
+ typedef const Value& first_argument_type;
+
+ replace_value(const Value& from, const Value& to)
+ : _from(from), _to(to)
+ {
+ }
+
+ const Value& operator()(const Value& x) const
+ {
+ return (x == _from) ? _to : x;
+ }
+
+ private:
+ Value _from;
+ Value _to;
+ };
+
+ template< class R >
+ class replace_range :
+ public boost::iterator_range<
+ boost::transform_iterator<
+ replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
+ {
+ private:
+ typedef replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
+
+ typedef boost::iterator_range<
+ boost::transform_iterator<
+ replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
+
+ replace_range( R& r, value_type from, value_type to )
+ : base_t( make_transform_iterator( boost::begin(r), Fn(from, to) ),
+ make_transform_iterator( boost::end(r), Fn(from, to) ) )
+ { }
+ };
+
+ template< class T >
+ class replace_holder : public holder2<T>
+ {
+ public:
+ replace_holder( const T& from, const T& to )
+ : holder2<T>(from, to)
+ { }
+ private:
+ // not assignable
+ void operator=(const replace_holder&);
+ };
+
+ template< class InputRng >
+ inline replace_range<InputRng>
+ operator|( InputRng& r,
+ const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
+ {
+ return replace_range<InputRng>(r, f.val1, f.val2);
+ }
+
+ template< class InputRng >
+ inline replace_range<const InputRng>
+ operator|( const InputRng& r,
+ const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
+ {
+ return replace_range<const InputRng>(r, f.val1, f.val2);
+ }
+ } // 'range_detail'
+
+ using range_detail::replace_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder2<range_detail::replace_holder>
+ replaced =
+ range_detail::forwarder2<range_detail::replace_holder>();
+ }
+ } // 'adaptors'
+
+ template<class InputRng>
+ inline replace_range<InputRng>
+ make_replaced_range(InputRng& rng,
+ BOOST_DEDUCED_TYPENAME range_value<InputRng>::type from,
+ BOOST_DEDUCED_TYPENAME range_value<InputRng>::type to)
+ {
+ return rng | adaptors::replaced(from, to);
+ }
+
+ template<class InputRng>
+ inline replace_range<const InputRng>
+ make_replaced_range(const InputRng& rng,
+ BOOST_DEDUCED_TYPENAME range_value<InputRng>::type from,
+ BOOST_DEDUCED_TYPENAME range_value<InputRng>::type to)
+ {
+ return rng | adaptors::replaced(from, to);
+ }
+} // 'boost'
+
+#endif // include guard
Added: sandbox/async/boost/range/adaptor/replaced_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/replaced_if.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,135 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2007. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_REPLACED_IF_IMPL_HPP_INCLUDED
+#define BOOST_RANGE_ADAPTOR_REPLACED_IF_IMPL_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class Pred, class Value >
+ class replace_value_if
+ {
+ public:
+ typedef const Value& result_type;
+ typedef const Value& first_argument_type;
+
+ replace_value_if(const Pred& pred, const Value& to)
+ : _pred(pred), _to(to)
+ {
+ }
+
+ const Value& operator()(const Value& x) const
+ {
+ return _pred(x) ? _to : x;
+ }
+
+ private:
+ Pred _pred;
+ Value _to;
+ };
+
+ template< class Pred, class R >
+ class replace_if_range :
+ public boost::iterator_range<
+ boost::transform_iterator<
+ replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
+ {
+ private:
+ typedef replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
+
+ typedef boost::iterator_range<
+ boost::transform_iterator<
+ replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
+
+ replace_if_range( R& r, const Pred& pred, value_type to )
+ : base_t( make_transform_iterator( boost::begin(r), Fn(pred, to) ),
+ make_transform_iterator( boost::end(r), Fn(pred, to) ) )
+ { }
+ };
+
+ template< class Pred, class T >
+ class replace_if_holder
+ {
+ public:
+ replace_if_holder( const Pred& pred, const T& to )
+ : _pred(pred), _to(to)
+ { }
+
+ const Pred& pred() const { return _pred; }
+ const T& to() const { return _to; }
+
+ private:
+ Pred _pred;
+ T _to;
+ };
+
+ template< class Pred, class InputRng >
+ inline replace_if_range<Pred, InputRng>
+ operator|( InputRng& r,
+ const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
+ {
+ return replace_if_range<Pred, InputRng>(r, f.pred(), f.to());
+ }
+
+ template< class Pred, class InputRng >
+ inline replace_if_range<Pred, const InputRng>
+ operator|( const InputRng& r,
+ const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
+ {
+ return replace_if_range<Pred, const InputRng>(r, f.pred(), f.to());
+ }
+ } // 'range_detail'
+
+ using range_detail::replace_if_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder2TU<range_detail::replace_if_holder>
+ replaced_if =
+ range_detail::forwarder2TU<range_detail::replace_if_holder>();
+ }
+ } // 'adaptors'
+
+ template<class Pred, class InputRng>
+ inline replace_if_range<Pred, InputRng>
+ make_replaced_if_range(InputRng& rng, Pred pred,
+ BOOST_DEDUCED_TYPENAME range_value<InputRng>::type to)
+ {
+ return rng | adaptors::replaced_if(pred, to);
+ }
+
+ template<class Pred, class InputRng>
+ inline replace_if_range<Pred, const InputRng>
+ make_replaced_if_range(const InputRng& rng, Pred pred,
+ BOOST_DEDUCED_TYPENAME range_value<InputRng>::type to)
+ {
+ return rng | adaptors::replaced_if(pred, to);
+ }
+} // 'boost'
+
+#endif // include guard
Added: sandbox/async/boost/range/adaptor/reversed.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/reversed.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,89 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_REVERSED_HPP
+#define BOOST_RANGE_ADAPTOR_REVERSED_HPP
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class R >
+ struct reverse_range :
+ public boost::iterator_range<
+ boost::reverse_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef boost::iterator_range<
+ boost::reverse_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ base;
+
+ public:
+ typedef boost::reverse_iterator<BOOST_DEDUCED_TYPENAME range_iterator<R>::type> iterator;
+
+ reverse_range( R& r )
+ : base( iterator(boost::end(r)), iterator(boost::begin(r)) )
+ { }
+ };
+
+ struct reverse_forwarder {};
+
+ template< class BidirectionalRng >
+ inline reverse_range<BidirectionalRng>
+ operator|( BidirectionalRng& r, reverse_forwarder )
+ {
+ return reverse_range<BidirectionalRng>( r );
+ }
+
+ template< class BidirectionalRng >
+ inline reverse_range<const BidirectionalRng>
+ operator|( const BidirectionalRng& r, reverse_forwarder )
+ {
+ return reverse_range<const BidirectionalRng>( r );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::reverse_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::reverse_forwarder reversed =
+ range_detail::reverse_forwarder();
+ }
+ }
+
+ template<class BidirectionalRng>
+ inline reverse_range<BidirectionalRng>
+ make_reversed_range(BidirectionalRng& rng)
+ {
+ return rng | adaptors::reversed;
+ }
+
+ template<class BidirectionalRng>
+ inline reverse_range<const BidirectionalRng>
+ make_reversed_range(const BidirectionalRng& rng)
+ {
+ return rng | adaptors::reversed;
+ }
+}
+
+#endif
Added: sandbox/async/boost/range/adaptor/sliced.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/sliced.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,88 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_SLICED_HPP
+#define BOOST_RANGE_ADAPTOR_SLICED_HPP
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class T >
+ struct slice_holder
+ : holder2<std::size_t>
+ {
+ slice_holder( std::size_t t, std::size_t u )
+ : holder2<std::size_t>(t,u)
+ { }
+ };
+
+ template< class R, class H >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<R>::type >
+ sliced_impl( R& r, const H& f )
+ {
+ BOOST_ASSERT( f.val1 <= f.val2 &&
+ "error in slice indexes" );
+ BOOST_ASSERT( static_cast<std::size_t>(boost::size(r)) >= f.val2 &&
+ "second slice index out of bounds" );
+
+ return make_iterator_range( r, f.val1,
+ f.val2 - boost::size(r) );
+ }
+
+ template< class RandomAccessRng, class Int >
+ inline iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRng>::type >
+ operator|( RandomAccessRng& r, const slice_holder<Int>& f )
+ {
+ return sliced_impl( r, f );
+ }
+
+ template< class RandomAccessRng, class Int >
+ inline iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRng>::type >
+ operator|( const RandomAccessRng& r, const slice_holder<Int>& f )
+ {
+ return sliced_impl( r, f );
+ }
+
+ } // 'range_detail'
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder2<range_detail::slice_holder>
+ sliced = range_detail::forwarder2<range_detail::slice_holder>();
+ }
+ }
+
+ template<class RandomAccessRng>
+ inline iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRng>::type>
+ make_sliced_range(RandomAccessRng& rng, std::size_t t, std::size_t u)
+ {
+ return rng | adaptors::sliced(t, u);
+ }
+
+ template<class RandomAccessRng>
+ inline iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRng>::type>
+ make_sliced_range(const RandomAccessRng& rng, std::size_t t, std::size_t u)
+ {
+ return rng | adaptors::sliced(t, u);
+ }
+}
+
+#endif
Added: sandbox/async/boost/range/adaptor/strided.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/strided.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,147 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2007. 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/range/
+//
+#ifndef BOOST_RANGE_ADAPTOR_STRIDED_HPP_INCLUDED
+#define BOOST_RANGE_ADAPTOR_STRIDED_HPP_INCLUDED
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <iterator>
+
+namespace boost
+{
+ namespace range_detail
+ {
+
+ template<typename BaseIterator>
+ class strided_iterator
+ : public iterator_adaptor<
+ strided_iterator<BaseIterator>,
+ BaseIterator>
+ {
+ friend class iterator_core_access;
+
+ typedef BOOST_DEDUCED_TYPENAME iterator_adaptor<strided_iterator<BaseIterator>,
+ BaseIterator> super_t;
+
+ public:
+ typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type
+ difference_type;
+
+ strided_iterator() : m_stride() { }
+
+ strided_iterator(const strided_iterator& other)
+ : super_t(other), m_stride(other.m_stride) { }
+
+ explicit strided_iterator(BaseIterator base_it, difference_type stride)
+ : super_t(base_it), m_stride(stride) { }
+
+ strided_iterator&
+ operator=(const strided_iterator& other)
+ {
+ super_t::operator=(other);
+
+ // Is the interoperation of the stride safe?
+ m_stride = other.m_stride;
+ return *this;
+ }
+
+ void increment() { std::advance(this->base_reference(), m_stride); }
+
+ void decrement() { std::advance(this->base_reference(), -m_stride); }
+
+ void advance(difference_type n) { std::advance(this->base_reference(), n * m_stride); }
+
+ difference_type
+ distance_to(const strided_iterator& other) const
+ {
+ return std::distance(this->base_reference(), other.base_reference()) / m_stride;
+ }
+
+ // Using the compiler generated copy constructor and
+ // and assignment operator
+
+ private:
+ difference_type m_stride;
+ };
+
+ template<class BaseIterator> inline
+ strided_iterator<BaseIterator>
+ make_strided_iterator(
+ const BaseIterator& first,
+ BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type stride)
+ {
+ return strided_iterator<BaseIterator>(first, stride);
+ }
+
+ template< class Rng >
+ class strided_range
+ : public iterator_range<range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> >
+ {
+ typedef range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> iter_type;
+ typedef iterator_range<iter_type> super_t;
+ public:
+ template< typename Difference >
+ strided_range(Difference stride, Rng& r)
+ : super_t(make_strided_iterator(begin(r), stride),
+ make_strided_iterator(end(r), stride))
+ {
+ }
+ };
+
+ template<class Difference>
+ class strided_holder : public holder<Difference>
+ {
+ public:
+ strided_holder(Difference value) : holder<Difference>(value) {}
+ };
+
+ template<class Rng, class Difference>
+ inline strided_range<Rng>
+ operator|(Rng& rng, const strided_holder<Difference>& stride)
+ {
+ return strided_range<Rng>(stride.val, rng);
+ }
+
+ template<class Rng, class Difference>
+ inline strided_range<Rng>
+ operator|(const Rng& rng, const strided_holder<Difference>& stride)
+ {
+ return strided_range<const Rng>(stride.val, rng);
+ }
+
+ } // namespace range_detail
+
+ using range_detail::strided_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder<range_detail::strided_holder>
+ strided = range_detail::forwarder<range_detail::strided_holder>();
+ }
+ } // namespace adaptors
+
+ template<class Rng, class Difference>
+ inline make_strided_range(Rng& rng, Difference step)
+ {
+ return rng | adaptors::stride(step);
+ }
+
+ template<class Rng, class Difference>
+ inline make_strided_range(const Rng& rng, Difference step)
+ {
+ return rng | adaptors::stride(step);
+ }
+} // namespace boost
+
+#endif
Added: sandbox/async/boost/range/adaptor/tokenized.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/tokenized.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,136 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_TOKENIZED_HPP
+#define BOOST_RANGE_ADAPTOR_TOKENIZED_HPP
+
+#include <boost/regex.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+
+ template< class R >
+ struct token_range :
+ public boost::iterator_range<
+ boost::regex_token_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef
+ boost::regex_token_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ regex_iter;
+
+ typedef BOOST_DEDUCED_TYPENAME regex_iter::regex_type
+ regex_type;
+
+ typedef boost::iterator_range<regex_iter>
+ base;
+
+ public:
+ template< class Regex, class Submatch, class Flag >
+ token_range( R& r, const Regex& re, const Submatch& sub, Flag f )
+ : base( regex_iter( boost::begin(r), boost::end(r),
+ regex_type(re), sub, f ),
+ regex_iter() )
+ { }
+ };
+
+ template< class T, class U, class V >
+ struct regex_holder
+ {
+ const T& re;
+ const U& sub;
+ V f;
+
+ regex_holder( const T& rex, const U& subm, V flag ) :
+ re(rex), sub(subm), f(flag)
+ { }
+ private:
+ // Not assignable
+ void operator=(const regex_holder&);
+ };
+
+ struct regex_forwarder
+ {
+ template< class Regex >
+ regex_holder<Regex,int,regex_constants::match_flag_type>
+ operator()( const Regex& re,
+ int submatch = 0,
+ regex_constants::match_flag_type f =
+ regex_constants::match_default ) const
+ {
+ return regex_holder<Regex,int,
+ regex_constants::match_flag_type>( re, submatch, f );
+ }
+
+ template< class Regex, class Submatch >
+ regex_holder<Regex,Submatch,regex_constants::match_flag_type>
+ operator()( const Regex& re,
+ const Submatch& sub,
+ regex_constants::match_flag_type f =
+ regex_constants::match_default ) const
+ {
+ return regex_holder<Regex,Submatch,
+ regex_constants::match_flag_type>( re, sub, f );
+ }
+ };
+
+ template< class BidirectionalRng, class R, class S, class F >
+ inline token_range<BidirectionalRng>
+ operator|( BidirectionalRng& r,
+ const regex_holder<R,S,F>& f )
+ {
+ return token_range<BidirectionalRng>( r, f.re, f.sub, f.f );
+ }
+
+ template< class BidirectionalRng, class R, class S, class F >
+ inline token_range<const BidirectionalRng>
+ operator|( const BidirectionalRng& r,
+ const regex_holder<R,S,F>& f )
+ {
+ return token_range<const BidirectionalRng>( r, f.re, f.sub, f.f );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::token_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::regex_forwarder tokenized =
+ range_detail::regex_forwarder();
+ }
+ }
+
+ template<class BidirectionalRng, class Regex, class Submatch, class Flag>
+ inline token_range<BidirectionalRng>
+ make_tokenized_range(BidirectionalRng& rng, const Regex& reg, const Submatch& sub, Flag f)
+ {
+ return token_range<BidirectionalRng>(rng, reg, sub, f);
+ }
+
+ template<class BidirectionalRng, class Regex, class Submatch, class Flag>
+ inline token_range<const BidirectionalRng>
+ make_tokenized_range(const BidirectionalRng& rng, const Regex& reg, const Submatch& sub, Flag f)
+ {
+ return token_range<const BidirectionalRng>(rng, reg, sub, f);
+ }
+}
+
+#endif
Added: sandbox/async/boost/range/adaptor/transformed.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/transformed.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,102 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_TRANSFORMED_HPP
+#define BOOST_RANGE_ADAPTOR_TRANSFORMED_HPP
+
+#include <boost/range/adaptor/argument_fwd.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+
+ template< class F, class R >
+ struct transform_range :
+ public boost::iterator_range<
+ boost::transform_iterator< F,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ {
+ private:
+ typedef boost::iterator_range<
+ boost::transform_iterator< F,
+ BOOST_DEDUCED_TYPENAME range_iterator<R>::type
+ >
+ >
+ base;
+
+ public:
+ typedef F transform_fn_type;
+ typedef R source_range_type;
+
+ transform_range( F f, R& r )
+ : base( make_transform_iterator( boost::begin(r), f ),
+ make_transform_iterator( boost::end(r), f ) )
+
+ { }
+ };
+
+ template< class T >
+ struct transform_holder : holder<T>
+ {
+ transform_holder( T r ) : holder<T>(r)
+ { }
+ };
+
+ template< class InputRng, class UnaryFunction >
+ inline transform_range<UnaryFunction,InputRng>
+ operator|( InputRng& r,
+ const transform_holder<UnaryFunction>& f )
+ {
+ return transform_range<UnaryFunction,InputRng>( f.val, r );
+ }
+
+ template< class InputRng, class UnaryFunction >
+ inline transform_range<UnaryFunction, const InputRng>
+ operator|( const InputRng& r,
+ const transform_holder<UnaryFunction>& f )
+ {
+ return transform_range<UnaryFunction, const InputRng>( f.val, r );
+ }
+
+ } // 'range_detail'
+
+ using range_detail::transform_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::forwarder<range_detail::transform_holder>
+ transformed =
+ range_detail::forwarder<range_detail::transform_holder>();
+ }
+ }
+
+ template<class UnaryFunction, class InputRng>
+ inline transform_range<UnaryFunction,InputRng>
+ make_transformed_range(InputRng& rng, UnaryFunction fn)
+ {
+ return rng | adaptors::transformed(fn);
+ }
+
+ template<class UnaryFunction, class InputRng>
+ inline transform_range<UnaryFunction, const InputRng>
+ make_transformed_range(const InputRng& rng, UnaryFunction fn)
+ {
+ return rng | adaptors::transformed(fn);
+ }
+}
+
+#endif
Added: sandbox/async/boost/range/adaptor/uniqued.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptor/uniqued.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,90 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTOR_UNIQUED_IMPL_HPP
+#define BOOST_RANGE_ADAPTOR_UNIQUED_IMPL_HPP
+
+#include <boost/range/adaptor/adjacent_filtered.hpp>
+
+namespace boost
+{
+
+ namespace range_detail
+ {
+ struct unique_forwarder { };
+
+ struct unique_not_equal_to
+ {
+ typedef bool result_type;
+
+ template< class T >
+ bool operator()( const T& l, const T& r ) const
+ {
+ return !(l == r);
+ }
+ };
+
+ template<class ForwardRng>
+ class unique_range : public adjacent_filter_range<unique_not_equal_to, ForwardRng>
+ {
+ typedef adjacent_filter_range<unique_not_equal_to, ForwardRng> base;
+ public:
+ explicit unique_range(ForwardRng& rng)
+ : base(unique_not_equal_to(), rng, true)
+ {
+ }
+ };
+
+ template< class ForwardRng >
+ inline unique_range<ForwardRng>
+ operator|( ForwardRng& r,
+ unique_forwarder )
+ {
+ return unique_range<ForwardRng>(r);
+ }
+
+ template< class ForwardRng >
+ inline unique_range<const ForwardRng>
+ operator|( const ForwardRng& r,
+ unique_forwarder )
+ {
+ return unique_range<const ForwardRng>(r);
+ }
+
+ } // 'range_detail'
+
+ using range_detail::unique_range;
+
+ namespace adaptors
+ {
+ namespace
+ {
+ const range_detail::unique_forwarder uniqued =
+ range_detail::unique_forwarder();
+ }
+ }
+
+ template<class ForwardRng>
+ inline unique_range<ForwardRng>
+ make_uniqued_range(ForwardRng& rng)
+ {
+ return unique_range<ForwardRng>(rng);
+ }
+
+ template<class ForwardRng>
+ inline unique_range<const ForwardRng>
+ make_uniqued_range(const ForwardRng& rng)
+ {
+ return unique_range<const ForwardRng>(rng);
+ }
+
+}
+
+#endif
Added: sandbox/async/boost/range/adaptors.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/adaptors.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,29 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2007.
+// Copyright Thorsten Ottosen 2006.
+// 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/range/
+//
+
+#ifndef BOOST_RANGE_ADAPTORS_HPP
+#define BOOST_RANGE_ADAPTORS_HPP
+
+#include <boost/range/adaptor/adjacent_filtered.hpp>
+#include <boost/range/adaptor/copied.hpp>
+#include <boost/range/adaptor/filtered.hpp>
+#include <boost/range/adaptor/indexed.hpp>
+#include <boost/range/adaptor/indirected.hpp>
+#include <boost/range/adaptor/map.hpp>
+#include <boost/range/adaptor/replaced.hpp>
+#include <boost/range/adaptor/replaced_if.hpp>
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/adaptor/sliced.hpp>
+#include <boost/range/adaptor/tokenized.hpp>
+#include <boost/range/adaptor/transformed.hpp>
+#include <boost/range/adaptor/uniqued.hpp>
+
+#endif
Added: sandbox/async/boost/range/algorithm.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,85 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file algorithm.hpp
+/// Includes the range-based versions of the algorithms in the
+/// C++ standard header file <algorithm>
+//
+/////////////////////////////////////////////////////////////////////////////
+
+// Copyright 2009 Neil Groves.
+// 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)
+//
+// Acknowledgements:
+// This code uses combinations of ideas, techniques and code snippets
+// from: Thorsten Ottosen, Eric Niebler, Jeremy Siek,
+// and Vladimir Prus'
+//
+// The original mutating algorithms that served as the first version
+// were originally written by Vladimir Prus'
+// <ghost_at_[hidden]> code from Boost Wiki
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+#pragma once
+#endif
+
+#ifndef BOOST_RANGE_ALGORITHM_HPP_INCLUDED_01012009
+#define BOOST_RANGE_ALGORITHM_HPP_INCLUDED_01012009
+
+#include <boost/range/concepts.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/next_prior.hpp>
+#include <algorithm>
+
+// Non-Modifying Sequence Operations
+#include <boost/range/algorithm/adjacent_find.hpp>
+#include <boost/range/algorithm/binary_search.hpp>
+#include <boost/range/algorithm/count.hpp>
+#include <boost/range/algorithm/count_if.hpp>
+#include <boost/range/algorithm/equal.hpp>
+#include <boost/range/algorithm/equal_range.hpp>
+#include <boost/range/algorithm/for_each.hpp>
+#include <boost/range/algorithm/find.hpp>
+#include <boost/range/algorithm/find_end.hpp>
+#include <boost/range/algorithm/find_first_of.hpp>
+#include <boost/range/algorithm/find_if.hpp>
+#include <boost/range/algorithm/lexicographical_compare.hpp>
+#include <boost/range/algorithm/lower_bound.hpp>
+#include <boost/range/algorithm/max_element.hpp>
+#include <boost/range/algorithm/min_element.hpp>
+#include <boost/range/algorithm/mismatch.hpp>
+#include <boost/range/algorithm/search.hpp>
+#include <boost/range/algorithm/upper_bound.hpp>
+
+// Modifying Sequence Operations
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/range/algorithm/copy_backward.hpp>
+#include <boost/range/algorithm/fill.hpp>
+#include <boost/range/algorithm/generate.hpp>
+#include <boost/range/algorithm/inplace_merge.hpp>
+#include <boost/range/algorithm/merge.hpp>
+#include <boost/range/algorithm/nth_element.hpp>
+#include <boost/range/algorithm/partial_sort.hpp>
+#include <boost/range/algorithm/partition.hpp>
+#include <boost/range/algorithm/random_shuffle.hpp>
+#include <boost/range/algorithm/remove.hpp>
+#include <boost/range/algorithm/remove_if.hpp>
+#include <boost/range/algorithm/replace.hpp>
+#include <boost/range/algorithm/replace_if.hpp>
+#include <boost/range/algorithm/reverse.hpp>
+#include <boost/range/algorithm/rotate.hpp>
+#include <boost/range/algorithm/sort.hpp>
+#include <boost/range/algorithm/stable_partition.hpp>
+#include <boost/range/algorithm/stable_sort.hpp>
+#include <boost/range/algorithm/transform.hpp>
+#include <boost/range/algorithm/unique.hpp>
+
+#include <boost/range/algorithm/set_algorithm.hpp>
+#include <boost/range/algorithm/heap_algorithm.hpp>
+#include <boost/range/algorithm/permutation.hpp>
+
+#endif // include guard
+
Added: sandbox/async/boost/range/algorithm/adjacent_find.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/adjacent_find.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,114 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_ADJACENT_FIND_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_ADJACENT_FIND_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function adjacent_find
+ ///
+ /// range-based version of the adjacent_find std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template< class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ adjacent_find(ForwardRange & rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
+ return std::adjacent_find(boost::begin(rng),boost::end(rng));
+ }
+
+ /// \overload
+ template< class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ adjacent_find(const ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::adjacent_find(boost::begin(rng),boost::end(rng));
+ }
+
+ /// \overload
+ template< class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ adjacent_find(ForwardRange & rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
+ }
+
+ /// \overload
+ template< class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ adjacent_find(ForwardRange & rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
+ return range_return<ForwardRange,re>::
+ pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ adjacent_find(const ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
+ return range_return<const ForwardRange,re>::
+ pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ adjacent_find(ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
+ return range_return<ForwardRange,re>::
+ pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
+ return range_return<const ForwardRange,re>::
+ pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
+ rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/binary_search.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/binary_search.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,43 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_BINARY_SEARCH_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_BINARY_SEARCH_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function binary_search
+ ///
+ /// range-based version of the binary_search std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class ForwardRange, class Value>
+ inline bool binary_search(const ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::binary_search(boost::begin(rng), boost::end(rng), val);
+ }
+
+ /// \overload
+ template<class ForwardRange, class Value, class BinaryPredicate>
+ inline bool binary_search(const ForwardRange& rng, const Value& val,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::binary_search(boost::begin(rng), boost::end(rng), val, pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/copy.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/copy.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,35 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_COPY_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_COPY_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function copy
+ ///
+ /// range-based version of the copy std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ /// \pre OutputIterator is a model of the OutputIteratorConcept
+ template< class SinglePassRange, class OutputIterator >
+ inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::copy(boost::begin(rng),boost::end(rng),out);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/copy_backward.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/copy_backward.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,37 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_COPY_BACKWARD_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_COPY_BACKWARD_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function copy_backward
+ ///
+ /// range-based version of the copy_backwards std algorithm
+ ///
+ /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+ /// \pre BidirectionalTraversalWriteableIterator is a model of the BidirectionalIteratorConcept
+ /// \pre BidirectionalTraversalWriteableIterator is a model of the WriteableIteratorConcept
+ template< class BidirectionalRange, class BidirectionalTraversalWriteableIterator >
+ inline BidirectionalTraversalWriteableIterator
+ copy_backward(const BidirectionalRange& rng,
+ BidirectionalTraversalWriteableIterator out)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ return std::copy_backward(boost::begin(rng), boost::end(rng), out);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/count.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/count.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,44 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_COUNT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_COUNT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/difference_type.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function count
+ ///
+ /// range-based version of the count std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ template< class SinglePassRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
+ count(SinglePassRange& rng, const Value& val)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::count(boost::begin(rng), boost::end(rng), val);
+ }
+
+ /// \overload
+ template< class SinglePassRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type
+ count(const SinglePassRange& rng, const Value& val)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::count(boost::begin(rng), boost::end(rng), val);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/count_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/count_if.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,45 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_COUNT_IF_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_COUNT_IF_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/difference_type.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function count_if
+ ///
+ /// range-based version of the count_if std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
+ template< class SinglePassRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type
+ count_if(SinglePassRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::count_if(boost::begin(rng), boost::end(rng), pred);
+ }
+
+ /// \overload
+ template< class SinglePassRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type
+ count_if(const SinglePassRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::count_if(boost::begin(rng), boost::end(rng), pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/equal.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,182 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009.
+// 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/range/concepts.hpp>
+#include <iterator>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ // An implementation of equality comparison that is optimized for iterator
+ // traversal categories less than RandomAccessTraversal.
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2,
+ class IteratorCategoryTag1,
+ class IteratorCategoryTag2 >
+ inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2,
+ IteratorCategoryTag1,
+ IteratorCategoryTag2 )
+ {
+ do
+ {
+ // If we have reached the end of the left range then this is
+ // the end of the loop. They are equal if and only if we have
+ // simultaneously reached the end of the right range.
+ if (first1 == last1)
+ return first2 == last2;
+
+ // If we have reached the end of the right range at this line
+ // it indicates that the right range is shorter than the left
+ // and hence the result is false.
+ if (first2 == last2)
+ return false;
+
+ // continue looping if and only if the values are equal
+ } while(*first1++ == *first2++);
+
+ // Reaching this line in the algorithm indicates that a value
+ // inequality has been detected.
+ return false;
+ }
+
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2,
+ class IteratorCategoryTag1,
+ class IteratorCategoryTag2,
+ class BinaryPredicate >
+ inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2,
+ BinaryPredicate pred,
+ IteratorCategoryTag1,
+ IteratorCategoryTag2 )
+ {
+ do
+ {
+ // If we have reached the end of the left range then this is
+ // the end of the loop. They are equal if and only if we have
+ // simultaneously reached the end of the right range.
+ if (first1 == last1)
+ return first2 == last2;
+
+ // If we have reached the end of the right range at this line
+ // it indicates that the right range is shorter than the left
+ // and hence the result is false.
+ if (first2 == last2)
+ return false;
+
+ // continue looping if and only if the values are equal
+ } while(pred(*first1++, *first2++));
+
+ // Reaching this line in the algorithm indicates that a value
+ // inequality has been detected.
+ return false;
+ }
+
+ // An implementation of equality comparison that is optimized for
+ // random access iterators.
+ template< class RandomAccessTraversalReadableIterator1,
+ class RandomAccessTraversalReadableIterator2 >
+ inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
+ RandomAccessTraversalReadableIterator1 last1,
+ RandomAccessTraversalReadableIterator2 first2,
+ RandomAccessTraversalReadableIterator2 last2,
+ std::random_access_iterator_tag,
+ std::random_access_iterator_tag )
+ {
+ return ((last1 - first1) == (last2 - first2))
+ && std::equal(first1, last1, first2);
+ }
+
+ template< class RandomAccessTraversalReadableIterator1,
+ class RandomAccessTraversalReadableIterator2,
+ class BinaryPredicate >
+ inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
+ RandomAccessTraversalReadableIterator1 last1,
+ RandomAccessTraversalReadableIterator2 first2,
+ RandomAccessTraversalReadableIterator2 last2,
+ BinaryPredicate pred )
+ {
+ return ((last1 - first1) == (last2 - first2))
+ && std::equal(first1, last1, first2, pred);
+ }
+
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2 >
+ inline bool equal( SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2 )
+ {
+ BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
+ BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
+
+ return equal_impl(first1, last1, first2, last2, tag1, tag2);
+ }
+
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2,
+ class BinaryPredicate >
+ inline bool equal( SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2,
+ BinaryPredicate pred )
+ {
+ BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
+ BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;
+
+ return equal_impl(first1, last1, first2, last2, pred, tag1, tag2);
+ }
+
+ }
+
+ /// \brief template function equal
+ ///
+ /// range-based version of the equal std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template< class SinglePassRange1, class SinglePassRange2 >
+ inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::equal(
+ boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2) );
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+ inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
+ BinaryPredicate pred )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::equal(
+ boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2),
+ pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/equal_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/equal_range.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,74 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EQUAL_RANGE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EQUAL_RANGE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function equal_range
+ ///
+ /// range-based version of the equal_range std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre SortPredicate is a model of the BinaryPredicateConcept
+ template<class ForwardRange, class Value>
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
+ >
+ equal_range(ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::equal_range(boost::begin(rng), boost::end(rng), val);
+ }
+
+ /// \overload
+ template<class ForwardRange, class Value>
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+ >
+ equal_range(const ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::equal_range(boost::begin(rng), boost::end(rng), val);
+ }
+
+ /// \overload
+ template<class ForwardRange, class Value, class SortPredicate>
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
+ >
+ equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
+ }
+
+ /// \overload
+ template<class ForwardRange, class Value, class SortPredicate>
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+ >
+ equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/fill.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/fill.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,41 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_FILL_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_FILL_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function fill
+ ///
+ /// range-based version of the fill std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ template< class ForwardRange, class Value >
+ inline void fill(ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::fill(boost::begin(rng), boost::end(rng), val);
+ }
+
+ /// \overload
+ template< class ForwardRange, class Value >
+ inline void fill(const ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::fill(boost::begin(rng), boost::end(rng), val);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/find.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/find.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,66 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_FIND_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_FIND_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function find
+ ///
+ /// range-based version of the find std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ template< class SinglePassRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
+ find( SinglePassRange& rng, Value val )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::find(boost::begin(rng), boost::end(rng), val);
+ }
+ /// \overload
+ template< class SinglePassRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+ find( const SinglePassRange& rng, Value val )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::find(boost::begin(rng), boost::end(rng), val);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, class SinglePassRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+ find( SinglePassRange& rng, Value val )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return range_return<SinglePassRange,re>::
+ pack(std::find(boost::begin(rng), boost::end(rng), val),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class SinglePassRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
+ find( const SinglePassRange& rng, Value val )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return range_return<const SinglePassRange,re>::
+ pack(std::find(boost::begin(rng), boost::end(rng), val),
+ rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/find_end.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/find_end.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,136 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_FIND_END_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_FIND_END_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function find_end
+ ///
+ /// range-based version of the find_end std algorithm
+ ///
+ /// \pre ForwardRange1 is a model of the ForwardRangeConcept
+ /// \pre ForwardRange2 is a model of the ForwardRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template< class ForwardRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
+ find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return std::find_end(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2));
+ }
+
+ /// \overload
+ template< class ForwardRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+ find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return std::find_end(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2));
+ }
+
+ /// \overload
+ template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
+ find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return std::find_end(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2),pred);
+ }
+
+ /// \overload
+ template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+ find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return std::find_end(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2),pred);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+ find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return range_return<ForwardRange1,re>::
+ pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2)),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+ find_end(const ForwardRange1& rng1, const ForwardRange2& rng2)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return range_return<const ForwardRange1,re>::
+ pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2)),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange1, class ForwardRange2,
+ class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+ find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return range_return<ForwardRange1,re>::
+ pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange1, class ForwardRange2,
+ class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+ find_end(const ForwardRange1& rng1, const ForwardRange2& rng2,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return range_return<const ForwardRange1,re>::
+ pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred),
+ rng1);
+ }
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/find_first_of.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/find_first_of.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,139 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_FIND_FIRST_OF_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_FIND_FIRST_OF_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function find_first_of
+ ///
+ /// range-based version of the find_first_of std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre ForwardRange2 is a model of the ForwardRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template< class SinglePassRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
+ find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2));
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+ find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2));
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
+ find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2),pred);
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+ find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2),pred);
+ }
+
+// range return overloads
+ /// \overload
+ template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
+ find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return range_return<SinglePassRange1,re>::
+ pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2)),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
+ find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return range_return<const SinglePassRange1,re>::
+ pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2)),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class SinglePassRange1, class ForwardRange2,
+ class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
+ find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return range_return<SinglePassRange1,re>::
+ pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class SinglePassRange1, class ForwardRange2,
+ class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
+ find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+
+ return range_return<const SinglePassRange1,re>::
+ pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2),pred),
+ rng1);
+ }
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/find_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/find_if.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,69 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_FIND_IF_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_FIND_IF_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function find_if
+ ///
+ /// range-based version of the find_if std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
+ template< class SinglePassRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
+ find_if( SinglePassRange& rng, UnaryPredicate pred )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::find_if(boost::begin(rng), boost::end(rng), pred);
+ }
+ /// \overload
+ template< class SinglePassRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+ find_if( const SinglePassRange& rng, UnaryPredicate pred )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::find_if(boost::begin(rng), boost::end(rng), pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, class SinglePassRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+ find_if( SinglePassRange& rng, UnaryPredicate pred )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return range_return<SinglePassRange,re>::
+ pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class SinglePassRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
+ find_if( const SinglePassRange& rng, UnaryPredicate pred )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return range_return<const SinglePassRange,re>::
+ pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/for_each.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/for_each.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,42 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_FOR_EACH_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_FOR_EACH_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function for_each
+ ///
+ /// range-based version of the for_each std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ /// \pre UnaryFunction is a model of the UnaryFunctionConcept
+ template< class SinglePassRange, class UnaryFunction >
+ inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
+ {
+ boost::function_requires< SinglePassRangeConcept< SinglePassRange > >();
+ return std::for_each(boost::begin(rng),boost::end(rng),fun);
+ }
+
+ /// \overload
+ template< class SinglePassRange, class UnaryFunction >
+ inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
+ {
+ boost::function_requires< SinglePassRangeConcept< SinglePassRange > >();
+ return std::for_each(boost::begin(rng),boost::end(rng),fun);
+ }
+} // namespace boost
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/generate.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/generate.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,44 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_GENERATE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_GENERATE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function generate
+ ///
+ /// range-based version of the generate std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre Generator is a model of the UnaryFunctionConcept
+ template< class ForwardRange, class Generator >
+ inline ForwardRange& generate( ForwardRange& rng, Generator gen )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::generate(boost::begin(rng), boost::end(rng), gen);
+ return rng;
+ }
+
+ /// \overload
+ template< class ForwardRange, class Generator >
+ inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::generate(boost::begin(rng), boost::end(rng), gen);
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/heap_algorithm.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/heap_algorithm.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,169 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_HEAP_ALGORITHM_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_HEAP_ALGORITHM_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function push_heap
+ ///
+ /// range-based version of the push_heap std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre Compare is a model of the BinaryPredicateConcept
+ template<class RandomAccessRange>
+ inline void push_heap(RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::push_heap(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline void push_heap(const RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::push_heap(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Compare>
+ inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Compare>
+ inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
+ }
+
+ /// \brief template function pop_heap
+ ///
+ /// range-based version of the pop_heap std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre Compare is a model of the BinaryPredicateConcept
+ template<class RandomAccessRange>
+ inline void pop_heap(RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::pop_heap(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline void pop_heap(const RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::pop_heap(boost::begin(rng),boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Compare>
+ inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Compare>
+ inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
+ }
+
+ /// \brief template function make_heap
+ ///
+ /// range-based version of the make_heap std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre Compare is a model of the BinaryPredicateConcept
+ template<class RandomAccessRange>
+ inline void make_heap(RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::make_heap(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline void make_heap(const RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::make_heap(boost::begin(rng),boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Compare>
+ inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Compare>
+ inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
+ }
+
+ /// \brief template function sort_heap
+ ///
+ /// range-based version of the sort_heap std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre Compare is a model of the BinaryPredicateConcept
+ template<class RandomAccessRange>
+ inline void sort_heap(RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::sort_heap(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline void sort_heap(const RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::sort_heap(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Compare>
+ inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Compare>
+ inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/inplace_merge.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/inplace_merge.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,68 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_INPLACE_MERGE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_INPLACE_MERGE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function inplace_merge
+ ///
+ /// range-based version of the inplace_merge std algorithm
+ ///
+ /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class BidirectionalRange>
+ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type middle)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class BidirectionalRange>
+ inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class BidirectionalRange, class BinaryPredicate>
+ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
+ return rng;
+ }
+
+ /// \overload
+ template<class BidirectionalRange, class BinaryPredicate>
+ inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/lexicographical_compare.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/lexicographical_compare.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,52 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_LEXICOGRAPHICAL_COMPARE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_LEXICOGRAPHICAL_COMPARE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function lexicographic_compare
+ ///
+ /// range-based version of the lexicographic_compare std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ template<class SinglePassRange1, class SinglePassRange2>
+ inline bool lexicographical_compare(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::lexicographical_compare(
+ boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2));
+ }
+
+ /// \overload
+ template<class SinglePassRange1, class SinglePassRange2,
+ class BinaryPredicate>
+ inline bool lexicographical_compare(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::lexicographical_compare(
+ boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/lower_bound.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/lower_bound.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,99 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_LOWER_BOUND_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_LOWER_BOUND_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function lower_bound
+ ///
+ /// range-based version of the lower_bound std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ template< class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ lower_bound( ForwardRange& rng, Value val )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::lower_bound(boost::begin(rng), boost::end(rng), val);
+ }
+ /// \overload
+ template< class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ lower_bound( const ForwardRange& rng, Value val )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::lower_bound(boost::begin(rng), boost::end(rng), val);
+ }
+ /// \overload
+ template< class ForwardRange, class Value, class SortPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
+ }
+ /// \overload
+ template< class ForwardRange, class Value, class SortPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ lower_bound( ForwardRange& rng, Value val )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::
+ pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ lower_bound( const ForwardRange& rng, Value val )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::
+ pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::
+ pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::
+ pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
+ rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/max_element.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/max_element.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,109 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_MAX_ELEMENT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_MAX_ELEMENT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function max_element
+ ///
+ /// range-based version of the max_element std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class ForwardRange>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ max_element(ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::max_element(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class ForwardRange>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ max_element(const ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::max_element(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class ForwardRange, class BinaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ max_element(ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::max_element(boost::begin(rng), boost::end(rng), pred);
+ }
+
+ /// \overload
+ template<class ForwardRange, class BinaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ max_element(const ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::max_element(boost::begin(rng), boost::end(rng), pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template<range_return_value re, class ForwardRange>
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ max_element(ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::pack(
+ std::max_element(boost::begin(rng), boost::end(rng)),
+ rng);
+ }
+
+ /// \overload
+ template<range_return_value re, class ForwardRange>
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ max_element(const ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::pack(
+ std::max_element(boost::begin(rng), boost::end(rng)),
+ rng);
+ }
+
+ /// \overload
+ template<range_return_value re, class ForwardRange, class BinaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ max_element(ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::pack(
+ std::max_element(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+
+ /// \overload
+ template<range_return_value re, class ForwardRange, class BinaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ max_element(const ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::pack(
+ std::max_element(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/merge.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/merge.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,55 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_MERGE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_MERGE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function merge
+ ///
+ /// range-based version of the merge std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ ///
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator>
+ inline OutputIterator merge(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::merge(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out);
+ }
+
+ /// \overload
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator, class BinaryPredicate>
+ inline OutputIterator merge(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::merge(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out, pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/min_element.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/min_element.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,109 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_MIN_ELEMENT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_MIN_ELEMENT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function min_element
+ ///
+ /// range-based version of the min_element std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class ForwardRange>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ min_element(ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::min_element(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class ForwardRange>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ min_element(const ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::min_element(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class ForwardRange, class BinaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ min_element(ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::min_element(boost::begin(rng), boost::end(rng), pred);
+ }
+
+ /// \overload
+ template<class ForwardRange, class BinaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ min_element(const ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::min_element(boost::begin(rng), boost::end(rng), pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template<range_return_value re, class ForwardRange>
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ min_element(ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::pack(
+ std::min_element(boost::begin(rng), boost::end(rng)),
+ rng);
+ }
+
+ /// \overload
+ template<range_return_value re, class ForwardRange>
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ min_element(const ForwardRange& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::pack(
+ std::min_element(boost::begin(rng), boost::end(rng)),
+ rng);
+ }
+
+ /// \overload
+ template<range_return_value re, class ForwardRange, class BinaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ min_element(ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::pack(
+ std::min_element(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+
+ /// \overload
+ template<range_return_value re, class ForwardRange, class BinaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ min_element(const ForwardRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::pack(
+ std::min_element(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/mismatch.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/mismatch.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,182 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_MISMATCH_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_MISMATCH_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/difference_type.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2 >
+ inline std::pair<SinglePassTraversalReadableIterator1,
+ SinglePassTraversalReadableIterator2>
+ mismatch_impl(SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2)
+ {
+ while (first1 != last1 && first2 != last2 && *first1 == *first2)
+ {
+ ++first1;
+ ++first2;
+ }
+ return std::pair<SinglePassTraversalReadableIterator1,
+ SinglePassTraversalReadableIterator2>(first1, first2);
+ }
+
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2,
+ class BinaryPredicate >
+ inline std::pair<SinglePassTraversalReadableIterator1,
+ SinglePassTraversalReadableIterator2>
+ mismatch_impl(SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2,
+ BinaryPredicate pred)
+ {
+ while (first1 != last1 && first2 != last2 && pred(*first1, *first2))
+ {
+ ++first1;
+ ++first2;
+ }
+ return std::pair<SinglePassTraversalReadableIterator1,
+ SinglePassTraversalReadableIterator2>(first1, first2);
+ }
+ }
+
+ /// \brief template function mismatch
+ ///
+ /// range-based version of the mismatch std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template< class SinglePassRange1, class SinglePassRange2 >
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
+ mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2));
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2 >
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
+ mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2));
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2 >
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
+ mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2));
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2 >
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
+ mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2));
+ }
+
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
+ mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred);
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
+ mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred);
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
+ mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred);
+ }
+
+ /// \overload
+ template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
+ inline std::pair<
+ BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
+ mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/nth_element.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/nth_element.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,64 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_NTH_ELEMENT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_NTH_ELEMENT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function nth_element
+ ///
+ /// range-based version of the nth_element std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class RandomAccessRange>
+ inline void nth_element(RandomAccessRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::nth_element(boost::begin(rng), nth, boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline void nth_element(const RandomAccessRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::nth_element(boost::begin(rng),nth,boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class BinaryPredicate>
+ inline void nth_element(RandomAccessRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
+ BinaryPredicate sort_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class BinaryPredicate>
+ inline void nth_element(const RandomAccessRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
+ BinaryPredicate sort_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/partial_sort.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/partial_sort.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,65 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_PARTIAL_SORT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_PARTIAL_SORT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function partial_sort
+ ///
+ /// range-based version of the partial_sort std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class RandomAccessRange>
+ inline void partial_sort(RandomAccessRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::partial_sort(boost::begin(rng), middle, boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline void partial_sort(const RandomAccessRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::partial_sort(boost::begin(rng), middle, boost::end(rng));
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class BinaryPredicate>
+ inline void partial_sort(RandomAccessRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
+ BinaryPredicate sort_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::partial_sort(boost::begin(rng), middle, boost::end(rng),
+ sort_pred);
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class BinaryPredicate>
+ inline void partial_sort(const RandomAccessRange& rng,
+ BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
+ BinaryPredicate sort_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/partition.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/partition.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,68 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_PARTITION__HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_PARTITION__HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function partition
+ ///
+ /// range-based version of the partition std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ template<class ForwardRange, class UnaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ partition(ForwardRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::partition(boost::begin(rng),boost::end(rng),pred);
+ }
+
+ /// \overload
+ template<class ForwardRange, class UnaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ partition(const ForwardRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::partition(boost::begin(rng),boost::end(rng),pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, class ForwardRange,
+ class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ partition(ForwardRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return boost::range_return<ForwardRange,re>::
+ pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange,
+ class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ partition(const ForwardRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return boost::range_return<const ForwardRange,re>::
+ pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/permutation.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/permutation.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,117 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_PERMUTATION_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_PERMUTATION_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function next_permutation
+ ///
+ /// range-based version of the next_permutation std algorithm
+ ///
+ /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+ /// \pre Compare is a model of the BinaryPredicateConcept
+ template<class BidirectionalRange>
+ inline bool next_permutation(BidirectionalRange& rng)
+ {
+ boost::function_requires<
+ BidirectionalRangeConcept<BidirectionalRange> >();
+
+ return std::next_permutation(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class BidirectionalRange>
+ inline bool next_permutation(const BidirectionalRange& rng)
+ {
+ boost::function_requires<
+ BidirectionalRangeConcept<BidirectionalRange> >();
+
+ return std::next_permutation(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class BidirectionalRange, class Compare>
+ inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
+ {
+ boost::function_requires<
+ BidirectionalRangeConcept<BidirectionalRange> >();
+
+ return std::next_permutation(boost::begin(rng), boost::end(rng),
+ comp_pred);
+ }
+
+ /// \overload
+ template<class BidirectionalRange, class Compare>
+ inline bool next_permutation(const BidirectionalRange& rng,
+ Compare comp_pred)
+ {
+ boost::function_requires<
+ BidirectionalRangeConcept<BidirectionalRange> >();
+
+ return std::next_permutation(boost::begin(rng), boost::end(rng),
+ comp_pred);
+ }
+
+ /// \brief template function prev_permutation
+ ///
+ /// range-based version of the prev_permutation std algorithm
+ ///
+ /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+ /// \pre Compare is a model of the BinaryPredicateConcept
+ template<class BidirectionalRange>
+ inline bool prev_permutation(BidirectionalRange& rng)
+ {
+ boost::function_requires<
+ BidirectionalRangeConcept<BidirectionalRange> >();
+
+ return std::prev_permutation(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class BidirectionalRange>
+ inline bool prev_permutation(const BidirectionalRange& rng)
+ {
+ boost::function_requires<
+ BidirectionalRangeConcept<BidirectionalRange> >();
+
+ return std::prev_permutation(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<class BidirectionalRange, class Compare>
+ inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
+ {
+ boost::function_requires<
+ BidirectionalRangeConcept<BidirectionalRange> >();
+
+ return std::prev_permutation(boost::begin(rng), boost::end(rng),
+ comp_pred);
+ }
+
+ /// \overload
+ template<class BidirectionalRange, class Compare>
+ inline bool prev_permutation(const BidirectionalRange& rng,
+ Compare comp_pred)
+ {
+ boost::function_requires<
+ BidirectionalRangeConcept<BidirectionalRange> >();
+
+ return std::prev_permutation(boost::begin(rng), boost::end(rng),
+ comp_pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/random_shuffle.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/random_shuffle.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,62 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_RANDOM_SHUFFLE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_RANDOM_SHUFFLE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function random_shuffle
+ ///
+ /// range-based version of the random_shuffle std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre Generator is a model of the UnaryFunctionConcept
+ template<class RandomAccessRange>
+ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::random_shuffle(boost::begin(rng), boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::random_shuffle(boost::begin(rng),boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Generator>
+ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class Generator>
+ inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/remove.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/remove.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,70 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_REMOVE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REMOVE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function remove
+ ///
+ /// range-based version of the remove std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ template< class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ remove(ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::remove(boost::begin(rng),boost::end(rng),val);
+ }
+
+ /// \overload
+ template< class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ remove(const ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::remove(boost::begin(rng),boost::end(rng),val);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ remove(ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
+ return range_return<ForwardRange,re>::pack(
+ std::remove(boost::begin(rng), boost::end(rng), val),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ remove(const ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+
+ return range_return<const ForwardRange,re>::pack(
+ std::remove(boost::begin(rng), boost::end(rng), val),
+ rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/remove_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/remove_if.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,70 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_REMOVE_IF_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REMOVE_IF_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function remove_if
+ ///
+ /// range-based version of the remove_if std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
+ template< class ForwardRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
+ remove_if(ForwardRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::remove_if(boost::begin(rng), boost::end(rng), pred);
+ }
+
+ /// \overload
+ template< class ForwardRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+ remove_if(const ForwardRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::remove_if(boost::begin(rng),boost::end(rng),pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, class ForwardRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ remove_if(ForwardRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::pack(
+ std::remove_if(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange, class UnaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ remove_if(const ForwardRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::pack(
+ std::remove_if(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/replace.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/replace.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,47 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_REPLACE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REPLACE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function replace
+ ///
+ /// range-based version of the replace std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ template< class ForwardRange, class Value >
+ inline ForwardRange&
+ replace(ForwardRange& rng, const Value& what,
+ const Value& with_what)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::replace(boost::begin(rng), boost::end(rng), what, with_what);
+ return rng;
+ }
+
+ /// \overload
+ template< class ForwardRange, class Value >
+ inline const ForwardRange&
+ replace(const ForwardRange& rng, const Value& what,
+ const Value& with_what)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::replace(boost::begin(rng), boost::end(rng), what, with_what);
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/replace_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/replace_if.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,49 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_REPLACE_IF_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REPLACE_IF_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function replace_if
+ ///
+ /// range-based version of the replace_if std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
+ template< class ForwardRange, class UnaryPredicate, class Value >
+ inline ForwardRange&
+ replace_if(ForwardRange& rng, UnaryPredicate pred,
+ const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
+ return rng;
+ }
+
+ /// \overload
+ template< class ForwardRange, class UnaryPredicate, class Value >
+ inline const ForwardRange&
+ replace_if(const ForwardRange& rng, UnaryPredicate pred,
+ const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
+ return rng;
+ }
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/reverse.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/reverse.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,44 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_REVERSE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REVERSE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function reverse
+ ///
+ /// range-based version of the reverse std algorithm
+ ///
+ /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+ template<class BidirectionalRange>
+ inline BidirectionalRange& reverse(BidirectionalRange& rng)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ std::reverse(boost::begin(rng), boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class BidirectionalRange>
+ inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ std::reverse(boost::begin(rng), boost::end(rng));
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/rotate.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/rotate.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,47 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_ROTATE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_ROTATE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function rotate
+ ///
+ /// range-based version of the rotate std algorithm
+ ///
+ /// \pre Rng meets the requirements for a Forward range
+ template<class ForwardRange>
+ inline ForwardRange& rotate(ForwardRange& rng,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type middle)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::rotate(boost::begin(rng), middle, boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class ForwardRange>
+ inline const ForwardRange&
+ rotate(const ForwardRange& rng,
+ BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type middle)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::rotate(boost::begin(rng),middle,boost::end(rng));
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/search.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/search.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,131 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_SEARCH_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_SEARCH_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function search
+ ///
+ /// range-based version of the search std algorithm
+ ///
+ /// \pre ForwardRange1 is a model of the ForwardRangeConcept
+ /// \pre ForwardRange2 is a model of the ForwardRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template< class ForwardRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
+ search(ForwardRange1& rng1, const ForwardRange2& rng2)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+ return std::search(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2));
+ }
+
+ /// \overload
+ template< class ForwardRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+ search(const ForwardRange1& rng1, const ForwardRange2& rng2)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+ return std::search(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2));
+ }
+
+ /// \overload
+ template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
+ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+ return std::search(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2),pred);
+ }
+
+ /// \overload
+ template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+ search(const ForwardRange1& rng1, const ForwardRange2& rng2,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+ return std::search(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2),pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+ search(ForwardRange1& rng1, const ForwardRange2& rng2)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+ return range_return<ForwardRange1,re>::
+ pack(std::search(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2)),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+ search(const ForwardRange1& rng1, const ForwardRange2& rng2)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+ return range_return<const ForwardRange1,re>::
+ pack(std::search(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2)),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange1, class ForwardRange2,
+ class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+ return range_return<ForwardRange1,re>::
+ pack(std::search(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2),pred),
+ rng1);
+ }
+
+ /// \overload
+ template< range_return_value re, class ForwardRange1, class ForwardRange2,
+ class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+ search(const ForwardRange1& rng1, const ForwardRange2& rng2,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
+ boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
+ return range_return<const ForwardRange1,re>::
+ pack(std::search(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2),pred),
+ rng1);
+ }
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/set_algorithm.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/set_algorithm.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,188 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_SET_ALGORITHM_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_SET_ALGORITHM_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function includes
+ ///
+ /// range-based version of the includes std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class SinglePassRange1, class SinglePassRange2>
+ inline bool includes(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::includes(boost::begin(rng1),boost::end(rng1),
+ boost::begin(rng2),boost::end(rng2));
+ }
+
+ /// \overload
+ template<class SinglePassRange1, class SinglePassRange2,
+ class BinaryPredicate>
+ inline bool includes(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::includes(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred);
+ }
+
+ /// \brief template function set_union
+ ///
+ /// range-based version of the set_union std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator>
+ inline OutputIterator set_union(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::set_union(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out);
+ }
+
+ /// \overload
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator, class BinaryPredicate>
+ inline OutputIterator set_union(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::set_union(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out, pred);
+ }
+
+ /// \brief template function set_intersection
+ ///
+ /// range-based version of the set_intersection std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator>
+ inline OutputIterator set_intersection(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::set_intersection(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out);
+ }
+
+ /// \overload
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator, class BinaryPredicate>
+ inline OutputIterator set_intersection(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::set_intersection(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2),
+ out, pred);
+ }
+
+ /// \brief template function set_difference
+ ///
+ /// range-based version of the set_difference std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator>
+ inline OutputIterator set_difference(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::set_difference(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out);
+ }
+
+ /// \overload
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator, class BinaryPredicate>
+ inline OutputIterator set_difference(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::set_difference(
+ boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out, pred);
+ }
+
+ /// \brief template function set_symmetric_difference
+ ///
+ /// range-based version of the set_symmetric_difference std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator>
+ inline OutputIterator
+ set_symmetric_difference(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out);
+ }
+
+ /// \overload
+ template<class SinglePassRange1, class SinglePassRange2,
+ class OutputIterator, class BinaryPredicate>
+ inline OutputIterator
+ set_symmetric_difference(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out,
+ BinaryPredicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return std::set_symmetric_difference(
+ boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), out, pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/sort.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/sort.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,63 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_SORT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_SORT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function sort
+ ///
+ /// range-based version of the sort std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class RandomAccessRange>
+ inline RandomAccessRange& sort(RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::sort(boost::begin(rng), boost::end(rng));
+
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline const RandomAccessRange& sort(const RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::sort(boost::begin(rng),boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class BinaryPredicate>
+ inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::sort(boost::begin(rng), boost::end(rng), pred);
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class BinaryPredicate>
+ inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::sort(boost::begin(rng), boost::end(rng), pred);
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/stable_partition.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/stable_partition.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,68 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_STABLE_PARTITION_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_STABLE_PARTITION_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function stable_partition
+ ///
+ /// range-based version of the stable_partition std algorithm
+ ///
+ /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+ /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
+ template<class BidirectionalRange, class UnaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type
+ stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ return std::stable_partition(boost::begin(rng), boost::end(rng), pred);
+ }
+
+ /// \overload
+ template<class BidirectionalRange, class UnaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type
+ stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ return std::stable_partition(boost::begin(rng),boost::end(rng),pred);
+ }
+
+// range_return overloads
+ template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type
+ stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ return range_return<BidirectionalRange,re>::pack(
+ std::stable_partition(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+
+ /// \overload
+ template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
+ inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type
+ stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
+ {
+ boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
+ return range_return<const BidirectionalRange,re>::pack(
+ std::stable_partition(boost::begin(rng),boost::end(rng),pred),
+ rng);
+ }
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/stable_sort.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/stable_sort.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,62 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_STABLE_SORT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_STABLE_SORT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function stable_sort
+ ///
+ /// range-based version of the stable_sort std algorithm
+ ///
+ /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<class RandomAccessRange>
+ inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::stable_sort(boost::begin(rng), boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange>
+ inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::stable_sort(boost::begin(rng), boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class BinaryPredicate>
+ inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
+ return rng;
+ }
+
+ /// \overload
+ template<class RandomAccessRange, class BinaryPredicate>
+ inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
+ {
+ boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
+ std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/transform.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/transform.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,85 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_TRANSFORM_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_TRANSFORM_HPP_INCLUDED
+
+#include <boost/assert.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function transform
+ ///
+ /// range-based version of the transform std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ /// \pre OutputIterator is a model of the OutputIteratorConcept
+ /// \pre UnaryOperation is a model of the UnaryFunctionConcept
+ /// \pre BinaryOperation is a model of the BinaryFunctionConcept
+ template< class SinglePassRange1,
+ class OutputIterator,
+ class UnaryOperation >
+ inline OutputIterator
+ transform(const SinglePassRange1& rng,
+ OutputIterator out,
+ UnaryOperation fun)
+ {
+ return std::transform(boost::begin(rng),boost::end(rng),out,fun);
+ }
+
+ namespace range_detail
+ {
+ template< class SinglePassTraversalReadableIterator1,
+ class SinglePassTraversalReadableIterator2,
+ class OutputIterator,
+ class BinaryFunction >
+ inline OutputIterator
+ transform_impl(SinglePassTraversalReadableIterator1 first1,
+ SinglePassTraversalReadableIterator1 last1,
+ SinglePassTraversalReadableIterator2 first2,
+ SinglePassTraversalReadableIterator2 last2,
+ OutputIterator out,
+ BinaryFunction fn)
+ {
+ for (; first1 != last1; ++first1, ++first2)
+ {
+ BOOST_ASSERT( first2 != last2 );
+ *out = fn(*first1, *first2);
+ ++out;
+ }
+ return out;
+ }
+ }
+
+ /// \overload
+ template< class SinglePassRange1,
+ class SinglePassRange2,
+ class OutputIterator,
+ class BinaryOperation >
+ inline OutputIterator
+ transform(const SinglePassRange1& rng1,
+ const SinglePassRange2& rng2,
+ OutputIterator out,
+ BinaryOperation fun)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ return range_detail::transform_impl(
+ boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2),
+ out, fun);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/unique.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/unique.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,102 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_UNIQUE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_UNIQUE_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function unique
+ ///
+ /// range-based version of the unique std algorithm
+ ///
+ /// \pre Rng meets the requirements for a Forward range
+ template< class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ unique( ForwardRange& rng )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::unique( boost::begin(rng), boost::end(rng) );
+ }
+ /// \overload
+ template< class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ unique( const ForwardRange& rng )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::unique( boost::begin(rng), boost::end(rng) );
+ }
+ /// \overload
+ template< class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ unique( ForwardRange& rng, BinaryPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::unique(boost::begin(rng), boost::end(rng), pred);
+ }
+ /// \overload
+ template< class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ unique( const ForwardRange& rng, BinaryPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::unique(boost::begin(rng), boost::end(rng), pred);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ unique( ForwardRange& rng )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::
+ pack( std::unique( boost::begin(rng),
+ boost::end(rng)), rng );
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ unique( const ForwardRange& rng )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::
+ pack( std::unique( boost::begin(rng),
+ boost::end(rng)), rng );
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ unique( ForwardRange& rng, BinaryPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::
+ pack(std::unique(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ unique( const ForwardRange& rng, BinaryPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::
+ pack(std::unique(boost::begin(rng), boost::end(rng), pred),
+ rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm/upper_bound.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm/upper_bound.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,101 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_UPPER_BOUND_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_UPPER_BOUND_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/detail/range_return.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function upper_bound
+ ///
+ /// range-based version of the upper_bound std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ template< class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ upper_bound( ForwardRange& rng, Value val )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::upper_bound(boost::begin(rng), boost::end(rng), val);
+ }
+ /// \overload
+ template< class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ upper_bound( const ForwardRange& rng, Value val )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::upper_bound(boost::begin(rng), boost::end(rng), val);
+ }
+ /// \overload
+ template< class ForwardRange, class Value, class SortPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+ upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
+ }
+ /// \overload
+ template< class ForwardRange, class Value, class SortPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+ upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ upper_bound( ForwardRange& rng, Value val )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::
+ pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ upper_bound( const ForwardRange& rng, Value val )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::
+ pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value,
+ class SortPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+ upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<ForwardRange,re>::
+ pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
+ rng);
+ }
+ /// \overload
+ template< range_return_value re, class ForwardRange, class Value,
+ class SortPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+ upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return range_return<const ForwardRange,re>::
+ pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
+ rng);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm_ext.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm_ext.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,25 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2007. 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)
+//
+// Copyright Thorsten Ottosen 2006. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EXT_HPP
+#define BOOST_RANGE_ALGORITHM_EXT_HPP
+
+#include <boost/range/algorithm_ext/for_each.hpp>
+#include <boost/range/algorithm_ext/overwrite.hpp>
+#include <boost/range/algorithm_ext/push_back.hpp>
+#include <boost/range/algorithm_ext/push_front.hpp>
+#include <boost/range/algorithm_ext/insert.hpp>
+#include <boost/range/algorithm_ext/erase.hpp>
+
+#endif
Added: sandbox/async/boost/range/algorithm_ext/erase.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm_ext/erase.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,45 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EXT_ERASE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EXT_ERASE_HPP_INCLUDED
+
+#include <boost/range/config.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+ template< class Container >
+ inline void erase( Container& on,
+ iterator_range<BOOST_DEDUCED_TYPENAME Container::iterator> to_erase )
+ {
+ on.erase( boost::begin(to_erase), boost::end(to_erase) );
+ }
+
+ template< class Container, class T >
+ inline void remove_erase( Container& on, const T& val )
+ {
+ on.erase(
+ std::remove(boost::begin(on), boost::end(on), val),
+ boost::end(on));
+ }
+
+ template< class Container, class Pred >
+ inline void remove_erase_if( Container& on, Pred pred )
+ {
+ on.erase(
+ std::remove_if(boost::begin(on), boost::end(on), pred),
+ boost::end(on));
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm_ext/for_each.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm_ext/for_each.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,65 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EXT_FOR_EACH_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EXT_FOR_EACH_HPP_INCLUDED
+
+#include <boost/range/config.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template<class InputIterator1, class InputIterator2, class Fn2>
+ inline Fn2 for_each_impl(InputIterator1 first1, InputIterator1 last1,
+ InputIterator2 first2, InputIterator2 last2,
+ Fn2 fn)
+ {
+ for (; first1 != last1 && first2 != last2; ++first1, ++first2)
+ {
+ fn(*first1, *first2);
+ }
+ return fn;
+ }
+ }
+
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(const SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
+ {
+ return range_detail::for_each_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), fn);
+ }
+
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(const SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
+ {
+ return range_detail::for_each_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), fn);
+ }
+
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
+ {
+ return range_detail::for_each_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), fn);
+ }
+
+ template<class SinglePassRange1, class SinglePassRange2, class Fn2>
+ inline Fn2 for_each(SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
+ {
+ return range_detail::for_each_impl(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), fn);
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm_ext/insert.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm_ext/insert.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,32 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EXT_INSERT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EXT_INSERT_HPP_INCLUDED
+
+#include <boost/range/config.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+ template< class Container, class Range >
+ inline void insert( Container& on,
+ BOOST_DEDUCED_TYPENAME Container::iterator before,
+ const Range& from )
+ {
+ BOOST_ASSERT( (void*)&on != (void*)&from &&
+ "cannot copy from a container to itself" );
+ on.insert( before, boost::begin(from), boost::end(from) );
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm_ext/overwrite.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm_ext/overwrite.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,46 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EXT_OVERWRITE_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EXT_OVERWRITE_HPP_INCLUDED
+
+#include <boost/range/config.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+ template< class SinglePassRange1, class SinglePassRange2 >
+ inline void overwrite( const SinglePassRange1& from, SinglePassRange2& to )
+ {
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
+ i = boost::begin(from), e = boost::end(from);
+
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type
+ out = boost::begin(to);
+
+#ifndef NDEBUG
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type
+ last_out = boost::end(to);
+#endif
+
+ for( ; i != e; ++out, ++i )
+ {
+#ifndef NDEBUG
+ BOOST_ASSERT( out != last_out
+ && "out of bounds in boost::overwrite()" );
+#endif
+ *out = *i;
+ }
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm_ext/push_back.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm_ext/push_back.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,31 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EXT_PUSH_BACK_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EXT_PUSH_BACK_HPP_INCLUDED
+
+#include <boost/range/config.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+ template< class Container, class Range >
+ inline void push_back( Container& on, const Range& from )
+ {
+ BOOST_ASSERT( (void*)&on != (void*)&from &&
+ "cannot copy from a container to itself" );
+ on.insert( on.end(), boost::begin(from), boost::end(from) );
+ }
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/algorithm_ext/push_front.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/algorithm_ext/push_front.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,30 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_ALGORITHM_EXT_PUSH_FRONT_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EXT_PUSH_FRONT_HPP_INCLUDED
+
+#include <boost/range/config.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+ template< class Container, class Range >
+ inline void push_front( Container& on, const Range& from )
+ {
+ BOOST_ASSERT( (void*)&on != (void*)&from &&
+ "cannot copy from a container to itself" );
+ on.insert( on.begin(), boost::begin(from), boost::end(from) );
+ }
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/as_array.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/as_array.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,45 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_AS_ARRAY_HPP
+#define BOOST_RANGE_AS_ARRAY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/detail/str_types.hpp>
+
+namespace boost
+{
+
+ template< class R >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<R>::type >
+ as_array( R& r )
+ {
+ return boost::make_iterator_range( r );
+ }
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< class Range >
+ inline boost::iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
+ as_array( const Range& r )
+ {
+ return boost::make_iterator_range( r );
+ }
+
+#endif
+
+}
+
+#endif
+
Added: sandbox/async/boost/range/as_literal.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/as_literal.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,127 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_AS_LITERAL_HPP
+#define BOOST_RANGE_AS_LITERAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#include <boost/range/detail/as_literal.hpp>
+#else
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/detail/str_types.hpp>
+
+#include <boost/detail/workaround.hpp>
+
+#include <cstring>
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#endif
+
+namespace boost
+{
+ namespace range_detail
+ {
+ inline std::size_t length( const char* s )
+ {
+ return strlen( s );
+ }
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ inline std::size_t length( const wchar_t* s )
+ {
+ return wcslen( s );
+ }
+#endif
+
+ //
+ // Remark: the compiler cannot choose between T* and T[sz]
+ // overloads, so we must put the T* internal to the
+ // unconstrained version.
+ //
+
+ inline bool is_char_ptr( char* )
+ {
+ return true;
+ }
+
+ inline bool is_char_ptr( const char* )
+ {
+ return true;
+ }
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ inline bool is_char_ptr( wchar_t* )
+ {
+ return true;
+ }
+
+ inline bool is_char_ptr( const wchar_t* )
+ {
+ return true;
+ }
+#endif
+
+ template< class T >
+ inline long is_char_ptr( T /* r */ )
+ {
+ return 0L;
+ }
+
+ template< class T >
+ inline iterator_range<T*>
+ make_range( T* const r, bool )
+ {
+ return iterator_range<T*>( r, r + length(r) );
+ }
+
+ template< class T >
+ inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type>
+ make_range( T& r, long )
+ {
+ return boost::make_iterator_range( r );
+ }
+
+ }
+
+ template< class Range >
+ inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type>
+ as_literal( Range& r )
+ {
+ return range_detail::make_range( r, range_detail::is_char_ptr(r) );
+ }
+
+ template< class Range >
+ inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type>
+ as_literal( const Range& r )
+ {
+ return range_detail::make_range( r, range_detail::is_char_ptr(r) );
+ }
+
+ template< class Char, std::size_t sz >
+ inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
+ {
+ return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
+ }
+
+ template< class Char, std::size_t sz >
+ inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
+ {
+ return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
+ }
+}
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+#endif
Added: sandbox/async/boost/range/atl.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/atl.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,733 @@
+#ifndef BOOST_RANGE_ATL_HPP
+#define BOOST_RANGE_ATL_HPP
+
+
+
+
+// Boost.Range ATL Extension
+//
+// Copyright Shunsuke Sogame 2005-2006.
+// 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)
+
+
+
+
+// config
+//
+
+
+#include <atldef.h> // _ATL_VER
+
+
+#if !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+ #if (_ATL_VER < 0x0700)
+ #define BOOST_RANGE_ATL_NO_COLLECTIONS
+ #endif
+#endif
+
+
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+ #if (_ATL_VER < 0x0700) // dubious
+ #define BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX
+ #endif
+#endif
+
+
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING)
+ #if (_MSC_VER < 1310) // from <boost/regex/mfc.hpp>, but dubious
+ #define BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING
+ #endif
+#endif
+
+
+
+
+// forward declarations
+//
+
+
+#include <basetyps.h> // IID
+
+
+namespace ATL {
+
+
+#if !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+ // arrays
+ //
+ template< class E, class ETraits >
+ class CAtlArray;
+
+ template< class E >
+ class CAutoPtrArray;
+
+ template< class I, const IID *piid >
+ class CInterfaceArray;
+
+
+ // lists
+ //
+ template< class E, class ETraits >
+ class CAtlList;
+
+ template< class E >
+ class CAutoPtrList;
+
+ template< class E, class Allocator >
+ class CHeapPtrList;
+
+ template< class I, const IID *piid >
+ class CInterfaceList;
+
+
+ // maps
+ //
+ template< class K, class V, class KTraits, class VTraits >
+ class CAtlMap;
+
+ template< class K, class V, class KTraits, class VTraits >
+ class CRBTree;
+
+ template< class K, class V, class KTraits, class VTraits >
+ class CRBMap;
+
+ template< class K, class V, class KTraits, class VTraits >
+ class CRBMultiMap;
+
+
+ // strings
+ //
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING)
+ template< class BaseType, bool t_bMFCDLL >
+ class CSimpleStringT;
+#else
+ template< class BaseType >
+ class CSimpleStringT;
+#endif
+
+ template< class BaseType, class StringTraits >
+ class CStringT;
+
+ template< class StringType, int t_nChars >
+ class CFixedStringT;
+
+ template< class BaseType, const int t_nSize >
+ class CStaticString;
+
+
+#endif // !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+ // simples
+ //
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+ template< class T, class TEqual >
+ class CSimpleArray;
+
+ template< class TKey, class TVal, class TEqual >
+ class CSimpleMap;
+
+#else
+
+ template< class T >
+ class CSimpleArray;
+
+ template< class T >
+ class CSimpleValArray;
+
+ template< class TKey, class TVal >
+ class CSimpleMap;
+
+#endif // !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+
+ // pointers
+ //
+ template< class E >
+ class CAutoPtr;
+
+ template< class T >
+ class CComPtr;
+
+ template< class T, const IID *piid >
+ class CComQIPtr;
+
+ template< class E, class Allocator >
+ class CHeapPtr;
+
+ template< class T >
+ class CAdapt;
+
+
+} // namespace ATL
+
+
+
+
+// indirect_iterator customizations
+//
+
+
+#include <boost/mpl/identity.hpp>
+#include <boost/pointee.hpp>
+
+
+namespace boost {
+
+
+ template< class E >
+ struct pointee< ATL::CAutoPtr<E> > :
+ mpl::identity<E>
+ { };
+
+ template< class T >
+ struct pointee< ATL::CComPtr<T> > :
+ mpl::identity<T>
+ { };
+
+ template< class T, const IID *piid >
+ struct pointee< ATL::CComQIPtr<T, piid> > :
+ mpl::identity<T>
+ { };
+
+ template< class E, class Allocator >
+ struct pointee< ATL::CHeapPtr<E, Allocator> > :
+ mpl::identity<E>
+ { };
+
+ template< class T >
+ struct pointee< ATL::CAdapt<T> > :
+ pointee<T>
+ { };
+
+
+} // namespace boost
+
+
+
+
+// extended customizations
+//
+
+
+#include <boost/iterator/indirect_iterator.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+#include <boost/range/detail/microsoft.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <atlbase.h> // CComBSTR
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+#if !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+ // arrays
+ //
+
+ struct atl_array_functions :
+ array_functions
+ {
+ template< class Iterator, class X >
+ Iterator end(X& x) // redefine
+ {
+ return x.GetData() + x.GetCount(); // no 'GetSize()'
+ }
+ };
+
+
+ template< class E, class ETraits >
+ struct customization< ATL::CAtlArray<E, ETraits> > :
+ atl_array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef E val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ template< class E >
+ struct customization< ATL::CAutoPtrArray<E> > :
+ atl_array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ // ATL::CAutoPtr/CHeapPtr is no assignable.
+ typedef ATL::CAutoPtr<E> val_t;
+ typedef val_t *miter_t;
+ typedef val_t const *citer_t;
+
+ typedef indirect_iterator<miter_t> mutable_iterator;
+ typedef indirect_iterator<citer_t> const_iterator;
+ };
+ };
+
+
+ template< class I, const IID *piid >
+ struct customization< ATL::CInterfaceArray<I, piid> > :
+ atl_array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ATL::CComQIPtr<I, piid> val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ template< class E, class ETraits >
+ struct customization< ATL::CAtlList<E, ETraits> > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef E val_t;
+
+ typedef list_iterator<X, val_t> mutable_iterator;
+ typedef list_iterator<X const, val_t const> const_iterator;
+ };
+ };
+
+
+ struct indirected_list_functions
+ {
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ typedef typename Iterator::base_type base_t; // == list_iterator
+ return Iterator(base_t(x, x.GetHeadPosition()));
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ typedef typename Iterator::base_type base_t;
+ return Iterator(base_t(x, POSITION(0)));
+ }
+ };
+
+
+ template< class E >
+ struct customization< ATL::CAutoPtrList<E> > :
+ indirected_list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ATL::CAutoPtr<E> val_t;
+ typedef list_iterator<X, val_t> miter_t;
+ typedef list_iterator<X const, val_t const> citer_t;
+
+ typedef indirect_iterator<miter_t> mutable_iterator;
+ typedef indirect_iterator<citer_t> const_iterator;
+ };
+ };
+
+
+ template< class E, class Allocator >
+ struct customization< ATL::CHeapPtrList<E, Allocator> > :
+ indirected_list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ATL::CHeapPtr<E, Allocator> val_t;
+ typedef list_iterator<X, val_t> miter_t;
+ typedef list_iterator<X const, val_t const> citer_t;
+
+ typedef indirect_iterator<miter_t> mutable_iterator;
+ typedef indirect_iterator<citer_t> const_iterator;
+ };
+ };
+
+
+ template< class I, const IID *piid >
+ struct customization< ATL::CInterfaceList<I, piid> > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ATL::CComQIPtr<I, piid> val_t;
+
+ typedef list_iterator<X, val_t> mutable_iterator;
+ typedef list_iterator<X const, val_t const> const_iterator;
+ };
+ };
+
+
+ // maps
+ //
+
+ struct atl_rb_tree_tag
+ { };
+
+ template< >
+ struct customization< atl_rb_tree_tag > :
+ indirected_list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef typename X::CPair val_t;
+
+ typedef list_iterator<X, val_t *, val_t *> miter_t;
+ typedef list_iterator<X const, val_t const *, val_t const *> citer_t;
+
+ typedef indirect_iterator<miter_t> mutable_iterator;
+ typedef indirect_iterator<citer_t> const_iterator;
+ };
+ };
+
+
+ template< class K, class V, class KTraits, class VTraits >
+ struct customization< ATL::CAtlMap<K, V, KTraits, VTraits> > :
+ customization< atl_rb_tree_tag >
+ {
+ template< class Iterator, class X >
+ Iterator begin(X& x) // redefine
+ {
+ typedef typename Iterator::base_type base_t; // == list_iterator
+ return Iterator(base_t(x, x.GetStartPosition())); // no 'GetHeadPosition'
+ }
+ };
+
+
+ // strings
+ //
+
+ struct atl_string_tag
+ { };
+
+ template< >
+ struct customization< atl_string_tag >
+ {
+ template< class X >
+ struct meta
+ {
+ typedef typename X::PXSTR mutable_iterator;
+ typedef typename X::PCXSTR const_iterator;
+ };
+
+ template< class Iterator, class X >
+ typename mutable_<Iterator, X>::type begin(X& x)
+ {
+ return x.GetBuffer(0);
+ }
+
+ template< class Iterator, class X >
+ Iterator begin(X const& x)
+ {
+ return x.GetString();
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return begin<Iterator>(x) + x.GetLength();
+ }
+ };
+
+
+ template< class BaseType, const int t_nSize >
+ struct customization< ATL::CStaticString<BaseType, t_nSize> >
+ {
+ template< class X >
+ struct meta
+ {
+ typedef BaseType const *mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+
+ template< class Iterator, class X >
+ Iterator begin(X const& x)
+ {
+ return x;
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X const& x)
+ {
+ return begin<Iterator>(x) + X::GetLength();
+ }
+ };
+
+
+#endif // !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+ template< >
+ struct customization< ATL::CComBSTR >
+ {
+ template< class X >
+ struct meta
+ {
+ typedef OLECHAR *mutable_iterator;
+ typedef OLECHAR const *const_iterator;
+ };
+
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ return x.operator BSTR();
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return begin<Iterator>(x) + x.Length();
+ }
+ };
+
+
+ // simples
+ //
+
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+ template< class T, class TEqual >
+ struct customization< ATL::CSimpleArray<T, TEqual> > :
+#else
+ template< class T >
+ struct customization< ATL::CSimpleArray<T> > :
+#endif
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef T val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+#if defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+ template< class T >
+ struct customization< ATL::CSimpleValArray<T> > :
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef T val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+#endif // defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+ template< class TKey, class TVal, class TEqual >
+ struct customization< ATL::CSimpleMap<TKey, TVal, TEqual> >
+#else
+ template< class TKey, class TVal >
+ struct customization< ATL::CSimpleMap<TKey, TVal> >
+#endif
+ {
+ template< class X >
+ struct meta
+ {
+ typedef TKey k_val_t;
+ typedef k_val_t *k_miter_t;
+ typedef k_val_t const *k_citer_t;
+
+ typedef TVal v_val_t;
+ typedef v_val_t *v_miter_t;
+ typedef v_val_t const *v_citer_t;
+
+ // Topic:
+ // 'std::pair' can't contain references
+ // because of reference to reference problem.
+
+ typedef zip_iterator< tuple<k_miter_t, v_miter_t> > mutable_iterator;
+ typedef zip_iterator< tuple<k_citer_t, v_citer_t> > const_iterator;
+ };
+
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ return Iterator(boost::make_tuple(x.m_aKey, x.m_aVal));
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return Iterator(boost::make_tuple(x.m_aKey + x.GetSize(), x.m_aVal + x.GetSize()));
+ }
+ };
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+
+
+// range customizations
+//
+
+
+#if !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+ // arrays
+ //
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CAtlArray, 2
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CAutoPtrArray, 1
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CInterfaceArray, (class)(const IID *)
+ )
+
+
+ // lists
+ //
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CAtlList, 2
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CAutoPtrList, 1
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CHeapPtrList, 2
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CInterfaceList, (class)(const IID *)
+ )
+
+
+ //maps
+ //
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CAtlMap, 4
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::atl_rb_tree_tag,
+ (ATL, BOOST_PP_NIL), CRBTree, 4
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::atl_rb_tree_tag,
+ (ATL, BOOST_PP_NIL), CRBMap, 4
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::atl_rb_tree_tag,
+ (ATL, BOOST_PP_NIL), CRBMultiMap, 4
+ )
+
+
+ // strings
+ //
+ #if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING)
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::atl_string_tag,
+ (ATL, BOOST_PP_NIL), CSimpleStringT, (class)(bool)
+ )
+ #else
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::atl_string_tag,
+ (ATL, BOOST_PP_NIL), CSimpleStringT, 1
+ )
+ #endif
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::atl_string_tag,
+ (ATL, BOOST_PP_NIL), CStringT, 2
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::atl_string_tag,
+ (ATL, BOOST_PP_NIL), CFixedStringT, (class)(int)
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CStaticString, (class)(const int)
+ )
+
+
+#endif // !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CComBSTR
+)
+
+
+// simples
+//
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CSimpleArray, 2
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CSimpleMap, 3
+ )
+
+#else
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CSimpleArray, 1
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CSimpleMap, 2
+ )
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ (ATL, BOOST_PP_NIL), CSimpleValArray, 1
+ )
+
+#endif // !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+
+
+
+#endif
Added: sandbox/async/boost/range/begin.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/begin.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,132 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_BEGIN_HPP
+#define BOOST_RANGE_BEGIN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#include <boost/range/detail/begin.hpp>
+#else
+
+#include <boost/range/iterator.hpp>
+
+namespace boost
+{
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+ !BOOST_WORKAROUND(__GNUC__, < 3) \
+ /**/
+namespace range_detail
+{
+#endif
+
+ //////////////////////////////////////////////////////////////////////
+ // primary template
+ //////////////////////////////////////////////////////////////////////
+
+ template< typename C >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
+ range_begin( C& c )
+ {
+ //
+ // If you get a compile-error here, it is most likely because
+ // you have not implemented range_begin() properly in
+ // the namespace of C
+ //
+ return c.begin();
+ }
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template< typename Iterator >
+ inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
+ {
+ return p.first;
+ }
+
+ template< typename Iterator >
+ inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
+ {
+ return p.first;
+ }
+
+ //////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////
+
+ //
+ // May this be discarded? Or is it needed for bad compilers?
+ //
+ template< typename T, std::size_t sz >
+ inline const T* range_begin( const T (&a)[sz] )
+ {
+ return a;
+ }
+
+ template< typename T, std::size_t sz >
+ inline T* range_begin( T (&a)[sz] )
+ {
+ return a;
+ }
+
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+ !BOOST_WORKAROUND(__GNUC__, < 3) \
+ /**/
+} // namespace 'range_detail'
+#endif
+
+
+template< class T >
+inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
+{
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+ !BOOST_WORKAROUND(__GNUC__, < 3) \
+ /**/
+ using namespace range_detail;
+#endif
+ return range_begin( r );
+}
+
+template< class T >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
+{
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+ !BOOST_WORKAROUND(__GNUC__, < 3) \
+ /**/
+ using namespace range_detail;
+#endif
+ return range_begin( r );
+}
+
+} // namespace boost
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+namespace boost
+{
+ template< class T >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
+ const_begin( const T& r )
+ {
+ return boost::begin( r );
+ }
+}
+
+#endif
+
Added: sandbox/async/boost/range/category.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/category.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,29 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_CATEGORY_HPP
+#define BOOST_RANGE_CATEGORY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+ template< class T >
+ struct range_category : iterator_category< typename range_iterator<T>::type >
+ { };
+}
+
+#endif
Added: sandbox/async/boost/range/combine.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/combine.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,310 @@
+#ifndef BOOST_RANGE_COMBINE_HPP
+#define BOOST_RANGE_COMBINE_HPP
+
+#include <boost/iterator/zip_iterator.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/arithmetic.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+ namespace detail
+ {
+ struct void_ { typedef void_ type; };
+ }
+
+ template<> struct range_iterator<detail::void_>
+ {
+ typedef tuples::null_type type;
+ };
+
+ namespace detail
+ {
+ inline tuples::null_type range_begin( void_& )
+ { return tuples::null_type(); }
+
+ inline tuples::null_type range_end( void_& )
+ { return tuples::null_type(); }
+
+ template< class T >
+ struct tuple_iter
+ {
+ typedef typename mpl::eval_if_c< is_same<T,void_>::value,
+ mpl::identity<tuples::null_type>,
+ range_iterator<T> >::type
+ type;
+ };
+
+ template< class Rng1, class Rng2 >
+ struct tuple_range
+ {
+ typedef typename mpl::eval_if_c< is_same<Rng1,void_>::value,
+ void_,
+ mpl::identity<Rng1> >::type
+ type;
+ };
+
+ template
+ <
+ class R1,
+ class R2,
+ class R3,
+ class R4,
+ class R5,
+ class R6
+ >
+ struct generate_tuple
+ {
+ typedef boost::tuple< typename tuple_iter<R1>::type,
+ typename tuple_iter<R2>::type,
+ typename tuple_iter<R3>::type,
+ typename tuple_iter<R4>::type,
+ typename tuple_iter<R5>::type,
+ typename tuple_iter<R6>::type >
+ type;
+
+ static type begin( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
+ {
+ return make_tuple( boost::begin(r1),
+ boost::begin(r2),
+ boost::begin(r3),
+ boost::begin(r4),
+ boost::begin(r5),
+ boost::begin(r6) );
+ }
+
+ static type end( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
+ {
+ return make_tuple( boost::end(r1),
+ boost::end(r2),
+ boost::end(r3),
+ boost::end(r4),
+ boost::end(r5),
+ boost::end(r6) );
+ }
+ };
+
+ template
+ <
+ class R1,
+ class R2 = void_,
+ class R3 = void_,
+ class R4 = void_,
+ class R5 = void_,
+ class R6 = void_
+ >
+ struct zip_rng
+ : iterator_range<
+ zip_iterator< typename generate_tuple<R1,R2,R3,R4,R5,R6>::type >
+ >
+ {
+ private:
+ typedef generate_tuple<R1,R2,R3,R4,R5,R6>
+ generator;
+ typedef typename generator::type
+ tuple;
+ typedef zip_iterator<tuple>
+ zip_iter;
+ typedef iterator_range<zip_iter>
+ base;
+
+ public:
+ zip_rng( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
+ : base( zip_iter( generator::begin(r1,r2,r3,r4,r5,r6) ),
+ zip_iter( generator::end(r1,r2,r3,r4,r5,r6) ) )
+ {
+ BOOST_ASSERT(boost::distance(r1) <= boost::distance(r2));
+ BOOST_ASSERT(boost::distance(r1) <= boost::distance(r3));
+ BOOST_ASSERT(boost::distance(r1) <= boost::distance(r4));
+ BOOST_ASSERT(boost::distance(r1) <= boost::distance(r5));
+ BOOST_ASSERT(boost::distance(r1) <= boost::distance(r6));
+ }
+
+ template< class Zip, class Rng >
+ zip_rng( Zip& z, Rng& r )
+ : base( zip_iter( generator::begin( z, r ) ),
+ zip_iter( generator::end( z, r ) ) )
+ {
+
+ // @todo: tuple::begin( should be overloaded for this situation
+ }
+
+ struct tuple_length : tuples::length<tuple>
+ { };
+
+ template< unsigned N >
+ struct get
+ {
+ template< class Z, class R >
+ static typename tuples::element<N,tuple>::type begin( Z& z, R& )
+ {
+ return get<N>( z.begin().get_iterator_tuple() );
+ }
+
+ template< class Z, class R >
+ static typename tuples::element<N,tuple>::type end( Z& z, R& r )
+ {
+ return get<N>( z.end().get_iterator_tuple() );
+ }
+ };
+
+ };
+
+ template< class Rng1, class Rng2 >
+ struct zip_range
+ : iterator_range<
+ zip_iterator<
+ tuple< typename range_iterator<Rng1>::type,
+ typename range_iterator<Rng2>::type >
+ > >
+ {
+ private:
+ typedef zip_iterator<
+ tuple< typename range_iterator<Rng1>::type,
+ typename range_iterator<Rng2>::type >
+ >
+ zip_iter;
+ typedef iterator_range<zip_iter>
+ base;
+
+ public:
+ zip_range( Rng1& r1, Rng2& r2 )
+ : base( zip_iter( make_tuple(boost::begin(r1),
+ boost::begin(r2)) ),
+ zip_iter( make_tuple(boost::end(r1),
+ boost::end(r2)) ) )
+ {
+ BOOST_ASSERT(boost::distance(r1) <= boost::distance(r2));
+ }
+ };
+
+ template< class Rng1, class Rng2, class Rng3 >
+ struct zip_range3
+ : iterator_range<
+ zip_iterator<
+ tuple< typename range_iterator<Rng1>::type,
+ typename range_iterator<Rng2>::type,
+ typename range_iterator<Rng3>::type >
+ > >
+ {
+ private:
+ typedef zip_iterator<
+ tuple< typename range_iterator<Rng1>::type,
+ typename range_iterator<Rng2>::type,
+ typename range_iterator<Rng3>::type >
+ >
+ zip_iter;
+ typedef iterator_range<zip_iter>
+ base;
+
+ public:
+ zip_range3( Rng1& r1, Rng2& r2, Rng3& r3 )
+ : base( zip_iter( make_tuple(boost::begin(r1),
+ boost::begin(r2),
+ boost::begin(r3)) ),
+ zip_iter( make_tuple(boost::end(r1),
+ boost::end(r2),
+ boost::end(r3)) )
+ )
+ {
+ BOOST_ASSERT(distance(r1) <= distance(r2));
+ BOOST_ASSERT(distance(r1) <= distance(r3));
+ }
+ };
+
+
+ struct combine_tag {};
+
+ template< class Rng >
+ inline zip_rng<Rng>
+ operator&( combine_tag, Rng& r )
+ {
+ return zip_rng<Rng>(r);
+ }
+
+ template< class Rng >
+ inline iterator_range<const Rng>
+ operator&( combine_tag, const Rng& r )
+ {
+ return iterator_range<const Rng>(r);
+ }
+
+ template
+ <
+ class R1,
+ class R2,
+ class R3,
+ class R4,
+ class R5,
+ class Rng
+ >
+ inline typename zip_rng<R1,R2,R3,R4,R5>::next
+ operator&( const zip_rng<R1,R2,R3,R4,R5>& zip,
+ Rng& r )
+ {
+ return zip_rng<R1,R2,R3,R4,R5>::next( zip, r );
+ }
+
+ //
+ // This one should be able to be made generic
+ //
+ // template
+ // <
+ // class R1,
+ // class R2 = void,
+ // class R3 = void,
+ // class R4 = void,
+ // class R5 = void,
+ // class R6 = void
+ // >
+ // inline zip_range<R1,R2,R3,R4,R4,R5,R6>::type
+ // x
+ //
+ //
+ /*
+ template< class Rng1, class Rng2, class Rng3 >
+ inline zip_range3<Rng1,Rng2,Rng3>
+ operator&( const zip_range<Rng1,Rng2>& r1, const Rng3& r3 )
+ {
+ return zip_range3<Rn1,Rng2,Rng3>(
+ }*/
+
+ } // namespace 'detail'
+
+ template< class Rng1, class Rng2 >
+ inline detail::zip_range<Rng1,Rng2> combine( Rng1& r1, Rng2& r2 )
+ {
+ return detail::zip_range<Rng1,Rng2>(r1,r2);
+ }
+
+ template< class Rng1, class Rng2 >
+ inline detail::zip_range<const Rng1,Rng2> combine( const Rng1& r1, Rng2& r2 )
+ {
+ return detail::zip_range<const Rng1,Rng2>(r1,r2);
+ }
+
+ template< class Rng1, class Rng2 >
+ inline detail::zip_range<Rng1,const Rng2> combine( Rng1& r1, const Rng2& r2 )
+ {
+ return detail::zip_range<Rng1,Rng2>(r1,r2);
+ }
+
+ template< class Rng1, class Rng2 >
+ inline detail::zip_range<const Rng1,const Rng2> combine( const Rng1& r1, const Rng2& r2 )
+ {
+ return detail::zip_range<const Rng1,const Rng2>(r1,r2);
+ }
+
+ //
+ // @todo: find a solution that scales better
+ // instead of adding 6 overloads!
+ //
+}
+
+#endif
Added: sandbox/async/boost/range/concepts.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/concepts.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,140 @@
+// Boost.Range library concept checks
+//
+// Copyright Daniel Walker 2006. Use, modification and distribution
+// are 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/range/
+//
+
+#ifndef BOOST_RANGE_CONCEPTS_HPP
+#define BOOST_RANGE_CONCEPTS_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/iterator/iterator_concepts.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+/*!
+ * \file
+ * \brief Concept checks for the Boost Range library.
+ *
+ * The structures in this file may be used in conjunction with the
+ * Boost Concept Check library to insure that the type of a function
+ * parameter is compatible with a range concept. If not, a meaningful
+ * compile time error is generated. Checks are provided for the range
+ * concepts related to iterator traversal categories. For example, the
+ * following line checks that the type T models the ForwardRange
+ * concept.
+ *
+ * \code
+ * function_requires<ForwardRangeConcept<T> >();
+ * \endcode
+ *
+ * An additional concept check is required for the value access
+ * property of the range. For example to check for a
+ * ForwardReadableRange, the following code is required.
+ *
+ * \code
+ * function_requires<ForwardRangeConcept<T> >();
+ * function_requires<
+ * ReadableIteratorConcept<
+ * typename range_iterator<T>::type
+ * >
+ * >();
+ * \endcode
+ *
+ * \see http://www.boost.org/libs/range/doc/range.html for details
+ * about range concepts.
+ * \see http://www.boost.org/libs/iterator/doc/iterator_concepts.html
+ * for details about iterator concepts.
+ * \see http://www.boost.org/libs/concept_check/concept_check.htm for
+ * details about concept checks.
+ */
+
+namespace boost {
+
+ //! Check if a type T models the SinglePassRange range concept.
+ template<typename T>
+ struct SinglePassRangeConcept
+ {
+ typedef typename range_iterator<T const>::type range_const_iterator;
+ typedef typename range_iterator<T>::type range_iterator;
+
+ void constraints()
+ {
+ function_requires<
+ boost_concepts::SinglePassIteratorConcept<
+ range_iterator
+ >
+ >();
+ i = boost::begin(a);
+ i = boost::end(a);
+ const_constraints(a);
+ }
+
+ void const_constraints(const T& a)
+ {
+ ci = boost::begin(a);
+ ci = boost::end(a);
+ }
+ T a;
+ range_iterator i;
+ range_const_iterator ci;
+ };
+
+ //! Check if a type T models the ForwardRange range concept.
+ template<typename T>
+ struct ForwardRangeConcept
+ {
+ void constraints()
+ {
+ function_requires<
+ SinglePassRangeConcept<T>
+ >();
+ function_requires<
+ boost_concepts::ForwardTraversalConcept<
+ typename range_iterator<T>::type
+ >
+ >();
+ }
+ };
+
+ //! Check if a type T models the BidirectionalRange range concept.
+ template<typename T>
+ struct BidirectionalRangeConcept
+ {
+ void constraints()
+ {
+ function_requires<
+ ForwardRangeConcept<T>
+ >();
+ function_requires<
+ boost_concepts::BidirectionalTraversalConcept<
+ typename range_iterator<T>::type
+ >
+ >();
+ }
+ };
+
+ //! Check if a type T models the RandomAccessRange range concept.
+ template<typename T>
+ struct RandomAccessRangeConcept
+ {
+ void constraints()
+ {
+ function_requires<
+ BidirectionalRangeConcept<T>
+ >();
+ function_requires<
+ boost_concepts::RandomAccessTraversalConcept<
+ typename range_iterator<T>::type
+ >
+ >();
+ }
+ };
+
+} // namespace boost
+
+#endif // BOOST_RANGE_CONCEPTS_HPP
Added: sandbox/async/boost/range/config.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/config.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,54 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_CONFIG_HPP
+#define BOOST_RANGE_CONFIG_HPP
+
+#include <boost/detail/workaround.hpp>
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_RANGE_DEDUCED_TYPENAME
+#error "macro already defined!"
+#endif
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+# define BOOST_RANGE_DEDUCED_TYPENAME typename
+#else
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300) && !defined(_MSC_EXTENSIONS)
+# define BOOST_RANGE_DEDUCED_TYPENAME typename
+# else
+# define BOOST_RANGE_DEDUCED_TYPENAME BOOST_DEDUCED_TYPENAME
+# endif
+#endif
+
+#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT
+#error "macro already defined!"
+#endif
+
+#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
+#define BOOST_RANGE_NO_ARRAY_SUPPORT 1
+#endif
+
+#ifdef BOOST_RANGE_NO_ARRAY_SUPPORT
+#define BOOST_RANGE_ARRAY_REF() (boost_range_array)
+#define BOOST_RANGE_NO_STATIC_ASSERT
+#else
+#define BOOST_RANGE_ARRAY_REF() (&boost_range_array)
+#endif
+
+
+
+#endif
+
Added: sandbox/async/boost/range/const_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/const_iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,67 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_CONST_ITERATOR_HPP
+#define BOOST_RANGE_CONST_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/range/detail/const_iterator.hpp>
+#else
+
+#include <boost/range/detail/extract_optional_type.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <cstddef>
+#include <utility>
+
+namespace boost
+{
+ //////////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////////
+
+ namespace range_detail {
+ BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
+ }
+
+ template< typename C >
+ struct range_const_iterator : range_detail::extract_const_iterator<C>
+ {};
+
+ //////////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////////
+
+ template< typename Iterator >
+ struct range_const_iterator< std::pair<Iterator,Iterator> >
+ {
+ typedef Iterator type;
+ };
+
+ //////////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////////
+
+ template< typename T, std::size_t sz >
+ struct range_const_iterator< T[sz] >
+ {
+ typedef const T* type;
+ };
+
+} // namespace boost
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#endif
Added: sandbox/async/boost/range/const_reverse_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/const_reverse_iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,32 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_CONST_REVERSE_ITERATOR_HPP
+#define BOOST_RANGE_CONST_REVERSE_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/reverse_iterator.hpp>
+
+namespace boost
+{
+ //
+ // This interface is deprecated, use range_reverse_iterator<const T>
+ //
+
+ template< typename C >
+ struct range_const_reverse_iterator : range_reverse_iterator<const C>
+ { };
+
+} // namespace boost
+
+#endif
Added: sandbox/async/boost/range/counting_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/counting_range.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,54 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2008. Use, modification and
+// distribution is subject to the Boost Software Licence, 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/range
+//
+
+#ifndef BOOST_RANGE_COUNTING_RANGE_HPP_INCLUDED
+#define BOOST_RANGE_COUNTING_RANGE_HPP_INCLUDED
+
+#include <boost/range.hpp>
+#include <boost/iterator/counting_iterator.hpp>
+
+namespace boost
+{
+
+ template<class Incrementable, class Elem>
+ inline range<counting_iterator<Incrementable> >
+ counting_range(Elem first, Elem last)
+ {
+ typedef counting_iterator<Incrementable> counting_iterator_t;
+ typedef range<counting_iterator_t> result_t;
+ return result_t(
+ make_counting_iterator(first),
+ make_counting_iterator(last));
+ }
+
+ template<class Range>
+ inline range<counting_iterator<typename range_iterator<Range>::type> >
+ counting_range(const Range& r)
+ {
+ typedef counting_iterator<typename range_iterator<Range>::type> counting_iterator_t;
+ typedef range<counting_iterator_t> result_t;
+ return result_t(
+ counting_iterator_t(begin(r)),
+ counting_iterator_t(end(r)));
+ }
+
+ template<class Range>
+ inline range<counting_iterator<typename range_iterator<Range>::type> >
+ counting_range(Range& r)
+ {
+ typedef counting_iterator<typename range_iterator<Range>::type> counting_iterator_t;
+ typedef range<counting_iterator_t> result_t;
+ return result_t(
+ counting_iterator_t(begin(r)),
+ counting_iterator_t(end(r)));
+ }
+} // namespace boost
+
+#endif // include guard
Added: sandbox/async/boost/range/detail/as_literal.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/as_literal.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,33 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+#define BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/detail/detail_str.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost
+{
+ template< class Range >
+ inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type>
+ as_literal( Range& r )
+ {
+ return ::boost::make_iterator_range( ::boost::range_detail::str_begin(r),
+ ::boost::range_detail::str_end(r) );
+ }
+
+}
+
+#endif
Added: sandbox/async/boost/range/detail/begin.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/begin.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,92 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_BEGIN_HPP
+#define BOOST_RANGE_DETAIL_BEGIN_HPP
+
+#include <boost/config.hpp> // BOOST_MSVC
+#include <boost/detail/workaround.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/detail/common.hpp>
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+# include <boost/range/value_type.hpp>
+#endif
+
+namespace boost
+{
+
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_begin;
+
+ //////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_begin<std_container_>
+ {
+ template< typename C >
+ static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type fun( C& c )
+ {
+ return c.begin();
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_begin<std_pair_>
+ {
+ template< typename P >
+ static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type fun( const P& p )
+ {
+ return p.first;
+ }
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_begin<array_>
+ {
+ #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+ template< typename T, std::size_t sz >
+ static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return boost_range_array;
+ }
+ #else
+ template<typename T>
+ static BOOST_RANGE_DEDUCED_TYPENAME range_value<T>::type* fun(T& t)
+ {
+ return t;
+ }
+ #endif
+ };
+
+ } // namespace 'range_detail'
+
+ template< typename C >
+ inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
+ begin( C& c )
+ {
+ return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
+ }
+
+} // namespace 'boost'
+
+
+#endif
Added: sandbox/async/boost/range/detail/collection_traits.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/collection_traits.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,266 @@
+// Boost string_algo library collection_traits.hpp header file -------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// (C) Copyright Thorsten Ottosen 2002-2003. 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)
+
+// (C) Copyright Jeremy Siek 2001. 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)
+
+// Original idea of container traits was proposed by Jeremy Siek and
+// Thorsten Ottosen. This implementation is lightweighted version
+// of container_traits adapter for usage with string_algo library
+
+#ifndef BOOST_RANGE_STRING_COLLECTION_TRAITS_HPP
+#define BOOST_RANGE_STRING_COLLECTION_TRAITS_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+// Implementation
+#include <boost/range/detail/collection_traits_detail.hpp>
+
+/*! \file
+ Defines collection_traits class and related free-standing functions.
+ This facility is used to unify the access to different types of collections.
+ It allows the algorithms in the library to work with STL collections, c-style
+ array, null-terminated c-strings (and more) using the same interface.
+*/
+
+namespace boost {
+ namespace algorithm {
+
+// collection_traits template class -----------------------------------------//
+
+ //! collection_traits class
+ /*!
+ Collection traits provide uniform access to different types of
+ collections. This functionality allows to write generic algorithms
+ which work with several different kinds of collections.
+
+ Currently following collection types are supported:
+ - containers with STL compatible container interface ( see ContainerConcept )
+ ( i.e. \c std::vector<>, \c std::list<>, \c std::string<> ... )
+ - c-style array
+ ( \c char[10], \c int[15] ... )
+ - null-terminated c-strings
+ ( \c char*, \c wchar_T* )
+ - std::pair of iterators
+ ( i.e \c std::pair<vector<int>::iterator,vector<int>::iterator> )
+
+ Collection traits provide an external collection interface operations.
+ All are accessible using free-standing functions.
+
+ The following operations are supported:
+ - \c size()
+ - \c empty()
+ - \c begin()
+ - \c end()
+
+ Container traits have somewhat limited functionality on compilers not
+ supporting partial template specialization and partial template ordering.
+ */
+ template< typename T >
+ struct collection_traits
+ {
+ private:
+ typedef BOOST_STRING_TYPENAME ::boost::mpl::eval_if<
+ ::boost::algorithm::detail::is_pair<T>,
+ detail::pair_container_traits_selector<T>,
+ BOOST_STRING_TYPENAME ::boost::mpl::eval_if<
+ ::boost::is_array<T>,
+ detail::array_container_traits_selector<T>,
+ BOOST_STRING_TYPENAME ::boost::mpl::eval_if<
+ ::boost::is_pointer<T>,
+ detail::pointer_container_traits_selector<T>,
+ detail::default_container_traits_selector<T>
+ >
+ >
+ >::type container_helper_type;
+ public:
+ //! Function type
+ typedef container_helper_type function_type;
+ //! Value type
+ typedef BOOST_STRING_TYPENAME
+ container_helper_type::value_type value_type;
+ //! Size type
+ typedef BOOST_STRING_TYPENAME
+ container_helper_type::size_type size_type;
+ //! Iterator type
+ typedef BOOST_STRING_TYPENAME
+ container_helper_type::iterator iterator;
+ //! Const iterator type
+ typedef BOOST_STRING_TYPENAME
+ container_helper_type::const_iterator const_iterator;
+ //! Result iterator type ( iterator of const_iterator, depending on the constness of the container )
+ typedef BOOST_STRING_TYPENAME
+ container_helper_type::result_iterator result_iterator;
+ //! Difference type
+ typedef BOOST_STRING_TYPENAME
+ container_helper_type::difference_type difference_type;
+
+ }; // 'collection_traits'
+
+// collection_traits metafunctions -----------------------------------------//
+
+ //! Container value_type trait
+ /*!
+ Extract the type of elements contained in a container
+ */
+ template< typename C >
+ struct value_type_of
+ {
+ typedef BOOST_STRING_TYPENAME collection_traits<C>::value_type type;
+ };
+
+ //! Container difference trait
+ /*!
+ Extract the container's difference type
+ */
+ template< typename C >
+ struct difference_type_of
+ {
+ typedef BOOST_STRING_TYPENAME collection_traits<C>::difference_type type;
+ };
+
+ //! Container iterator trait
+ /*!
+ Extract the container's iterator type
+ */
+ template< typename C >
+ struct iterator_of
+ {
+ typedef BOOST_STRING_TYPENAME collection_traits<C>::iterator type;
+ };
+
+ //! Container const_iterator trait
+ /*!
+ Extract the container's const_iterator type
+ */
+ template< typename C >
+ struct const_iterator_of
+ {
+ typedef BOOST_STRING_TYPENAME collection_traits<C>::const_iterator type;
+ };
+
+
+ //! Container result_iterator
+ /*!
+ Extract the container's result_iterator type. This type maps to \c C::iterator
+ for mutable container and \c C::const_iterator for const containers.
+ */
+ template< typename C >
+ struct result_iterator_of
+ {
+ typedef BOOST_STRING_TYPENAME collection_traits<C>::result_iterator type;
+ };
+
+// collection_traits related functions -----------------------------------------//
+
+ //! Free-standing size() function
+ /*!
+ Get the size of the container. Uses collection_traits.
+ */
+ template< typename C >
+ inline BOOST_STRING_TYPENAME collection_traits<C>::size_type
+ size( const C& c )
+ {
+ return collection_traits<C>::function_type::size( c );
+ }
+
+ //! Free-standing empty() function
+ /*!
+ Check whether the container is empty. Uses container traits.
+ */
+ template< typename C >
+ inline bool empty( const C& c )
+ {
+ return collection_traits<C>::function_type::empty( c );
+ }
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ //! Free-standing begin() function
+ /*!
+ Get the begin iterator of the container. Uses collection_traits.
+ */
+ template< typename C >
+ inline BOOST_STRING_TYPENAME collection_traits<C>::iterator
+ begin( C& c )
+ {
+ return collection_traits<C>::function_type::begin( c );
+ }
+
+ //! Free-standing begin() function
+ /*!
+ \overload
+ */
+ template< typename C >
+ inline BOOST_STRING_TYPENAME collection_traits<C>::const_iterator
+ begin( const C& c )
+ {
+ return collection_traits<C>::function_type::begin( c );
+ }
+
+ //! Free-standing end() function
+ /*!
+ Get the begin iterator of the container. Uses collection_traits.
+ */
+ template< typename C >
+ inline BOOST_STRING_TYPENAME collection_traits<C>::iterator
+ end( C& c )
+ {
+ return collection_traits<C>::function_type::end( c );
+ }
+
+ //! Free-standing end() function
+ /*!
+ \overload
+ */
+ template< typename C >
+ inline BOOST_STRING_TYPENAME collection_traits<C>::const_iterator
+ end( const C& c )
+ {
+ return collection_traits<C>::function_type::end( c );
+ }
+
+#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ //! Free-standing begin() function
+ /*!
+ \overload
+ */
+ template< typename C >
+ inline BOOST_STRING_TYPENAME collection_traits<C>::result_iterator
+ begin( C& c )
+ {
+ return collection_traits<C>::function_type::begin( c );
+ }
+
+ //! Free-standing end() function
+ /*!
+ \overload
+ */
+ template< typename C >
+ inline BOOST_STRING_TYPENAME collection_traits<C>::result_iterator
+ end( C& c )
+ {
+ return collection_traits<C>::function_type::end( c );
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ } // namespace algorithm
+} // namespace boost
+
+#endif // BOOST_STRING_COLLECTION_TRAITS_HPP
Added: sandbox/async/boost/range/detail/collection_traits_detail.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/collection_traits_detail.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,621 @@
+// Boost string_algo library collection_traits.hpp header file -----------------------//
+
+// Copyright Pavol Droba 2002-2003. 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)
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#ifndef BOOST_RANGE_STRING_DETAIL_COLLECTION_TRAITS_HPP
+#define BOOST_RANGE_STRING_DETAIL_COLLECTION_TRAITS_HPP
+
+#include <boost/algorithm/string/config.hpp>
+#include <cstddef>
+#include <string>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/detail/iterator.hpp>
+#include <boost/algorithm/string/yes_no_type.hpp>
+
+// Container traits implementation ---------------------------------------------------------
+
+namespace boost {
+ namespace algorithm {
+ namespace detail {
+
+// Default collection traits -----------------------------------------------------------------
+
+ // Default collection helper
+ /*
+ Wraps std::container compliant containers
+ */
+ template< typename ContainerT >
+ struct default_container_traits
+ {
+ typedef BOOST_STRING_TYPENAME ContainerT::value_type value_type;
+ typedef BOOST_STRING_TYPENAME ContainerT::iterator iterator;
+ typedef BOOST_STRING_TYPENAME ContainerT::const_iterator const_iterator;
+ typedef BOOST_STRING_TYPENAME
+ ::boost::mpl::if_< ::boost::is_const<ContainerT>,
+ const_iterator,
+ iterator
+ >::type result_iterator;
+ typedef BOOST_STRING_TYPENAME ContainerT::difference_type difference_type;
+ typedef BOOST_STRING_TYPENAME ContainerT::size_type size_type;
+
+ // static operations
+ template< typename C >
+ static size_type size( const C& c )
+ {
+ return c.size();
+ }
+
+ template< typename C >
+ static bool empty( const C& c )
+ {
+ return c.empty();
+ }
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< typename C >
+ static iterator begin( C& c )
+ {
+ return c.begin();
+ }
+
+ template< typename C >
+ static const_iterator begin( const C& c )
+ {
+ return c.begin();
+ }
+
+ template< typename C >
+ static iterator end( C& c )
+ {
+ return c.end();
+ }
+
+ template< typename C >
+ static const_iterator end( const C& c )
+ {
+ return c.end();
+ }
+
+#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< typename C >
+ static result_iterator begin( C& c )
+ {
+ return c.begin();
+ }
+
+ template< typename C >
+ static result_iterator end( C& c )
+ {
+ return c.end();
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ };
+
+ template<typename T>
+ struct default_container_traits_selector
+ {
+ typedef default_container_traits<T> type;
+ };
+
+// Pair container traits ---------------------------------------------------------------------
+
+ // pair selector
+ template< typename T, typename U >
+ yes_type is_pair_impl( const std::pair<T,U>* );
+ no_type is_pair_impl( ... );
+
+ template<typename T> struct is_pair
+ {
+ private:
+ static T* t;
+ public:
+ BOOST_STATIC_CONSTANT( bool, value=
+ sizeof(is_pair_impl(t))==sizeof(yes_type) );
+ };
+
+ // pair helper
+ template< typename PairT >
+ struct pair_container_traits
+ {
+ typedef BOOST_STRING_TYPENAME PairT::first_type element_type;
+
+ typedef BOOST_STRING_TYPENAME ::boost::detail::
+ iterator_traits<element_type>::value_type value_type;
+ typedef std::size_t size_type;
+ typedef BOOST_STRING_TYPENAME ::boost::detail::
+ iterator_traits<element_type>::difference_type difference_type;
+
+ typedef element_type iterator;
+ typedef element_type const_iterator;
+ typedef element_type result_iterator;
+
+ // static operations
+ template< typename P >
+ static size_type size( const P& p )
+ {
+ difference_type diff = std::distance( p.first, p.second );
+ if ( diff < 0 )
+ return 0;
+ else
+ return diff;
+ }
+
+ template< typename P >
+ static bool empty( const P& p )
+ {
+ return p.first==p.second;
+ }
+
+ template< typename P >
+ static const_iterator begin( const P& p )
+ {
+ return p.first;
+ }
+
+ template< typename P >
+ static const_iterator end( const P& p )
+ {
+ return p.second;
+ }
+ }; // 'pair_container_helper'
+
+ template<typename T>
+ struct pair_container_traits_selector
+ {
+ typedef pair_container_traits<T> type;
+ };
+
+// Array container traits ---------------------------------------------------------------
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ // array traits ( partial specialization )
+ template< typename T >
+ struct array_traits;
+
+ template< typename T, std::size_t sz >
+ struct array_traits<T[sz]>
+ {
+ // typedef
+ typedef T* iterator;
+ typedef const T* const_iterator;
+ typedef T value_type;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+ // size of the array ( static );
+ BOOST_STATIC_CONSTANT( size_type, array_size = sz );
+ };
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ // array traits ( no partial specialization )
+ /*
+ without parial specialization we are able to
+ provide support only for a limited number of
+ types. Currently the primitive numeric types
+ are supported
+ */
+ template< typename T, typename BaseT >
+ struct array_traits_impl
+ {
+ typedef BaseT value_type;
+ typedef BaseT* iterator;
+ typedef const BaseT* const_iterator;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+
+ // size of the array
+ BOOST_STATIC_CONSTANT( size_type, array_size = sizeof(T)/sizeof(BaseT) );
+ };
+
+ template< typename T, typename BaseT >
+ struct array_traits_impl_selector
+ {
+ typedef array_traits_impl<T,BaseT> type;
+ };
+
+ struct array_traits_void
+ {
+ typedef void type;
+ };
+
+ template< typename T, typename BaseT >
+ struct array_traits_cv_selector
+ {
+ typedef BOOST_STRING_TYPENAME
+ ::boost::mpl::eval_if<
+ ::boost::is_convertible<T,BaseT*>,
+ array_traits_impl_selector<T,BaseT>,
+ ::boost::mpl::eval_if<
+ ::boost::is_convertible<T,const BaseT*>,
+ array_traits_impl_selector<T, const BaseT>,
+ ::boost::mpl::eval_if<
+ ::boost::is_convertible<T, volatile BaseT*>,
+ array_traits_impl_selector<T, volatile BaseT>,
+ array_traits_impl_selector<T, const volatile BaseT>
+ >
+ >
+ >::type type;
+ };
+
+ template< typename T >
+ struct array_traits_select
+ {
+ template< typename T1, typename T2 >
+ struct apply
+ {
+ typedef BOOST_STRING_TYPENAME
+ ::boost::mpl::eval_if<
+ ::boost::is_convertible<T,const volatile T2*>,
+ array_traits_cv_selector<T,T2>,
+ ::boost::mpl::identity<T1> >::type type;
+ };
+ };
+
+ template< typename T >
+ struct array_traits_selector
+ {
+ private:
+ // supported array base types
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ typedef BOOST_STRING_TYPENAME
+ ::boost::mpl::vector10<
+ wchar_t,
+#else // BOOST_NO_INTRINSIC_WCHAR_T
+ typedef BOOST_STRING_TYPENAME
+ ::boost::mpl::vector9<
+#endif // BOOST_NO_INTRINSIC_WCHAR_T
+ char,
+ signed char,
+ unsigned char,
+ signed short,
+ unsigned short,
+ signed int,
+ unsigned int,
+ signed long,
+ unsigned long
+ >::type array_base_types;
+
+ public:
+ typedef BOOST_STRING_TYPENAME
+ ::boost::mpl::fold<
+ array_base_types,
+ ::boost::algorithm::detail::array_traits_void,
+ ::boost::algorithm::detail::array_traits_select<T> >::type type;
+ };
+
+ template< typename T >
+ struct array_traits
+ {
+ typedef BOOST_STRING_TYPENAME
+ array_traits_selector<T>::type traits_type;
+
+ typedef BOOST_STRING_TYPENAME
+ traits_type::value_type value_type;
+ typedef BOOST_STRING_TYPENAME
+ traits_type::iterator iterator;
+ typedef BOOST_STRING_TYPENAME
+ traits_type::const_iterator const_iterator;
+ typedef BOOST_STRING_TYPENAME
+ traits_type::size_type size_type;
+ typedef BOOST_STRING_TYPENAME
+ traits_type::difference_type difference_type;
+
+ BOOST_STATIC_CONSTANT( size_type, array_size = traits_type::array_size );
+ };
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+ // array lenght resolving
+ /*
+ Lenght of string contained in a static array could
+ be different from the size of the array.
+ For string processing we need the lenght without
+ terminating 0.
+
+ Therefore, the lenght is calulated for char and wchar_t
+ using char_traits, rather then simply returning
+ the array size.
+ */
+ template< typename T >
+ struct array_length_selector
+ {
+ template< typename TraitsT >
+ struct array_length
+ {
+ typedef BOOST_STRING_TYPENAME
+ TraitsT::size_type size_type;
+
+ BOOST_STATIC_CONSTANT(
+ size_type,
+ array_size=TraitsT::array_size );
+
+ template< typename A >
+ static size_type length( const A& )
+ {
+ return array_size;
+ }
+
+ template< typename A >
+ static bool empty( const A& )
+ {
+ return array_size==0;
+ }
+ };
+ };
+
+ // specialization for char
+ template<>
+ struct array_length_selector<char>
+ {
+ template< typename TraitsT >
+ struct array_length
+ {
+ typedef BOOST_STRING_TYPENAME
+ TraitsT::size_type size_type;
+
+ template< typename A >
+ static size_type length( const A& a )
+ {
+ if ( a==0 )
+ return 0;
+ else
+ return std::char_traits<char>::length(a);
+ }
+
+ template< typename A >
+ static bool empty( const A& a )
+ {
+ return a==0 || a[0]==0;
+ }
+ };
+ };
+
+ // specialization for wchar_t
+ template<>
+ struct array_length_selector<wchar_t>
+ {
+ template< typename TraitsT >
+ struct array_length
+ {
+ typedef BOOST_STRING_TYPENAME
+ TraitsT::size_type size_type;
+
+ template< typename A >
+ static size_type length( const A& a )
+ {
+ if ( a==0 )
+ return 0;
+ else
+ return std::char_traits<wchar_t>::length(a);
+ }
+
+ template< typename A >
+ static bool empty( const A& a )
+ {
+ return a==0 || a[0]==0;
+ }
+ };
+ };
+
+ template< typename T >
+ struct array_container_traits
+ {
+ private:
+ // resolve array traits
+ typedef array_traits<T> traits_type;
+
+ public:
+ typedef BOOST_STRING_TYPENAME
+ traits_type::value_type value_type;
+ typedef BOOST_STRING_TYPENAME
+ traits_type::iterator iterator;
+ typedef BOOST_STRING_TYPENAME
+ traits_type::const_iterator const_iterator;
+ typedef BOOST_STRING_TYPENAME
+ traits_type::size_type size_type;
+ typedef BOOST_STRING_TYPENAME
+ traits_type::difference_type difference_type;
+
+ typedef BOOST_STRING_TYPENAME
+ ::boost::mpl::if_< ::boost::is_const<T>,
+ const_iterator,
+ iterator
+ >::type result_iterator;
+
+ private:
+ // resolve array size
+ typedef BOOST_STRING_TYPENAME
+ ::boost::remove_cv<value_type>::type char_type;
+ typedef BOOST_STRING_TYPENAME
+ array_length_selector<char_type>::
+ BOOST_NESTED_TEMPLATE array_length<traits_type> array_length_type;
+
+ public:
+ BOOST_STATIC_CONSTANT( size_type, array_size = traits_type::array_size );
+
+ // static operations
+ template< typename A >
+ static size_type size( const A& a )
+ {
+ return array_length_type::length(a);
+ }
+
+ template< typename A >
+ static bool empty( const A& a )
+ {
+ return array_length_type::empty(a);
+ }
+
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< typename A >
+ static iterator begin( A& a )
+ {
+ return a;
+ }
+
+ template< typename A >
+ static const_iterator begin( const A& a )
+ {
+ return a;
+ }
+
+ template< typename A >
+ static iterator end( A& a )
+ {
+ return a+array_length_type::length(a);
+ }
+
+ template< typename A >
+ static const_iterator end( const A& a )
+ {
+ return a+array_length_type::length(a);
+ }
+
+#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< typename A >
+ static result_iterator begin( A& a )
+ {
+ return a;
+ }
+
+ template< typename A >
+ static result_iterator end( A& a )
+ {
+ return a+array_length_type::length(a);
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ };
+
+ template<typename T>
+ struct array_container_traits_selector
+ {
+ typedef array_container_traits<T> type;
+ };
+
+// Pointer container traits ---------------------------------------------------------------
+
+ template<typename T>
+ struct pointer_container_traits
+ {
+ typedef BOOST_STRING_TYPENAME
+ ::boost::remove_pointer<T>::type value_type;
+
+ typedef BOOST_STRING_TYPENAME
+ ::boost::remove_cv<value_type>::type char_type;
+ typedef ::std::char_traits<char_type> char_traits;
+
+ typedef value_type* iterator;
+ typedef const value_type* const_iterator;
+ typedef std::ptrdiff_t difference_type;
+ typedef std::size_t size_type;
+
+ typedef BOOST_STRING_TYPENAME
+ ::boost::mpl::if_< ::boost::is_const<T>,
+ const_iterator,
+ iterator
+ >::type result_iterator;
+
+ // static operations
+ template< typename P >
+ static size_type size( const P& p )
+ {
+ if ( p==0 )
+ return 0;
+ else
+ return char_traits::length(p);
+ }
+
+ template< typename P >
+ static bool empty( const P& p )
+ {
+ return p==0 || p[0]==0;
+ }
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< typename P >
+ static iterator begin( P& p )
+ {
+ return p;
+ }
+
+ template< typename P >
+ static const_iterator begin( const P& p )
+ {
+ return p;
+ }
+
+ template< typename P >
+ static iterator end( P& p )
+ {
+ if ( p==0 )
+ return p;
+ else
+ return p+char_traits::length(p);
+ }
+
+ template< typename P >
+ static const_iterator end( const P& p )
+ {
+ if ( p==0 )
+ return p;
+ else
+ return p+char_traits::length(p);
+ }
+
+#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< typename P >
+ static result_iterator begin( P& p )
+ {
+ return p;
+ }
+
+ template< typename P >
+ static result_iterator end( P& p )
+ {
+ if ( p==0 )
+ return p;
+ else
+ return p+char_traits::length(p);
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ };
+
+ template<typename T>
+ struct pointer_container_traits_selector
+ {
+ typedef pointer_container_traits<T> type;
+ };
+
+ } // namespace detail
+ } // namespace algorithm
+} // namespace boost
+
+
+#endif // BOOST_STRING_DETAIL_COLLECTION_HPP
Added: sandbox/async/boost/range/detail/common.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/common.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,117 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_COMMON_HPP
+#define BOOST_RANGE_DETAIL_COMMON_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/detail/sfinae.hpp>
+#include <boost/type_traits/is_void.hpp>
+#include <boost/type_traits/detail/ice_or.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/int.hpp>
+#include <cstddef>
+
+//////////////////////////////////////////////////////////////////////////////
+// missing partial specialization workaround.
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost
+{
+ namespace range_detail
+ {
+ // 1 = std containers
+ // 2 = std::pair
+ // 3 = const std::pair
+ // 4 = array
+ // 5 = const array
+ // 6 = char array
+ // 7 = wchar_t array
+ // 8 = char*
+ // 9 = const char*
+ // 10 = whar_t*
+ // 11 = const wchar_t*
+ // 12 = string
+
+ typedef mpl::int_<1>::type std_container_;
+ typedef mpl::int_<2>::type std_pair_;
+ typedef mpl::int_<3>::type const_std_pair_;
+ typedef mpl::int_<4>::type array_;
+ typedef mpl::int_<5>::type const_array_;
+ typedef mpl::int_<6>::type char_array_;
+ typedef mpl::int_<7>::type wchar_t_array_;
+ typedef mpl::int_<8>::type char_ptr_;
+ typedef mpl::int_<9>::type const_char_ptr_;
+ typedef mpl::int_<10>::type wchar_t_ptr_;
+ typedef mpl::int_<11>::type const_wchar_t_ptr_;
+ typedef mpl::int_<12>::type string_;
+
+ template< typename C >
+ struct range_helper
+ {
+ static C* c;
+ static C ptr;
+
+ BOOST_STATIC_CONSTANT( bool, is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type ) );
+ BOOST_STATIC_CONSTANT( bool, is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type ) );
+ BOOST_STATIC_CONSTANT( bool, is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type ) );
+ BOOST_STATIC_CONSTANT( bool, is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
+ BOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
+ BOOST_STATIC_CONSTANT( bool, is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) );
+ BOOST_STATIC_CONSTANT( bool, is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) );
+ BOOST_STATIC_CONSTANT( bool, is_string_ = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value ));
+ BOOST_STATIC_CONSTANT( bool, is_array_ = boost::is_array<C>::value );
+
+ };
+
+ template< typename C >
+ class range
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
+ boost::range_detail::std_pair_,
+ void >::type pair_t;
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
+ boost::range_detail::array_,
+ pair_t >::type array_t;
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
+ boost::range_detail::string_,
+ array_t >::type string_t;
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
+ boost::range_detail::const_char_ptr_,
+ string_t >::type const_char_ptr_t;
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
+ boost::range_detail::char_ptr_,
+ const_char_ptr_t >::type char_ptr_t;
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
+ boost::range_detail::const_wchar_t_ptr_,
+ char_ptr_t >::type const_wchar_ptr_t;
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
+ boost::range_detail::wchar_t_ptr_,
+ const_wchar_ptr_t >::type wchar_ptr_t;
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
+ boost::range_detail::wchar_t_array_,
+ wchar_ptr_t >::type wchar_array_t;
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
+ boost::range_detail::char_array_,
+ wchar_array_t >::type char_array_t;
+ public:
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
+ boost::range_detail::std_container_,
+ char_array_t >::type type;
+ }; // class 'range'
+ }
+}
+
+#endif
+
Added: sandbox/async/boost/range/detail/const_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/const_iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,71 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
+#define BOOST_RANGE_DETAIL_CONST_ITERATOR_HPP
+
+#include <boost/range/detail/common.hpp>
+#include <boost/range/detail/remove_extent.hpp>
+
+//////////////////////////////////////////////////////////////////////////////
+// missing partial specialization workaround.
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_const_iterator_;
+
+ template<>
+ struct range_const_iterator_<std_container_>
+ {
+ template< typename C >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME C::const_iterator type;
+ };
+ };
+
+ template<>
+ struct range_const_iterator_<std_pair_>
+ {
+ template< typename P >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
+ };
+ };
+
+
+ template<>
+ struct range_const_iterator_<array_>
+ {
+ template< typename T >
+ struct pts
+ {
+ typedef const BOOST_RANGE_DEDUCED_TYPENAME
+ remove_extent<T>::type* type;
+ };
+ };
+ }
+
+ template< typename C >
+ class range_const_iterator
+ {
+ typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+ public:
+ typedef BOOST_DEDUCED_TYPENAME range_detail::range_const_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
+ };
+
+}
+
+#endif
Added: sandbox/async/boost/range/detail/detail_str.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/detail_str.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,376 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_DETAIL_STR_HPP
+#define BOOST_RANGE_DETAIL_DETAIL_STR_HPP
+
+#include <boost/config.hpp> // BOOST_MSVC
+#include <boost/range/iterator.hpp>
+
+namespace boost
+{
+
+ namespace range_detail
+ {
+ //
+ // iterator
+ //
+
+ template<>
+ struct range_iterator_<char_array_>
+ {
+ template< typename T >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ remove_extent<T>::type* type;
+ };
+ };
+
+ template<>
+ struct range_iterator_<char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef char* type;
+ };
+ };
+
+ template<>
+ struct range_iterator_<const_char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef const char* type;
+ };
+ };
+
+ template<>
+ struct range_iterator_<wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef wchar_t* type;
+ };
+ };
+
+ template<>
+ struct range_iterator_<const_wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef const wchar_t* type;
+ };
+ };
+
+
+ //
+ // const iterator
+ //
+
+ template<>
+ struct range_const_iterator_<char_array_>
+ {
+ template< typename T >
+ struct pts
+ {
+ typedef const BOOST_RANGE_DEDUCED_TYPENAME
+ remove_extent<T>::type* type;
+ };
+ };
+
+ template<>
+ struct range_const_iterator_<char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef const char* type;
+ };
+ };
+
+ template<>
+ struct range_const_iterator_<const_char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef const char* type;
+ };
+ };
+
+ template<>
+ struct range_const_iterator_<wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef const wchar_t* type;
+ };
+ };
+
+ template<>
+ struct range_const_iterator_<const_wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef const wchar_t* type;
+ };
+ };
+ }
+}
+
+#include <boost/range/detail/begin.hpp>
+#include <boost/range/detail/end.hpp>
+#include <boost/range/detail/size_type>
+#include <boost/range/detail/value_type>
+#include <boost/range/detail/common.hpp>
+
+namespace boost
+{
+
+ namespace range_detail
+ {
+ //
+ // str_begin()
+ //
+ template<>
+ struct range_begin<char_ptr_>
+ {
+ static char* fun( char* s )
+ {
+ return s;
+ }
+ };
+
+ template<>
+ struct range_begin<const_char_ptr_>
+ {
+ static const char* fun( const char* s )
+ {
+ return s;
+ }
+ };
+
+ template<>
+ struct range_begin<wchar_t_ptr_>
+ {
+
+ static wchar_t* fun( wchar_t* s )
+ {
+ return s;
+ }
+ };
+
+ template<>
+ struct range_begin<const_wchar_t_ptr_>
+ {
+ static const wchar_t* fun( const wchar_t* s )
+ {
+ return s;
+ }
+ };
+
+ template< typename C >
+ inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
+ str_begin( C& c )
+ {
+ return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME
+ range_detail::range<C>::type >::fun( c );
+ }
+
+ //
+ // str_end()
+ //
+
+ template<>
+ struct range_end<char_array_>
+ {
+ template< typename T, std::size_t sz >
+ static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return boost::range_detail::array_end( boost_range_array );
+ }
+ };
+
+ template<>
+ struct range_end<wchar_t_array_>
+ {
+ template< typename T, std::size_t sz >
+ static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return boost::range_detail::array_end( boost_range_array );
+ }
+ };
+
+ template<>
+ struct range_end<char_ptr_>
+ {
+ static char* fun( char* s )
+ {
+ return boost::range_detail::str_end( s );
+ }
+ };
+
+ template<>
+ struct range_end<const_char_ptr_>
+ {
+ static const char* fun( const char* s )
+ {
+ return boost::range_detail::str_end( s );
+ }
+ };
+
+ template<>
+ struct range_end<wchar_t_ptr_>
+ {
+ static wchar_t* fun( wchar_t* s )
+ {
+ return boost::range_detail::str_end( s );
+ }
+ };
+
+
+ template<>
+ struct range_end<const_wchar_t_ptr_>
+ {
+ static const wchar_t* fun( const wchar_t* s )
+ {
+ return boost::range_detail::str_end( s );
+ }
+ };
+
+ template< typename C >
+ inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
+ str_end( C& c )
+ {
+ return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME
+ range_detail::range<C>::type >::fun( c );
+ }
+
+ //
+ // size_type
+ //
+
+ template<>
+ struct range_size_type_<char_array_>
+ {
+ template< typename A >
+ struct pts
+ {
+ typedef std::size_t type;
+ };
+ };
+
+ template<>
+ struct range_size_type_<char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef std::size_t type;
+ };
+ };
+
+ template<>
+ struct range_size_type_<const_char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef std::size_t type;
+ };
+ };
+
+ template<>
+ struct range_size_type_<wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef std::size_t type;
+ };
+ };
+
+ template<>
+ struct range_size_type_<const_wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef std::size_t type;
+ };
+ };
+
+ //
+ // value_type
+ //
+
+ template<>
+ struct range_value_type_<char_array_>
+ {
+ template< typename T >
+ struct pts
+ {
+ typedef char type;
+ };
+ };
+
+ template<>
+ struct range_value_type_<char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef char type;
+ };
+ };
+
+ template<>
+ struct range_value_type_<const_char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef const char type;
+ };
+ };
+
+ template<>
+ struct range_value_type_<wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef wchar_t type;
+ };
+ };
+
+ template<>
+ struct range_value_type_<const_wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef const wchar_t type;
+ };
+ };
+
+ } // namespace 'range_detail'
+
+} // namespace 'boost'
+
+
+#endif
Added: sandbox/async/boost/range/detail/difference_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/difference_type.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,121 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_DIFFERENCE_TYPE_HPP
+#define BOOST_RANGE_DETAIL_DIFFERENCE_TYPE_HPP
+
+#include <boost/range/detail/common.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+//////////////////////////////////////////////////////////////////////////////
+// missing partial specialization workaround.
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_difference_type_;
+
+ template<>
+ struct range_difference_type_<std_container_>
+ {
+ template< typename C >
+ struct pts
+ {
+ typedef BOOST_DEDUCED_TYPENAME C::difference_type type;
+ };
+ };
+
+ template<>
+ struct range_difference_type_<std_pair_>
+ {
+ template< typename P >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::iterator_difference< BOOST_DEDUCED_TYPENAME P::first_type>::type type;
+ };
+ };
+
+ template<>
+ struct range_difference_type_<array_>
+ {
+ template< typename A >
+ struct pts
+ {
+ typedef std::ptrdiff_t type;
+ };
+ };
+
+ template<>
+ struct range_difference_type_<char_array_>
+ {
+ template< typename A >
+ struct pts
+ {
+ typedef std::ptrdiff_t type;
+ };
+ };
+
+ template<>
+ struct range_difference_type_<char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef std::ptrdiff_t type;
+ };
+ };
+
+ template<>
+ struct range_difference_type_<const_char_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef std::ptrdiff_t type;
+ };
+ };
+
+ template<>
+ struct range_difference_type_<wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef std::ptrdiff_t type;
+ };
+ };
+
+ template<>
+ struct range_difference_type_<const_wchar_t_ptr_>
+ {
+ template< typename S >
+ struct pts
+ {
+ typedef std::ptrdiff_t type;
+ };
+ };
+
+ }
+
+ template< typename C >
+ class range_difference
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+ public:
+ typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range_difference_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
+ };
+
+}
+
+#endif
+
Added: sandbox/async/boost/range/detail/empty.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/empty.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,120 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_EMPTY_HPP
+#define BOOST_RANGE_DETAIL_EMPTY_HPP
+
+#include <boost/range/detail/common.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_empty;
+
+ //////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_empty<std_container_>
+ {
+ template< typename C >
+ static bool fun( C& c )
+ {
+ return c.empty();
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_empty<std_pair_>
+ {
+ template< typename P >
+ static bool fun( const P& p )
+ {
+ return p.first == p.second;
+ }
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_empty<array_>
+ {
+ template< typename T, std::size_t sz >
+ static bool fun( T BOOST_ARRAY_REF[sz] )
+ {
+ if( boost_range_array == 0 )
+ return true;
+ return false;
+ }
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // string
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_empty<char_ptr_>
+ {
+ static bool fun( const char* s )
+ {
+ return s == 0 || s[0] == 0;
+ }
+ };
+
+ template<>
+ struct range_empty<const_char_ptr_>
+ {
+ static bool fun( const char* s )
+ {
+ return s == 0 || s[0] == 0;
+ }
+ };
+
+ template<>
+ struct range_empty<wchar_t_ptr_>
+ {
+ static bool fun( const wchar_t* s )
+ {
+ return s == 0 || s[0] == 0;
+ }
+ };
+
+ template<>
+ struct range_empty<const_wchar_t_ptr_>
+ {
+ static bool fun( const wchar_t* s )
+ {
+ return s == 0 || s[0] == 0;
+ }
+ };
+
+ } // namespace 'range_detail'
+
+
+ template< typename C >
+ inline bool
+ empty( const C& c )
+ {
+ return range_detail::range_empty< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
+ }
+
+} // namespace 'boost'
+
+
+#endif
Added: sandbox/async/boost/range/detail/end.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/end.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,98 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_END_HPP
+#define BOOST_RANGE_DETAIL_END_HPP
+
+#include <boost/config.hpp> // BOOST_MSVC
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# include <boost/range/detail/vc6/end.hpp>
+#else
+# include <boost/range/detail/implementation_help.hpp>
+# include <boost/range/iterator.hpp>
+# include <boost/range/detail/common.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+# include <boost/range/detail/remove_extent.hpp>
+# endif
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_end;
+
+ //////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_end<std_container_>
+ {
+ template< typename C >
+ static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
+ fun( C& c )
+ {
+ return c.end();
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_end<std_pair_>
+ {
+ template< typename P >
+ static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type
+ fun( const P& p )
+ {
+ return p.second;
+ }
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_end<array_>
+ {
+ #if !BOOST_WORKAROUND(BOOST_MSVC, < 1310)
+ template< typename T, std::size_t sz >
+ static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return boost::range_detail::array_end( boost_range_array );
+ }
+ #else
+ template<typename T>
+ static BOOST_RANGE_DEDUCED_TYPENAME remove_extent<T>::type* fun(T& t)
+ {
+ return t + remove_extent<T>::size;
+ }
+ #endif
+ };
+
+ } // namespace 'range_detail'
+
+ template< typename C >
+ inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type
+ end( C& c )
+ {
+ return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
+ }
+
+} // namespace 'boost'
+
+# endif // VC6
+#endif
Added: sandbox/async/boost/range/detail/extract_optional_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/extract_optional_type.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,52 @@
+// Boost.Range library
+//
+// Copyright Arno Schoedl & Neil Groves 2009.
+// 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/range/
+//
+#ifndef BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
+#define BOOST_RANGE_DETAIL_EXTRACT_OPTIONAL_TYPE_HPP_INCLUDED
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_PARTIAL_TEMPLATE_SPECIALIZATION
+
+#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \
+ template< typename C > \
+ struct extract_ ## a_typedef \
+ { \
+ typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \
+ };
+
+#else
+
+namespace boost {
+ namespace range_detail {
+ template< typename T > struct exists { typedef void type; };
+ }
+}
+
+// Defines extract_some_typedef<T> which exposes T::some_typedef as
+// extract_some_typedef<T>::type if T::some_typedef exists. Otherwise
+// extract_some_typedef<T> is empty.
+#define BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( a_typedef ) \
+ template< typename C, typename Enable=void > \
+ struct extract_ ## a_typedef \
+ {}; \
+ template< typename C > \
+ struct extract_ ## a_typedef< C \
+ , BOOST_DEDUCED_TYPENAME boost::range_detail::exists< BOOST_DEDUCED_TYPENAME C::a_typedef >::type \
+ > { \
+ typedef BOOST_DEDUCED_TYPENAME C::a_typedef type; \
+ };
+
+#endif
+
+#endif // include guard
Added: sandbox/async/boost/range/detail/implementation_help.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/implementation_help.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,103 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP
+#define BOOST_RANGE_DETAIL_IMPLEMENTATION_HELP_HPP
+
+#include <boost/range/config.hpp>
+#include <boost/range/detail/common.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <cstddef>
+#include <string.h>
+
+#ifndef BOOST_NO_CWCHAR
+#include <wchar.h>
+#endif
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template <typename T>
+ inline void boost_range_silence_warning( const T& ) { }
+
+ /////////////////////////////////////////////////////////////////////
+ // end() help
+ /////////////////////////////////////////////////////////////////////
+
+ inline const char* str_end( const char* s, const char* )
+ {
+ return s + strlen( s );
+ }
+
+#ifndef BOOST_NO_CWCHAR
+ inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
+ {
+ return s + wcslen( s );
+ }
+#else
+ inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
+ {
+ if( s == 0 || s[0] == 0 )
+ return s;
+ while( *++s != 0 )
+ ;
+ return s;
+ }
+#endif
+
+ template< class Char >
+ inline Char* str_end( Char* s )
+ {
+ return const_cast<Char*>( str_end( s, s ) );
+ }
+
+ template< class T, std::size_t sz >
+ inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return boost_range_array + sz;
+ }
+
+ template< class T, std::size_t sz >
+ inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return boost_range_array + sz;
+ }
+
+ /////////////////////////////////////////////////////////////////////
+ // size() help
+ /////////////////////////////////////////////////////////////////////
+
+ template< class Char >
+ inline std::size_t str_size( const Char* const& s )
+ {
+ return str_end( s ) - s;
+ }
+
+ template< class T, std::size_t sz >
+ inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ boost_range_silence_warning( boost_range_array );
+ return sz;
+ }
+
+ template< class T, std::size_t sz >
+ inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ boost_range_silence_warning( boost_range_array );
+ return sz;
+ }
+
+ } // namespace 'range_detail'
+
+} // namespace 'boost'
+
+
+#endif
Added: sandbox/async/boost/range/detail/iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,78 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_ITERATOR_HPP
+#define BOOST_RANGE_DETAIL_ITERATOR_HPP
+
+#include <boost/range/detail/common.hpp>
+#include <boost/range/detail/remove_extent.hpp>
+
+#include <boost/static_assert.hpp>
+
+//////////////////////////////////////////////////////////////////////////////
+// missing partial specialization workaround.
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_iterator_ {
+ template< typename C >
+ struct pts
+ {
+ typedef int type;
+ };
+ };
+
+ template<>
+ struct range_iterator_<std_container_>
+ {
+ template< typename C >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME C::iterator type;
+ };
+ };
+
+ template<>
+ struct range_iterator_<std_pair_>
+ {
+ template< typename P >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME P::first_type type;
+ };
+ };
+
+ template<>
+ struct range_iterator_<array_>
+ {
+ template< typename T >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ remove_extent<T>::type* type;
+ };
+ };
+
+ }
+
+ template< typename C >
+ class range_mutable_iterator
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+ public:
+ typedef typename range_detail::range_iterator_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
+ };
+}
+
+#endif
Added: sandbox/async/boost/range/detail/microsoft.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/microsoft.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,931 @@
+#ifndef BOOST_RANGE_DETAIL_MICROSOFT_HPP
+#define BOOST_RANGE_DETAIL_MICROSOFT_HPP
+
+// Boost.Range MFC/ATL Extension
+//
+// Copyright Shunsuke Sogame 2005-2006.
+// 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)
+
+
+
+
+// config
+//
+
+
+#include <boost/range/iterator.hpp>
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1 1
+
+
+#if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+ #define BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator range_mutable_iterator
+ #define BOOST_RANGE_DETAIL_MICROSOFT_range_begin range_begin
+ #define BOOST_RANGE_DETAIL_MICROSOFT_range_end range_end
+#else
+ #define BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator range_mutable_iterator
+ #define BOOST_RANGE_DETAIL_MICROSOFT_range_begin range_begin
+ #define BOOST_RANGE_DETAIL_MICROSOFT_range_end range_end
+#endif
+
+
+
+
+// yet another customization way
+//
+
+
+#include <boost/iterator/iterator_traits.hpp> // iterator_difference
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/comma_if.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
+#include <boost/preprocessor/list/for_each.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/seq/for_each_i.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/tuple/eat.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/utility/enable_if.hpp> // disable_if
+
+#if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+ #include <boost/range/mutable_iterator.hpp>
+#else
+ #include <iterator> // distance
+ #include <boost/range/begin.hpp>
+ #include <boost/range/end.hpp>
+ #include <boost/range/iterator.hpp>
+#endif
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+ // customization point
+ //
+
+ template< class Tag >
+ struct customization;
+
+
+ template< class T >
+ struct customization_tag;
+
+
+ struct using_type_as_tag
+ { };
+
+
+ // Topic:
+ // In fact, it is unnecessary for VC++.
+ // VC++'s behavior seems conforming, while GCC fails without this.
+ template< class Iterator, class T >
+ struct mutable_ :
+ disable_if< is_const<T>, Iterator >
+ { };
+
+
+ // helpers
+ //
+
+ template< class Tag, class T >
+ struct customization_tag_of
+ {
+ typedef typename mpl::if_< is_same<using_type_as_tag, Tag>,
+ T,
+ Tag
+ >::type type;
+ };
+
+
+ template< class T >
+ struct customization_of
+ {
+ typedef typename remove_cv<T>::type bare_t;
+ typedef typename customization_tag<bare_t>::type tag_t;
+ typedef customization<tag_t> type;
+ };
+
+
+ template< class T >
+ struct mutable_iterator_of
+ {
+ typedef typename remove_cv<T>::type bare_t;
+ typedef typename customization_of<bare_t>::type cust_t;
+ typedef typename cust_t::template meta<bare_t>::mutable_iterator type;
+ };
+
+
+ template< class T >
+ struct const_iterator_of
+ {
+ typedef typename remove_cv<T>::type bare_t;
+ typedef typename customization_of<bare_t>::type cust_t;
+ typedef typename cust_t::template meta<bare_t>::const_iterator type;
+ };
+
+
+ template< class T >
+ struct size_type_of
+ {
+ typedef typename range_detail_microsoft::mutable_iterator_of<T>::type miter_t;
+ typedef typename iterator_difference<miter_t>::type type;
+ };
+
+
+ template< class T > inline
+ typename mutable_iterator_of<T>::type
+ begin_of(T& x)
+ {
+ typedef typename customization_of<T>::type cust_t;
+ return cust_t().template begin<typename mutable_iterator_of<T>::type>(x);
+ }
+
+
+ template< class T > inline
+ typename const_iterator_of<T>::type
+ begin_of(T const& x)
+ {
+ typedef typename customization_of<T>::type cust_t;
+ return cust_t().template begin<typename const_iterator_of<T>::type>(x);
+ }
+
+
+ template< class T > inline
+ typename mutable_iterator_of<T>::type
+ end_of(T& x)
+ {
+ typedef typename customization_of<T>::type cust_t;
+ return cust_t().template end<typename mutable_iterator_of<T>::type>(x);
+ }
+
+
+ template< class T > inline
+ typename const_iterator_of<T>::type
+ end_of(T const& x)
+ {
+ typedef typename customization_of<T>::type cust_t;
+ return cust_t().template end<typename const_iterator_of<T>::type>(x);
+ }
+
+
+#if defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+
+ template< class T > inline
+ typename size_type_of<T>::type
+ size_of(T const& x)
+ {
+ return std::distance(boost::begin(x), boost::end(x));
+ }
+
+#endif
+
+
+ template< class Range >
+ struct compatible_mutable_iterator :
+ BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator<Range>
+ { };
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open(NamespaceList) \
+ BOOST_PP_LIST_FOR_EACH(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open_op, ~, NamespaceList) \
+/**/
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open_op(r, data, elem) \
+ namespace elem { \
+ /**/
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close(NamespaceList) \
+ BOOST_PP_LIST_FOR_EACH(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close_op, ~, NamespaceList) \
+/**/
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close_op(r, data, elem) \
+ } \
+ /**/
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_expand_op(r, data, elem) \
+ :: elem \
+/**/
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(Tag, NamespaceList, Name) \
+ namespace boost { namespace range_detail_microsoft { \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_tag(Tag, BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ } } \
+ \
+ namespace boost { \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_mutable_iterator(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_const_iterator(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size_type(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ } \
+ \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open(NamespaceList) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_begin(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_begin_const(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_end(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_end_const(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close(NamespaceList) \
+/**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name) \
+ BOOST_PP_LIST_FOR_EACH(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_expand_op, ~, NamespaceList) :: Name \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_tag(Tag, Fullname) \
+ template< > \
+ struct customization_tag< Fullname > : \
+ customization_tag_of< Tag, Fullname > \
+ { }; \
+ /**/
+
+
+ // metafunctions
+ //
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_mutable_iterator(Fullname) \
+ template< > \
+ struct BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator< Fullname > : \
+ range_detail_microsoft::mutable_iterator_of< Fullname > \
+ { }; \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_const_iterator(Fullname) \
+ template< > \
+ struct range_const_iterator< Fullname > : \
+ range_detail_microsoft::const_iterator_of< Fullname > \
+ { }; \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size_type(Fullname) \
+ template< > \
+ struct range_size< Fullname > : \
+ range_detail_microsoft::size_type_of< Fullname > \
+ { }; \
+ /**/
+
+
+ // functions
+ //
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_begin(Fullname) \
+ inline \
+ boost::range_detail_microsoft::mutable_iterator_of< Fullname >::type \
+ BOOST_RANGE_DETAIL_MICROSOFT_range_begin(Fullname& x) \
+ { \
+ return boost::range_detail_microsoft::begin_of(x); \
+ } \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_begin_const(Fullname) \
+ inline \
+ boost::range_detail_microsoft::const_iterator_of< Fullname >::type \
+ BOOST_RANGE_DETAIL_MICROSOFT_range_begin(Fullname const& x) \
+ { \
+ return boost::range_detail_microsoft::begin_of(x); \
+ } \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_end(Fullname) \
+ inline \
+ boost::range_detail_microsoft::mutable_iterator_of< Fullname >::type \
+ BOOST_RANGE_DETAIL_MICROSOFT_range_end(Fullname& x) \
+ { \
+ return boost::range_detail_microsoft::end_of(x); \
+ } \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_end_const(Fullname) \
+ inline \
+ boost::range_detail_microsoft::const_iterator_of< Fullname >::type \
+ BOOST_RANGE_DETAIL_MICROSOFT_range_end(Fullname const& x) \
+ { \
+ return boost::range_detail_microsoft::end_of(x); \
+ } \
+ /**/
+
+
+ #if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size(Fullname) \
+ /**/
+
+ #else
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size(Fullname) \
+ inline \
+ boost::range_detail_microsoft::size_type_of< Fullname >::type \
+ boost_range_size(Fullname const& x) \
+ { \
+ return boost::range_detail_microsoft::size_of(x); \
+ } \
+ /**/
+
+ #endif
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(Tag, NamespaceList, Name, ParamSeqOrCount) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_impl( \
+ Tag, NamespaceList, Name, \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_to_param_seq(ParamSeqOrCount) \
+ ) \
+/**/
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_to_param_seq(ParamSeqOrCount) \
+ BOOST_PP_IIF(BOOST_PP_IS_UNARY(ParamSeqOrCount), \
+ ParamSeqOrCount BOOST_PP_TUPLE_EAT(3), \
+ BOOST_PP_REPEAT \
+ )(ParamSeqOrCount, BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_to_param_seq_op, ~) \
+ /**/
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_to_param_seq_op(z, n, _) \
+ (class) \
+ /**/
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_impl(Tag, NamespaceList, Name, ParamSeq) \
+ namespace boost { namespace range_detail_microsoft { \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_tag( \
+ Tag, \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ } } \
+ \
+ namespace boost { \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_mutable_iterator( \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_const_iterator( \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size_type( \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ } \
+ \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open(NamespaceList) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_begin( \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_begin_const( \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_end( \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_end_const( \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size( \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ ) \
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close(NamespaceList) \
+/**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq) \
+ BOOST_PP_SEQ_FOR_EACH_I(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params_op, ~, ParamSeq) \
+ /**/
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params_op(r, data, i, elem) \
+ BOOST_PP_COMMA_IF(i) elem BOOST_PP_CAT(T, i) \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+ BOOST_PP_LIST_FOR_EACH(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_expand_op, ~, NamespaceList) \
+ :: Name < BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(ParamSeq), T) > \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_tag(Tag, Params, Fullname) \
+ template< Params > \
+ struct customization_tag< Fullname > : \
+ customization_tag_of< Tag, Fullname > \
+ { }; \
+ /**/
+
+
+ // metafunctions
+ //
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_mutable_iterator(Params, Fullname) \
+ template< Params > \
+ struct BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator< Fullname > : \
+ range_detail_microsoft::mutable_iterator_of< Fullname > \
+ { }; \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_const_iterator(Params, Fullname) \
+ template< Params > \
+ struct range_const_iterator< Fullname > : \
+ range_detail_microsoft::const_iterator_of< Fullname > \
+ { }; \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size_type(Params, Fullname) \
+ template< Params > \
+ struct range_size< Fullname > : \
+ range_detail_microsoft::size_type_of< Fullname > \
+ { }; \
+ /**/
+
+
+ // functions
+ //
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_begin(Params, Fullname) \
+ template< Params > inline \
+ typename boost::range_detail_microsoft::mutable_iterator_of< Fullname >::type \
+ BOOST_RANGE_DETAIL_MICROSOFT_range_begin(Fullname& x) \
+ { \
+ return boost::range_detail_microsoft::begin_of(x); \
+ } \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_begin_const(Params, Fullname) \
+ template< Params > inline \
+ typename boost::range_detail_microsoft::const_iterator_of< Fullname >::type \
+ BOOST_RANGE_DETAIL_MICROSOFT_range_begin(Fullname const& x) \
+ { \
+ return boost::range_detail_microsoft::begin_of(x); \
+ } \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_end(Params, Fullname) \
+ template< Params > inline \
+ typename boost::range_detail_microsoft::mutable_iterator_of< Fullname >::type \
+ BOOST_RANGE_DETAIL_MICROSOFT_range_end(Fullname& x) \
+ { \
+ return boost::range_detail_microsoft::end_of(x); \
+ } \
+ /**/
+
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_end_const(Params, Fullname) \
+ template< Params > inline \
+ typename boost::range_detail_microsoft::const_iterator_of< Fullname >::type \
+ BOOST_RANGE_DETAIL_MICROSOFT_range_end(Fullname const& x) \
+ { \
+ return boost::range_detail_microsoft::end_of(x); \
+ } \
+ /**/
+
+
+ #if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size(Params, Fullname) \
+ /**/
+
+ #else
+
+ #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size(Params, Fullname) \
+ template< Params > inline \
+ typename boost::range_detail_microsoft::size_type_of< Fullname >::type \
+ boost_range_size(Fullname const& x) \
+ { \
+ return boost::range_detail_microsoft::size_of(x); \
+ } \
+ /**/
+
+ #endif
+
+
+
+
+// list_iterator and helpers
+//
+
+
+#include <boost/assert.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+// POSITION's header is undocumented, so is NULL.
+//
+struct __POSITION; // incomplete, but used as just a pointer.
+typedef __POSITION *POSITION;
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+ template<
+ class ListT,
+ class Value,
+ class Reference,
+ class Traversal
+ >
+ struct list_iterator;
+
+
+ template<
+ class ListT,
+ class Value,
+ class Reference,
+ class Traversal
+ >
+ struct list_iterator_super
+ {
+ typedef typename mpl::if_< is_same<use_default, Reference>,
+ Value&,
+ Reference
+ >::type ref_t;
+
+ typedef typename mpl::if_< is_same<use_default, Traversal>,
+ bidirectional_traversal_tag,
+ Traversal
+ >::type trv_t;
+
+ typedef iterator_facade<
+ list_iterator<ListT, Value, Reference, Traversal>,
+ Value,
+ trv_t,
+ ref_t
+ > type;
+ };
+
+
+ template<
+ class ListT,
+ class Value,
+ class Reference = use_default,
+ class Traversal = use_default
+ >
+ struct list_iterator :
+ list_iterator_super<ListT, Value, Reference, Traversal>::type
+ {
+ private:
+ typedef list_iterator self_t;
+ typedef typename list_iterator_super<ListT, Value, Reference, Traversal>::type super_t;
+ typedef typename super_t::reference ref_t;
+
+ public:
+ explicit list_iterator()
+ { }
+
+ explicit list_iterator(ListT& lst, POSITION pos) :
+ m_plst(boost::addressof(lst)), m_pos(pos)
+ { }
+
+ template< class, class, class, class > friend struct list_iterator;
+ template< class ListT_, class Value_, class Reference_, class Traversal_>
+ list_iterator(list_iterator<ListT_, Value_, Reference_, Traversal_> const& other) :
+ m_plst(other.m_plst), m_pos(other.m_pos)
+ { }
+
+ private:
+ ListT *m_plst;
+ POSITION m_pos;
+
+ friend class iterator_core_access;
+ ref_t dereference() const
+ {
+ BOOST_ASSERT(m_pos != 0 && "out of range");
+ return m_plst->GetAt(m_pos);
+ }
+
+ // A B C D x
+ // Head Tail NULL(0)
+ //
+ void increment()
+ {
+ BOOST_ASSERT(m_pos != 0 && "out of range");
+ m_plst->GetNext(m_pos);
+ }
+
+ void decrement()
+ {
+ if (m_pos == 0) {
+ m_pos = m_plst->GetTailPosition();
+ return;
+ }
+
+ m_plst->GetPrev(m_pos);
+ }
+
+ bool equal(self_t const& other) const
+ {
+ BOOST_ASSERT(m_plst == other.m_plst && "iterators incompatible");
+ return m_pos == other.m_pos;
+ }
+ };
+
+
+ // customization helpers
+ //
+
+ struct array_functions
+ {
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ return x.GetData();
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return begin<Iterator>(x) + x.GetSize();
+ }
+ };
+
+
+ struct list_functions
+ {
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ return Iterator(x, x.GetHeadPosition());
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return Iterator(x, POSITION(0));
+ }
+ };
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+
+
+// test
+//
+
+
+#if defined(BOOST_RANGE_DETAIL_MICROSOFT_TEST)
+
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+#include <boost/concept_check.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/distance.hpp>
+#include <boost/range/empty.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/mutable_iterator.hpp>
+#include <boost/range/rbegin.hpp>
+#include <boost/range/rend.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+ template< class Range1, class Range2 >
+ bool test_equals(Range1 const& rng1, Range2 const& rng2)
+ {
+ return
+ boost::distance(rng1) == boost::distance(rng2) &&
+ std::equal(boost::begin(rng1), boost::end(rng1), boost::begin(rng2))
+ ;
+ }
+
+
+ template< class AssocContainer, class PairT >
+ bool test_find_key_and_mapped(AssocContainer const& ac, PairT const& pa)
+ {
+ typedef typename boost::range_const_iterator<AssocContainer>::type iter_t;
+ for (iter_t it = boost::const_begin(ac), last = boost::const_end(ac); it != last; ++it) {
+ if (it->first == pa.first && it->second == pa.second)
+ return true;
+ }
+
+ return false;
+ }
+
+
+ // test functions
+ //
+
+ template< class Range >
+ bool test_emptiness(Range& )
+ {
+ bool result = true;
+
+ Range emptyRng;
+ result = result && boost::empty(emptyRng);
+
+ return result;
+ }
+
+
+ template< class Range >
+ bool test_trivial(Range& rng)
+ {
+ bool result = true;
+
+ // convertibility check
+ typedef typename range_const_iterator<Range>::type citer_t;
+ citer_t cit = boost::begin(rng);
+ (void)cit; // unused
+
+ // mutability check
+ typedef typename range_value<Range>::type val_t;
+ val_t v = *boost::begin(rng);
+ *boost::begin(rng) = v;
+ result = result && *boost::begin(rng) == v;
+
+ return result;
+ }
+
+
+ template< class Range >
+ bool test_forward(Range& rng)
+ {
+ boost::function_requires< ForwardRangeConcept<Range> >();
+
+ bool result = (test_trivial)(rng);
+
+ typedef typename range_value<Range>::type val_t;
+
+ std::vector<val_t> saved;
+ std::copy(boost::begin(rng), boost::end(rng), std::back_inserter(saved));
+ std::rotate(boost::begin(saved), boost::next(boost::begin(saved)), boost::end(saved));
+
+ std::rotate(boost::begin(rng), boost::next(boost::begin(rng)), boost::end(rng));
+
+ return result && (test_equals)(saved, rng);
+ };
+
+
+ template< class Range >
+ bool test_bidirectional(Range& rng)
+ {
+ boost::function_requires< BidirectionalRangeConcept<Range> >();
+
+ bool result = (test_forward)(rng);
+
+ typedef typename range_value<Range>::type val_t;
+
+ std::vector<val_t> saved;
+ std::copy(boost::begin(rng), boost::end(rng), std::back_inserter(saved));
+
+ result = result && (test_equals)(
+ boost::make_iterator_range(boost::rbegin(saved), boost::rend(saved)),
+ boost::make_iterator_range(boost::rbegin(rng), boost::rend(rng))
+ );
+
+ return result;
+ }
+
+
+ template< class Range >
+ bool test_random_access(Range& rng)
+ {
+ boost::function_requires< RandomAccessRangeConcept<Range> >();
+
+ bool result = (test_bidirectional)(rng);
+
+ typedef typename range_value<Range>::type val_t;
+
+ std::vector<val_t> saved;
+ std::copy(boost::begin(rng), boost::end(rng), std::back_inserter(saved));
+ std::sort(boost::begin(saved), boost::end(saved));
+
+ std::random_shuffle(boost::begin(rng), boost::end(rng));
+ std::sort(boost::begin(rng), boost::end(rng));
+ result = result && (test_equals)(rng, saved);
+
+ std::random_shuffle(boost::begin(rng), boost::end(rng));
+ std::stable_sort(boost::begin(rng), boost::end(rng));
+ result = result && (test_equals)(rng, saved);
+
+ std::random_shuffle(boost::begin(rng), boost::end(rng));
+ std::partial_sort(boost::begin(rng), boost::end(rng), boost::end(rng));
+ result = result && (test_equals)(rng, saved);
+
+ return result;
+ }
+
+
+ // initializer
+ //
+
+ template< class ArrayT, class SampleRange >
+ bool test_init_array(ArrayT& arr, SampleRange const& sample)
+ {
+ typedef typename range_const_iterator<SampleRange>::type iter_t;
+ typedef typename range_value<SampleRange>::type val_t;
+
+ for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+ val_t v = *it; // works around ATL3 CSimpleArray
+ arr.Add(v);
+ }
+
+ return (test_equals)(arr, sample);
+ }
+
+
+ template< class ListT, class SampleRange >
+ bool test_init_list(ListT& lst, SampleRange const& sample)
+ {
+ typedef typename range_const_iterator<SampleRange>::type iter_t;
+
+ for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+ lst.AddTail(*it);
+ }
+
+ return (test_equals)(lst, sample);
+ }
+
+
+ template< class StringT, class SampleRange >
+ bool test_init_string(StringT& str, SampleRange const& sample)
+ {
+ typedef typename range_const_iterator<SampleRange>::type iter_t;
+ typedef typename range_value<SampleRange>::type val_t;
+
+ for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+ str += *it;
+ }
+
+ return (test_equals)(str, sample);
+ }
+
+
+ template< class MapT, class SampleMap >
+ bool test_init_map(MapT& map, SampleMap const& sample)
+ {
+ typedef typename range_const_iterator<SampleMap>::type iter_t;
+
+ for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+ map.SetAt(it->first, it->second);
+ }
+
+ return boost::distance(map) == boost::distance(sample);
+ }
+
+
+ // metafunction test
+ //
+
+ template< class Range, class Iter >
+ struct test_mutable_iter :
+ boost::is_same< typename boost::BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator<Range>::type, Iter >
+ { };
+
+
+ template< class Range, class Iter >
+ struct test_const_iter :
+ boost::is_same< typename boost::range_const_iterator<Range>::type, Iter >
+ { };
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+#endif // defined(BOOST_RANGE_DETAIL_MICROSOFT_TEST)
+
+
+
+#endif
Added: sandbox/async/boost/range/detail/range_return.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/range_return.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,180 @@
+// Copyright Neil Groves 2009. 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/range/
+//
+#ifndef BOOST_RANGE_DETAIL_RANGE_RETURN_HPP_INCLUDED
+#define BOOST_RANGE_DETAIL_RANGE_RETURN_HPP_INCLUDED
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost
+{
+ enum range_return_value
+ {
+ // (*) indicates the most common values
+ return_found, // only the found resulting iterator (*)
+ return_next, // next(found) iterator
+ return_prior, // prior(found) iterator
+ return_begin_found, // [begin, found) range (*)
+ return_begin_next, // [begin, next(found)) range
+ return_begin_prior, // [begin, prior(found)) range
+ return_found_end, // [found, end) range (*)
+ return_next_end, // [next(found), end) range
+ return_prior_end, // [prior(found), end) range
+ return_begin_end // [begin, end) range
+ };
+
+ template< class SinglePassRange, range_return_value >
+ struct range_return
+ {
+ typedef boost::iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type > type;
+
+ static type pack(BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type found,
+ SinglePassRange& rng)
+ {
+ return type(found, boost::end(rng));
+ }
+ };
+
+ template< class SinglePassRange >
+ struct range_return< SinglePassRange, return_found >
+ {
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type type;
+
+ static type pack(type found, SinglePassRange&)
+ {
+ return found;
+ }
+ };
+
+ template< class SinglePassRange >
+ struct range_return< SinglePassRange, return_next >
+ {
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type type;
+
+ static type pack(type found, SinglePassRange& rng)
+ {
+ return found == boost::end(rng)
+ ? found
+ : boost::next(found);
+ }
+ };
+
+ template< class BidirectionalRange >
+ struct range_return< BidirectionalRange, return_prior >
+ {
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type type;
+
+ static type pack(type found, BidirectionalRange& rng)
+ {
+ return found == boost::begin(rng)
+ ? found
+ : boost::prior(found);
+ }
+ };
+
+ template< class SinglePassRange >
+ struct range_return< SinglePassRange, return_begin_found >
+ {
+ typedef boost::iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type > type;
+
+ static type pack(BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type found,
+ SinglePassRange& rng)
+ {
+ return type(boost::begin(rng), found);
+ }
+ };
+
+ template< class SinglePassRange >
+ struct range_return< SinglePassRange, return_begin_next >
+ {
+ typedef boost::iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type > type;
+
+ static type pack(BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type found,
+ SinglePassRange& rng)
+ {
+ return type( boost::begin(rng),
+ found == boost::end(rng) ? found : boost::next(found) );
+ }
+ };
+
+ template< class BidirectionalRange >
+ struct range_return< BidirectionalRange, return_begin_prior >
+ {
+ typedef boost::iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type > type;
+
+ static type pack(BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type found,
+ BidirectionalRange& rng)
+ {
+ return type( boost::begin(rng),
+ found == boost::begin(rng) ? found : boost::prior(found) );
+ }
+ };
+
+ template< class SinglePassRange >
+ struct range_return< SinglePassRange, return_found_end >
+ {
+ typedef boost::iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type > type;
+
+ static type pack(BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type found,
+ SinglePassRange& rng)
+ {
+ return type(found, boost::end(rng));
+ }
+ };
+
+ template< class SinglePassRange >
+ struct range_return< SinglePassRange, return_next_end >
+ {
+ typedef boost::iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type > type;
+
+ static type pack(BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type found,
+ SinglePassRange& rng)
+ {
+ return type( found == boost::end(rng) ? found : boost::next(found),
+ boost::end(rng) );
+ }
+ };
+
+ template< class BidirectionalRange >
+ struct range_return< BidirectionalRange, return_prior_end >
+ {
+ typedef boost::iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type > type;
+
+ static type pack(BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type found,
+ BidirectionalRange& rng)
+ {
+ return type( found == boost::begin(rng) ? found : boost::prior(found),
+ boost::end(rng) );
+ }
+ };
+
+ template< class SinglePassRange >
+ struct range_return< SinglePassRange, return_begin_end >
+ {
+ typedef boost::iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type > type;
+
+ static type pack(BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type found,
+ SinglePassRange& rng)
+ {
+ return type(boost::begin(rng), boost::end(rng));
+ }
+ };
+
+}
+
+#endif // include guard
Added: sandbox/async/boost/range/detail/remove_extent.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/remove_extent.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,157 @@
+// Boost.Range library
+//
+// Copyright Jonathan Turkanis 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/range/
+//
+
+
+#ifndef BOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP
+#define BOOST_RANGE_DETAIL_REMOVE_BOUNDS_HPP
+
+#include <boost/config.hpp> // MSVC, NO_INTRINSIC_WCHAR_T, put size_t in std.
+#include <cstddef>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+
+ template< typename Case1 = mpl::true_,
+ typename Type1 = mpl::void_,
+ typename Case2 = mpl::true_,
+ typename Type2 = mpl::void_,
+ typename Case3 = mpl::true_,
+ typename Type3 = mpl::void_,
+ typename Case4 = mpl::true_,
+ typename Type4 = mpl::void_,
+ typename Case5 = mpl::true_,
+ typename Type5 = mpl::void_,
+ typename Case6 = mpl::true_,
+ typename Type6 = mpl::void_,
+ typename Case7 = mpl::true_,
+ typename Type7 = mpl::void_,
+ typename Case8 = mpl::true_,
+ typename Type8 = mpl::void_,
+ typename Case9 = mpl::true_,
+ typename Type9 = mpl::void_,
+ typename Case10 = mpl::true_,
+ typename Type10 = mpl::void_,
+ typename Case11 = mpl::true_,
+ typename Type11 = mpl::void_,
+ typename Case12 = mpl::true_,
+ typename Type12 = mpl::void_,
+ typename Case13 = mpl::true_,
+ typename Type13 = mpl::void_,
+ typename Case14 = mpl::true_,
+ typename Type14 = mpl::void_,
+ typename Case15 = mpl::true_,
+ typename Type15 = mpl::void_,
+ typename Case16 = mpl::true_,
+ typename Type16 = mpl::void_,
+ typename Case17 = mpl::true_,
+ typename Type17 = mpl::void_,
+ typename Case18 = mpl::true_,
+ typename Type18 = mpl::void_,
+ typename Case19 = mpl::true_,
+ typename Type19 = mpl::void_,
+ typename Case20 = mpl::true_,
+ typename Type20 = mpl::void_>
+ struct select {
+ typedef typename
+ mpl::eval_if<
+ Case1, mpl::identity<Type1>, mpl::eval_if<
+ Case2, mpl::identity<Type2>, mpl::eval_if<
+ Case3, mpl::identity<Type3>, mpl::eval_if<
+ Case4, mpl::identity<Type4>, mpl::eval_if<
+ Case5, mpl::identity<Type5>, mpl::eval_if<
+ Case6, mpl::identity<Type6>, mpl::eval_if<
+ Case7, mpl::identity<Type7>, mpl::eval_if<
+ Case8, mpl::identity<Type8>, mpl::eval_if<
+ Case9, mpl::identity<Type9>, mpl::if_<
+ Case10, Type10, mpl::void_ > > > > > > > > >
+ >::type result1;
+ typedef typename
+ mpl::eval_if<
+ Case11, mpl::identity<Type11>, mpl::eval_if<
+ Case12, mpl::identity<Type12>, mpl::eval_if<
+ Case13, mpl::identity<Type13>, mpl::eval_if<
+ Case14, mpl::identity<Type14>, mpl::eval_if<
+ Case15, mpl::identity<Type15>, mpl::eval_if<
+ Case16, mpl::identity<Type16>, mpl::eval_if<
+ Case17, mpl::identity<Type17>, mpl::eval_if<
+ Case18, mpl::identity<Type18>, mpl::eval_if<
+ Case19, mpl::identity<Type19>, mpl::if_<
+ Case20, Type20, mpl::void_ > > > > > > > > >
+ > result2;
+ typedef typename
+ mpl::eval_if<
+ is_same<result1, mpl::void_>,
+ result2,
+ mpl::identity<result1>
+ >::type type;
+ };
+
+ template<typename T>
+ struct remove_extent {
+ static T* ar;
+ BOOST_STATIC_CONSTANT(std::size_t, size = sizeof(*ar) / sizeof((*ar)[0]));
+
+ typedef typename
+ select<
+ is_same<T, bool[size]>, bool,
+ is_same<T, char[size]>, char,
+ is_same<T, signed char[size]>, signed char,
+ is_same<T, unsigned char[size]>, unsigned char,
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ is_same<T, wchar_t[size]>, wchar_t,
+ #endif
+ is_same<T, short[size]>, short,
+ is_same<T, unsigned short[size]>, unsigned short,
+ is_same<T, int[size]>, int,
+ is_same<T, unsigned int[size]>, unsigned int,
+ is_same<T, long[size]>, long,
+ is_same<T, unsigned long[size]>, unsigned long,
+ is_same<T, float[size]>, float,
+ is_same<T, double[size]>, double,
+ is_same<T, long double[size]>, long double
+ >::type result1;
+ typedef typename
+ select<
+ is_same<T, const bool[size]>, const bool,
+ is_same<T, const char[size]>, const char,
+ is_same<T, const signed char[size]>, const signed char,
+ is_same<T, const unsigned char[size]>, const unsigned char,
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ is_same<T, const wchar_t[size]>, const wchar_t,
+ #endif
+ is_same<T, const short[size]>, const short,
+ is_same<T, const unsigned short[size]>, const unsigned short,
+ is_same<T, const int[size]>, const int,
+ is_same<T, const unsigned int[size]>, const unsigned int,
+ is_same<T, const long[size]>, const long,
+ is_same<T, const unsigned long[size]>, const unsigned long,
+ is_same<T, const float[size]>, const float,
+ is_same<T, const double[size]>, const double,
+ is_same<T, const long double[size]>, const long double
+ > result2;
+ typedef typename
+ mpl::eval_if<
+ is_same<result1, mpl::void_>,
+ result2,
+ mpl::identity<result1>
+ >::type type;
+ };
+
+ } // namespace 'range_detail'
+
+} // namespace 'boost'
+
+
+#endif
Added: sandbox/async/boost/range/detail/sfinae.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/sfinae.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,77 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_SFINAE_HPP
+#define BOOST_RANGE_DETAIL_SFINAE_HPP
+
+#include <boost/range/config.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+#include <utility>
+
+
+namespace boost
+{
+ namespace range_detail
+ {
+ using type_traits::yes_type;
+ using type_traits::no_type;
+
+ //////////////////////////////////////////////////////////////////////
+ // string
+ //////////////////////////////////////////////////////////////////////
+
+ yes_type is_string_impl( const char* const );
+ yes_type is_string_impl( const wchar_t* const );
+ no_type is_string_impl( ... );
+
+ template< std::size_t sz >
+ yes_type is_char_array_impl( char BOOST_RANGE_ARRAY_REF()[sz] );
+ template< std::size_t sz >
+ yes_type is_char_array_impl( const char BOOST_RANGE_ARRAY_REF()[sz] );
+ no_type is_char_array_impl( ... );
+
+ template< std::size_t sz >
+ yes_type is_wchar_t_array_impl( wchar_t BOOST_RANGE_ARRAY_REF()[sz] );
+ template< std::size_t sz >
+ yes_type is_wchar_t_array_impl( const wchar_t BOOST_RANGE_ARRAY_REF()[sz] );
+ no_type is_wchar_t_array_impl( ... );
+
+ yes_type is_char_ptr_impl( char* const );
+ no_type is_char_ptr_impl( ... );
+
+ yes_type is_const_char_ptr_impl( const char* const );
+ no_type is_const_char_ptr_impl( ... );
+
+ yes_type is_wchar_t_ptr_impl( wchar_t* const );
+ no_type is_wchar_t_ptr_impl( ... );
+
+ yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
+ no_type is_const_wchar_t_ptr_impl( ... );
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template< typename Iterator >
+ yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
+ no_type is_pair_impl( ... );
+
+ //////////////////////////////////////////////////////////////////////
+ // tags
+ //////////////////////////////////////////////////////////////////////
+
+ struct char_or_wchar_t_array_tag {};
+
+ } // namespace 'range_detail'
+
+} // namespace 'boost'
+
+#endif
Added: sandbox/async/boost/range/detail/size.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/size.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,159 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+
+#ifndef BOOST_RANGE_DETAIL_SIZE_HPP
+#define BOOST_RANGE_DETAIL_SIZE_HPP
+
+#include <boost/config.hpp> // BOOST_MSVC
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+# include <boost/range/detail/vc6/size.hpp>
+#else
+# include <boost/range/detail/implementation_help.hpp>
+# include <boost/range/detail/size_type.hpp>
+# include <boost/range/detail/common.hpp>
+# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
+# include <boost/range/detail/remove_extent.hpp>
+# endif
+# include <iterator>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_size_;
+
+ //////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_size_<std_container_>
+ {
+ template< typename C >
+ static BOOST_RANGE_DEDUCED_TYPENAME C::size_type fun( const C& c )
+ {
+ return c.size();
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_size_<std_pair_>
+ {
+ template< typename P >
+ static BOOST_RANGE_DEDUCED_TYPENAME range_size<P>::type
+ fun( const P& p )
+ {
+ return std::distance( p.first, p.second );
+ }
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_size_<array_>
+ {
+ #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+ template< typename T, std::size_t sz >
+ static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return sz;
+ }
+ #else
+ template<typename T>
+ static std::size_t fun(T& t)
+ {
+ return remove_extent<T>::size;
+ }
+ #endif
+ };
+
+ template<>
+ struct range_size_<char_array_>
+ {
+ template< typename T, std::size_t sz >
+ static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return boost::range_detail::array_size( boost_range_array );
+ }
+ };
+
+ template<>
+ struct range_size_<wchar_t_array_>
+ {
+ template< typename T, std::size_t sz >
+ static std::size_t fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+ {
+ return boost::range_detail::array_size( boost_range_array );
+ }
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // string
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_size_<char_ptr_>
+ {
+ static std::size_t fun( const char* s )
+ {
+ return boost::range_detail::str_size( s );
+ }
+ };
+
+ template<>
+ struct range_size_<const_char_ptr_>
+ {
+ static std::size_t fun( const char* s )
+ {
+ return boost::range_detail::str_size( s );
+ }
+ };
+
+ template<>
+ struct range_size_<wchar_t_ptr_>
+ {
+ static std::size_t fun( const wchar_t* s )
+ {
+ return boost::range_detail::str_size( s );
+ }
+ };
+
+ template<>
+ struct range_size_<const_wchar_t_ptr_>
+ {
+ static std::size_t fun( const wchar_t* s )
+ {
+ return boost::range_detail::str_size( s );
+ }
+ };
+
+ } // namespace 'range_detail'
+
+
+ template< typename C >
+ BOOST_RANGE_DEDUCED_TYPENAME range_size<C>::type
+ size( const C& c )
+ {
+ return range_detail::range_size_< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
+ }
+
+} // namespace 'boost'
+
+# endif
+#endif
Added: sandbox/async/boost/range/detail/size_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/size_type.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,70 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_SIZE_TYPE_HPP
+#define BOOST_RANGE_DETAIL_SIZE_TYPE_HPP
+
+#include <boost/range/detail/common.hpp>
+
+//////////////////////////////////////////////////////////////////////////////
+// missing partial specialization workaround.
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_size_type_;
+
+ template<>
+ struct range_size_type_<std_container_>
+ {
+ template< typename C >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME C::size_type type;
+ };
+ };
+
+ template<>
+ struct range_size_type_<std_pair_>
+ {
+ template< typename P >
+ struct pts
+ {
+ typedef std::size_t type;
+ };
+ };
+
+ template<>
+ struct range_size_type_<array_>
+ {
+ template< typename A >
+ struct pts
+ {
+ typedef std::size_t type;
+ };
+ };
+
+
+ }
+
+ template< typename C >
+ class range_size
+ {
+ typedef typename range_detail::range<C>::type c_type;
+ public:
+ typedef typename range_detail::range_size_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
+ };
+}
+
+#endif
+
Added: sandbox/async/boost/range/detail/sizer.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/sizer.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,35 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_SIZER_HPP
+#define BOOST_RANGE_DETAIL_SIZER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <cstddef>
+
+namespace boost
+{
+ //////////////////////////////////////////////////////////////////////
+ // constant array size
+ //////////////////////////////////////////////////////////////////////
+
+ template< typename T, std::size_t sz >
+ char (& sizer( const T BOOST_RANGE_ARRAY_REF()[sz] ) )[sz];
+
+ template< typename T, std::size_t sz >
+ char (& sizer( T BOOST_RANGE_ARRAY_REF()[sz] ) )[sz];
+
+} // namespace 'boost'
+
+#endif
Added: sandbox/async/boost/range/detail/str_types.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/str_types.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,38 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_STR_TYPES_HPP
+#define BOOST_RANGE_DETAIL_STR_TYPES_HPP
+
+#include <boost/range/size_type.hpp>
+#include <boost/range/iterator.hpp>
+
+namespace boost
+{
+ template< class T >
+ struct range_mutable_iterator<T*>
+ {
+ typedef T* type;
+ };
+
+ template< class T >
+ struct range_const_iterator<T*>
+ {
+ typedef const T* type;
+ };
+
+ template< class T >
+ struct range_size<T*>
+ {
+ typedef std::size_t type;
+ };
+}
+
+#endif
Added: sandbox/async/boost/range/detail/value_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/value_type.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,72 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_VALUE_TYPE_HPP
+#define BOOST_RANGE_DETAIL_VALUE_TYPE_HPP
+
+#include <boost/range/detail/common.hpp>
+#include <boost/range/detail/remove_extent.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+//////////////////////////////////////////////////////////////////////////////
+// missing partial specialization workaround.
+//////////////////////////////////////////////////////////////////////////////
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_value_type_;
+
+ template<>
+ struct range_value_type_<std_container_>
+ {
+ template< typename C >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME C::value_type type;
+ };
+ };
+
+ template<>
+ struct range_value_type_<std_pair_>
+ {
+ template< typename P >
+ struct pts
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME boost::iterator_value< BOOST_RANGE_DEDUCED_TYPENAME P::first_type >::type type;
+ };
+ };
+
+ template<>
+ struct range_value_type_<array_>
+ {
+ template< typename T >
+ struct pts
+ {
+ typedef BOOST_DEDUCED_TYPENAME remove_extent<T>::type type;
+ };
+ };
+
+ }
+
+ template< typename C >
+ class range_value
+ {
+ typedef BOOST_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
+ public:
+ typedef BOOST_DEDUCED_TYPENAME range_detail::range_value_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type type;
+ };
+
+}
+
+#endif
+
Added: sandbox/async/boost/range/detail/vc6/end.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/vc6/end.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,170 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_VC6_END_HPP
+#define BOOST_RANGE_DETAIL_VC6_END_HPP
+
+#include <boost/range/detail/implementation_help.hpp>
+#include <boost/range/detail/implementation_help.hpp>
+#include <boost/range/result_iterator.hpp>
+#include <boost/range/detail/common.hpp>
+#include <boost/range/detail/remove_extent.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_end;
+
+ //////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_end<std_container_>
+ {
+ template< typename C >
+ struct inner {
+ static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type
+ fun( C& c )
+ {
+ return c.end();
+ };
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_end<std_pair_>
+ {
+ template< typename P >
+ struct inner {
+ static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type
+ fun( const P& p )
+ {
+ return p.second;
+ }
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_end<array_>
+ {
+ template< typename T >
+ struct inner {
+ static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
+ fun(T& t)
+ {
+ return t + remove_extent<T>::size;
+ }
+ };
+ };
+
+
+ template<>
+ struct range_end<char_array_>
+ {
+ template< typename T >
+ struct inner {
+ static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
+ fun(T& t)
+ {
+ return t + remove_extent<T>::size;
+ }
+ };
+ };
+
+ template<>
+ struct range_end<wchar_t_array_>
+ {
+ template< typename T >
+ struct inner {
+ static BOOST_DEDUCED_TYPENAME remove_extent<T>::type*
+ fun(T& t)
+ {
+ return t + remove_extent<T>::size;
+ }
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // string
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_end<char_ptr_>
+ {
+ template< typename T >
+ struct inner {
+ static char* fun( char* s )
+ {
+ return boost::range_detail::str_end( s );
+ }
+ };
+ };
+
+ template<>
+ struct range_end<const_char_ptr_>
+ {
+ template< typename T >
+ struct inner {
+ static const char* fun( const char* s )
+ {
+ return boost::range_detail::str_end( s );
+ }
+ };
+ };
+
+ template<>
+ struct range_end<wchar_t_ptr_>
+ {
+ template< typename T >
+ struct inner {
+ static wchar_t* fun( wchar_t* s )
+ {
+ return boost::range_detail::str_end( s );
+ }
+ };
+ };
+
+
+ template<>
+ struct range_end<const_wchar_t_ptr_>
+ {
+ template< typename T >
+ struct inner {
+ static const wchar_t* fun( const wchar_t* s )
+ {
+ return boost::range_detail::str_end( s );
+ }
+ };
+ };
+
+ } // namespace 'range_detail'
+
+ template< typename C >
+ inline BOOST_DEDUCED_TYPENAME range_result_iterator<C>::type
+ end( C& c )
+ {
+ return range_detail::range_end<range_detail::range<C>::type>::inner<C>::fun( c );
+ }
+
+} // namespace 'boost'
+
+
+#endif
Added: sandbox/async/boost/range/detail/vc6/size.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/detail/vc6/size.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,166 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+
+#ifndef BOOST_RANGE_DETAIL_VC6_SIZE_HPP
+#define BOOST_RANGE_DETAIL_VC6_SIZE_HPP
+
+#include <boost/range/detail/implementation_help.hpp>
+#include <boost/range/detail/size_type.hpp>
+#include <boost/range/detail/common.hpp>
+#include <boost/range/detail/remove_extent.hpp>
+#include <iterator>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template< typename T >
+ struct range_size_;
+
+ //////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_size_<std_container_>
+ {
+ template< typename C >
+ struct inner {
+ static BOOST_RANGE_DEDUCED_TYPENAME C::size_type fun( const C& c )
+ {
+ return c.size();
+ };
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_size_<std_pair_>
+ {
+ template< typename P >
+ struct inner {
+ static BOOST_RANGE_DEDUCED_TYPENAME range_size<P>::type
+ fun( const P& p )
+ {
+ return std::distance( p.first, p.second );
+ }
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_size_<array_>
+ {
+ template<typename T>
+ struct inner {
+ static std::size_t fun(T& t)
+ {
+ return remove_extent<T>::size;
+ }
+ };
+ };
+
+ template<>
+ struct range_size_<char_array_>
+ {
+ template<typename T>
+ struct inner {
+ static std::size_t fun(T& t)
+ {
+ return sizeof(T) / sizeof(T[0]);
+ }
+ };
+ };
+
+ template<>
+ struct range_size_<wchar_t_array_>
+ {
+ template<typename T>
+ struct inner {
+ static std::size_t fun(T& t)
+ {
+ return sizeof(T) / sizeof(T[0]);
+ }
+ };
+ };
+
+ //////////////////////////////////////////////////////////////////////
+ // string
+ //////////////////////////////////////////////////////////////////////
+
+ template<>
+ struct range_size_<char_ptr_>
+ {
+ template<typename T>
+ struct inner {
+ static std::size_t fun( const char* s )
+ {
+ return boost::range_detail::str_size( s );
+ }
+ };
+ };
+
+ template<>
+ struct range_size_<const_char_ptr_>
+ {
+ template<typename T>
+ struct inner {
+ static std::size_t fun( const char* s )
+ {
+ return boost::range_detail::str_size( s );
+ }
+ };
+ };
+
+ template<>
+ struct range_size_<wchar_t_ptr_>
+ {
+ template<typename T>
+ struct inner {
+ static std::size_t fun( const wchar_t* s )
+ {
+ return boost::range_detail::str_size( s );
+ }
+ };
+ };
+
+ template<>
+ struct range_size_<const_wchar_t_ptr_>
+ {
+ template<typename T>
+ struct inner {
+ static std::size_t fun( const wchar_t* s )
+ {
+ return boost::range_detail::str_size( s );
+ }
+ };
+ };
+
+ } // namespace 'range_detail'
+
+
+ template< typename C >
+ BOOST_RANGE_DEDUCED_TYPENAME range_size<C>::type
+ size( const C& c )
+ {
+ return range_detail::range_size_<range_detail::range<C>::type>::inner<C>::fun( c );
+ }
+
+} // namespace 'boost'
+
+
+#endif
Added: sandbox/async/boost/range/difference_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/difference_type.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,29 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_DIFFERENCE_TYPE_HPP
+#define BOOST_RANGE_DIFFERENCE_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+ template< class T >
+ struct range_difference : iterator_difference< typename range_iterator<T>::type >
+ { };
+}
+
+#endif
Added: sandbox/async/boost/range/distance.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/distance.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,34 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_DISTANCE_HPP
+#define BOOST_RANGE_DISTANCE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/difference_type.hpp>
+
+namespace boost
+{
+
+ template< class T >
+ inline BOOST_DEDUCED_TYPENAME range_difference<T>::type
+ distance( const T& r )
+ {
+ return std::distance( boost::begin( r ), boost::end( r ) );
+ }
+
+} // namespace 'boost'
+
+#endif
Added: sandbox/async/boost/range/empty.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/empty.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,34 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_EMPTY_HPP
+#define BOOST_RANGE_EMPTY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost
+{
+
+ template< class T >
+ inline bool empty( const T& r )
+ {
+ return boost::begin( r ) == boost::end( r );
+ }
+
+} // namepace 'boost'
+
+
+#endif
Added: sandbox/async/boost/range/end.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/end.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,131 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_END_HPP
+#define BOOST_RANGE_END_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#include <boost/range/detail/end.hpp>
+#else
+
+#include <boost/range/detail/implementation_help.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+
+namespace boost
+{
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+ !BOOST_WORKAROUND(__GNUC__, < 3) \
+ /**/
+namespace range_detail
+{
+#endif
+
+ //////////////////////////////////////////////////////////////////////
+ // primary template
+ //////////////////////////////////////////////////////////////////////
+ template< typename C >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
+ range_end( C& c )
+ {
+ //
+ // If you get a compile-error here, it is most likely because
+ // you have not implemented range_begin() properly in
+ // the namespace of C
+ //
+ return c.end();
+ }
+
+ //////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////
+
+ template< typename Iterator >
+ inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
+ {
+ return p.second;
+ }
+
+ template< typename Iterator >
+ inline Iterator range_end( std::pair<Iterator,Iterator>& p )
+ {
+ return p.second;
+ }
+
+ //////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////
+
+ template< typename T, std::size_t sz >
+ inline const T* range_end( const T (&a)[sz] )
+ {
+ return range_detail::array_end<T,sz>( a );
+ }
+
+ template< typename T, std::size_t sz >
+ inline T* range_end( T (&a)[sz] )
+ {
+ return range_detail::array_end<T,sz>( a );
+ }
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+ !BOOST_WORKAROUND(__GNUC__, < 3) \
+ /**/
+} // namespace 'range_detail'
+#endif
+
+template< class T >
+inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
+{
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+ !BOOST_WORKAROUND(__GNUC__, < 3) \
+ /**/
+ using namespace range_detail;
+#endif
+ return range_end( r );
+}
+
+template< class T >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
+{
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+ !BOOST_WORKAROUND(__GNUC__, < 3) \
+ /**/
+ using namespace range_detail;
+#endif
+ return range_end( r );
+}
+
+} // namespace 'boost'
+
+
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+
+namespace boost
+{
+ template< class T >
+ inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
+ const_end( const T& r )
+ {
+ return boost::end( r );
+ }
+}
+
+#endif
+
Added: sandbox/async/boost/range/functions.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/functions.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,27 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_FUNCTIONS_HPP
+#define BOOST_RANGE_FUNCTIONS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/size.hpp>
+#include <boost/range/distance.hpp>
+#include <boost/range/empty.hpp>
+#include <boost/range/rbegin.hpp>
+#include <boost/range/rend.hpp>
+
+#endif
+
Added: sandbox/async/boost/range/istream_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/istream_range.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,34 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2008. Use, modification and
+// distribution is subject to the Boost Software Licence, 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/range
+//
+
+#ifndef BOOST_RANGE_ISTREAM_RANGE_HPP_INCLUDED
+#define BOOST_RANGE_ISTREAM_RANGE_HPP_INCLUDED
+
+/*!
+ * \file istream_range.hpp
+ */
+
+#include <iterator>
+#include <boost/config.hpp>
+#include <boost/range/range.hpp>
+
+namespace boost
+{
+ template<class Type, class Elem, class Traits> inline
+ range<std::istream_iterator<Type, Elem, Traits> >
+ istream_range(std::basic_istream<Elem, Traits>& in)
+ {
+ return range<std::istream_iterator<Type, Elem, Traits> >(
+ std::istream_iterator<Type>(in),
+ std::istream_iterator<Type>());
+ }
+} // namespace boost
+
+#endif // include guard
Added: sandbox/async/boost/range/iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,72 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_ITERATOR_HPP
+#define BOOST_RANGE_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/mutable_iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+namespace boost
+{
+
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+
+ namespace range_detail_vc7_1
+ {
+ template< typename C, typename Sig = void(C) >
+ struct range_iterator
+ {
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ mpl::eval_if_c< is_const<C>::value,
+ range_const_iterator< typename remove_const<C>::type >,
+ range_mutable_iterator<C> >::type type;
+ };
+
+ template< typename C, typename T >
+ struct range_iterator< C, void(T[]) >
+ {
+ typedef T* type;
+ };
+ }
+
+#endif
+
+ template< typename C >
+ struct range_iterator
+ {
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ range_detail_vc7_1::range_iterator<C>::type type;
+
+#else
+
+ typedef BOOST_RANGE_DEDUCED_TYPENAME
+ mpl::eval_if_c< is_const<C>::value,
+ range_const_iterator< typename remove_const<C>::type >,
+ range_mutable_iterator<C> >::type type;
+
+#endif
+ };
+
+} // namespace boost
+
+//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#endif
Added: sandbox/async/boost/range/iterator_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/iterator_range.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,16 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009.
+// 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/range/
+//
+#ifndef BOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
+#define BOOST_RANGE_ITERATOR_RANGE_HPP_INCLUDED
+
+#include "boost/range/iterator_range_core.hpp"
+#include "boost/range/iterator_range_io.hpp"
+
+#endif // include guard
Added: sandbox/async/boost/range/iterator_range_core.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/iterator_range_core.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,618 @@
+// Boost.Range library
+//
+// Copyright Neil Groves & Thorsten Ottosen & Pavol Droba 2003-2004.
+// 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/range/
+//
+#ifndef BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
+#define BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
+
+#include <boost/config.hpp> // Define __STL_CONFIG_H, if appropriate.
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning( push )
+ #pragma warning( disable : 4996 )
+#endif
+
+#include <boost/assert.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/range/functions.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/algorithm/equal.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <iterator>
+#include <algorithm>
+#include <cstddef>
+
+/*! \file
+ Defines the \c iterator_class and related functions.
+ \c iterator_range is a simple wrapper of iterator pair idiom. It provides
+ a rich subset of Container interface.
+*/
+
+
+namespace boost
+{
+ namespace iterator_range_detail
+ {
+ //
+ // The functions adl_begin and adl_end are implemented in a separate
+ // class for gcc-2.9x
+ //
+ template<typename IteratorT>
+ struct iterator_range_impl {
+ template< class ForwardRange >
+ static IteratorT adl_begin( ForwardRange& r )
+ {
+ return IteratorT( boost::begin( r ) );
+ }
+
+ template< class ForwardRange >
+ static IteratorT adl_end( ForwardRange& r )
+ {
+ return IteratorT( boost::end( r ) );
+ }
+ };
+
+ template< class Left, class Right >
+ inline bool less_than( const Left& l, const Right& r )
+ {
+ return std::lexicographical_compare( boost::begin(l),
+ boost::end(l),
+ boost::begin(r),
+ boost::end(r) );
+ }
+
+ // This version is maintained since it is used in other boost libraries
+ // such as Boost.Assign
+ template< class Left, class Right >
+ inline bool equal(const Left& l, const Right& r)
+ {
+ return boost::equal(l, r);
+ }
+
+ struct range_tag { };
+ struct const_range_tag { };
+
+ }
+
+// iterator range template class -----------------------------------------//
+
+ //! iterator_range class
+ /*!
+ An \c iterator_range delimits a range in a sequence by beginning and ending iterators.
+ An iterator_range can be passed to an algorithm which requires a sequence as an input.
+ For example, the \c toupper() function may be used most frequently on strings,
+ but can also be used on iterator_ranges:
+
+ \code
+ boost::tolower( find( s, "UPPERCASE STRING" ) );
+ \endcode
+
+ Many algorithms working with sequences take a pair of iterators,
+ delimiting a working range, as an arguments. The \c iterator_range class is an
+ encapsulation of a range identified by a pair of iterators.
+ It provides a collection interface,
+ so it is possible to pass an instance to an algorithm requiring a collection as an input.
+ */
+ template<typename IteratorT>
+ class iterator_range
+ {
+ protected: // Used by sub_range
+ //! implementation class
+ typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
+ public:
+
+ //! this type
+ typedef iterator_range<IteratorT> type;
+ //BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type);
+
+ //! Encapsulated value type
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_value<IteratorT>::type value_type;
+
+ //! Difference type
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_difference<IteratorT>::type difference_type;
+
+ //! Size type
+ typedef std::size_t size_type; // note: must be unsigned
+
+ //! This type
+ typedef iterator_range<IteratorT> this_type;
+
+ //! Refence type
+ //
+ // Needed because value-type is the same for
+ // const and non-const iterators
+ //
+ typedef BOOST_DEDUCED_TYPENAME
+ iterator_reference<IteratorT>::type reference;
+
+ //! const_iterator type
+ /*!
+ There is no distinction between const_iterator and iterator.
+ These typedefs are provides to fulfill container interface
+ */
+ typedef IteratorT const_iterator;
+ //! iterator type
+ typedef IteratorT iterator;
+
+ private: // for return value of operator()()
+ typedef BOOST_DEDUCED_TYPENAME
+ boost::mpl::if_< boost::is_abstract<value_type>,
+ reference, value_type >::type abstract_value_type;
+
+ public:
+ iterator_range() : m_Begin( iterator() ), m_End( iterator() )
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ , singular( true )
+#endif
+ { }
+
+ //! Constructor from a pair of iterators
+ template< class Iterator >
+ iterator_range( Iterator Begin, Iterator End ) :
+ m_Begin(Begin), m_End(End)
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ , singular(false)
+#endif
+ {}
+
+ //! Constructor from a Range
+ template< class Range >
+ iterator_range( const Range& r ) :
+ m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ , singular(false)
+#endif
+ {}
+
+ //! Constructor from a Range
+ template< class Range >
+ iterator_range( Range& r ) :
+ m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ , singular(false)
+#endif
+ {}
+
+ //! Constructor from a Range
+ template< class Range >
+ iterator_range( const Range& r, iterator_range_detail::const_range_tag ) :
+ m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ , singular(false)
+#endif
+ {}
+
+ //! Constructor from a Range
+ template< class Range >
+ iterator_range( Range& r, iterator_range_detail::range_tag ) :
+ m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ , singular(false)
+#endif
+ {}
+
+ #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+ this_type& operator=( const this_type& r )
+ {
+ m_Begin = r.begin();
+ m_End = r.end();
+
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ singular = r.singular;
+#endif
+ return *this;
+ }
+ #endif
+
+ template< class Iterator >
+ iterator_range& operator=( const iterator_range<Iterator>& r )
+ {
+ m_Begin = r.begin();
+ m_End = r.end();
+
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ singular = r.is_singular();
+#endif
+ return *this;
+ }
+
+ template< class ForwardRange >
+ iterator_range& operator=( ForwardRange& r )
+ {
+ m_Begin = impl::adl_begin( r );
+ m_End = impl::adl_end( r );
+
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ singular = false;
+#endif
+ return *this;
+ }
+
+ template< class ForwardRange >
+ iterator_range& operator=( const ForwardRange& r )
+ {
+ m_Begin = impl::adl_begin( r );
+ m_End = impl::adl_end( r );
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ singular = false;
+#endif
+ return *this;
+ }
+
+ IteratorT begin() const
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ return m_Begin;
+ }
+
+ IteratorT end() const
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ return m_End;
+ }
+
+ difference_type size() const
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ return m_End - m_Begin;
+ }
+
+ bool empty() const
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ return m_Begin == m_End;
+ }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+ operator bool() const
+ {
+ return !empty();
+ }
+#else
+ typedef iterator (iterator_range::*unspecified_bool_type) () const;
+ operator unspecified_bool_type() const
+ {
+ return empty() ? 0: &iterator_range::end;
+ }
+#endif
+
+ bool equal( const iterator_range& r ) const
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ return m_Begin == r.m_Begin && m_End == r.m_End;
+ }
+
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ bool operator==( const iterator_range& r ) const
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ return boost::equal( *this, r );
+ }
+
+ bool operator!=( const iterator_range& r ) const
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ return !operator==(r);
+ }
+
+ bool operator<( const iterator_range& r ) const
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ return iterator_range_detail::less_than( *this, r );
+ }
+
+#endif
+
+ public: // convenience
+ reference front() const
+ {
+ BOOST_ASSERT( !empty() );
+ return *m_Begin;
+ }
+
+ reference back() const
+ {
+ BOOST_ASSERT( !empty() );
+ IteratorT last( m_End );
+ return *--last;
+ }
+
+ reference operator[]( difference_type at ) const
+ {
+ BOOST_ASSERT( at >= 0 && at < size() );
+ return m_Begin[at];
+ }
+
+ //
+ // When storing transform iterators, operator[]()
+ // fails because it returns by reference. Therefore
+ // operator()() is provided for these cases.
+ //
+ abstract_value_type operator()( difference_type at ) const
+ {
+ BOOST_ASSERT( at >= 0 && at < size() );
+ return m_Begin[at];
+ }
+
+ iterator_range& advance_begin( difference_type n )
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ std::advance( m_Begin, n );
+ return *this;
+ }
+
+ iterator_range& advance_end( difference_type n )
+ {
+#ifdef BOOST_RANGE_SINGULAR_COMPATIBLE_MODE
+ BOOST_ASSERT( !is_singular() );
+#endif
+ std::advance( m_End, n );
+ return *this;
+ }
+
+ private:
+ // begin and end iterators
+ IteratorT m_Begin;
+ IteratorT m_End;
+
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ bool singular;
+#endif
+
+ public:
+ bool is_singular() const
+ {
+#if defined(BOOST_RANGE_SINGULAR_COMPATIBLE_MODE) && !defined(NDEBUG)
+ return singular;
+#else
+ return false;
+#endif
+ }
+
+
+ protected:
+ //
+ // Allow subclasses an easy way to access the
+ // base type
+ //
+ typedef iterator_range iterator_range_;
+ };
+
+// iterator range free-standing operators ---------------------------//
+
+ /////////////////////////////////////////////////////////////////////
+ // comparison operators
+ /////////////////////////////////////////////////////////////////////
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator==( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return boost::equal( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator!=( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return !boost::equal( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator<( const ForwardRange& l,
+ const iterator_range<IteratorT>& r )
+ {
+ return iterator_range_detail::less_than( l, r );
+ }
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#else
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator==( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return boost::equal( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator==( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return boost::equal( l, r );
+ }
+
+
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator!=( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return !boost::equal( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator!=( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return !boost::equal( l, r );
+ }
+
+
+ template< class Iterator1T, class Iterator2T >
+ inline bool operator<( const iterator_range<Iterator1T>& l,
+ const iterator_range<Iterator2T>& r )
+ {
+ return iterator_range_detail::less_than( l, r );
+ }
+
+ template< class IteratorT, class ForwardRange >
+ inline bool operator<( const iterator_range<IteratorT>& l,
+ const ForwardRange& r )
+ {
+ return iterator_range_detail::less_than( l, r );
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+// iterator range utilities -----------------------------------------//
+
+ //! iterator_range construct helper
+ /*!
+ Construct an \c iterator_range from a pair of iterators
+
+ \param Begin A begin iterator
+ \param End An end iterator
+ \return iterator_range object
+ */
+ template< typename IteratorT >
+ inline iterator_range< IteratorT >
+ make_iterator_range( IteratorT Begin, IteratorT End )
+ {
+ return iterator_range<IteratorT>( Begin, End );
+ }
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< typename Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ make_iterator_range( Range& r )
+ {
+ return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ ( boost::begin( r ), boost::end( r ) );
+ }
+
+#else
+ //! iterator_range construct helper
+ /*!
+ Construct an \c iterator_range from a \c Range containing the begin
+ and end iterators.
+ */
+ template< class ForwardRange >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+ make_iterator_range( ForwardRange& r )
+ {
+ return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+ ( r, iterator_range_detail::range_tag() );
+ }
+
+ template< class ForwardRange >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
+ make_iterator_range( const ForwardRange& r )
+ {
+ return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
+ ( r, iterator_range_detail::const_range_tag() );
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ namespace iterator_range_detail
+ {
+ template< class Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ make_range_impl( Range& r,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+ {
+ //
+ // Not worth the effort
+ //
+ //if( advance_begin == 0 && advance_end == 0 )
+ // return make_iterator_range( r );
+ //
+
+ BOOST_DEDUCED_TYPENAME range_iterator<Range>::type
+ new_begin = boost::begin( r ),
+ new_end = boost::end( r );
+ std::advance( new_begin, advance_begin );
+ std::advance( new_end, advance_end );
+ return make_iterator_range( new_begin, new_end );
+ }
+ }
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ template< class Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ make_iterator_range( Range& r,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+ {
+ //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+ return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
+ }
+
+#else
+
+ template< class Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+ make_iterator_range( Range& r,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+ {
+ //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+ return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
+ }
+
+ template< class Range >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
+ make_iterator_range( const Range& r,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
+ BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
+ {
+ //BOOST_ASSERT( advance_begin - advance_end <= size(r) && "creating invalid range" );
+ return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
+ }
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+ //! copy a range into a sequence
+ /*!
+ Construct a new sequence of the specified type from the elements
+ in the given range
+
+ \param Range An input range
+ \return New sequence
+ */
+ template< typename SeqT, typename Range >
+ inline SeqT copy_range( const Range& r )
+ {
+ return SeqT( boost::begin( r ), boost::end( r ) );
+ }
+
+} // namespace 'boost'
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning( pop )
+#endif
+
+#endif
+
Added: sandbox/async/boost/range/iterator_range_io.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/iterator_range_io.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,93 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009.
+// 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/range/
+//
+#ifndef BOOST_RANGE_ITERATOR_RANGE_IO_HPP_INCLUDED
+#define BOOST_RANGE_ITERATOR_RANGE_IO_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning( push )
+ #pragma warning( disable : 4996 )
+#endif
+
+// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for Cray X1 patch.
+#ifndef BOOST_OLD_IOSTREAMS
+# if defined(__STL_CONFIG_H) && \
+ !defined (__STL_USE_NEW_IOSTREAMS) && !defined(__crayx1) \
+ /**/
+# define BOOST_OLD_IOSTREAMS
+# endif
+#endif // #ifndef BOOST_OLD_IOSTREAMS
+
+#ifndef _STLP_NO_IOSTREAMS
+# ifndef BOOST_OLD_IOSTREAMS
+# include <ostream>
+# else
+# include <ostream.h>
+# endif
+#endif // _STLP_NO_IOSTREAMS
+
+#include <boost/range/iterator_range_core.hpp>
+#include <iterator>
+#include <algorithm>
+#include <cstddef>
+
+namespace boost
+{
+
+#ifndef _STLP_NO_IOSTREAMS
+# ifndef BOOST_OLD_IOSTREAMS
+
+ //! iterator_range output operator
+ /*!
+ Output the range to an ostream. Elements are outputed
+ in a sequence without separators.
+ */
+ template< typename IteratorT, typename Elem, typename Traits >
+ inline std::basic_ostream<Elem,Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& Os,
+ const iterator_range<IteratorT>& r )
+ {
+ std::copy( r.begin(), r.end(),
+ std::ostream_iterator< BOOST_DEDUCED_TYPENAME
+ iterator_value<IteratorT>::type,
+ Elem, Traits>(Os) );
+ return Os;
+ }
+
+# else
+
+ //! iterator_range output operator
+ /*!
+ Output the range to an ostream. Elements are outputed
+ in a sequence without separators.
+ */
+ template< typename IteratorT >
+ inline std::ostream& operator<<(
+ std::ostream& Os,
+ const iterator_range<IteratorT>& r )
+ {
+ std::copy( r.begin(), r.end(), std::ostream_iterator<char>(Os));
+ return Os;
+ }
+
+# endif
+#endif // _STLP_NO_IOSTREAMS
+
+} // namespace boost
+
+#undef BOOST_OLD_IOSTREAMS
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning(pop)
+#endif
+
+#endif // include guard
Added: sandbox/async/boost/range/metafunctions.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/metafunctions.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,30 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_METAFUNCTIONS_HPP
+#define BOOST_RANGE_METAFUNCTIONS_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/iterator.hpp>
+#include <boost/range/result_iterator.hpp>
+#include <boost/range/reverse_iterator.hpp>
+#include <boost/range/const_reverse_iterator.hpp>
+#include <boost/range/reverse_result_iterator.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/category.hpp>
+#include <boost/range/reference.hpp>
+#include <boost/range/pointer.hpp>
+
+#endif
Added: sandbox/async/boost/range/mfc.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/mfc.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,984 @@
+#ifndef BOOST_RANGE_MFC_HPP
+#define BOOST_RANGE_MFC_HPP
+
+
+
+
+// Boost.Range MFC Extension
+//
+// Copyright Shunsuke Sogame 2005-2006.
+// 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)
+
+
+
+
+// config
+//
+
+
+#include <afx.h> // _MFC_VER
+
+
+#if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ #if (_MFC_VER < 0x0700) // dubious
+ #define BOOST_RANGE_MFC_NO_CPAIR
+ #endif
+#endif
+
+
+#if !defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+ #if (_MFC_VER < 0x0700) // dubious
+ #define BOOST_RANGE_MFC_HAS_LEGACY_STRING
+ #endif
+#endif
+
+
+// A const collection of old MFC doesn't return const reference.
+//
+#if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+ #if (_MFC_VER < 0x0700) // dubious
+ #define BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF
+ #endif
+#endif
+
+
+
+
+// forward declarations
+//
+
+
+template< class Type, class ArgType >
+class CArray;
+
+template< class Type, class ArgType >
+class CList;
+
+template< class Key, class ArgKey, class Mapped, class ArgMapped >
+class CMap;
+
+template< class BaseClass, class PtrType >
+class CTypedPtrArray;
+
+template< class BaseClass, class PtrType >
+class CTypedPtrList;
+
+template< class BaseClass, class KeyPtrType, class MappedPtrType >
+class CTypedPtrMap;
+
+
+
+
+// extended customizations
+//
+
+
+#include <cstddef> // ptrdiff_t
+#include <utility> // pair
+#include <boost/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/range/atl.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/detail/microsoft.hpp>
+#include <boost/range/end.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/utility/addressof.hpp>
+#include <afx.h> // legacy CString
+#include <afxcoll.h> // CXXXArray, CXXXList, CMapXXXToXXX
+#include <tchar.h>
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+ // mfc_ptr_array_iterator
+ //
+ // 'void **' is not convertible to 'void const **',
+ // so we define...
+ //
+
+ template< class ArrayT, class PtrType >
+ struct mfc_ptr_array_iterator;
+
+ template< class ArrayT, class PtrType >
+ struct mfc_ptr_array_iterator_super
+ {
+ typedef iterator_adaptor<
+ mfc_ptr_array_iterator<ArrayT, PtrType>,
+ std::ptrdiff_t, // Base!
+ PtrType, // Value
+ random_access_traversal_tag,
+ use_default,
+ std::ptrdiff_t // Difference
+ > type;
+ };
+
+ template< class ArrayT, class PtrType >
+ struct mfc_ptr_array_iterator :
+ mfc_ptr_array_iterator_super<ArrayT, PtrType>::type
+ {
+ private:
+ typedef mfc_ptr_array_iterator self_t;
+ typedef typename mfc_ptr_array_iterator_super<ArrayT, PtrType>::type super_t;
+ typedef typename super_t::reference ref_t;
+
+ public:
+ explicit mfc_ptr_array_iterator()
+ { }
+
+ explicit mfc_ptr_array_iterator(ArrayT& arr, INT_PTR index) :
+ super_t(index), m_parr(boost::addressof(arr))
+ { }
+
+ template< class, class > friend struct mfc_ptr_array_iterator;
+ template< class ArrayT_, class PtrType_ >
+ mfc_ptr_array_iterator(mfc_ptr_array_iterator<ArrayT_, PtrType_> const& other) :
+ super_t(other.base()), m_parr(other.m_parr)
+ { }
+
+ private:
+ ArrayT *m_parr;
+
+ friend class iterator_core_access;
+ ref_t dereference() const
+ {
+ BOOST_ASSERT(0 <= this->base() && this->base() < m_parr->GetSize() && "out of range");
+ return *( m_parr->GetData() + this->base() );
+ }
+
+ bool equal(self_t const& other) const
+ {
+ BOOST_ASSERT(m_parr == other.m_parr && "iterators incompatible");
+ return this->base() == other.base();
+ }
+ };
+
+ struct mfc_ptr_array_functions
+ {
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ return Iterator(x, 0);
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return Iterator(x, x.GetSize());
+ }
+ };
+
+
+ // arrays
+ //
+
+ template< >
+ struct customization< ::CByteArray > :
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef BYTE val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CDWordArray > :
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef DWORD val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CObArray > :
+ mfc_ptr_array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef mfc_ptr_array_iterator<X, CObject *> mutable_iterator;
+ typedef mfc_ptr_array_iterator<X const, CObject const *> const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CPtrArray > :
+ mfc_ptr_array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef mfc_ptr_array_iterator<X, void *> mutable_iterator;
+ typedef mfc_ptr_array_iterator<X const, void const *> const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CStringArray > :
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ::CString val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CUIntArray > :
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef UINT val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CWordArray > :
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef WORD val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ // lists
+ //
+
+ template< >
+ struct customization< ::CObList > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef list_iterator<X, ::CObject *> mutable_iterator;
+ #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+ typedef list_iterator<X const, ::CObject const *> const_iterator;
+ #else
+ typedef list_iterator<X const, ::CObject const * const, ::CObject const * const> const_iterator;
+ #endif
+ };
+ };
+
+
+ template< >
+ struct customization< ::CPtrList > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef list_iterator<X, void *> mutable_iterator;
+ #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+ typedef list_iterator<X const, void const *> const_iterator;
+ #else
+ typedef list_iterator<X const, void const * const, void const * const> const_iterator;
+ #endif
+ };
+ };
+
+
+ template< >
+ struct customization< ::CStringList > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ::CString val_t;
+
+ typedef list_iterator<X, val_t> mutable_iterator;
+ #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+ typedef list_iterator<X const, val_t const> const_iterator;
+ #else
+ typedef list_iterator<X const, val_t const, val_t const> const_iterator;
+ #endif
+ };
+ };
+
+
+ // mfc_map_iterator
+ //
+
+ template< class MapT, class KeyT, class MappedT >
+ struct mfc_map_iterator;
+
+ template< class MapT, class KeyT, class MappedT >
+ struct mfc_map_iterator_super
+ {
+ typedef iterator_facade<
+ mfc_map_iterator<MapT, KeyT, MappedT>,
+ std::pair<KeyT, MappedT>,
+ forward_traversal_tag,
+ std::pair<KeyT, MappedT> const
+ > type;
+ };
+
+ template< class MapT, class KeyT, class MappedT >
+ struct mfc_map_iterator :
+ mfc_map_iterator_super<MapT, KeyT, MappedT>::type
+ {
+ private:
+ typedef mfc_map_iterator self_t;
+ typedef typename mfc_map_iterator_super<MapT, KeyT, MappedT>::type super_t;
+ typedef typename super_t::reference ref_t;
+
+ public:
+ explicit mfc_map_iterator()
+ { }
+
+ explicit mfc_map_iterator(MapT const& map, POSITION pos) :
+ m_pmap(boost::addressof(map)), m_posNext(pos)
+ {
+ increment();
+ }
+
+ explicit mfc_map_iterator(MapT const& map) :
+ m_pmap(&map), m_pos(0) // end iterator
+ { }
+
+ template< class, class, class > friend struct mfc_map_iterator;
+ template< class MapT_, class KeyT_, class MappedT_>
+ mfc_map_iterator(mfc_map_iterator<MapT_, KeyT_, MappedT_> const& other) :
+ m_pmap(other.m_pmap),
+ m_pos(other.m_pos), m_posNext(other.m_posNext),
+ m_key(other.m_key), m_mapped(other.m_mapped)
+ { }
+
+ private:
+ MapT const *m_pmap;
+ POSITION m_pos, m_posNext;
+ KeyT m_key; MappedT m_mapped;
+
+ friend class iterator_core_access;
+ ref_t dereference() const
+ {
+ BOOST_ASSERT(m_pos != 0 && "out of range");
+ return std::make_pair(m_key, m_mapped);
+ }
+
+ void increment()
+ {
+ BOOST_ASSERT(m_pos != 0 && "out of range");
+
+ if (m_posNext == 0) {
+ m_pos = 0;
+ return;
+ }
+
+ m_pos = m_posNext;
+ m_pmap->GetNextAssoc(m_posNext, m_key, m_mapped);
+ }
+
+ bool equal(self_t const& other) const
+ {
+ BOOST_ASSERT(m_pmap == other.m_pmap && "iterators incompatible");
+ return m_pos == other.m_pos;
+ }
+ };
+
+ struct mfc_map_functions
+ {
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ return Iterator(x, x.GetStartPosition());
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return Iterator(x);
+ }
+ };
+
+
+#if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+
+
+ // mfc_cpair_map_iterator
+ //
+ // used by ::CMap and ::CMapStringToString
+ //
+
+ template< class MapT, class PairT >
+ struct mfc_cpair_map_iterator;
+
+ template< class MapT, class PairT >
+ struct mfc_pget_map_iterator_super
+ {
+ typedef iterator_facade<
+ mfc_cpair_map_iterator<MapT, PairT>,
+ PairT,
+ forward_traversal_tag
+ > type;
+ };
+
+ template< class MapT, class PairT >
+ struct mfc_cpair_map_iterator :
+ mfc_pget_map_iterator_super<MapT, PairT>::type
+ {
+ private:
+ typedef mfc_cpair_map_iterator self_t;
+ typedef typename mfc_pget_map_iterator_super<MapT, PairT>::type super_t;
+ typedef typename super_t::reference ref_t;
+
+ public:
+ explicit mfc_cpair_map_iterator()
+ { }
+
+ explicit mfc_cpair_map_iterator(MapT& map, PairT *pp) :
+ m_pmap(boost::addressof(map)), m_pp(pp)
+ { }
+
+ template< class, class > friend struct mfc_cpair_map_iterator;
+ template< class MapT_, class PairT_>
+ mfc_cpair_map_iterator(mfc_cpair_map_iterator<MapT_, PairT_> const& other) :
+ m_pmap(other.m_pmap), m_pp(other.m_pp)
+ { }
+
+ private:
+ MapT *m_pmap;
+ PairT *m_pp;
+
+ friend class iterator_core_access;
+ ref_t dereference() const
+ {
+ BOOST_ASSERT(m_pp != 0 && "out of range");
+ return *m_pp;
+ }
+
+ void increment()
+ {
+ BOOST_ASSERT(m_pp != 0 && "out of range");
+ m_pp = m_pmap->PGetNextAssoc(m_pp);
+ }
+
+ bool equal(self_t const& other) const
+ {
+ BOOST_ASSERT(m_pmap == other.m_pmap && "iterators incompatible");
+ return m_pp == other.m_pp;
+ }
+ };
+
+ struct mfc_cpair_map_functions
+ {
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ // Workaround:
+ // Assertion fails if empty.
+ // MFC document is wrong.
+ #if !defined(NDEBUG)
+ if (x.GetCount() == 0)
+ return Iterator(x, 0);
+ #endif
+
+ return Iterator(x, x.PGetFirstAssoc());
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return Iterator(x, 0);
+ }
+ };
+
+
+#endif // !defined(BOOST_RANGE_MFC_NO_CPAIR)
+
+
+ // maps
+ //
+
+ template< >
+ struct customization< ::CMapPtrToWord > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef void *key_t;
+ typedef WORD mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapPtrToPtr > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef void *key_t;
+ typedef void *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapStringToOb > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ::CString key_t;
+ typedef ::CObject *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapStringToPtr > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef ::CString key_t;
+ typedef void *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapStringToString > :
+ #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ mfc_cpair_map_functions
+ #else
+ mfc_map_functions
+ #endif
+ {
+ template< class X >
+ struct meta
+ {
+ #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ typedef typename X::CPair pair_t;
+
+ typedef mfc_cpair_map_iterator<X, pair_t> mutable_iterator;
+ typedef mfc_cpair_map_iterator<X const, pair_t const> const_iterator;
+ #else
+ typedef ::CString key_t;
+ typedef ::CString mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ #endif
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapWordToOb > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef WORD key_t;
+ typedef ::CObject *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ template< >
+ struct customization< ::CMapWordToPtr > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef WORD key_t;
+ typedef void *mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ // templates
+ //
+
+ template< class Type, class ArgType >
+ struct customization< ::CArray<Type, ArgType> > :
+ array_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef Type val_t;
+
+ typedef val_t *mutable_iterator;
+ typedef val_t const *const_iterator;
+ };
+ };
+
+
+ template< class Type, class ArgType >
+ struct customization< ::CList<Type, ArgType> > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef Type val_t;
+
+ typedef list_iterator<X, val_t> mutable_iterator;
+ #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+ typedef list_iterator<X const, val_t const> const_iterator;
+ #else
+ typedef list_iterator<X const, val_t const, val_t const> const_iterator;
+ #endif
+ };
+ };
+
+
+ template< class Key, class ArgKey, class Mapped, class ArgMapped >
+ struct customization< ::CMap<Key, ArgKey, Mapped, ArgMapped> > :
+ #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ mfc_cpair_map_functions
+ #else
+ mfc_map_functions
+ #endif
+ {
+ template< class X >
+ struct meta
+ {
+ #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+ typedef typename X::CPair pair_t;
+
+ typedef mfc_cpair_map_iterator<X, pair_t> mutable_iterator;
+ typedef mfc_cpair_map_iterator<X const, pair_t const> const_iterator;
+ #else
+ typedef Key key_t;
+ typedef Mapped mapped_t;
+
+ typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ #endif
+ };
+ };
+
+
+ template< class BaseClass, class PtrType >
+ struct customization< ::CTypedPtrArray<BaseClass, PtrType> >
+ {
+ template< class X >
+ struct fun
+ {
+ typedef typename remove_pointer<PtrType>::type val_t;
+
+ typedef typename mpl::if_< is_const<X>,
+ val_t const,
+ val_t
+ >::type val_t_;
+
+ typedef val_t_ * const result_type;
+
+ template< class PtrType_ >
+ result_type operator()(PtrType_ p) const
+ {
+ return static_cast<result_type>(p);
+ }
+ };
+
+ template< class X >
+ struct meta
+ {
+ typedef typename compatible_mutable_iterator<BaseClass>::type miter_t;
+ typedef typename range_const_iterator<BaseClass>::type citer_t;
+
+ typedef transform_iterator<fun<X>, miter_t> mutable_iterator;
+ typedef transform_iterator<fun<X const>, citer_t> const_iterator;
+ };
+
+ template< class Iterator, class X >
+ Iterator begin(X& x)
+ {
+ return Iterator(boost::begin<BaseClass>(x), fun<X>());
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return Iterator(boost::end<BaseClass>(x), fun<X>());
+ }
+ };
+
+
+ template< class BaseClass, class PtrType >
+ struct customization< ::CTypedPtrList<BaseClass, PtrType> > :
+ list_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef typename remove_pointer<PtrType>::type val_t;
+
+ // not l-value
+ typedef list_iterator<X, val_t * const, val_t * const> mutable_iterator;
+ typedef list_iterator<X const, val_t const * const, val_t const * const> const_iterator;
+ };
+ };
+
+
+ template< class BaseClass, class KeyPtrType, class MappedPtrType >
+ struct customization< ::CTypedPtrMap<BaseClass, KeyPtrType, MappedPtrType> > :
+ mfc_map_functions
+ {
+ template< class X >
+ struct meta
+ {
+ typedef mfc_map_iterator<X, KeyPtrType, MappedPtrType> mutable_iterator;
+ typedef mutable_iterator const_iterator;
+ };
+ };
+
+
+ // strings
+ //
+
+#if defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+ template< >
+ struct customization< ::CString >
+ {
+ template< class X >
+ struct meta
+ {
+ // LPTSTR/LPCTSTR is not always defined in <tchar.h>.
+ typedef TCHAR *mutable_iterator;
+ typedef TCHAR const *const_iterator;
+ };
+
+ template< class Iterator, class X >
+ typename mutable_<Iterator, X>::type begin(X& x)
+ {
+ return x.GetBuffer(0);
+ }
+
+ template< class Iterator, class X >
+ Iterator begin(X const& x)
+ {
+ return x;
+ }
+
+ template< class Iterator, class X >
+ Iterator end(X& x)
+ {
+ return begin<Iterator>(x) + x.GetLength();
+ }
+ };
+
+#endif // defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+
+
+// range customizations
+//
+
+
+// arrays
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CByteArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CDWordArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CStringArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CUIntArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CWordArray
+)
+
+
+// lists
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CObList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CPtrList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CStringList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CObArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CPtrArray
+)
+
+
+// maps
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapPtrToWord
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapPtrToPtr
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapStringToOb
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapStringToPtr
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapStringToString
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapWordToOb
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMapWordToPtr
+)
+
+
+// templates
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CArray, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CList, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CMap, 4
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CTypedPtrArray, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CTypedPtrList, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CTypedPtrMap, 3
+)
+
+
+// strings
+//
+#if defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+ BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+ boost::range_detail_microsoft::using_type_as_tag,
+ BOOST_PP_NIL, CString
+ )
+
+#endif
+
+
+
+
+#endif
Added: sandbox/async/boost/range/mutable_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/mutable_iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,67 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP
+#define BOOST_RANGE_MUTABLE_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/range/detail/iterator.hpp>
+#else
+
+#include <boost/range/detail/extract_optional_type.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <cstddef>
+#include <utility>
+
+namespace boost
+{
+ //////////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////////
+
+ namespace range_detail {
+ BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator )
+ }
+
+ template< typename C >
+ struct range_mutable_iterator : range_detail::extract_iterator<C>
+ {};
+
+ //////////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////////
+
+ template< typename Iterator >
+ struct range_mutable_iterator< std::pair<Iterator,Iterator> >
+ {
+ typedef Iterator type;
+ };
+
+ //////////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////////
+
+ template< typename T, std::size_t sz >
+ struct range_mutable_iterator< T[sz] >
+ {
+ typedef T* type;
+ };
+
+} // namespace boost
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#endif
Added: sandbox/async/boost/range/numeric.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/numeric.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,93 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file algorithm.hpp
+/// Contains range-based versions of the std algorithms
+//
+/////////////////////////////////////////////////////////////////////////////
+
+// Copyright 2006 Thorsten Ottosen.
+// 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)
+//
+// Copyright 2004 Eric Niebler.
+// 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)
+
+#if defined(_MSC_VER) && _MSC_VER >= 1000
+ #pragma once
+#endif
+
+#ifndef BOOST_RANGE_NUMERIC_HPP
+#define BOOST_RANGE_NUMERIC_HPP
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <numeric>
+
+
+namespace boost
+{
+ template< class InputRng, class T >
+ inline T accumulate( const InputRng& r, T init )
+ {
+ return std::accumulate( boost::begin(r), boost::end(r), init );
+ }
+
+ template< class InputRng, class T, class BinaryOperation >
+ inline T accumulate( const InputRng& r, T init, BinaryOperation bin )
+ {
+ return std::accumulate( boost::begin(r), boost::end(r), init, bin );
+ }
+
+
+ template< class InputRng, class InputIterator, class T >
+ inline T inner_product ( const InputRng& r, InputIterator first, T init )
+ {
+ return std::inner_product( boost::begin(r), boost::end(r),
+ first, init );
+ }
+
+ template< class InputRng, class InputIterator, class T,
+ class BinaryOperation1, class BinaryOperation2 >
+ inline T inner_product ( const InputRng& r, InputIterator first, T init,
+ BinaryOperation1 bin1, BinaryOperation2 bin2 )
+ {
+ return std::inner_product( boost::begin(r), boost::end(r),
+ first, init, bin1, bin2 );
+ }
+
+ template< class InputRng, class OutputIterator >
+ inline OutputIterator partial_sum ( const InputRng& r,
+ OutputIterator result )
+ {
+ return std::partial_sum( boost::begin(r), boost::end(r), result );
+ }
+
+ template< class InputRng, class OutputIterator, class BinaryOperation >
+ inline OutputIterator partial_sum ( const InputRng& r, OutputIterator result,
+ BinaryOperation bin )
+ {
+ return std::partial_sum( boost::begin(r), boost::end(r), result, bin );
+ }
+
+ template< class InputRng, class OutputIterator >
+ inline OutputIterator adjacent_difference ( const InputRng& r,
+ OutputIterator result )
+ {
+ return std::adjacent_difference( boost::begin(r), boost::end(r),
+ result );
+ }
+
+ template< class InputRng, class OutputIterator, class BinaryOperation >
+ inline OutputIterator adjacent_difference ( const InputRng& r,
+ OutputIterator result,
+ BinaryOperation bin )
+ {
+ return std::adjacent_difference( boost::begin(r), boost::end(r),
+ result, bin );
+ }
+
+}
+
+#endif
Added: sandbox/async/boost/range/pointer.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/pointer.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,29 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2006. 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/range/
+//
+
+#ifndef BOOST_RANGE_POINTER_TYPE_HPP
+#define BOOST_RANGE_POINTER_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+ template< class T >
+ struct range_pointer : iterator_pointer< typename range_iterator<T>::type >
+ { };
+}
+
+#endif
Added: sandbox/async/boost/range/rbegin.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/rbegin.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,65 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_RBEGIN_HPP
+#define BOOST_RANGE_RBEGIN_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/end.hpp>
+#include <boost/range/reverse_iterator.hpp>
+
+namespace boost
+{
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+template< class C >
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+rbegin( C& c )
+{
+ return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::end( c ) );
+}
+
+#else
+
+template< class C >
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+rbegin( C& c )
+{
+ typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+ iter_type;
+ return iter_type( boost::end( c ) );
+}
+
+template< class C >
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+rbegin( const C& c )
+{
+ typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+ iter_type;
+ return iter_type( boost::end( c ) );
+}
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+template< class T >
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
+const_rbegin( const T& r )
+{
+ return boost::rbegin( r );
+}
+
+} // namespace 'boost'
+
+#endif
+
Added: sandbox/async/boost/range/reference.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/reference.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,29 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_REFERENCE_TYPE_HPP
+#define BOOST_RANGE_REFERENCE_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+ template< class T >
+ struct range_reference : iterator_reference< typename range_iterator<T>::type >
+ { };
+}
+
+#endif
Added: sandbox/async/boost/range/rend.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/rend.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,65 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_REND_HPP
+#define BOOST_RANGE_REND_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/begin.hpp>
+#include <boost/range/reverse_iterator.hpp>
+
+namespace boost
+{
+
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+template< class C >
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+rend( C& c )
+{
+ return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::begin( c ) );
+}
+
+#else
+
+template< class C >
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+rend( C& c )
+{
+ typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+ iter_type;
+ return iter_type( boost::begin( c ) );
+}
+
+template< class C >
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+rend( const C& c )
+{
+ typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+ iter_type;
+ return iter_type( boost::begin( c ) );
+}
+
+#endif
+
+template< class T >
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
+const_rend( const T& r )
+{
+ return boost::rend( r );
+}
+
+} // namespace 'boost'
+
+#endif
+
Added: sandbox/async/boost/range/result_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/result_iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,33 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_RESULT_ITERATOR_HPP
+#define BOOST_RANGE_RESULT_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/range/iterator.hpp>
+
+namespace boost
+{
+ //
+ // This interface is deprecated, use range_iterator<T>
+ //
+
+ template< typename C >
+ struct range_result_iterator : range_iterator<C>
+ { };
+
+} // namespace boost
+
+
+#endif
Added: sandbox/async/boost/range/reverse_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/reverse_iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,40 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_REVERSE_ITERATOR_HPP
+#define BOOST_RANGE_REVERSE_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+
+
+namespace boost
+{
+ //////////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////////
+
+ template< typename C >
+ struct range_reverse_iterator
+ {
+ typedef reverse_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<C>::type > type;
+ };
+
+
+} // namespace boost
+
+
+#endif
Added: sandbox/async/boost/range/reverse_result_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/reverse_result_iterator.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,32 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_REVERSE_RESULT_ITERATOR_HPP
+#define BOOST_RANGE_REVERSE_RESULT_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/range/reverse_iterator.hpp>
+
+namespace boost
+{
+ //
+ // This interface is deprecated, use range_reverse_iterator<T>
+ //
+
+ template< typename C >
+ struct range_reverse_result_iterator : range_reverse_iterator<C>
+ { };
+
+} // namespace boost
+
+#endif
Added: sandbox/async/boost/range/size.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/size.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,36 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_SIZE_HPP
+#define BOOST_RANGE_SIZE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/assert.hpp>
+
+namespace boost
+{
+
+ template< class T >
+ inline BOOST_DEDUCED_TYPENAME range_difference<T>::type size( const T& r )
+ {
+ BOOST_ASSERT( (boost::end( r ) - boost::begin( r )) >= 0 &&
+ "reachability invariant broken!" );
+ return boost::end( r ) - boost::begin( r );
+ }
+
+} // namespace 'boost'
+
+#endif
Added: sandbox/async/boost/range/size_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/size_type.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,78 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_SIZE_TYPE_HPP
+#define BOOST_RANGE_SIZE_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/range/detail/size_type.hpp>
+#else
+
+#include <boost/type_traits/remove_const.hpp>
+#include <cstddef>
+#include <utility>
+
+namespace boost
+{
+ namespace detail
+ {
+
+ //////////////////////////////////////////////////////////////////////////
+ // default
+ //////////////////////////////////////////////////////////////////////////
+
+ template< typename C >
+ struct range_size
+ {
+ typedef BOOST_DEDUCED_TYPENAME C::size_type type;
+ };
+
+ //////////////////////////////////////////////////////////////////////////
+ // pair
+ //////////////////////////////////////////////////////////////////////////
+
+ template< typename Iterator >
+ struct range_size< std::pair<Iterator,Iterator> >
+ {
+ typedef std::size_t type;
+ };
+
+ //////////////////////////////////////////////////////////////////////////
+ // array
+ //////////////////////////////////////////////////////////////////////////
+
+ template< typename T, std::size_t sz >
+ struct range_size< T[sz] >
+ {
+ typedef std::size_t type;
+ };
+ }
+
+ template< class T >
+ struct range_size :
+ detail::range_size<T>
+ { };
+
+ template< class T >
+ struct range_size<const T > : range_size<T>
+ { };
+
+} // namespace boost
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+
+#endif
Added: sandbox/async/boost/range/sub_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/sub_range.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,181 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2009.
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_SUB_RANGE_HPP
+#define BOOST_RANGE_SUB_RANGE_HPP
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning( push )
+ #pragma warning( disable : 4996 )
+#endif
+
+#include <boost/detail/workaround.hpp>
+#include <boost/range/config.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/algorithm/equal.hpp>
+#include <boost/assert.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost
+{
+
+ template< class ForwardRange >
+ class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+ {
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;
+ typedef iterator_range< iterator_t > base;
+
+ typedef BOOST_DEDUCED_TYPENAME base::impl impl;
+ public:
+ typedef BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type value_type;
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator;
+ typedef BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type const_iterator;
+ typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type difference_type;
+ typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type size_type;
+ typedef BOOST_DEDUCED_TYPENAME base::reference reference;
+
+ public: // for return value of front/back
+ typedef BOOST_DEDUCED_TYPENAME
+ boost::mpl::if_< boost::is_reference<reference>,
+ const BOOST_DEDUCED_TYPENAME boost::remove_reference<reference>::type&,
+ reference >::type const_reference;
+
+ public:
+ sub_range() : base()
+ { }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
+ sub_range( const sub_range& r )
+ : base( static_cast<const base&>( r ) )
+ { }
+#endif
+
+ template< class ForwardRange2 >
+ sub_range( ForwardRange2& r ) :
+
+#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
+ base( impl::adl_begin( r ), impl::adl_end( r ) )
+#else
+ base( r )
+#endif
+ { }
+
+ template< class ForwardRange2 >
+ sub_range( const ForwardRange2& r ) :
+
+#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
+ base( impl::adl_begin( r ), impl::adl_end( r ) )
+#else
+ base( r )
+#endif
+ { }
+
+ template< class Iter >
+ sub_range( Iter first, Iter last ) :
+ base( first, last )
+ { }
+
+ template< class ForwardRange2 >
+ sub_range& operator=( ForwardRange2& r )
+ {
+ base::operator=( r );
+ return *this;
+ }
+
+ template< class ForwardRange2 >
+ sub_range& operator=( const ForwardRange2& r )
+ {
+ base::operator=( r );
+ return *this;
+ }
+
+ sub_range& operator=( const sub_range& r )
+ {
+ base::operator=( static_cast<const base&>(r) );
+ return *this;
+ }
+
+ public:
+
+ iterator begin() { return base::begin(); }
+ const_iterator begin() const { return base::begin(); }
+ iterator end() { return base::end(); }
+ const_iterator end() const { return base::end(); }
+ difference_type size() const { return base::size(); }
+
+
+ public: // convenience
+ reference front()
+ {
+ return base::front();
+ }
+
+ const_reference front() const
+ {
+ return base::front();
+ }
+
+ reference back()
+ {
+ return base::back();
+ }
+
+ const_reference back() const
+ {
+ return base::back();
+ }
+
+ reference operator[]( difference_type sz )
+ {
+ return base::operator[](sz);
+ }
+
+ const_reference operator[]( difference_type sz ) const
+ {
+ return base::operator[](sz);
+ }
+
+ };
+
+ template< class ForwardRange, class ForwardRange2 >
+ inline bool operator==( const sub_range<ForwardRange>& l,
+ const sub_range<ForwardRange2>& r )
+ {
+ return boost::equal( l, r );
+ }
+
+ template< class ForwardRange, class ForwardRange2 >
+ inline bool operator!=( const sub_range<ForwardRange>& l,
+ const sub_range<ForwardRange2>& r )
+ {
+ return !boost::equal( l, r );
+ }
+
+ template< class ForwardRange, class ForwardRange2 >
+ inline bool operator<( const sub_range<ForwardRange>& l,
+ const sub_range<ForwardRange2>& r )
+ {
+ return iterator_range_detail::less_than( l, r );
+ }
+
+
+} // namespace 'boost'
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ #pragma warning( pop )
+#endif
+
+#endif
+
Added: sandbox/async/boost/range/unbounded_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/unbounded_range.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,73 @@
+#ifndef BOOST_RANGE_UNBOUNDED_RANGE_HPP
+#define BOOST_RANGE_UNBOUNDED_RANGE_HPP
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+ template< class Iter >
+ struct unbounded_iterator_range : iterator_range<Iter>
+ {
+ explicit unbounded_iterator_range( Iter r )
+ : iterator_range<Iter>( r, r )
+ {
+ //
+ // Remark: by storing the same iterator
+ // twice, we can still allow
+ // comparison to execute without leading to
+ // operations on singular iterators
+ //
+ }
+
+ private:
+
+ bool empty() const
+ {
+ return false;
+ }
+ //
+ // Hide members that are illegal to use.
+ //
+ /*
+ void end() const;
+ void size() const;
+ void empty() const;
+ void equal() const;
+ operator bool() const;
+ bool operator==( unbounded_iterator_range );
+ bool operator!=( unbounded_iterator_range );
+ template< class S >
+ void operator[]( S s ) const;
+ template< class D >
+ void advance_end( D d ) const;
+ void back() const;
+ */
+ };
+
+ template< class Iter >
+ inline unbounded_iterator_range<Iter> unbounded_range( Iter r )
+ {
+ return unbounded_iterator_range<Iter>(r);
+ }
+
+ namespace detail
+ {
+ char is_unbounded_range( ... );
+ template< class Iter >
+ long is_unbounded_range( const unbounded_iterator_range<Iter>* );
+ }
+
+ template< class T >
+ struct is_unbounded_range
+ {
+ private:
+ static T* ptr_;
+
+ public:
+ BOOST_STATIC_CONSTANT( bool,
+ value = sizeof(long) == sizeof(detail::is_unbounded_range(ptr_) ) );
+ };
+}
+
+#endif
Added: sandbox/async/boost/range/value_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/async/boost/range/value_type.hpp 2009-10-13 03:03:40 EDT (Tue, 13 Oct 2009)
@@ -0,0 +1,34 @@
+// Boost.Range library
+//
+// Copyright Thorsten Ottosen 2003-2004. 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/range/
+//
+
+#ifndef BOOST_RANGE_VALUE_TYPE_HPP
+#define BOOST_RANGE_VALUE_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+
+//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#include <boost/range/detail/value_type.hpp>
+//#else
+
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+ template< class T >
+ struct range_value : iterator_value< typename range_iterator<T>::type >
+ { };
+}
+
+#endif
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk