|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r55149 - in sandbox/SOC/2009/unicode: boost boost/introspection boost/iterator boost/mpl boost/range boost/range/adaptor boost/range/algorithm boost/range/algorithm_ext boost/range/detail boost/range/detail/vc6 boost/unicode boost/unicode/ucd boost/unicode/ucd/detail libs/unicode/build libs/unicode/data_parser libs/unicode/doc libs/unicode/doc/concepts libs/unicode/example libs/unicode/src libs/unicode/src/ucd
From: loufoque_at_[hidden]
Date: 2009-07-24 22:24:32
Author: mgaunard
Date: 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
New Revision: 55149
URL: http://svn.boost.org/trac/boost/changeset/55149
Log:
UTF type deduction + static utf codecs + source character set docs
Added:
sandbox/SOC/2009/unicode/boost/foreach_auto.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/mpl/
sandbox/SOC/2009/unicode/boost/mpl/ustring.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/
sandbox/SOC/2009/unicode/boost/range/adaptor/
sandbox/SOC/2009/unicode/boost/range/adaptor/adjacent_filtered.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/argument_fwd.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/copied.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/filtered.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/indexed.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/indirected.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/map.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/replaced.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/replaced_if.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/reversed.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/sliced.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/strided.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/tokenized.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/transformed.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptor/uniqued.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/adaptors.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/
sandbox/SOC/2009/unicode/boost/range/algorithm.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/adjacent_find.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/binary_search.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/copy.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/copy_backward.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/count.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/count_if.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/equal.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/equal_range.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/fill.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/fill_n.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/find.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/find_end.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/find_first_of.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/find_if.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/for_each.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/generate.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/heap_algorithm.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/inplace_merge.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/lexicographical_compare.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/lower_bound.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/max_element.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/merge.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/min_element.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/mismatch.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/nth_element.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/partial_sort.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/partial_sort_copy.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/partition.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/permutation.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/random_shuffle.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/remove.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/remove_copy.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/remove_copy_if.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/remove_if.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/replace.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/replace_copy.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/replace_copy_if.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/replace_if.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/reverse.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/reverse_copy.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/rotate.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/rotate_copy.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/search.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/search_n.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/set_algorithm.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/sort.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/stable_partition.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/stable_sort.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/swap_ranges.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/transform.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/unique.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/unique_copy.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm/upper_bound.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/
sandbox/SOC/2009/unicode/boost/range/algorithm_ext.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/copy_n.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/erase.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/for_each.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/insert.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/is_sorted.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/overwrite.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/push_back.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/algorithm_ext/push_front.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/as_array.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/as_literal.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/atl.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/begin.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/category.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/chain.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/combine.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/concepts.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/config.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/const_iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/const_reverse_iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/counting_range.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/
sandbox/SOC/2009/unicode/boost/range/detail/as_literal.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/begin.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/chain_iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/collection_traits.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/collection_traits_detail.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/common.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/const_iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/demote_iterator_traversal_tag.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/detail_str.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/difference_type.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/empty.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/end.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/extract_optional_type.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/implementation_help.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/microsoft.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/misc_concept.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/range_return.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/remove_extent.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/sfinae.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/size.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/size_type.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/sizer.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/str_types.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/value_type.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/vc6/
sandbox/SOC/2009/unicode/boost/range/detail/vc6/end.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/detail/vc6/size.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/difference_type.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/distance.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/empty.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/end.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/functions.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/istream_range.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/iterator_range.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/iterator_range_core.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/iterator_range_io.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/metafunctions.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/mfc.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/mutable_iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/numeric.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/pointer.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/rbegin.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/reference.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/rend.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/result_iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/reverse_iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/reverse_result_iterator.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/size.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/size_type.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/sub_range.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/unbounded_range.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/range/value_type.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/unicode/static_utf.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/unicode/static_utf_codecs.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/unicode/string_cp.hpp (contents, props changed)
sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unicode_decl.hpp (contents, props changed)
sandbox/SOC/2009/unicode/libs/unicode/build/
sandbox/SOC/2009/unicode/libs/unicode/build/Jamfile.v2 (contents, props changed)
Removed:
sandbox/SOC/2009/unicode/boost/introspection/
Text files modified:
sandbox/SOC/2009/unicode/boost/iterator/pipe_iterator.hpp | 2
sandbox/SOC/2009/unicode/boost/unicode/graphemes.hpp | 66 +++++++--------
sandbox/SOC/2009/unicode/boost/unicode/surrogates.hpp | 7 +
sandbox/SOC/2009/unicode/boost/unicode/ucd/block_types.hpp | 2
sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unichar_data.hpp | 14 ++-
sandbox/SOC/2009/unicode/boost/unicode/ucd/properties.hpp | 5
sandbox/SOC/2009/unicode/boost/unicode/ucd/properties_types.hpp | 21 ++--
sandbox/SOC/2009/unicode/boost/unicode/utf.hpp | 108 +++++++++++++------------
sandbox/SOC/2009/unicode/boost/unicode/utf_codecs.hpp | 161 ++++++++++++++++++++++++++++++++++++++-
sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.cpp | 13 +-
sandbox/SOC/2009/unicode/libs/unicode/doc/concepts/OneManyPipe.xml | 2
sandbox/SOC/2009/unicode/libs/unicode/doc/concepts/Pipe.xml | 2
sandbox/SOC/2009/unicode/libs/unicode/doc/users_manual.qbk | 122 ++++++++++++++++++++++++++++--
sandbox/SOC/2009/unicode/libs/unicode/example/Jamfile.v2 | 10 +
sandbox/SOC/2009/unicode/libs/unicode/example/test.cpp | 128 ++++++++++++-------------------
sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data.cpp | 7
sandbox/SOC/2009/unicode/libs/unicode/src/unicode_blocks.cpp | 5
sandbox/SOC/2009/unicode/libs/unicode/src/unicode_graphemes.cpp | 3
sandbox/SOC/2009/unicode/libs/unicode/src/unicode_properties.cpp | 21 ++--
19 files changed, 472 insertions(+), 227 deletions(-)
Added: sandbox/SOC/2009/unicode/boost/foreach_auto.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/foreach_auto.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,21 @@
+#ifndef BOOST_FOREACH_AUTO
+
+#include <boost/typeof/typeof.hpp>
+#include <boost/preprocessor/cat.hpp>
+
+#define BOOST_FOREACH_AUTO(name, range) \
+if(boost::begin(range) != boost::end(range)) \
+if(bool BOOST_PP_CAT(_once_, __LINE__) = 1) \
+for( \
+ BOOST_AUTO(name, *boost::begin(range)); \
+ BOOST_PP_CAT(_once_, __LINE__); \
+ BOOST_PP_CAT(_once_, __LINE__) = 0 \
+) \
+for( \
+ BOOST_AUTO(BOOST_PP_CAT(_it_, __LINE__), boost::begin(range)); \
+ BOOST_PP_CAT(_it_, __LINE__) != boost::end(range) \
+ && (name = *BOOST_PP_CAT(_it_, __LINE__), 1); \
+ ++BOOST_PP_CAT(_it_, __LINE__) \
+) \
+
+#endif
Modified: sandbox/SOC/2009/unicode/boost/iterator/pipe_iterator.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/iterator/pipe_iterator.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/iterator/pipe_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -2,14 +2,12 @@
#define BOOST_PIPE_ITERATOR_HPP
#include <boost/iterator/iterator_facade.hpp>
-#include <iterator>
#include <vector>
#include <utility>
#include <boost/range.hpp>
#include <boost/assert.hpp>
-#include <boost/introspection/has_member_data.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/has_xxx.hpp>
Added: sandbox/SOC/2009/unicode/boost/mpl/ustring.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/mpl/ustring.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,34 @@
+#ifndef BOOST_MPL_USTRING_HPP
+#define BOOST_MPL_USTRING_HPP
+
+#include <boost/mpl/vector_c.hpp>
+
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+
+#include <boost/cuchar.hpp>
+
+namespace boost
+{
+namespace mpl
+{
+
+#define BOOST_MPL_USTRING_MAX_PARAMS BOOST_PP_SUB(BOOST_MPL_LIMIT_VECTOR_SIZE, 1)
+
+template<BOOST_PP_ENUM_BINARY_PARAMS(BOOST_MPL_USTRING_MAX_PARAMS, char16 cp, = 0 BOOST_PP_INTERCEPT)>
+struct u16string
+ : vector_c<char16, BOOST_PP_ENUM_PARAMS(BOOST_MPL_USTRING_MAX_PARAMS, cp)>
+{
+};
+
+template<BOOST_PP_ENUM_BINARY_PARAMS(BOOST_MPL_USTRING_MAX_PARAMS, char32 cp, = 0 BOOST_PP_INTERCEPT)>
+struct u32string
+ : vector_c<char32, BOOST_PP_ENUM_PARAMS(BOOST_MPL_USTRING_MAX_PARAMS, cp)>
+{
+};
+
+} // namespace mpl
+} // namespace boost
+
+#endif
Added: sandbox/SOC/2009/unicode/boost/range/adaptor/adjacent_filtered.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/adjacent_filtered.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/argument_fwd.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/argument_fwd.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/copied.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/copied.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/filtered.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/filtered.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/indexed.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/indexed.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/indirected.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/indirected.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/map.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/map.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/replaced.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/replaced.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/replaced_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/replaced_if.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/reversed.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/reversed.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/sliced.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/sliced.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/strided.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/strided.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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 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& rng)
+ : super_t(make_strided_iterator(boost::begin(rng), stride),
+ make_strided_iterator(boost::end(rng), 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 strided_range<Rng>
+ make_strided_range(Rng& rng, Difference step)
+ {
+ return rng | adaptors::strided(step);
+ }
+
+ template<class Rng, class Difference>
+ inline strided_range<const Rng>
+ make_strided_range(const Rng& rng, Difference step)
+ {
+ return rng | adaptors::strided(step);
+ }
+} // namespace boost
+
+#endif
Added: sandbox/SOC/2009/unicode/boost/range/adaptor/tokenized.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/tokenized.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/transformed.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/transformed.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptor/uniqued.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptor/uniqued.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/adaptors.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/adaptors.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,104 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \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-mutating algorithms
+#include <boost/range/algorithm/adjacent_find.hpp>
+#include <boost/range/algorithm/count.hpp>
+#include <boost/range/algorithm/count_if.hpp>
+#include <boost/range/algorithm/equal.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/mismatch.hpp>
+#include <boost/range/algorithm/search.hpp>
+#include <boost/range/algorithm/search_n.hpp>
+
+// Mutating algorithms
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/range/algorithm/copy_backward.hpp>
+#include <boost/range/algorithm/fill.hpp>
+#include <boost/range/algorithm/fill_n.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/partial_sort_copy.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_copy.hpp>
+#include <boost/range/algorithm/remove_copy_if.hpp>
+#include <boost/range/algorithm/remove_if.hpp>
+#include <boost/range/algorithm/replace.hpp>
+#include <boost/range/algorithm/replace_copy.hpp>
+#include <boost/range/algorithm/replace_copy_if.hpp>
+#include <boost/range/algorithm/replace_if.hpp>
+#include <boost/range/algorithm/reverse.hpp>
+#include <boost/range/algorithm/reverse_copy.hpp>
+#include <boost/range/algorithm/rotate.hpp>
+#include <boost/range/algorithm/rotate_copy.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/unique_copy.hpp>
+
+// Binary search
+#include <boost/range/algorithm/binary_search.hpp>
+#include <boost/range/algorithm/equal_range.hpp>
+#include <boost/range/algorithm/lower_bound.hpp>
+#include <boost/range/algorithm/upper_bound.hpp>
+
+// Set operations of sorted ranges
+#include <boost/range/algorithm/set_algorithm.hpp>
+
+// Heap operations
+#include <boost/range/algorithm/heap_algorithm.hpp>
+
+// Minimum and Maximum
+#include <boost/range/algorithm/max_element.hpp>
+#include <boost/range/algorithm/min_element.hpp>
+
+// Permutations
+#include <boost/range/algorithm/permutation.hpp>
+
+#endif // include guard
+
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/adjacent_find.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/adjacent_find.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,119 @@
+// 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/value_type.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< typename ForwardRange >
+ inline typename range_iterator<ForwardRange>::type
+ adjacent_find(ForwardRange & rng)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return std::adjacent_find(boost::begin(rng),boost::end(rng));
+ }
+
+ /// \overload
+ template< typename ForwardRange >
+ inline typename range_iterator<const ForwardRange>::type
+ adjacent_find(const ForwardRange& rng)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return std::adjacent_find(boost::begin(rng),boost::end(rng));
+ }
+
+ /// \overload
+ template< typename ForwardRange, typename BinaryPredicate >
+ inline typename range_iterator<ForwardRange>::type
+ adjacent_find(ForwardRange & rng, BinaryPredicate pred)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ typename range_value<ForwardRange>::type,
+ typename range_value<ForwardRange>::type>));
+ return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
+ }
+
+ /// \overload
+ template< typename ForwardRange, typename BinaryPredicate >
+ inline typename range_iterator<const ForwardRange>::type
+ adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ typename range_value<const ForwardRange>::type,
+ typename range_value<const ForwardRange>::type>));
+ return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, typename ForwardRange >
+ inline typename range_return<ForwardRange,re>::type
+ adjacent_find(ForwardRange & rng)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return range_return<ForwardRange,re>::
+ pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, typename ForwardRange >
+ inline typename range_return<const ForwardRange,re>::type
+ adjacent_find(const ForwardRange& rng)
+ {
+ BOOST_CONCEPT_ASSERT((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, typename ForwardRange, typename BinaryPredicate >
+ inline typename range_return<ForwardRange,re>::type
+ adjacent_find(ForwardRange& rng, BinaryPredicate pred)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ typename range_value<ForwardRange>::type,
+ typename range_value<ForwardRange>::type>));
+ return range_return<ForwardRange,re>::
+ pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
+ inline typename range_return<const ForwardRange,re>::type
+ adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
+ {
+ BOOST_CONCEPT_ASSERT((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/SOC/2009/unicode/boost/range/algorithm/binary_search.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/binary_search.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/copy.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/copy.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/copy_backward.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/copy_backward.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/count.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/count.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/count_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/count_if.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/equal.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/equal.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/equal_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/equal_range.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/fill.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/fill.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,34 @@
+// 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 ForwardRange& fill(ForwardRange& rng, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ std::fill(boost::begin(rng), boost::end(rng), val);
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/fill_n.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/fill_n.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,36 @@
+// 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_N_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_FILL_N_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 fill_n
+ ///
+ /// range-based version of the fill_n std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ template< class ForwardRange, class Size, class Value >
+ inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n );
+ std::fill_n(boost::begin(rng), n, val);
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/find.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/find.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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, const 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, const 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, const 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, const 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/SOC/2009/unicode/boost/range/algorithm/find_end.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/find_end.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/find_first_of.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/find_first_of.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/find_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/find_if.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/for_each.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/for_each.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/generate.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/generate.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/heap_algorithm.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/heap_algorithm.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/inplace_merge.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/inplace_merge.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/lexicographical_compare.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/lexicographical_compare.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/lower_bound.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/lower_bound.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/max_element.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/max_element.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/merge.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/merge.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/min_element.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/min_element.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/mismatch.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/mismatch.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/nth_element.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/nth_element.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/partial_sort.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/partial_sort.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/partial_sort_copy.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/partial_sort_copy.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,58 @@
+// 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_COPY_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_PARTIAL_SORT_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/value_type.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function partial_sort_copy
+ ///
+ /// range-based version of the partial_sort_copy std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ /// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template<typename SinglePassRange, typename RandomAccessRange>
+ inline typename range_iterator<RandomAccessRange>::type
+ partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
+ {
+ BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
+ BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
+ BOOST_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
+
+ return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2));
+ }
+
+ /// \overload
+ template<typename SinglePassRange, typename RandomAccessRange,
+ typename BinaryPredicate>
+ inline typename range_iterator<RandomAccessRange>::type
+ partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
+ BinaryPredicate pred)
+ {
+ BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
+ BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<RandomAccessRange>::type, typename range_value<RandomAccessRange>::type>));
+
+ return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), boost::end(rng2), pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/partition.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/partition.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/permutation.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/permutation.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/random_shuffle.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/random_shuffle.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/remove.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/remove.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/remove_copy.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/remove_copy.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,38 @@
+// 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_COPY_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REMOVE_COPY_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 remove_copy
+ ///
+ /// range-based version of the remove_copy std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ /// \pre OutputIterator is a model of the OutputIteratorConcept
+ /// \pre Value is a model of the EqualityComparableConcept
+ /// \pre Objects of type Value can be compared for equality with objects of
+ /// InputIterator's value type.
+ template< class SinglePassRange, class OutputIterator, class Value >
+ inline OutputIterator
+ remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/remove_copy_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/remove_copy_if.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,38 @@
+// 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_COPY_IF_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REMOVE_COPY_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 remove_copy_if
+ ///
+ /// range-based version of the remove_copy_if std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ /// \pre OutputIterator is a model of the OutputIteratorConcept
+ /// \pre Predicate is a model of the PredicateConcept
+ /// \pre InputIterator's value type is convertible to Predicate's argument type
+ /// \pre out_it is not an iterator in the range rng
+ template< class SinglePassRange, class OutputIterator, class Predicate >
+ inline OutputIterator
+ remove_copy_if(SinglePassRange& rng, OutputIterator out_it, Predicate pred)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::remove_copy_if(boost::begin(rng), boost::end(rng), out_it, pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/remove_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/remove_if.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/replace.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/replace.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/replace_copy.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/replace_copy.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,36 @@
+// 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_COPY_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REPLACE_COPY_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_copy
+ ///
+ /// range-based version of the replace_copy std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ template< class ForwardRange, class OutputIterator, class Value >
+ inline OutputIterator
+ replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
+ const Value& with_what)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::replace_copy(boost::begin(rng), boost::end(rng), out_it,
+ what, with_what);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/replace_copy_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/replace_copy_if.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,40 @@
+// 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_COPY_IF_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REPLACE_COPY_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_copy_if
+ ///
+ /// range-based version of the replace_copy_if std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre Predicate is a model of the PredicateConcept
+ /// \pre Value is convertible to Predicate's argument type
+ /// \pre Value is Assignable
+ /// \pre Value is convertible to a type in OutputIterator's set of value types.
+ template< class ForwardRange, class OutputIterator, class Predicate, class Value >
+ inline OutputIterator
+ replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
+ const Value& with_what)
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it,
+ pred, with_what);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/replace_if.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/replace_if.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/reverse.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/reverse.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/reverse_copy.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/reverse_copy.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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_REVERSE_COPY_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_REVERSE_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/iterator/iterator_concepts.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function reverse_copy
+ ///
+ /// range-based version of the reverse_copy std algorithm
+ ///
+ /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
+ template<typename BidirectionalRange, typename OutputIterator>
+ inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
+ {
+ BOOST_CONCEPT_ASSERT((BidirectionalRangeConcept<BidirectionalRange>));
+ return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
+ }
+
+ /// \overload
+ template<typename BidirectionalRange, typename OutputIterator>
+ inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
+ {
+ BOOST_CONCEPT_ASSERT((BidirectionalRangeConcept<BidirectionalRange>));
+ return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/rotate.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/rotate.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,46 @@
+// 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 <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<typename ForwardRange>
+ inline ForwardRange& rotate(ForwardRange& rng,
+ typename range_iterator<ForwardRange>::type middle)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ std::rotate(boost::begin(rng), middle, boost::end(rng));
+ return rng;
+ }
+
+ /// \overload
+ template<typename ForwardRange>
+ inline const ForwardRange&
+ rotate(const ForwardRange& rng,
+ typename range_iterator<const ForwardRange>::type middle)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ std::rotate(boost::begin(rng), middle, boost::end(rng));
+ return rng;
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/rotate_copy.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/rotate_copy.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,38 @@
+// 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_COPY_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_ROTATE_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.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<typename ForwardRange, typename OutputIterator>
+ inline OutputIterator rotate_copy(
+ const ForwardRange& rng,
+ typename range_iterator<const ForwardRange>::type middle,
+ OutputIterator target
+ )
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return std::rotate_copy(boost::begin(rng), middle, boost::end(rng), target);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/search.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/search.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/search_n.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/search_n.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,140 @@
+// 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_N_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_SEARCH_N_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 <boost/range/value_type.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ /// \brief template function search
+ ///
+ /// range-based version of the search std algorithm
+ ///
+ /// \pre ForwardRange is a model of the ForwardRangeConcept
+ /// \pre Integer is an integral type
+ /// \pre Value is a model of the EqualityComparableConcept
+ /// \pre ForwardRange's value type is a model of the EqualityComparableConcept
+ /// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value
+ template< typename ForwardRange, typename Integer, typename Value >
+ inline typename range_iterator<ForwardRange>::type
+ search_n(ForwardRange& rng, Integer count, const Value& value)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return std::search_n(boost::begin(rng),boost::end(rng), count, value);
+ }
+
+ /// \overload
+ template< typename ForwardRange, typename Integer, typename Value >
+ inline typename range_iterator<const ForwardRange>::type
+ search_n(const ForwardRange& rng, Integer count, const Value& value)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return std::search_n(boost::begin(rng), boost::end(rng), count, value);
+ }
+
+ /// \overload
+ template< typename ForwardRange, typename Integer, class Value,
+ typename BinaryPredicate >
+ inline typename range_iterator<ForwardRange>::type
+ search_n(ForwardRange& rng, Integer count, const Value& value,
+ BinaryPredicate binary_pred)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ typename range_value<ForwardRange>::type, const Value&>));
+ return std::search_n(boost::begin(rng), boost::end(rng),
+ count, value, binary_pred);
+ }
+
+ /// \overload
+ template< typename ForwardRange, typename Integer, typename Value,
+ typename BinaryPredicate >
+ inline typename range_iterator<const ForwardRange>::type
+ search_n(const ForwardRange& rng, Integer count, const Value& value,
+ BinaryPredicate binary_pred)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ typename range_value<const ForwardRange>::type, const Value&>));
+ return std::search_n(boost::begin(rng), boost::end(rng),
+ count, value, binary_pred);
+ }
+
+// range_return overloads
+
+ /// \overload
+ template< range_return_value re, typename ForwardRange, typename Integer,
+ typename Value >
+ inline typename range_return<ForwardRange,re>::type
+ search_n(ForwardRange& rng, Integer count, const Value& value)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return range_return<ForwardRange,re>::
+ pack(std::search_n(boost::begin(rng),boost::end(rng),
+ count, value),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, typename ForwardRange, typename Integer,
+ class Value >
+ inline typename range_return<const ForwardRange,re>::type
+ search_n(const ForwardRange& rng, Integer count, const Value& value)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return range_return<const ForwardRange,re>::
+ pack(std::search_n(boost::begin(rng), boost::end(rng),
+ count, value),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, typename ForwardRange, typename Integer,
+ typename Value, typename BinaryPredicate >
+ inline typename range_return<ForwardRange,re>::type
+ search_n(ForwardRange& rng, Integer count, const Value& value,
+ BinaryPredicate pred)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ typename range_value<ForwardRange>::type,
+ const Value&>));
+ return range_return<ForwardRange,re>::
+ pack(std::search_n(boost::begin(rng), boost::end(rng),
+ count, value, pred),
+ rng);
+ }
+
+ /// \overload
+ template< range_return_value re, typename ForwardRange, typename Integer,
+ typename Value, typename BinaryPredicate >
+ inline typename range_return<const ForwardRange,re>::type
+ search_n(const ForwardRange& rng, Integer count, const Value& value,
+ BinaryPredicate pred)
+ {
+ BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ typename range_value<const ForwardRange>::type,
+ const Value&>));
+ return range_return<const ForwardRange,re>::
+ pack(std::search_n(boost::begin(rng), boost::end(rng),
+ count, value, pred),
+ rng);
+ }
+
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/set_algorithm.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/set_algorithm.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/sort.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/sort.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/stable_partition.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/stable_partition.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/stable_sort.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/stable_sort.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/swap_ranges.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/swap_ranges.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,81 @@
+// 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_SWAP_RANGES_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_SWAP_RANGES_HPP_INCLUDED
+
+#include <boost/assert.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/iterator.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template<typename Iterator1, typename Iterator2>
+ void swap_ranges_impl(Iterator1 it1, Iterator1 last1,
+ Iterator2 it2, Iterator2 last2,
+ single_pass_traversal_tag,
+ single_pass_traversal_tag)
+ {
+ ignore_unused_variable_warning(last2);
+ for (; it1 != last1; ++it1, ++it2)
+ {
+ BOOST_ASSERT( it2 != last2 );
+ std::iter_swap(it1, it2);
+ }
+ }
+
+ template<typename Iterator1, typename Iterator2>
+ void swap_ranges_impl(Iterator1 it1, Iterator1 last1,
+ Iterator2 it2, Iterator2 last2,
+ random_access_traversal_tag,
+ random_access_traversal_tag)
+ {
+ ignore_unused_variable_warning(last2);
+ BOOST_ASSERT( last2 - it2 >= last1 - it1 );
+ std::swap_ranges(it1, last1, it2);
+ }
+
+ template<typename Iterator1, typename Iterator2>
+ void swap_ranges_impl(Iterator1 first1, Iterator1 last1,
+ Iterator2 first2, Iterator2 last2)
+ {
+ swap_ranges_impl(first1, last1, first2, last2,
+ typename iterator_traversal<Iterator1>::type(),
+ typename iterator_traversal<Iterator2>::type());
+ }
+ } // namespace range_detail
+
+ /// \brief template function swap_ranges
+ ///
+ /// range-based version of the swap_ranges std algorithm
+ ///
+ /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
+ /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
+ template< typename SinglePassRange1, typename SinglePassRange2 >
+ inline SinglePassRange2&
+ swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
+ {
+ BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
+ BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));
+
+ boost::range_detail::swap_ranges_impl(
+ boost::begin(range1), boost::end(range1),
+ boost::begin(range2), boost::end(range2));
+
+ return range2;
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/transform.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/transform.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm/unique.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/unique.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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_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< 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 );
+ }
+
+ /// \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);
+ }
+
+ /// \overload
+ template< class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
+ unique( ForwardRange& rng )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return boost::unique<return_begin_found>(rng);
+ }
+ /// \overload
+ template< class ForwardRange >
+ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
+ unique( const ForwardRange& rng )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return boost::unique<return_begin_found>(rng);
+ }
+ /// \overload
+ template< class ForwardRange, class BinaryPredicate >
+ inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
+ unique( ForwardRange& rng, BinaryPredicate pred )
+ {
+ boost::function_requires< ForwardRangeConcept<ForwardRange> >();
+ return boost::unique<return_begin_found>(rng);
+ }
+ /// \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 boost::unique<return_begin_found>(rng, pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/unique_copy.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/unique_copy.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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_UNIQUE_COPY_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_UNIQUE_COPY_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 unique_copy
+ ///
+ /// range-based version of the unique_copy std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ /// \pre OutputIterator is a model of the OutputIteratorConcept
+ /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
+ template< class SinglePassRange, class OutputIterator >
+ inline OutputIterator
+ unique_copy( const SinglePassRange& rng, OutputIterator out_it )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::unique_copy(boost::begin(rng), boost::end(rng), out_it);
+ }
+ /// \overload
+ template< class SinglePassRange, class OutputIterator, class BinaryPredicate >
+ inline OutputIterator
+ unique_copy( const SinglePassRange& rng, OutputIterator out_it,
+ BinaryPredicate pred )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm/upper_bound.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm/upper_bound.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm_ext.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,27 @@
+// 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/copy_n.hpp>
+#include <boost/range/algorithm_ext/for_each.hpp>
+#include <boost/range/algorithm_ext/is_sorted.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/SOC/2009/unicode/boost/range/algorithm_ext/copy_n.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext/copy_n.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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_COPY_N_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_COPY_N_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 <boost/range/distance.hpp>
+#include <boost/range/iterator.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
+ /// \pre 0 <= n < distance(rng)
+ template< class SinglePassRange, class Size, class OutputIterator >
+ inline OutputIterator copy_n(const SinglePassRange& rng, Size n, OutputIterator out)
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ BOOST_ASSERT( n < static_cast<Size>(boost::distance(rng)) );
+ BOOST_ASSERT( n >= static_cast<Size>(0) );
+
+ BOOST_DEDUCED_TYPENAME range_const_iterator<SinglePassRange>::type source = boost::begin(rng);
+
+ for (Size i = 0; i < n; ++i, ++out, ++source)
+ *out = *source;
+
+ return out;
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm_ext/erase.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext/erase.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm_ext/for_each.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext/for_each.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm_ext/insert.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext/insert.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm_ext/is_sorted.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext/is_sorted.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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_EXT_IS_SORTED_HPP_INCLUDED
+#define BOOST_RANGE_ALGORITHM_EXT_IS_SORTED_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/value_type.hpp>
+#include <algorithm>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template<typename ForwardIterator>
+ inline bool is_sorted(ForwardIterator first, ForwardIterator last)
+ {
+ for (ForwardIterator next = first; first != last && ++next != last; ++first)
+ if (*next < *first)
+ return false;
+ return true;
+ }
+
+ template<typename ForwardIterator, typename BinaryPredicate>
+ inline bool is_sorted(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
+ {
+ for (ForwardIterator next = first; first != last && ++next != last; ++first)
+ if (pred(*next, *first))
+ return false;
+ return true;
+ }
+ }
+
+ /// \brief template function count
+ ///
+ /// range-based version of the count std algorithm
+ ///
+ /// \pre SinglePassRange is a model of the SinglePassRangeConcept
+ template<typename SinglePassRange>
+ inline bool is_sorted(const SinglePassRange& rng)
+ {
+ BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
+ return range_detail::is_sorted(boost::begin(rng), boost::end(rng));
+ }
+
+ /// \overload
+ template<typename SinglePassRange, typename BinaryPredicate>
+ inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
+ {
+ BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+ BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<SinglePassRange>::type, typename range_value<SinglePassRange>::type>));
+ return range_detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/algorithm_ext/overwrite.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext/overwrite.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm_ext/push_back.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext/push_back.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/algorithm_ext/push_front.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/algorithm_ext/push_front.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/as_array.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/as_array.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/as_literal.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/as_literal.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/atl.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/atl.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/begin.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/begin.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/category.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/category.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/chain.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/chain.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,68 @@
+// 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_CHAIN_HPP_INCLUDED
+#define BOOST_RANGE_CHAIN_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/range/detail/chain_iterator.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost
+{
+
+template<class SinglePassRange1, class SinglePassRange2>
+iterator_range<range_detail::chain_iterator<
+ BOOST_DEDUCED_TYPENAME range_const_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_const_iterator<SinglePassRange2>::type,
+ BOOST_DEDUCED_TYPENAME add_const<
+ BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type>::type>
+>
+chain(const SinglePassRange1& r1, const SinglePassRange2& r2)
+{
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ typedef range_detail::chain_iterator<
+ BOOST_DEDUCED_TYPENAME range_const_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_const_iterator<SinglePassRange2>::type,
+ BOOST_DEDUCED_TYPENAME add_const<
+ BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type>::type> iterator_t;
+
+ return iterator_range<iterator_t>(
+ iterator_t(r1, r2, range_detail::chain_iterator_begin_tag()),
+ iterator_t(r1, r2, range_detail::chain_iterator_end_tag()));
+}
+
+template<class SinglePassRange1, class SinglePassRange2>
+iterator_range<range_detail::chain_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
+ BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type>
+>
+chain(SinglePassRange1& r1, SinglePassRange2& r2)
+{
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+
+ typedef range_detail::chain_iterator<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
+ BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type> iterator_t;
+
+ return iterator_range<iterator_t>(
+ iterator_t(r1, r2, range_detail::chain_iterator_begin_tag()),
+ iterator_t(r1, r2, range_detail::chain_iterator_end_tag()));
+}
+
+} // namespace boost
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/combine.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/combine.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/concepts.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/concepts.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,276 @@
+// Boost.Range library concept checks
+//
+// Copyright Neil Groves 2009. 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)
+//
+// 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>
+#include <boost/range/iterator.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/detail/misc_concept.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
+ * BOOST_CONCEPT_ASSERT((ForwardRangeConcept<T>));
+ * \endcode
+ *
+ * A different concept check is required to ensure writeable value
+ * access. For example to check for a ForwardRange that can be written
+ * to, the following code is required.
+ *
+ * \code
+ * BOOST_CONCEPT_ASSERT((WriteableForwardRangeConcept<T>));
+ * \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 {
+
+ namespace range_detail {
+
+ // Rationale for the inclusion of redefined iterator concept
+ // classes:
+ //
+ // The Range algorithms often do not require that the iterators are
+ // Assignable, but the correct standard conformant iterators
+ // do require the iterators to be a model of the Assignable concept.
+ // Iterators that contains a functor that is not assignable therefore
+ // are not correct models of the standard iterator concepts,
+ // despite being adequate for most algorithms. An example of this
+ // use case is the combination of the boost::adaptors::filtered
+ // class with a boost::lambda::bind generated functor.
+ // Ultimately modeling the range concepts using composition
+ // with the Boost.Iterator concepts would render the library
+ // incompatible with many common Boost.Lambda expressions.
+ template<typename Iterator>
+ struct IncrementableIteratorConcept : CopyConstructible<Iterator>
+ {
+ typedef typename iterator_traversal<Iterator>::type traversal_category;
+
+ BOOST_CONCEPT_ASSERT((
+ Convertible<
+ traversal_category,
+ incrementable_traversal_tag
+ >));
+
+ BOOST_CONCEPT_USAGE(IncrementableIteratorConcept)
+ {
+ ++i;
+ (void)i++;
+ }
+ private:
+ Iterator i;
+ };
+
+ template<typename Iterator>
+ struct SinglePassIteratorConcept
+ : IncrementableIteratorConcept<Iterator>
+ , EqualityComparable<Iterator>
+ {
+ BOOST_CONCEPT_ASSERT((
+ Convertible<
+ typename SinglePassIteratorConcept::traversal_category,
+ single_pass_traversal_tag
+ >));
+ };
+
+ template<typename Iterator>
+ struct ForwardIteratorConcept
+ : SinglePassIteratorConcept<Iterator>
+ , DefaultConstructible<Iterator>
+ {
+ typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+
+ BOOST_MPL_ASSERT((is_integral<difference_type>));
+ BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
+
+ BOOST_CONCEPT_ASSERT((
+ Convertible<
+ typename ForwardIteratorConcept::traversal_category,
+ forward_traversal_tag
+ >));
+ };
+
+ template<typename Iterator>
+ struct BidirectionalIteratorConcept
+ : ForwardIteratorConcept<Iterator>
+ {
+ BOOST_CONCEPT_ASSERT((
+ Convertible<
+ typename BidirectionalIteratorConcept::traversal_category,
+ bidirectional_traversal_tag
+ >));
+
+ BOOST_CONCEPT_USAGE(BidirectionalIteratorConcept)
+ {
+ --i;
+ (void)i--;
+ }
+ private:
+ Iterator i;
+ };
+
+ template<typename Iterator>
+ struct RandomAccessIteratorConcept
+ : BidirectionalIteratorConcept<Iterator>
+ {
+ BOOST_CONCEPT_ASSERT((
+ Convertible<
+ typename RandomAccessIteratorConcept::traversal_category,
+ random_access_traversal_tag
+ >));
+
+ BOOST_CONCEPT_USAGE(RandomAccessIteratorConcept)
+ {
+ i += n;
+ i = i + n;
+ i = n + i;
+ i -= n;
+ i = i - n;
+ n = i - j;
+ }
+ private:
+ typename RandomAccessIteratorConcept::difference_type n;
+ Iterator i;
+ Iterator j;
+ };
+
+ } // namespace range_detail
+
+ //! Check if a type T models the SinglePassRange range concept.
+ template<typename T>
+ struct SinglePassRangeConcept
+ {
+ typedef typename range_iterator<T const>::type const_iterator;
+ typedef typename range_iterator<T>::type iterator;
+
+ BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
+ BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
+
+ BOOST_CONCEPT_USAGE(SinglePassRangeConcept)
+ {
+ // This has been modified from assigning to this->i
+ // (where i was a member variable) to improve
+ // compatibility with Boost.Lambda
+ iterator i1 = boost::begin(m_range);
+ iterator i2 = boost::end(m_range);
+
+ ignore_unused_variable_warning(i1);
+ ignore_unused_variable_warning(i2);
+
+ const_constraints(m_range);
+ }
+
+ private:
+ void const_constraints(const T& const_range)
+ {
+ const_iterator ci1 = boost::begin(const_range);
+ const_iterator ci2 = boost::end(const_range);
+
+ ignore_unused_variable_warning(ci1);
+ ignore_unused_variable_warning(ci2);
+ }
+
+ // Rationale:
+ // The type of m_range is T& rather than T because it allows
+ // T to be an abstract class.
+ T& m_range;
+ };
+
+ //! Check if a type T models the ForwardRange range concept.
+ template<typename T>
+ struct ForwardRangeConcept : SinglePassRangeConcept<T>
+ {
+ BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::iterator>));
+ BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::const_iterator>));
+ };
+
+ template<typename Range>
+ struct WriteableRangeConcept
+ {
+ typedef typename range_iterator<Range>::type iterator;
+
+ BOOST_CONCEPT_USAGE(WriteableRangeConcept)
+ {
+ *i = v;
+ }
+ private:
+ iterator i;
+ typename range_value<Range>::type v;
+ };
+
+ //! Check if a type T models the WriteableForwardRange range concept.
+ template<typename T>
+ struct WriteableForwardRangeConcept
+ : ForwardRangeConcept<T>
+ , WriteableRangeConcept<T>
+ {
+ };
+
+ //! Check if a type T models the BidirectionalRange range concept.
+ template<typename T>
+ struct BidirectionalRangeConcept : ForwardRangeConcept<T>
+ {
+ BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<typename BidirectionalRangeConcept::iterator>));
+ BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<typename BidirectionalRangeConcept::const_iterator>));
+ };
+
+ //! Check if a type T models the WriteableBidirectionalRange range concept.
+ template<typename T>
+ struct WriteableBidirectionalRangeConcept
+ : BidirectionalRangeConcept<T>
+ , WriteableRangeConcept<T>
+ {
+ };
+
+ //! Check if a type T models the RandomAccessRange range concept.
+ template<typename T>
+ struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
+ {
+ BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<typename RandomAccessRangeConcept::iterator>));
+ BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<typename RandomAccessRangeConcept::const_iterator>));
+ };
+
+ //! Check if a type T models the WriteableRandomAccessRange range concept.
+ template<typename T>
+ struct WriteableRandomAccessRangeConcept
+ : RandomAccessRangeConcept<T>
+ , WriteableRangeConcept<T>
+ {
+ };
+
+} // namespace boost
+
+#endif // BOOST_RANGE_CONCEPTS_HPP
Added: sandbox/SOC/2009/unicode/boost/range/config.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/config.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/const_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/const_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/const_reverse_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/const_reverse_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/counting_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/counting_range.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,69 @@
+// 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/config.hpp>
+#if BOOST_MSVC >= 1400
+#pragma warning(push)
+#pragma warning(disable : 4244)
+#endif
+
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/iterator/counting_iterator.hpp>
+#include <boost/utility.hpp>
+
+namespace boost
+{
+
+ template<class Value>
+ inline iterator_range<counting_iterator<Value> >
+ counting_range(Value first, Value last)
+ {
+ typedef counting_iterator<Value> counting_iterator_t;
+ typedef iterator_range<counting_iterator_t> result_t;
+ return result_t(counting_iterator_t(first),
+ counting_iterator_t(last));
+ }
+
+ template<class Range>
+ inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> >
+ counting_range(const Range& rng)
+ {
+ typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> counting_iterator_t;
+ typedef iterator_range<counting_iterator_t> result_t;
+ return boost::empty(rng)
+ ? result_t()
+ : result_t(
+ counting_iterator_t(*boost::begin(rng)),
+ counting_iterator_t(*boost::prior(boost::end(rng))));
+ }
+
+ template<class Range>
+ inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> >
+ counting_range(Range& rng)
+ {
+ typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> counting_iterator_t;
+ typedef iterator_range<counting_iterator_t> result_t;
+ return boost::empty(rng)
+ ? result_t()
+ : result_t(
+ counting_iterator_t(*boost::begin(rng)),
+ counting_iterator_t(*boost::prior(boost::end(rng))));
+ }
+} // namespace boost
+
+#if BOOST_MSVC >= 1400
+#pragma warning(pop)
+#endif
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/detail/as_literal.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/as_literal.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/begin.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/begin.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/chain_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/chain_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,355 @@
+// 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_DETAIL_CHAIN_ITERATOR_HPP_INCLUDED
+#define BOOST_RANGE_DETAIL_CHAIN_ITERATOR_HPP_INCLUDED
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/intrusive_ptr.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/empty.hpp>
+#include <boost/range/detail/demote_iterator_traversal_tag.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/utility.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+
+template<typename Iterator1, typename Iterator2>
+struct chain_iterator_link
+{
+private:
+ class reference_count_t
+ {
+ public:
+ reference_count_t() : m_count(0u) {}
+ reference_count_t(const reference_count_t&) : m_count(0u) {}
+ reference_count_t& operator=(const reference_count_t&) { return *this; }
+
+ void increment() { ++m_count; }
+ bool decrement() { return --m_count ? false : true; }
+
+ private:
+ unsigned int m_count;
+ };
+
+public:
+ chain_iterator_link(Iterator1 last1, Iterator2 first2)
+ : last1(last1)
+ , first2(first2)
+ {
+ }
+
+ void add_reference() const
+ {
+ count.increment();
+ }
+
+ bool release_reference() const
+ {
+ return count.decrement();
+ }
+
+ Iterator1 last1;
+ Iterator2 first2;
+
+private:
+ chain_iterator_link() /* = delete */ ;
+
+ mutable reference_count_t count;
+};
+
+} // range_detail
+
+template<typename Iterator1, typename Iterator2>
+inline void intrusive_ptr_add_ref(const range_detail::chain_iterator_link<Iterator1,Iterator2>* p)
+{
+ p->add_reference();
+}
+
+template<typename Iterator1, typename Iterator2>
+inline void intrusive_ptr_release(const range_detail::chain_iterator_link<Iterator1,Iterator2>* p)
+{
+ if (p->release_reference())
+ delete p;
+}
+
+namespace range_detail
+{
+
+class chain_iterator_begin_tag {};
+class chain_iterator_end_tag {};
+
+template<typename Iterator1
+ , typename Iterator2
+ , typename Reference
+>
+class chain_iterator_union
+{
+public:
+ typedef Iterator1 iterator1_t;
+ typedef Iterator2 iterator2_t;
+
+ chain_iterator_union() {}
+ chain_iterator_union(unsigned int /*selected*/, const iterator1_t& it1, const iterator2_t& it2) : m_it1(it1), m_it2(it2) {}
+
+ iterator1_t& it1() { return m_it1; }
+ const iterator1_t& it1() const { return m_it1; }
+
+ iterator2_t& it2() { return m_it2; }
+ const iterator2_t& it2() const { return m_it2; }
+
+ Reference dereference(unsigned int selected) const
+ {
+ return selected ? *m_it2 : *m_it1;
+ }
+
+ bool equal(const chain_iterator_union& other, unsigned int selected) const
+ {
+ return selected
+ ? m_it2 == other.m_it2
+ : m_it1 == other.m_it1;
+ }
+
+private:
+ iterator1_t m_it1;
+ iterator2_t m_it2;
+};
+
+template<class Iterator, class Reference>
+class chain_iterator_union<Iterator, Iterator, Reference>
+{
+public:
+ typedef Iterator iterator1_t;
+ typedef Iterator iterator2_t;
+
+ chain_iterator_union() {}
+
+ chain_iterator_union(unsigned int selected, const iterator1_t& it1, const iterator2_t& it2)
+ : m_it(selected ? it2 : it1)
+ {
+ }
+
+ iterator1_t& it1() { return m_it; }
+ const iterator1_t& it1() const { return m_it; }
+
+ iterator2_t& it2() { return m_it; }
+ const iterator2_t& it2() const { return m_it; }
+
+ Reference dereference(unsigned int) const
+ {
+ return *m_it;
+ }
+
+ bool equal(const chain_iterator_union& other, unsigned int selected) const
+ {
+ return m_it == other.m_it;
+ }
+
+private:
+ iterator1_t m_it;
+};
+
+template<typename Iterator1
+ , typename Iterator2
+ , typename ValueType = typename iterator_value<Iterator1>::type
+ , typename Reference = typename iterator_reference<Iterator1>::type
+ , typename Traversal = typename demote_iterator_traversal_tag<
+ typename iterator_traversal<Iterator1>::type
+ , typename iterator_traversal<Iterator2>::type>::type
+>
+class chain_iterator
+ : public iterator_facade<chain_iterator<Iterator1,Iterator2,ValueType,Reference,Traversal>, ValueType, Traversal, Reference>
+{
+ typedef chain_iterator_link<Iterator1, Iterator2> link_t;
+ typedef chain_iterator_union<Iterator1, Iterator2, Reference> iterator_union;
+public:
+ typedef Iterator1 iterator1_t;
+ typedef Iterator2 iterator2_t;
+
+ chain_iterator() : m_section(0u) {}
+
+ chain_iterator(unsigned int section, Iterator1 current1, Iterator1 last1, Iterator2 first2, Iterator2 current2)
+ : m_section(section)
+ , m_it(section, current1, current2)
+ , m_link(new link_t(last1, first2))
+ {
+ }
+
+ template<typename Range1, typename Range2>
+ chain_iterator(Range1& r1, Range2& r2, chain_iterator_begin_tag)
+ : m_section(boost::empty(r1) ? 1u : 0u)
+ , m_it(boost::empty(r1) ? 1u : 0u, boost::begin(r1), boost::begin(r2))
+ , m_link(new link_t(boost::end(r1), boost::begin(r2)))
+ {
+ }
+
+ template<typename Range1, typename Range2>
+ chain_iterator(const Range1& r1, const Range2& r2, chain_iterator_begin_tag)
+ : m_section(boost::empty(r1) ? 1u : 0u)
+ , m_it(boost::empty(r1) ? 1u : 0u, boost::const_begin(r1), boost::const_begin(r2))
+ , m_link(new link_t(boost::const_end(r1), boost::const_begin(r2)))
+ {
+ }
+
+ template<typename Range1, typename Range2>
+ chain_iterator(Range1& r1, Range2& r2, chain_iterator_end_tag)
+ : m_section(1u)
+ , m_it(1u, boost::end(r1), boost::end(r2))
+ , m_link(new link_t(boost::end(r1), boost::begin(r2)))
+ {
+ }
+
+ template<typename Range1, typename Range2>
+ chain_iterator(const Range1& r1, const Range2& r2, chain_iterator_end_tag)
+ : m_section(1u)
+ , m_it(1u, boost::const_end(r1), boost::const_end(r2))
+ , m_link(new link_t(boost::const_end(r1), boost::const_begin(r2)))
+ {
+ }
+
+private:
+ void increment()
+ {
+ if (m_section)
+ ++m_it.it2();
+ else
+ {
+ ++m_it.it1();
+ if (m_it.it1() == m_link->last1)
+ {
+ m_it.it2() = m_link->first2;
+ m_section = 1u;
+ }
+ }
+ }
+
+ void decrement()
+ {
+ if (m_section)
+ {
+ if (m_it.it2() == m_link->first2)
+ {
+ m_it.it1() = boost::prior(m_link->last1);
+ m_section = 0u;
+ }
+ else
+ --m_it.it2();
+ }
+ else
+ --m_it.it1();
+ }
+
+ typename chain_iterator::reference dereference() const
+ {
+ return m_it.dereference(m_section);
+ }
+
+ bool equal(const chain_iterator& other) const
+ {
+ return m_section == other.m_section
+ && m_it.equal(other.m_it, m_section);
+ }
+
+ void advance(typename chain_iterator::difference_type offset)
+ {
+ if (m_section)
+ advance_from_range2(offset);
+ else
+ advance_from_range1(offset);
+ }
+
+ typename chain_iterator::difference_type distance_to(const chain_iterator& other) const
+ {
+ typename chain_iterator::difference_type result;
+ if (m_section)
+ {
+ if (other.m_section)
+ result = other.m_it.it2() - m_it.it2();
+ else
+ {
+ result = (m_link->first2 - m_it.it2())
+ + (other.m_it.it1() - m_link->last1);
+
+ BOOST_ASSERT( result <= 0 );
+ }
+ }
+ else
+ {
+ if (other.m_section)
+ {
+ result = (m_link->last1 - m_it.it1())
+ + (other.m_it.it2() - m_link->first2);
+ }
+ else
+ result = other.m_it.it1() - m_it.it1();
+ }
+ return result;
+ }
+
+ void advance_from_range2(typename chain_iterator::difference_type offset)
+ {
+ typedef typename chain_iterator::difference_type difference_t;
+ BOOST_ASSERT( m_section == 1u );
+ if (offset < 0)
+ {
+ difference_t r2_dist = m_link->first2 - m_it.it2();
+ BOOST_ASSERT( r2_dist <= 0 );
+ if (offset >= r2_dist)
+ std::advance(m_it.it2(), offset);
+ else
+ {
+ difference_t r1_dist = offset - r2_dist;
+ BOOST_ASSERT( r1_dist <= 0 );
+ m_it.it1() = m_link->last1 + r1_dist;
+ m_section = 0u;
+ }
+ }
+ else
+ std::advance(m_it.it2(), offset);
+ }
+
+ void advance_from_range1(typename chain_iterator::difference_type offset)
+ {
+ typedef typename chain_iterator::difference_type difference_t;
+ BOOST_ASSERT( m_section == 0u );
+ if (offset > 0)
+ {
+ difference_t r1_dist = m_link->last1 - m_it.it1();
+ BOOST_ASSERT( r1_dist >= 0 );
+ if (offset < r1_dist)
+ std::advance(m_it.it1(), offset);
+ else
+ {
+ difference_t r2_dist = offset - r1_dist;
+ BOOST_ASSERT( r2_dist >= 0 );
+ m_it.it2() = m_link->first2 + r2_dist;
+ m_section = 1u;
+ }
+ }
+ else
+ std::advance(m_it.it1(), offset);
+ }
+
+ unsigned int m_section;
+ iterator_union m_it;
+ intrusive_ptr<const link_t> m_link;
+
+ friend class ::boost::iterator_core_access;
+};
+
+ } // namespace range_detail
+
+} // namespace boost
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/detail/collection_traits.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/collection_traits.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/collection_traits_detail.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/collection_traits_detail.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/common.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/common.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/const_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/const_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/demote_iterator_traversal_tag.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/demote_iterator_traversal_tag.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,79 @@
+// 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_DETAIL_DEMOTE_ITERATOR_TRAVERSAL_TAG_HPP_INCLUDED
+#define BOOST_RANGE_DETAIL_DEMOTE_ITERATOR_TRAVERSAL_TAG_HPP_INCLUDED
+
+#include <boost/iterator/iterator_categories.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+
+template<class IteratorTraversalTag1, class IteratorTraversalTag2>
+struct demote_iterator_traversal_tag
+{
+};
+
+#define BOOST_DEMOTE_TRAVERSAL_TAG( Tag1, Tag2, ResultTag ) \
+template<> struct demote_iterator_traversal_tag< Tag1 , Tag2 > \
+{ \
+ typedef ResultTag type; \
+};
+
+BOOST_DEMOTE_TRAVERSAL_TAG( no_traversal_tag, no_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( no_traversal_tag, incrementable_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( no_traversal_tag, single_pass_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( no_traversal_tag, forward_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( no_traversal_tag, bidirectional_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( no_traversal_tag, random_access_traversal_tag, no_traversal_tag )
+
+BOOST_DEMOTE_TRAVERSAL_TAG( incrementable_traversal_tag, no_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( incrementable_traversal_tag, incrementable_traversal_tag, incrementable_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( incrementable_traversal_tag, single_pass_traversal_tag, incrementable_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( incrementable_traversal_tag, forward_traversal_tag, incrementable_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( incrementable_traversal_tag, bidirectional_traversal_tag, incrementable_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( incrementable_traversal_tag, random_access_traversal_tag, incrementable_traversal_tag )
+
+BOOST_DEMOTE_TRAVERSAL_TAG( single_pass_traversal_tag, no_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( single_pass_traversal_tag, incrementable_traversal_tag, incrementable_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( single_pass_traversal_tag, single_pass_traversal_tag, single_pass_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( single_pass_traversal_tag, forward_traversal_tag, single_pass_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( single_pass_traversal_tag, bidirectional_traversal_tag, single_pass_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( single_pass_traversal_tag, random_access_traversal_tag, single_pass_traversal_tag )
+
+BOOST_DEMOTE_TRAVERSAL_TAG( forward_traversal_tag, no_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( forward_traversal_tag, incrementable_traversal_tag, incrementable_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( forward_traversal_tag, single_pass_traversal_tag, single_pass_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( forward_traversal_tag, forward_traversal_tag, forward_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( forward_traversal_tag, bidirectional_traversal_tag, forward_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( forward_traversal_tag, random_access_traversal_tag, forward_traversal_tag )
+
+BOOST_DEMOTE_TRAVERSAL_TAG( bidirectional_traversal_tag, no_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( bidirectional_traversal_tag, incrementable_traversal_tag, incrementable_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( bidirectional_traversal_tag, single_pass_traversal_tag, single_pass_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( bidirectional_traversal_tag, forward_traversal_tag, forward_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( bidirectional_traversal_tag, bidirectional_traversal_tag, bidirectional_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( bidirectional_traversal_tag, random_access_traversal_tag, bidirectional_traversal_tag )
+
+BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, no_traversal_tag, no_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, incrementable_traversal_tag, incrementable_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, single_pass_traversal_tag, single_pass_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, forward_traversal_tag, forward_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, bidirectional_traversal_tag, bidirectional_traversal_tag )
+BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, random_access_traversal_tag, random_access_traversal_tag )
+
+#undef BOOST_DEMOTE_TRAVERSAL_TAG
+
+ } // namespace range_detail
+} // namespace boost
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/detail/detail_str.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/detail_str.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/difference_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/difference_type.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/empty.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/empty.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/end.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/end.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/extract_optional_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/extract_optional_type.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/implementation_help.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/implementation_help.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/microsoft.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/microsoft.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/misc_concept.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/misc_concept.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,33 @@
+// Boost.Range library concept checks
+//
+// Copyright Neil Groves 2009. 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)
+//
+#ifndef BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED
+#define BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED
+
+#include <boost/concept_check.hpp>
+
+namespace boost
+{
+ namespace range_detail
+ {
+ template<typename T1, typename T2>
+ class SameTypeConcept
+ {
+ public:
+ BOOST_CONCEPT_USAGE(SameTypeConcept)
+ {
+ same_type(a,b);
+ }
+ private:
+ template<typename T> void same_type(T,T) {}
+ T1 a;
+ T2 b;
+ };
+ }
+}
+
+#endif // include guard
Added: sandbox/SOC/2009/unicode/boost/range/detail/range_return.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/range_return.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/remove_extent.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/remove_extent.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/sfinae.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/sfinae.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/size.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/size.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/size_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/size_type.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/sizer.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/sizer.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/str_types.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/str_types.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/value_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/value_type.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/vc6/end.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/vc6/end.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/detail/vc6/size.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/detail/vc6/size.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/difference_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/difference_type.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/distance.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/distance.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/empty.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/empty.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/end.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/end.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/functions.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/functions.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/istream_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/istream_range.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/iterator_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/iterator_range.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/iterator_range_core.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/iterator_range_core.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/iterator_range_io.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/iterator_range_io.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/metafunctions.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/metafunctions.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/mfc.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/mfc.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/mutable_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/mutable_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/numeric.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/numeric.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,117 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file algorithm.hpp
+/// Contains range-based versions of the std algorithms
+//
+/////////////////////////////////////////////////////////////////////////////
+// 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)
+//
+
+// 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/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/concepts.hpp>
+#include <numeric>
+
+
+namespace boost
+{
+ template< class SinglePassRange, class Value >
+ inline Value accumulate( const SinglePassRange& rng, Value init )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::accumulate( boost::begin(rng), boost::end(rng), init );
+ }
+
+ template< class SinglePassRange, class Value, class BinaryOperation >
+ inline Value accumulate( const SinglePassRange& rng, Value init, BinaryOperation op )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::accumulate( boost::begin(rng), boost::end(rng), init, op );
+ }
+
+
+ template< class SinglePassRange1, class SinglePassRange2, class Value >
+ inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
+ return std::inner_product( boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), init );
+ }
+
+ template< class SinglePassRange1,
+ class SinglePassRange2,
+ class Value,
+ class BinaryOperation1, class BinaryOperation2 >
+ inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
+ Value init,
+ BinaryOperation1 op1, BinaryOperation2 op2 )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+ BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
+
+ return std::inner_product( boost::begin(rng1), boost::end(rng1),
+ boost::begin(rng2), init, op1, op2 );
+ }
+
+ template< class SinglePassRange, class OutputIterator >
+ inline OutputIterator partial_sum ( const SinglePassRange& rng,
+ OutputIterator result )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::partial_sum( boost::begin(rng), boost::end(rng), result );
+ }
+
+ template< class SinglePassRange, class OutputIterator, class BinaryOperation >
+ inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result,
+ BinaryOperation op )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::partial_sum( boost::begin(rng), boost::end(rng), result, op );
+ }
+
+ template< class SinglePassRange, class OutputIterator >
+ inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
+ OutputIterator result )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::adjacent_difference( boost::begin(rng), boost::end(rng),
+ result );
+ }
+
+ template< class SinglePassRange, class OutputIterator, class BinaryOperation >
+ inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
+ OutputIterator result,
+ BinaryOperation op )
+ {
+ boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+ return std::adjacent_difference( boost::begin(rng), boost::end(rng),
+ result, op );
+ }
+
+}
+
+#endif
Added: sandbox/SOC/2009/unicode/boost/range/pointer.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/pointer.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/rbegin.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/rbegin.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/reference.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/reference.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/rend.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/rend.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/result_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/result_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/reverse_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/reverse_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/reverse_result_iterator.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/reverse_result_iterator.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/size.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/size.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/size_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/size_type.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/sub_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/sub_range.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/unbounded_range.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/unbounded_range.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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/SOC/2009/unicode/boost/range/value_type.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/range/value_type.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 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
Modified: sandbox/SOC/2009/unicode/boost/unicode/graphemes.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/graphemes.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/unicode/graphemes.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -15,7 +15,7 @@
namespace detail
{
- extern bool grapheme_is_break
+ BOOST_UNICODE_DECL extern bool grapheme_is_break
[boost::unicode::ucd::grapheme_cluster_break::_count]
[boost::unicode::ucd::grapheme_cluster_break::_count];
@@ -34,8 +34,6 @@
}
};
-} // unicode
-
/** Adapts the range of code points \c range into a range of ranges of code points,
* each subrange being a grapheme cluster. */
template<typename Range>
@@ -50,40 +48,36 @@
return consumed(range, make_boundary_consumer(unicode::grapheme_boundary()));
}
-/** Adapts the range of UTF-8 code units \c range into a range of ranges of UTF-8 code units,
- * each subrange being a grapheme cluster. */
-template<typename Range>
-iterator_range<
- consumer_iterator<
- typename range_iterator<const Range>::type,
- piped_consumer<
- unicode::u8_decoder,
- boundary_consumer<unicode::grapheme_boundary>
- >
- >
->
-u8_grapheme_bounded(const Range& range)
-{
- return consumed(range, make_piped_consumer(unicode::u8_decoder(), make_boundary_consumer(unicode::grapheme_boundary())));
-}
-
-/** Adapts the range of UTF-16 code units \c range into a range of ranges of UTF-16 code units,
- * each subrange being a grapheme cluster. */
-template<typename Range>
-iterator_range<
- consumer_iterator<
- typename range_iterator<const Range>::type,
- piped_consumer<
- unicode::u16_decoder,
- boundary_consumer<unicode::grapheme_boundary>
- >
- >
->
-u16_grapheme_bounded(const Range& range)
-{
- return consumed(range, make_piped_consumer(unicode::u16_decoder(), make_boundary_consumer(unicode::grapheme_boundary())));
-}
+/** INTERNAL ONLY */
+#define BOOST_UNICODE_GRAPHEME_BOUNDED_DEF(Name) \
+/** Adapts the range of X \c range into a range of ranges of X,
+ * each subrange being a grapheme cluster. */ \
+template<typename Range> \
+iterator_range< \
+ consumer_iterator< \
+ typename range_iterator<const Range>::type, \
+ piped_consumer< \
+ unicode::Name##_decoder, \
+ boundary_consumer<unicode::grapheme_boundary> \
+ > \
+ > \
+> \
+Name##_grapheme_bounded(const Range& range) \
+{ \
+ return consumed( \
+ range, \
+ make_piped_consumer( \
+ unicode::Name##_decoder(), \
+ make_boundary_consumer(unicode::grapheme_boundary()) \
+ ) \
+ ); \
+} \
+
+BOOST_UNICODE_GRAPHEME_BOUNDED_DEF(u16)
+BOOST_UNICODE_GRAPHEME_BOUNDED_DEF(u8)
+BOOST_UNICODE_GRAPHEME_BOUNDED_DEF(utf)
+} // unicode
} // boost
#endif
Added: sandbox/SOC/2009/unicode/boost/unicode/static_utf.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/unicode/static_utf.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,69 @@
+#ifndef BOOST_UNICODE_STATIC_UTF_HPP
+#define BOOST_UNICODE_STATIC_UTF_HPP
+
+#include <boost/unicode/static_utf_codecs.hpp>
+#include <boost/mpl/fold.hpp>
+
+namespace boost
+{
+namespace unicode
+{
+
+namespace detail
+{
+
+template<typename I>
+struct static_u8_encoder_type
+ : static_u8_encoder<I::value>
+{
+};
+
+template<typename S1, typename S2>
+struct concat
+ : mpl::fold<
+ S2,
+ S1,
+ mpl::push_back<
+ mpl::_1,
+ mpl::_2
+ >
+ >::type
+{
+};
+
+} // namespace detail
+
+/** Meta-function that takes an MPL sequence in UTF-32 and returns it
+ * encoded in UTF-8 as a \c boost::mpl::string */
+template<typename Sequence>
+struct static_u8_encode
+ : mpl::fold<
+ Sequence,
+ mpl::string<>,
+ detail::concat<
+ mpl::_1,
+ detail::static_u8_encoder_type<mpl::_2>
+ >
+ >::type
+{
+};
+
+/** Meta-function that takes an MPL sequence in UTF-32 and returns it
+ * encoded in UTF-16 as a \c boost::mpl::u16string */
+template<typename Sequence>
+struct static_u16_encode
+ : mpl::fold<
+ Sequence,
+ mpl::u16string<>,
+ detail::concat<
+ mpl::_1,
+ detail::static_u16_encoder_type<mpl::_2>
+ >
+ >::type
+{
+};
+
+} // namespace unicode
+} // namespace boost
+
+#endif
Added: sandbox/SOC/2009/unicode/boost/unicode/static_utf_codecs.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/unicode/static_utf_codecs.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,116 @@
+#ifndef BOOST_UNICODE_STATIC_UTF_CODECS_HPP
+#define BOOST_UNICODE_STATIC_UTF_CODECS_HPP
+
+#include <boost/cuchar.hpp>
+#include <boost/unicode/surrogates.hpp>
+
+#include <boost/mpl/string.hpp>
+#include <boost/mpl/ustring.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost
+{
+namespace unicode
+{
+
+namespace detail
+{
+
+ template<char32 I>
+ struct static_u8_encoder1
+ {
+ typedef mpl::string<
+ static_cast<unsigned char>(I)
+ > type;
+ };
+
+ template<char32 I>
+ struct static_u8_encoder2
+ {
+ typedef mpl::string<
+ static_cast<unsigned char>(0xC0u + (I >> 6)),
+ static_cast<unsigned char>(0x80u + (I & 0x3Fu))
+ > type;
+ };
+
+ template<char32 I>
+ struct static_u8_encoder3
+ {
+ typedef mpl::string<
+ static_cast<unsigned char>(0xE0u + (I >> 12)),
+ static_cast<unsigned char>(0x80u + ((I >> 6) & 0x3Fu)),
+ static_cast<unsigned char>(0x80u + (I & 0x3Fu))
+ > type;
+ };
+
+ template<char32 I>
+ struct static_u8_encoder4
+ {
+ typedef mpl::string<
+ static_cast<unsigned char>(0xF0u + (I >> 18)),
+ static_cast<unsigned char>(0x80u + ((I >> 12) & 0x3Fu)),
+ static_cast<unsigned char>(0x80u + ((I >> 6) & 0x3Fu)),
+ static_cast<unsigned char>(0x80u + (I & 0x3Fu))
+ > type;
+ };
+
+ template<char32 I>
+ struct static_u16_encoder1
+ {
+ typedef mpl::u16string<
+ static_cast<char16>(I)
+ > type;
+ };
+
+ template<char32 I>
+ struct static_u16_encoder2
+ {
+ typedef mpl::u16string<
+ static_cast<char16>((I >> 10) + high_surrogate_base),
+ static_cast<char16>((I & ten_bit_mask) + low_surrogate_base)
+ > type;
+ };
+
+} // namespace detail
+
+/** Meta-function that takes a Unicode code point and returns it encoded
+ * in UTF-8 as a \c boost::mpl::string */
+template<char32 I>
+struct static_u8_encoder
+{
+ BOOST_STATIC_ASSERT(I <= 0x10FFFFu);
+
+ typedef typename mpl::eval_if_c<
+ I < 0x80u,
+ detail::static_u8_encoder1<I>,
+ mpl::eval_if_c<
+ I < 0x800u,
+ detail::static_u8_encoder2<I>,
+ mpl::eval_if_c<
+ I < 0x10000u,
+ detail::static_u8_encoder3<I>,
+ detail::static_u8_encoder4<I>
+ >
+ >
+ >::type type;
+};
+
+/** Meta-function that takes a Unicode code point and returns it encoded
+ * in UTF-16 as a \c boost::mpl::u16string */
+template<char32 I>
+struct static_u16_encoder
+{
+ BOOST_STATIC_ASSERT(I <= 0x10FFFFu);
+
+ typedef typename mpl::eval_if_c<
+ I < 0x10000u,
+ detail::static_u16_encoder1<I>,
+ detail::static_u16_encoder2<I>
+ >::type type;
+};
+
+} // namespace unicode
+} // namespace boost
+
+#endif
Added: sandbox/SOC/2009/unicode/boost/unicode/string_cp.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/unicode/string_cp.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,55 @@
+#ifndef BOOST_UNICODE_STRING_CP_HPP
+#define BOOST_UNICODE_STRING_CP_HPP
+
+#include <boost/config.hpp>
+#include <boost/unicode/static_utf_codecs.hpp>
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bitwise.hpp>
+
+#if defined(BOOST_LITTLE_ENDIAN) && defined(__SUNPRO_CC)
+#include <boost/mpl/reverse_fold.hpp>
+#else
+#include <boost/mpl/fold.hpp>
+#endif
+
+namespace boost
+{
+namespace unicode
+{
+
+namespace detail
+{
+
+template<typename Sequence>
+struct combine_bytes
+#if defined(BOOST_LITTLE_ENDIAN) && defined(__SUNPRO_CC)
+ : mpl::reverse_fold<
+#else
+ : mpl::fold<
+#endif
+ Sequence,
+ mpl::int_<0>,
+ mpl::bitor_<
+ mpl::shift_left< mpl::_1, mpl::int_<8> >,
+ mpl::bitand_< mpl::_2, mpl::int_<0xff> >
+ >
+ >::type
+{
+};
+} // namespace detail
+
+/** Meta-function that takes a Unicode code point and returns it encoded
+ * in UTF-8 as an \c int usable as a parameter to
+ * \c boost::mpl::string.
+ * Note this only works if \c int is big enough to hold the set of
+ * encoded UTF-8 code units. */
+template<char32 I>
+struct string_cp : detail::combine_bytes<typename static_u8_encoder<I>::type>
+{
+};
+
+} // namespace unicode
+} // namespace boost
+
+#endif
Modified: sandbox/SOC/2009/unicode/boost/unicode/surrogates.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/surrogates.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/unicode/surrogates.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -8,6 +8,13 @@
namespace unicode
{
+namespace detail
+{
+ static const char16 high_surrogate_base = 0xD7C0u;
+ static const char16 low_surrogate_base = 0xDC00u;
+ static const char32 ten_bit_mask = 0x3FFu;
+}
+
inline bool is_high_surrogate(char32 v)
{
return (v & 0xFC00u) == 0xd800u;
Modified: sandbox/SOC/2009/unicode/boost/unicode/ucd/block_types.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/ucd/block_types.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/unicode/ucd/block_types.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -205,7 +205,7 @@
};
};
- const char* as_string(block::type);
+ BOOST_UNICODE_DECL const char* as_string(block::type);
}}} // namespaces
Modified: sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unichar_data.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unichar_data.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unichar_data.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -8,6 +8,8 @@
#include <boost/cuchar.hpp>
#include <boost/unicode/ucd/properties_types.hpp>
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
#define BOOST_UNICODE_ENUM_SIZE(en) (boost::static_log2<boost::unicode::ucd::en::_count>::value + 1)
//#define BOOST_UNICODE_UCD_BIG 1
@@ -80,7 +82,7 @@
};
enum { data_0x0020_0x000D_cp_offset = 5 };
};
- const char* as_string(sort_type::type);
+ BOOST_UNICODE_DECL const char* as_string(sort_type::type);
struct unichar_data_internal
{
@@ -131,13 +133,13 @@
const char* name;
};
- extern const boost::unicode::ucd::unichar_data_internal* __uni_char_data[];
- extern const boost::unicode::ucd::unichar_blocks_internal __uni_block_data[];
+ BOOST_UNICODE_DECL extern const boost::unicode::ucd::unichar_data_internal* __uni_char_data[];
+ BOOST_UNICODE_DECL extern const boost::unicode::ucd::unichar_blocks_internal __uni_block_data[];
#ifdef BOOST_UNICODE_UCD_BIG
- extern const boost::unicode::ucd::unichar_sort_data_entry __uni_sort_entry[];
+ BOOST_UNICODE_DECL extern const boost::unicode::ucd::unichar_sort_data_entry __uni_sort_entry[];
#endif
- extern const size_t __uni_block_data_size;
+ BOOST_UNICODE_DECL extern const size_t __uni_block_data_size;
inline const unichar_data_internal& get_data_internal(char32 ch)
{
@@ -152,4 +154,6 @@
} // namespace unicode
} // namespace boost
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+
#endif
Added: sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unicode_decl.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/boost/unicode/ucd/detail/unicode_decl.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,42 @@
+#ifndef BOOST_UNICODE_DECL_HPP
+#define BOOST_UNICODE_DECL_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_DECLSPEC
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_UNICODE_DYN_LINK)
+// export if this is our own source, otherwise import:
+#ifdef BOOST_UNICODE_SOURCE
+# define BOOST_UNICODE_DECL __declspec(dllexport)
+#else
+# define BOOST_UNICODE_DECL __declspec(dllimport)
+#endif // BOOST_UNICODE_SOURCE
+#endif // DYN_LINK
+#endif // BOOST_HAS_DECLSPEC
+
+#ifndef BOOST_UNICODE_DECL
+#define BOOST_UNICODE_DECL
+#endif
+
+//
+// Automatically link to the correct build variant where possible.
+//
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_UNICODE_NO_LIB) && !defined(BOOST_UNICODE_SOURCE)
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_unicode
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_UNICODE_DYN_LINK)
+# define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif // auto-linking disabled
+
+#endif // BOOST_UNICODE_DECL_HPP
Modified: sandbox/SOC/2009/unicode/boost/unicode/ucd/properties.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/ucd/properties.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/unicode/ucd/properties.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -10,6 +10,9 @@
#include <algorithm>
#include <iostream>
+/** BOOST_UNICODE_UCD_VERSION / 1000 is the major version
+ * BOOST_UNICODE_UCD_VERSION % 1000 is the minor version */
+#define BOOST_UNICODE_UCD_VERSION 5001
#define BOOST_UNICODE_UCD_VERSION_MAJOR 5
#define BOOST_UNICODE_UCD_VERSION_MINOR 1
@@ -69,7 +72,7 @@
/** Returns the block the code point designated by \c ch is in, or
* \c block::none if the code point does not lie in any block. */
-block::type get_block(char32 ch);
+BOOST_UNICODE_DECL block::type get_block(char32 ch);
/** Returns the decomposition associated with \c ch as a zero-terminated
* sequence of code points.
Modified: sandbox/SOC/2009/unicode/boost/unicode/ucd/properties_types.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/ucd/properties_types.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/unicode/ucd/properties_types.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -10,11 +10,12 @@
#ifndef BOOST_UNICODE_CHARACTER_PROPERTIES_HPP_INCLUDED
#define BOOST_UNICODE_CHARACTER_PROPERTIES_HPP_INCLUDED
+#include <boost/unicode/ucd/detail/unicode_decl.hpp>
+
namespace boost
{
namespace unicode
{
-
namespace ucd
{
/*
@@ -63,7 +64,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(category::type);
+ BOOST_UNICODE_DECL const char* as_string(category::type);
struct join_type
{
@@ -80,7 +81,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(join_type::type);
+ BOOST_UNICODE_DECL const char* as_string(join_type::type);
struct bidi_class
{
@@ -114,7 +115,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(bidi_class::type);
+ BOOST_UNICODE_DECL const char* as_string(bidi_class::type);
struct line_break
{
@@ -161,7 +162,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(line_break::type);
+ BOOST_UNICODE_DECL const char* as_string(line_break::type);
#if 0
struct break_action
@@ -178,7 +179,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(break_action::type);
+ BOOST_UNICODE_DECL const char* as_string(break_action::type);
#endif
struct decomposition_type
@@ -209,7 +210,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(decomposition_type::type);
+ BOOST_UNICODE_DECL const char* as_string(decomposition_type::type);
struct grapheme_cluster_break
@@ -233,7 +234,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(grapheme_cluster_break::type);
+ BOOST_UNICODE_DECL const char* as_string(grapheme_cluster_break::type);
struct word_break
{
@@ -257,7 +258,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(word_break::type);
+ BOOST_UNICODE_DECL const char* as_string(word_break::type);
struct sentence_break
{
@@ -283,7 +284,7 @@
_count /**< INTERNAL ONLY */
};
};
- const char* as_string(sentence_break::type);
+ BOOST_UNICODE_DECL const char* as_string(sentence_break::type);
} // namespace ucd
Modified: sandbox/SOC/2009/unicode/boost/unicode/utf.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/utf.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/unicode/utf.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -7,102 +7,106 @@
namespace boost
{
+namespace unicode
+{
/** INTERNAL ONLY */
-#define BOOST_UNICODE_ONE_MANY_PIPE_FUNC_DEF(Action) \
-/** Eagerly evaluates unicode::Action##r until the whole input range
- \c range has been treated, copying the result to \c out and
+#define BOOST_UNICODE_ENCODER_DEF(Name) \
+/** Eagerly evaluates unicode::Name##_encoder until the whole input
+ range \c range has been treated, copying the result to \c out and
returning the past-the-end output iterator */ \
template<typename Range, typename OutputIterator> \
-OutputIterator Action(const Range& range, OutputIterator out) \
+OutputIterator Name##_encode(const Range& range, OutputIterator out) \
{ \
- return pipe(range, make_one_many_pipe(unicode::Action##r()), out); \
+ return pipe( \
+ range, \
+ make_one_many_pipe(unicode::Name##_encoder()), out \
+ ); \
} \
\
-/** Lazily evalutes unicode::Action##r by returning a range adapter
+/** Lazily evalutes unicode::Name##_encoder by returning a range adapter
that wraps the range \c range and converts it step-by-step as
the range is advanced */ \
template<typename Range> \
iterator_range< \
pipe_iterator< \
typename range_iterator<const Range>::type, \
- one_many_pipe<unicode::Action##r> \
+ one_many_pipe<unicode::Name##_encoder> \
> \
> \
-Action##d(const Range& range) \
+Name##_encoded(const Range& range) \
{ \
- return piped(range, make_one_many_pipe(unicode::Action##r())); \
+ return piped(range, make_one_many_pipe(unicode::Name##_encoder()));\
} \
\
-/** Lazily evalutes unicode::Action##r by returning an output iterator
- that wraps \c out and converts every pushed element. */ \
+/** Lazily evalutes unicode::Name##_encoder by returning an output
+ iterator that wraps \c out and converts every pushed element. */ \
template<typename OutputIterator> \
pipe_output_iterator< \
OutputIterator, \
- unicode::Action##r \
-> Action##d_out(OutputIterator out) \
+ unicode::Name##_encoder \
+> Name##_encoded_out(OutputIterator out) \
{ \
- return piped_output(out, unicode::Action##r()); \
+ return piped_output(out, unicode::Name##_encoder()); \
} \
+
+/* */
+
/** INTERNAL ONLY */
-#define BOOST_UNICODE_PIPE_FUNC_DEF(Action) \
-/** Eagerly evaluates unicode::Action##r until the whole input range
- \c range has been treated, copying the result to \c out and
+#define BOOST_UNICODE_DECODER_DEF(Name) \
+/** Eagerly evaluates unicode::Name##_decoder until the whole input
+ range \c range has been treated, copying the result to \c out and
returning the past-the-end output iterator */ \
template<typename Range, typename OutputIterator> \
-OutputIterator Action(const Range& range, OutputIterator out) \
+OutputIterator Name##_decode(const Range& range, OutputIterator out) \
{ \
- return pipe(range, unicode::Action##r(), out); \
+ return pipe(range, unicode::Name##_decoder(), out); \
} \
\
-/** Lazily evalutes unicode::Action##r by returning a range adapter
+/** Lazily evalutes unicode::Name##_decoder by returning a range adapter
that wraps the range \c range and converts it step-by-step as
the range is advanced */ \
template<typename Range> \
iterator_range< \
pipe_iterator< \
typename range_iterator<const Range>::type, \
- unicode::Action##r \
+ unicode::Name##_decoder \
> \
> \
-Action##d(const Range& range) \
+Name##_decoded(const Range& range) \
{ \
- return piped(range, unicode::Action##r()); \
+ return piped(range, unicode::Name##_decoder()); \
+} \
+ \
+/** Adapts the range of X \c range into a range of ranges of X,
+ * each subrange being a decoded unit. */ \
+template<typename Range> \
+iterator_range< \
+ consumer_iterator< \
+ typename range_iterator<const Range>::type, \
+ pipe_consumer<unicode::Name##_decoder> \
+ > \
+> Name##_bounded(const Range& range) \
+{ \
+ return consumed( \
+ range, \
+ make_pipe_consumer(unicode::Name##_decoder()) \
+ ); \
} \
-BOOST_UNICODE_ONE_MANY_PIPE_FUNC_DEF(u16_encode)
-BOOST_UNICODE_PIPE_FUNC_DEF(u16_decode)
+BOOST_UNICODE_ENCODER_DEF(u16)
+BOOST_UNICODE_DECODER_DEF(u16)
-BOOST_UNICODE_ONE_MANY_PIPE_FUNC_DEF(u8_encode)
-BOOST_UNICODE_PIPE_FUNC_DEF(u8_decode)
-
-/** Adapts the range of UTF-16 code units \c range into a range of ranges of UTF-16 code units,
- * each subrange being a code point. */
-template<typename Range>
-iterator_range<
- consumer_iterator<
- typename range_iterator<const Range>::type,
- pipe_consumer<unicode::u16_decoder>
- >
-> u16_bounded(const Range& range)
-{
- return consumed(range, make_pipe_consumer(unicode::u16_decoder()));
-}
+BOOST_UNICODE_ENCODER_DEF(u8)
+BOOST_UNICODE_DECODER_DEF(u8)
-/** Adapts the range of UTF-8 code units \c range into a range of ranges of UTF-8 code units,
- * each subrange being a code point. */
-template<typename Range>
-iterator_range<
- consumer_iterator<
- typename range_iterator<const Range>::type,
- pipe_consumer<unicode::u8_decoder>
- >
-> u8_bounded(const Range& range)
-{
- return consumed(range, make_pipe_consumer(unicode::u8_decoder()));
-}
+BOOST_UNICODE_DECODER_DEF(utf)
+
+typedef cast_pipe<char> latin1_encoder;
+BOOST_UNICODE_ENCODER_DEF(latin1);
+} // namespace unicode
} // namespace boost
#endif
Modified: sandbox/SOC/2009/unicode/boost/unicode/utf_codecs.hpp
==============================================================================
--- sandbox/SOC/2009/unicode/boost/unicode/utf_codecs.hpp (original)
+++ sandbox/SOC/2009/unicode/boost/unicode/utf_codecs.hpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -12,6 +12,10 @@
#include <boost/unicode/surrogates.hpp>
+#include <boost/iterator/pipe_iterator.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/bool.hpp>
namespace boost
{
@@ -20,10 +24,6 @@
namespace detail
{
-
-static const char16 high_surrogate_base = 0xD7C0u;
-static const char16 low_surrogate_base = 0xDC00u;
-static const char32 ten_bit_mask = 0x3FFu;
inline unsigned utf8_byte_count(uint8_t c)
{
@@ -143,7 +143,7 @@
if(!unicode::is_low_surrogate(lo))
detail::invalid_code_point(lo);
- value = code_point(value, lo);
+ value = code_point((char16)value, lo);
}
// postcondition; result must not be a surrogate:
if(unicode::is_surrogate(value))
@@ -175,7 +175,7 @@
if(!unicode::is_high_surrogate(hi))
detail::invalid_code_point(hi);
- value = code_point(hi, value);
+ value = code_point(hi, (char16)value);
}
// postcondition; result must not be a surrogate:
if(unicode::is_surrogate(value))
@@ -372,7 +372,6 @@
}
};
-
/** Model of \c BoundaryChecker that tells whether a position lies on a code
* point boundary within a range of UTF-8 code units. */
struct u8_boundary
@@ -389,6 +388,154 @@
}
};
+/** Model of \c OneManyPipe that casts its input to its template
+ * parameter and writes it to its output. */
+template<typename T>
+struct cast_pipe
+{
+ typedef T output_type;
+ typedef mpl::int_<1> max_output;
+
+ template<typename U, typename Out>
+ Out operator()(U in, Out out)
+ {
+ *out++ = static_cast<output_type>(in);
+ return out;
+ }
+};
+
+namespace detail
+{
+
+template<typename T, typename Enable = void>
+struct is_u32 : mpl::false_ {};
+template<> struct is_u32<char32> : mpl::true_ {};
+template<typename T>
+struct is_u32<T, typename enable_if<
+ mpl::and_<
+ is_same<T, wchar_t>,
+ mpl::bool_<sizeof(T) == 4>
+ >
+>::type> : mpl::true_ {};
+
+template<typename T, typename Enable = void>
+struct is_u16 : mpl::false_ {};
+template<> struct is_u16<char16> : mpl::true_ {};
+template<typename T>
+struct is_u16<T, typename enable_if<
+ mpl::and_<
+ is_same<T, wchar_t>,
+ mpl::bool_<sizeof(T) == 2>
+ >
+>::type> : mpl::true_ {};
+
+template<typename T, typename Enable = void>
+struct is_u8 : mpl::false_ {};
+template<> struct is_u8<char> : mpl::true_ {};
+
+} // namespace detail
+
+/** Model of \c Pipe, either behaves like \c u16_decoder or
+ * \c u8_decoder depending on the value type of the input range. */
+struct utf_decoder
+{
+ typedef char32 output_type;
+ typedef mpl::int_<1> max_output;
+
+private:
+ template<typename Iterator, typename Enable = void>
+ struct decoder
+ {
+ };
+
+ template<typename Iterator>
+ struct decoder<Iterator, typename enable_if<
+ detail::is_u32<
+ typename std::iterator_traits<Iterator>::value_type
+ >
+ >::type>
+ {
+ typedef one_many_pipe< cast_pipe<char32> > type;
+ };
+
+
+ template<typename Iterator>
+ struct decoder<Iterator, typename enable_if<
+ detail::is_u16<
+ typename std::iterator_traits<Iterator>::value_type
+ >
+ >::type>
+ {
+ typedef u16_decoder type;
+ };
+
+ template<typename Iterator>
+ struct decoder<Iterator, typename enable_if<
+ detail::is_u8<
+ typename std::iterator_traits<Iterator>::value_type
+ >
+ >::type>
+ {
+ typedef u8_decoder type;
+ };
+
+public:
+ template<typename In, typename Out>
+ std::pair<In, Out>
+ ltr(In begin, In end, Out out)
+ {
+ return typename decoder<In>::type().ltr(begin, end, out);
+ }
+
+ template<typename In, typename Out>
+ std::pair<In, Out>
+ rtl(In begin, In end, Out out)
+ {
+ return typename decoder<In>::type().ltr(begin, end, out);
+ }
+};
+
+/** Model of \c BoundaryChecker, either behaves like \c u16_boundary or
+ * \c u8_boundary depending on the value type of the input range. */
+struct utf_boundary
+{
+ template<typename In>
+ typename enable_if<
+ detail::is_u32<
+ typename std::iterator_traits<In>::value_type
+ >,
+ bool
+ >::type
+ operator()(In, In, In)
+ {
+ return true;
+ }
+
+ template<typename In>
+ typename enable_if<
+ detail::is_u16<
+ typename std::iterator_traits<In>::value_type
+ >,
+ bool
+ >::type
+ operator()(In begin, In end, In pos)
+ {
+ return u16_boundary()(begin, end, pos);
+ }
+
+ template<typename In>
+ typename enable_if<
+ detail::is_u8<
+ typename std::iterator_traits<In>::value_type
+ >,
+ bool
+ >::type
+ operator()(In begin, In end, In pos)
+ {
+ return u8_boundary()(begin, end, pos);
+ }
+};
+
} // namespace unicode
} // namespace boost
Added: sandbox/SOC/2009/unicode/libs/unicode/build/Jamfile.v2
==============================================================================
--- (empty file)
+++ sandbox/SOC/2009/unicode/libs/unicode/build/Jamfile.v2 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -0,0 +1,23 @@
+#==============================================================================
+# Copyright (c) 2009 Mathias Gaunard
+#
+# 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)
+#==============================================================================
+
+project
+ : requirements
+ <include>../../..
+ <include>$(BOOST_ROOT)
+ ;
+
+lib boost_unicode
+ :
+ ../src/unicode_properties.cpp
+ ../src/unicode_blocks.cpp
+ ../src/unicode_graphemes.cpp
+ ../src/ucd/uni_ucd_interface_impl_data.cpp
+ :
+ <link>shared:<define>BOOST_UNICODE_DYN_LINK=1
+ ;
Modified: sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.cpp (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/data_parser/write_character_properties.cpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -447,7 +447,8 @@
file << "/**** Data in this file should not be accessed directly except ****/\n";
file << "/**** through the single published interface as documented in Boost ****/\n";
- file << "\n\n#include <boost/assert.hpp>\n";
+ file << "\n\n#define BOOST_UNICODE_SOURCE\n";
+ file << "#include <boost/assert.hpp>\n";
file << "#include <boost/static_assert.hpp>\n";
file << "#include <boost/unicode/ucd/properties.hpp>\n";
size_t n;
@@ -460,7 +461,7 @@
// ---- block table -------------------------------------------------------
- file << "const unichar_blocks_internal __uni_block_data[]=\n{\n";
+ file << "BOOST_UNICODE_DECL const unichar_blocks_internal __uni_block_data[]=\n{\n";
for (n = 0; n < tbl_block.size(); n++)
{
@@ -474,12 +475,12 @@
terminating_data.name = "";
file << terminating_data;*/
- file << "};\n\nconst size_t __uni_block_data_size = sizeof __uni_block_data / sizeof __uni_block_data[0];\n\n";
+ file << "};\n\nBOOST_UNICODE_DECL const size_t __uni_block_data_size = sizeof __uni_block_data / sizeof __uni_block_data[0];\n\n";
// ---- block table -------------------------------------------------------
// ---- block refs --------------------------------------------------------
- file << "const unichar_data_internal* __uni_char_data[]=\n{\n";
+ file << "BOOST_UNICODE_DECL const unichar_data_internal* __uni_char_data[]=\n{\n";
for (n = 0; n < tbl_block_ident.size(); n++)
{
@@ -552,7 +553,7 @@
file << "\t\t\t};\n";
file << "\t\t};\n";
- file << "\n\t\tconst char* as_string(block::type);\n\n";
+ file << "\n\t\tBOOST_UNICODE_DECL const char* as_string(block::type);\n\n";
file << "}}} // namespaces\n\n";
file << "#endif // BOOST_UNICODE_UNI_UCD_CHARACTER_PROPERTIES_HPP_INCLUDED\n";
@@ -1261,7 +1262,7 @@
// ---- sort data entry table ------------------------------------------------
- file << "\n\nextern const unichar_sort_data_entry __uni_sort_entry[]= {\n";
+ file << "\n\nBOOST_UNICODE_DECL extern const unichar_sort_data_entry __uni_sort_entry[]= {\n";
// write the dummy entry
file << "\t{ // entry means use canonical decomp";
Modified: sandbox/SOC/2009/unicode/libs/unicode/doc/concepts/OneManyPipe.xml
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/doc/concepts/OneManyPipe.xml (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/doc/concepts/OneManyPipe.xml 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -55,7 +55,7 @@
<type name="Pipe" />
</get-member-type>
<description>
- <simpara>Optional integral constant that states how many
+ <simpara>Optional MPL integral constant that states how many
elements may be added to <code>out</code> at maximum in a call to
the function object.</simpara>
</description>
Modified: sandbox/SOC/2009/unicode/libs/unicode/doc/concepts/Pipe.xml
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/doc/concepts/Pipe.xml (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/doc/concepts/Pipe.xml 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -55,7 +55,7 @@
<type name="Pipe" />
</get-member-type>
<description>
- <simpara>Optional integral constant that states how many
+ <simpara>Optional MPL integral constant that states how many
elements may be added to <code>out</code> at maximum in an <code>ltr</code>
or <code>rtl</code> call.</simpara>
</description>
Modified: sandbox/SOC/2009/unicode/libs/unicode/doc/users_manual.qbk
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/doc/users_manual.qbk (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/doc/users_manual.qbk 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -210,9 +210,9 @@
for example what is provided to convert UTF-32 to UTF-8:
* [classref boost::unicode::u8_encoder] is a model of the =OneManyPipe= concept.
-* [funcref boost::u8_encode] is an eager encoding algorithm.
-* [funcref boost::u8_encoded] returns a range adapter that does on-the-fly encoding.
-* [funcref boost::u8_encoded_out] returns an output iterator adapter that will encode its elements before forwarding them to the wrapped output iterator.
+* [funcref boost::unicode::u8_encode] is an eager encoding algorithm.
+* [funcref boost::unicode::u8_encoded] returns a range adapter that does on-the-fly encoding.
+* [funcref boost::unicode::u8_encoded_out] returns an output iterator adapter that will encode its elements before forwarding them to the wrapped output iterator.
[heading Segmentation]
@@ -234,9 +234,9 @@
* [classref boost::unicode::u8_boundary] is a =BoundaryChecker= that tells whether a position is the start of a code point in a range of UTF-8 code units.
* [classref boost::unicode::grapheme_boundary] is a =BoundaryChecker= that tells whether a position is the start of a grapheme cluster in a range of code points.
-* [funcref boost::u8_bounded] adapts its input range in UTF-8 into a range of ranges of code units, each range being a code point.
-* [funcref boost::grapheme_bounded] adapts its input range in UTF-32 into a range of ranges of code points, each range being a grapheme cluster.
-* [funcref boost::u8_grapheme_bounded] adapts its input range in UTF-8 into a range of code units, each range being a grapheme cluster.
+* [funcref boost::unicode::u8_bounded] adapts its input range in UTF-8 into a range of ranges of code units, each range being a code point.
+* [funcref boost::unicode::grapheme_bounded] adapts its input range in UTF-32 into a range of ranges of code points, each range being a grapheme cluster.
+* [funcref boost::unicode::u8_grapheme_bounded] adapts its input range in UTF-8 into a range of code units, each range being a grapheme cluster.
[heading UTF type deduction with SFINAE]
@@ -246,7 +246,7 @@
The naming scheme is as follows:
-* [funcref boost::utf_decode] either calls [funcref boost::u8_decode] or [funcref boost::u16_decode]
+* [funcref boost::unicode::utf_decode] either calls [funcref boost::unicode::u8_decode] or [funcref boost::unicode::u16_decode]
depending on the =value_type= of its input range.
* [classref boost::unicode::utf_boundary] either behaves like
[classref boost::unicode::u8_boundary] or [classref boost::unicode::u16_boundary]
@@ -315,13 +315,117 @@
[endsect]
-[section Examples]
+[section Unicode in source files]
+
+It is often quite useful to embed strings of text directly into source
+files, and C++, as of the 2003 standard, provides the following ways to
+do so: string literals, wide string literals, character and
+wide character literals, and finally type lists that form
+compile-time strings. One has to be aware, however, of the various
+portability issues associated with character encoding within source
+files.
+
+The first limitation is that of what character encoding the compiler
+expects the source files to be in, the source character set. The second
+one is what character encoding narrow and wide string literals will
+have at runtime: the execution character set, which may be different for
+narrow and wide strings.
+
+Indeed, while certain compilers remain encoding-agnostic as long as the
+source is ASCII-compatible, certain will convert the string literals
+from the source character set to their appropriate execution character
+sets.
+This is the case of MSVC which, when it detects a source file is in
+UTF-8 or UTF-16, will convert narrow string literals to ANSI and wide
+string literals to UTF-16. Furthermore, if it doesn't detect the
+character encoding of the source file, it will still convert wide string
+literals from ANSI to UTF-16 while leaving narrow ones untouched.
+
+Also, regardless of whether the compiler detects the character
+encoding of the source file or not, Unicode escape sequences,
+[^\u['xxxx]] and [^\U['xxxxxxxx]], will be translated to the execution
+character set of the literal type they're embedded in.
+Unfortunately, that makes them unusable portably within narrow strings,
+as there is no way to set the narrow execution character set to UTF-8
+with MSVC, and UTF-8 is the way Unices are going.
+
+Finally, wide characters are not well defined. In practice, they're
+either UTF-16 or UTF-32 code units, but their use is quite discouraged
+as the size of =wchar_t= is very variable: 16 bits on MS Windows,
+usually 32 bits on Unices.
+Nevertheless, in the lack of UTF-16 and UTF-32 literals that are coming
+with C++0x, wide string literals are probably the closest thing there is
+to native Unicode in the compiler. The library tools that automatically
+deduce the UTF encoding based on the size of the value
+type will therefore work as expected as they will expect =wchar_t= to
+represent either UTF-16 or UTF-32 depending on its size.
+
+Alternatively, compile-time strings may be used, which allow a great
+deal of flexibility as arbitrary character encoding conversion may
+then be performed at compile-time, but which remain more verbose to
+declare and increase compilation times.
+
+We can then infer certain guidelines to write Unicode data within
+C++ source files in a portable way while taking a few reasonable
+assumptions.
+
+[heading Portability guidelines]
+
+* Source file encoding: use UTF-8 without a Byte Order Mark or use
+ASCII. This ensures most compilers will run in an encoding-agnostic mode
+and not perform translations, plus most compilers only support
+ASCII-compatible input.
+* Narrow character literals: use ASCII only; if you use escape sequences
+such as =\x= treat the data you're inputting as UTF-8 code units. Ban
+=\u= and =\U=.
+* Narrow string literals: freely input UTF-8; if you use escape
+sequences such as =\x= treat the data you're inputting as UTF-8 code
+units. Ban =\u= and =\U=.
+* Wide character literals: use ASCII only; if you use escape sequences
+such as =\x= treat the data you're inputting as UTF-32 code units,
+but don't input anything higher than =0xD800=. Use heavily =\u= but ban
+=\U=.
+* Wide string literals: use ASCII only; if you use escape sequences
+such as =\x= treat the data you're inputting as UTF-32 code units,
+but don't input anything higher than =0xD800=. Use heavily both =\u= and
+=\U=.
+
+[heading Compile-time strings]
+
+Option one is to use =boost::mpl::string= as a UTF-8 compile-time
+string. Its support for multi-char character literals allows it to not
+be too verbose, and it can be coupled with [classref boost::unicode::string_cp]
+to insert Unicode code points in stead of the Unicode escape sequences.
+Any non-ASCII character shall be put as its own character literal. Note
+multi-char character literals require =int= to be at least 32 bits
+however.
+
+A second option is to use =boost::mpl::u32string= as a UTF-32 compile-time
+string, and use [classref boost::unicode::static_u8_encode] or
+[classref boost::unicode::static_u16_encode] to eventually encode it
+at compile-time to UTF-8 or UTF-16. =boost::mpl::u16string= may also be
+used to directly input UTF-16.
+However, none of these two sequence types provide support for easier
+declaration with multi-char character literals.
+
+Then, the =boost::mpl::c_str= meta-function may be used to convert
+any compile-time string into a zero-terminated equivalent.
+
[endsect]
[section Unicode String type]
A Unicode string type may be added in future versions that maintains
-its data in Normalized C form.
+its data in Normalized C form on top of a valid UTF encoding.
+
+[endsect]
+
+[section Examples]
+
+[section test]
+[import ../example/test.cpp]
+[file]
+[endsect]
[endsect]
Modified: sandbox/SOC/2009/unicode/libs/unicode/example/Jamfile.v2
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/example/Jamfile.v2 (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/example/Jamfile.v2 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -8,9 +8,13 @@
project
: requirements
- <include>../../..
- <include>$(BOOST_ROOT)
- <library>../src//boost-unicode
+ <include>../../..
+ <include>$(BOOST_ROOT)
+ <define>BOOST_ALL_NO_LIB=1
+ <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
+ <toolset>gcc:<cxxflags>-Wno-multichar
+ <library>../build//boost_unicode/
+ <link>shared:<define>BOOST_UNICODE_DYN_LINK=1
;
exe test : test.cpp ;
Modified: sandbox/SOC/2009/unicode/libs/unicode/example/test.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/example/test.cpp (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/example/test.cpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -1,56 +1,18 @@
+//[ file
#include <iostream>
+
#include <boost/foreach.hpp>
+#include <boost/foreach_auto.hpp>
+
+#include <boost/range/adaptors.hpp>
+#include <boost/range/algorithm.hpp>
+
#include <boost/unicode/utf.hpp>
#include <boost/unicode/ucd/properties.hpp>
#include <boost/unicode/graphemes.hpp>
-
-#include <boost/typeof/typeof.hpp>
-
-#include <algorithm>
-
#include <boost/unicode/compose.hpp>
-template<typename Range>
-std::pair<
- boost::reverse_iterator<typename boost::range_iterator<Range>::type>,
- boost::reverse_iterator<typename boost::range_iterator<Range>::type>
-> make_reverse_range(const Range& r)
-{
- return std::make_pair(
- boost::make_reverse_iterator(boost::end(r)),
- boost::make_reverse_iterator(boost::begin(r))
- );
-}
-
-template<typename Range, typename OutputIterator>
-void copy(const Range& range, OutputIterator out)
-{
- std::copy(boost::begin(range), boost::end(range), out);
-}
-
-template<typename Range>
-size_t count(const Range& range)
-{
- size_t count = 0;
- for(typename boost::range_iterator<const Range>::type it = boost::begin(range); it != boost::end(range); ++it)
- count++;
-
- return count;
-}
-
-#define FOREACH_AUTO(name, range) \
-if(boost::begin(range) != boost::end(range)) \
-if(bool _once_##__LINE__ = 1) \
-for( \
- BOOST_AUTO(name, *boost::begin(range)); \
- _once_##__LINE__; \
- _once_##__LINE__ = 0 \
-) \
-for( \
- BOOST_AUTO(_it_##__LINE__, boost::begin(range)); \
- name = *_it_##__LINE__, _it_##__LINE__ != boost::end(range); \
- ++_it_##__LINE__ \
-) \
+#include <boost/unicode/string_cp.hpp>
int main()
{
@@ -58,40 +20,40 @@
namespace ucd = boost::unicode::ucd;
using namespace boost;
- std::vector<boost::char32> v;
-
- /*v.push_back(122);
- v.push_back(27700);
- v.push_back(119070);
- v.push_back(123);*/
-
- v.push_back(1);
- v.push_back(0xE9);
- v.push_back(3);
-
-
- /*v.push_back(0x7a);
- v.push_back(0x6c34);
- v.push_back(0xd834);
- v.push_back(0xdd1e);
- v.push_back(0x7b);*/
-
-
- BOOST_FOREACH(char cp, make_reverse_range(boost::u8_encoded(v)))
- std::cout << std::hex << (int)(unsigned char)cp << std::endl;
+ std::vector<boost::char32> v;
+
+ /*v.push_back(122);
+ v.push_back(27700);
+ v.push_back(119070);
+ v.push_back(123);*/
+
+ v.push_back(1);
+ v.push_back(0xE9);
+ v.push_back(3);
+
+
+ /*v.push_back(0x7a);
+ v.push_back(0x6c34);
+ v.push_back(0xd834);
+ v.push_back(0xdd1e);
+ v.push_back(0x7b);*/
+
+
+ BOOST_FOREACH(char cp, make_reversed_range(unicode::u8_encoded(v)))
+ std::cout << std::hex << (int)(unsigned char)cp << std::endl;
std::vector<char> v2;
- copy(v, boost::u8_encoded_out(std::back_inserter(v2)));
+ copy(v, unicode::u8_encoded_out(std::back_inserter(v2)));
- BOOST_FOREACH(char cp, boost::u8_decoded(v2))
- std::cout << std::hex << (int)(unsigned char)cp << std::endl;
+ BOOST_FOREACH(char32 cp, unicode::utf_decoded(v2))
+ std::cout << std::hex << cp << std::endl;
std::cout << std::endl;
- BOOST_AUTO(range, boost::u8_bounded( boost::u8_encoded(v) ) );
- FOREACH_AUTO(code_points, range)
+ BOOST_AUTO(range, unicode::utf_bounded( unicode::u8_encoded(v) ) );
+ BOOST_FOREACH_AUTO(code_points, range)
{
- FOREACH_AUTO(cu, code_points)
+ BOOST_FOREACH_AUTO(cu, code_points)
std::cout << ' ' << std::hex << (int)(unsigned char)cu;
std::cout << ',';
@@ -100,7 +62,7 @@
std::cout << "\n";
char foo[] = "eoaéôn";
- FOREACH_AUTO(subrange, boost::u8_bounded(foo))
+ BOOST_FOREACH_AUTO(subrange, unicode::utf_bounded(foo))
{
BOOST_FOREACH(unsigned char c, subrange)
std::cout << c;
@@ -116,9 +78,9 @@
'f', 'o', 'o', '\r', '\n', 0x113, 0x301, ' ', 0x1e17
};
- BOOST_AUTO(grapheme_utf8_test, u8_encoded(grapheme_test));
+ BOOST_AUTO(grapheme_utf8_test, unicode::u8_encoded(grapheme_test));
- FOREACH_AUTO(grapheme, u8_grapheme_bounded(grapheme_utf8_test))
+ BOOST_FOREACH_AUTO(grapheme, unicode::utf_grapheme_bounded(grapheme_utf8_test))
{
std::cout << "(";
BOOST_FOREACH(unsigned char c, grapheme)
@@ -127,7 +89,7 @@
}
std::cout << std::endl << std::endl;
- for(const boost::char32* p = boost::unicode::ucd::get_decomposition(0x1e17); *p; ++p)
+ for(const boost::char32* p = ucd::get_decomposition(0x1e17); *p; ++p)
std::cout << "0x" << std::hex << *p << ' ';
std::cout << std::endl;
@@ -141,4 +103,16 @@
unicode::decomposer<static_pow<2, ucd::decomposition_type::compat>::value> decomp3;
decomp3(0xa8, std::ostream_iterator<char32>(std::cout, " "));
std::cout << std::endl;
+
+ wchar_t baz[] = L"foo\u00E9";
+ std::cout << unicode::u8_encoded(unicode::utf_decoded(baz)) << std::endl;
+
+ std::cout << mpl::c_str<
+ mpl::string<'foo ', unicode::string_cp<0xe9>::value, ' bar'>
+ >::value << std::endl;
+
+ std::cout << unicode::latin1_encoded(unicode::utf_decoded(mpl::c_str<
+ mpl::u16string<'f', 'o', 'o', ' ', 0xe9, ' ', 'b', 'a', 'r'>
+ >::value)) << std::endl;
}
+//]
Modified: sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data.cpp (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/ucd/uni_ucd_interface_impl_data.cpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -17,6 +17,7 @@
/**** through the single published interface as documented in Boost ****/
+#define BOOST_UNICODE_SOURCE
#include <boost/assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/unicode/ucd/properties.hpp>
@@ -34,7 +35,7 @@
namespace boost { namespace unicode { namespace ucd {
-const unichar_blocks_internal __uni_block_data[]=
+BOOST_UNICODE_DECL const unichar_blocks_internal __uni_block_data[]=
{
{ 0x0, 0x7f, "Basic Latin" },
{ 0x80, 0xff, "Latin-1 Supplement" },
@@ -209,9 +210,9 @@
{ 0x100000, 0x10ffff, "Supplementary Private Use Area-B" },
};
-const size_t __uni_block_data_size = sizeof __uni_block_data / sizeof __uni_block_data[0];
+BOOST_UNICODE_DECL const size_t __uni_block_data_size = sizeof __uni_block_data / sizeof __uni_block_data[0];
-const unichar_data_internal* __uni_char_data[]=
+BOOST_UNICODE_DECL const unichar_data_internal* __uni_char_data[]=
{
__uni_char_data_0,
__uni_char_data_80,
Modified: sandbox/SOC/2009/unicode/libs/unicode/src/unicode_blocks.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/unicode_blocks.cpp (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/unicode_blocks.cpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -1,3 +1,4 @@
+#define BOOST_UNICODE_SOURCE
#include <boost/unicode/ucd/properties.hpp>
#include <algorithm>
@@ -27,7 +28,7 @@
};
}
-boost::unicode::ucd::block::type boost::unicode::ucd::get_block(char32 ch)
+BOOST_UNICODE_DECL boost::unicode::ucd::block::type boost::unicode::ucd::get_block(char32 ch)
{
const unichar_blocks_internal* end = __uni_block_data + __uni_block_data_size;
@@ -46,7 +47,7 @@
return (boost::unicode::ucd::block::type)b->first;
}
-const char* boost::unicode::ucd::as_string(boost::unicode::ucd::block::type type)
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(boost::unicode::ucd::block::type type)
{
const unichar_blocks_internal* b = std::lower_bound(
__uni_block_data, __uni_block_data + __uni_block_data_size,
Modified: sandbox/SOC/2009/unicode/libs/unicode/src/unicode_graphemes.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/unicode_graphemes.cpp (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/unicode_graphemes.cpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -1,6 +1,7 @@
+#define BOOST_UNICODE_SOURCE
#include <boost/unicode/graphemes.hpp>
-bool boost::unicode::detail::grapheme_is_break
+BOOST_UNICODE_DECL bool boost::unicode::detail::grapheme_is_break
[boost::unicode::ucd::grapheme_cluster_break::_count]
[boost::unicode::ucd::grapheme_cluster_break::_count] =
{
Modified: sandbox/SOC/2009/unicode/libs/unicode/src/unicode_properties.cpp
==============================================================================
--- sandbox/SOC/2009/unicode/libs/unicode/src/unicode_properties.cpp (original)
+++ sandbox/SOC/2009/unicode/libs/unicode/src/unicode_properties.cpp 2009-07-24 22:24:18 EDT (Fri, 24 Jul 2009)
@@ -7,6 +7,7 @@
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
+#define BOOST_UNICODE_SOURCE
#include <boost/assert.hpp>
#include <boost/static_assert.hpp>
#include <boost/unicode/ucd/properties_types.hpp>
@@ -54,7 +55,7 @@
BOOST_STATIC_ASSERT(element_count(g_category) == category::_count); // check g_category matched category
-const char* boost::unicode::ucd::as_string(boost::unicode::ucd::category::type type)
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(boost::unicode::ucd::category::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::category::_count);
return g_category[type];
@@ -74,7 +75,7 @@
BOOST_STATIC_ASSERT(element_count(g_join_type) == join_type::_count); // check g_join_type matched join_type
-const char* boost::unicode::ucd::as_string(boost::unicode::ucd::join_type::type type)
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(boost::unicode::ucd::join_type::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::join_type::_count);
return g_join_type[type];
@@ -108,7 +109,7 @@
BOOST_STATIC_ASSERT(element_count(g_bidi_class) == bidi_class::_count); // check g_bidi_class matched bidi_class
-const char* boost::unicode::ucd::as_string(boost::unicode::ucd::bidi_class::type type)
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(boost::unicode::ucd::bidi_class::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::bidi_class::_count);
return g_bidi_class[type];
@@ -158,7 +159,7 @@
BOOST_STATIC_ASSERT(element_count(g_line_break) == line_break::_count); // check g_line_break matched line_break
-const char* boost::unicode::ucd::as_string(boost::unicode::ucd::line_break::type type)
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(boost::unicode::ucd::line_break::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::line_break::_count);
return g_line_break[type];
@@ -178,7 +179,7 @@
BOOST_STATIC_ASSERT(element_count(g_break_action) == break_action::_count); // check g_break_action matched break_action
-const char* boost::unicode::ucd::as_string(boost::unicode::ucd::break_action::type type)
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(boost::unicode::ucd::break_action::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::break_action::_count);
return g_break_action[type];
@@ -210,7 +211,7 @@
BOOST_STATIC_ASSERT(element_count(g_decomposition) == decomposition_type::_count); // check g_decomposition matched decomposition
-const char* boost::unicode::ucd::as_string(
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(
boost::unicode::ucd::decomposition_type::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::decomposition_type::_count);
@@ -237,7 +238,7 @@
BOOST_STATIC_ASSERT(element_count(g_grapheme_cluster_break) == grapheme_cluster_break::_count); // check g_grapheme_cluster_break matched grapheme_cluster_break
-const char* boost::unicode::ucd::as_string(
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(
boost::unicode::ucd::grapheme_cluster_break::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::grapheme_cluster_break::_count);
@@ -265,7 +266,7 @@
BOOST_STATIC_ASSERT(element_count(g_word_break) == word_break::_count); // check g_word_break matched word_break
-const char* boost::unicode::ucd::as_string(
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(
boost::unicode::ucd::word_break::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::word_break::_count);
@@ -295,7 +296,7 @@
BOOST_STATIC_ASSERT(element_count(g_sentence_break) == sentence_break::_count); // check g_sentence_break matched sentence_break
-const char* boost::unicode::ucd::as_string(
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(
boost::unicode::ucd::sentence_break::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::sentence_break::_count);
@@ -312,7 +313,7 @@
BOOST_STATIC_ASSERT(element_count(g_sort_type) == boost::unicode::ucd::sort_type::_count); // check g_sort_type matched sort_type
-const char* boost::unicode::ucd::as_string(boost::unicode::ucd::sort_type::type type)
+BOOST_UNICODE_DECL const char* boost::unicode::ucd::as_string(boost::unicode::ucd::sort_type::type type)
{
BOOST_ASSERT(type >= 0 && type < boost::unicode::ucd::sort_type::_count);
return g_sort_type[type];
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