boost/range/any_range.hpp

0001 //  Copyright Neil Groves 2010. Use, modification and
0002 //  distribution is subject to the Boost Software License, Version
0003 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
0004 //  http://www.boost.org/LICENSE_1_0.txt)
0005 //
0006 //
0007 // For more information, see http://www.boost.org/libs/range/
0008 //
0009 #ifndef BOOST_RANGE_ANY_RANGE_HPP_INCLUDED
0010 #define BOOST_RANGE_ANY_RANGE_HPP_INCLUDED
0011
0012 #include <boost/config.hpp>
0013 #include <boost/mpl/eval_if.hpp>
0014 #include <boost/mpl/identity.hpp>
0015 #include <boost/iterator/iterator_categories.hpp>
0016 #include <boost/iterator/iterator_traits.hpp>
0017 #include <boost/iterator/iterator_facade.hpp>
0018 #include <boost/iterator/iterator_adaptor.hpp>
0019 #include <boost/range/detail/any_iterator.hpp>
0020 #include <boost/range/concepts.hpp>
0021 #include <boost/range/reference.hpp>
0022 #include <boost/range/value_type.hpp>
0023 #include <boost/range/iterator_range_core.hpp>
0024
0025 namespace boost
0026 {
0027     namespace range_detail
0028     {
0029         // If T is use_default, return the result of Default, otherwise
0030         // return T.
0031         //
0032         // This is an implementation artifact used to pick intelligent default
0033         // values when the user specified boost::use_default as a template
0034         // parameter.
0035         template<
0036             class T,
0037             class Default
0038         >
0039         struct any_range_default_help
0040             : mpl::eval_if<
0041                 is_same<T, use_default>
0042               , Default
0043               , mpl::identity<T>
0044             >
0045         {
0046         };
0047
0048         template<
0049             class WrappedRange
0050           , class Value
0051           , class Reference
0052         >
0053         struct any_range_value_type
0054         {
0055 # ifdef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY
0056             typedef typename any_range_default_help<
0057                     Value
0058                   , mpl::eval_if<
0059                         is_same<Reference, use_default>
0060                       , range_value<
0061                             typename remove_const<WrappedRange>
0062                         ::type>
0063                       , remove_reference<Reference>
0064                     >
0065                 >::type type;
0066 # else
0067             typedef typename any_range_default_help<
0068                 Value
0069               , range_value<
0070                     typename remove_const<WrappedRange>
0071                 ::type>
0072             >::type type;
0073 # endif
0074         };
0075
0076         template<
0077             class Value
0078           , class Traversal
0079           , class Reference = Value&
0080           , class Difference = std::ptrdiff_t
0081           , class Buffer = use_default
0082         >
0083         class any_range
0084             : public iterator_range<
0085                         any_iterator<
0086                             Value
0087                           , Traversal
0088                           , Reference
0089                           , Difference
0090                           , typename any_range_default_help<
0091                                 Buffer
0092                               , mpl::identity<any_iterator_default_buffer>
0093                             >::type
0094                         >
0095                     >
0096         {
0097             typedef iterator_range<
0098                         any_iterator<
0099                             Value
0100                           , Traversal
0101                           , Reference
0102                           , Difference
0103                           , typename any_range_default_help<
0104                                 Buffer
0105                               , mpl::identity<any_iterator_default_buffer>
0106                             >::type
0107                         >
0108                     > base_type;
0109
0110             struct enabler {};
0111             struct disabler {};
0112         public:
0113             any_range()
0114             {
0115             }
0116
0117             any_range(const any_range& other)
0118                 : base_type(other)
0119             {
0120             }
0121
0122             template<class WrappedRange>
0123             any_range(WrappedRange& wrapped_range)
0124             : base_type(boost::begin(wrapped_range),
0125                         boost::end(wrapped_range))
0126             {
0127             }
0128
0129             template<class WrappedRange>
0130             any_range(const WrappedRange& wrapped_range)
0131             : base_type(boost::begin(wrapped_range),
0132                         boost::end(wrapped_range))
0133             {
0134             }
0135
0136             template<
0137                 class OtherValue
0138               , class OtherTraversal
0139               , class OtherReference
0140               , class OtherDifference
0141             >
0142             any_range(const any_range<
0143                                 OtherValue
0144                               , OtherTraversal
0145                               , OtherReference
0146                               , OtherDifference
0147                               , Buffer
0148                             >& other)
0149             : base_type(boost::begin(other), boost::end(other))
0150             {
0151             }
0152
0153             template<class Iterator>
0154             any_range(Iterator first, Iterator last)
0155                 : base_type(first, last)
0156             {
0157             }
0158         };
0159
0160         template<
0161             class WrappedRange
0162           , class Value = use_default
0163           , class Traversal = use_default
0164           , class Reference = use_default
0165           , class Difference = use_default
0166           , class Buffer = use_default
0167         >
0168         struct any_range_type_generator
0169         {
0170             BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<WrappedRange> ));
0171             typedef any_range<
0172                 typename any_range_value_type<
0173                     WrappedRange
0174                   , Value
0175                   , typename any_range_default_help<
0176                         Reference
0177                       , range_reference<WrappedRange>
0178                     >::type
0179                 >::type
0180               , typename any_range_default_help<
0181                             Traversal
0182                           , iterator_traversal<
0183                                 typename range_iterator<WrappedRange>::type
0184                             >
0185                         >::type
0186               , typename any_range_default_help<
0187                     Reference
0188                   , range_reference<WrappedRange>
0189                 >::type
0190               , typename any_range_default_help<
0191                     Difference
0192                   , range_difference<WrappedRange>
0193                 >::type
0194               , typename any_range_default_help<
0195                     Buffer
0196                   , mpl::identity<any_iterator_default_buffer>
0197                 >::type
0198             > type;
0199         };
0200     } // namespace range_detail
0201
0202     using range_detail::any_range;
0203     using range_detail::any_range_type_generator;
0204 } // namespace boost
0205
0206 #endif // include guard