FM / utility

/usr/include/boost/xpressive/detail/utility/

/usr/include/boost/xpressive/detail/utility

Name	Size	Mode	Actions
chset/	-	0755	rm
algorithm.hpp	4483	0644	edit dl rm
any.hpp	3163	0644	edit dl rm
boyer_moore.hpp	6480	0644	edit dl rm
cons.hpp	7982	0644	edit dl rm
counted_base.hpp	2384	0644	edit dl rm
dont_care.hpp	751	0644	edit dl rm
hash_peek_bitset.hpp	4812	0644	edit dl rm
ignore_unused.hpp	696	0644	edit dl rm
literals.hpp	2215	0644	edit dl rm
never_true.hpp	646	0644	edit dl rm
save_restore.hpp	1153	0644	edit dl rm
sequence_stack.hpp	7500	0644	edit dl rm
symbols.hpp	8736	0644	edit dl rm
tracking_ptr.hpp	13180	0644	edit dl rm
traits_utils.hpp	4399	0644	edit dl rm
width.hpp	2038	0644	edit dl rm

Edit: /usr/include/boost/xpressive/detail/utility/cons.hpp (7982B)

#ifndef BOOST_XPRESSIVE_DETAIL_UTILITY_CONS_HPP_EAN_11_19_2005
#define BOOST_XPRESSIVE_DETAIL_UTILITY_CONS_HPP_EAN_11_19_2005

#include <boost/version.hpp>

#if BOOST_VERSION >= 103300

// In Boost 1.33+, we have a cons list in Fusion, so just include it.

# if BOOST_VERSION >= 103500
#  include <boost/fusion/include/cons.hpp> // Boost 1.35+ has Fusion2
# else
#  include <boost/spirit/fusion/sequence/cons.hpp> // Fusion1
# endif

#else

// For earlier versions of Boost, put the definition of cons here
# include <boost/call_traits.hpp>
# include <boost/mpl/if.hpp>
# include <boost/mpl/eval_if.hpp>
# include <boost/mpl/identity.hpp>
# include <boost/type_traits/is_const.hpp>
# include <boost/type_traits/add_const.hpp>
# include <boost/type_traits/add_reference.hpp>
# include <boost/spirit/fusion/detail/config.hpp>
# include <boost/spirit/fusion/detail/access.hpp>
# include <boost/spirit/fusion/iterator/next.hpp>
# include <boost/spirit/fusion/iterator/equal_to.hpp>
# include <boost/spirit/fusion/iterator/as_fusion_iterator.hpp>
# include <boost/spirit/fusion/iterator/detail/iterator_base.hpp>
# include <boost/spirit/fusion/sequence/begin.hpp>
# include <boost/spirit/fusion/sequence/end.hpp>
# include <boost/spirit/fusion/sequence/as_fusion_sequence.hpp>
# include <boost/spirit/fusion/sequence/detail/sequence_base.hpp>

namespace boost { namespace fusion
{
    struct nil;

struct cons_tag;

template <typename Car, typename Cdr>
    struct cons;

struct cons_iterator_tag;

template <typename Cons>
    struct cons_iterator;

namespace cons_detail
    {
        template <typename Iterator>
        struct deref_traits_impl
        {
            typedef typename Iterator::cons_type cons_type;
            typedef typename cons_type::car_type value_type;

typedef typename mpl::eval_if<
                is_const<cons_type>
              , add_reference<typename add_const<value_type>::type>
              , add_reference<value_type> >::type
            type;

static type
            call(Iterator const& i)
            {
                return detail::ref(i.cons.car);
            }
        };

template <typename Iterator>
        struct next_traits_impl
        {
            typedef typename Iterator::cons_type cons_type;
            typedef typename cons_type::cdr_type cdr_type;

typedef cons_iterator<
                typename mpl::eval_if<
                    is_const<cons_type>
                  , add_const<cdr_type>
                  , mpl::identity<cdr_type>
                >::type>
            type;

static type
            call(Iterator const& i)
            {
                return type(detail::ref(i.cons.cdr));
            }
        };

template <typename Iterator>
        struct value_traits_impl
        {
            typedef typename Iterator::cons_type cons_type;
            typedef typename cons_type::car_type type;
        };

template <typename Cons>
        struct begin_traits_impl
        {
            typedef cons_iterator<Cons> type;

static type
            call(Cons& t)
            {
                return type(t);
            }
        };

template <typename Cons>
        struct end_traits_impl
        {
            typedef cons_iterator<
                typename mpl::if_<is_const<Cons>, nil const, nil>::type>
            type;

static type
            call(Cons& t)
            {
                FUSION_RETURN_DEFAULT_CONSTRUCTED;
            }
        };
    } // namespace cons_detail

namespace meta
    {
        template <typename Tag>
        struct deref_impl;

template <>
        struct deref_impl<cons_iterator_tag>
        {
            template <typename Iterator>
            struct apply : cons_detail::deref_traits_impl<Iterator> {};
        };

template <typename Tag>
        struct next_impl;

template <>
        struct next_impl<cons_iterator_tag>
        {
            template <typename Iterator>
            struct apply : cons_detail::next_traits_impl<Iterator> {};
        };

template <typename Tag>
        struct value_impl;

template <>
        struct value_impl<cons_iterator_tag>
        {
            template <typename Iterator>
            struct apply : cons_detail::value_traits_impl<Iterator> {};
        };

template <typename Tag>
        struct begin_impl;

template <>
        struct begin_impl<cons_tag>
        {
            template <typename Sequence>
            struct apply : cons_detail::begin_traits_impl<Sequence>
            {};
        };

template <typename Tag>
        struct end_impl;

template <>
        struct end_impl<cons_tag>
        {
            template <typename Sequence>
            struct apply : cons_detail::end_traits_impl<Sequence>
            {};
        };
    } // namespace meta

template <typename Cons = nil>
    struct cons_iterator : iterator_base<cons_iterator<Cons> >
    {
        typedef cons_iterator_tag tag;
        typedef Cons cons_type;

explicit cons_iterator(cons_type& cons_)
            : cons(cons_) {}

cons_type& cons;
    };

template <>
    struct cons_iterator<nil> : iterator_base<cons_iterator<nil> >
    {
        typedef cons_iterator_tag tag;
        typedef nil cons_type;
        cons_iterator() {}
        explicit cons_iterator(nil const&) {}
    };

template <>
    struct cons_iterator<nil const> : iterator_base<cons_iterator<nil const> >
    {
        typedef cons_iterator_tag tag;
        typedef nil const cons_type;
        cons_iterator() {}
        explicit cons_iterator(nil const&) {}
    };

struct nil : sequence_base<nil>
    {
        typedef cons_tag tag;
        typedef void_t car_type;
        typedef void_t cdr_type;
    };

template <typename Car, typename Cdr = nil>
    struct cons : sequence_base<cons<Car,Cdr> >
    {
        typedef cons_tag tag;
        typedef typename call_traits<Car>::value_type car_type;
        typedef Cdr cdr_type;

cons()
          : car(), cdr() {}

explicit cons(
            typename call_traits<Car>::param_type car_
          , typename call_traits<Cdr>::param_type cdr_ = Cdr())
          : car(car_), cdr(cdr_) {}

car_type car;
        cdr_type cdr;
    };

template <typename Car>
    inline cons<Car>
    make_cons(Car const& car)
    {
        return cons<Car>(car);
    }

template <typename Car, typename Cdr>
    inline cons<Car, Cdr>
    make_cons(Car const& car, Cdr const& cdr)
    {
        return cons<Car, Cdr>(car, cdr);
    }
}} // namespace boost::fusion

namespace boost { namespace mpl
{
    template <typename Tag>
    struct begin_impl;

template <typename Tag>
    struct end_impl;

template <>
    struct begin_impl<fusion::cons_tag>
      : fusion::meta::begin_impl<fusion::cons_tag>
    {
    };

template <>
    struct end_impl<fusion::cons_tag>
      : fusion::meta::end_impl<fusion::cons_tag>
    {
    };

}} // namespace boost::mpl

#endif

// Before Boost v1.33.1, Fusion cons lists were not valid MPL sequences.
#if BOOST_VERSION < 103301
namespace boost { namespace mpl
{
    template<typename Iterator>
    struct next;

template<typename Cons>
    struct next<fusion::cons_iterator<Cons> >
      : fusion::cons_detail::next_traits_impl<fusion::cons_iterator<Cons> >
    {
    };

template<typename Iterator>
    struct deref;

template<typename Cons>
    struct deref<fusion::cons_iterator<Cons> >
      : fusion::cons_detail::value_traits_impl<fusion::cons_iterator<Cons> >
    {
    };

}} // namespace boost::mpl
#endif

#endif

/////////////////////////////////////////////////////////////////////////////// // cons.hpp // // Copyright 2008 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) #ifndef BOOST_XPRESSIVE_DETAIL_UTILITY_CONS_HPP_EAN_11_19_2005 #define BOOST_XPRESSIVE_DETAIL_UTILITY_CONS_HPP_EAN_11_19_2005 #include #if BOOST_VERSION >= 103300 // In Boost 1.33+, we have a cons list in Fusion, so just include it. # if BOOST_VERSION >= 103500 # include // Boost 1.35+ has Fusion2 # else # include // Fusion1 # endif #else // For earlier versions of Boost, put the definition of cons here # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include namespace boost { namespace fusion { struct nil; struct cons_tag; template struct cons; struct cons_iterator_tag; template struct cons_iterator; namespace cons_detail { template struct deref_traits_impl { typedef typename Iterator::cons_type cons_type; typedef typename cons_type::car_type value_type; typedef typename mpl::eval_if< is_const , add_reference::type> , add_reference >::type type; static type call(Iterator const& i) { return detail::ref(i.cons.car); } }; template struct next_traits_impl { typedef typename Iterator::cons_type cons_type; typedef typename cons_type::cdr_type cdr_type; typedef cons_iterator< typename mpl::eval_if< is_const , add_const , mpl::identity >::type> type; static type call(Iterator const& i) { return type(detail::ref(i.cons.cdr)); } }; template struct value_traits_impl { typedef typename Iterator::cons_type cons_type; typedef typename cons_type::car_type type; }; template struct begin_traits_impl { typedef cons_iterator type; static type call(Cons& t) { return type(t); } }; template struct end_traits_impl { typedef cons_iterator< typename mpl::if_, nil const, nil>::type> type; static type call(Cons& t) { FUSION_RETURN_DEFAULT_CONSTRUCTED; } }; } // namespace cons_detail namespace meta { template struct deref_impl; template <> struct deref_impl { template struct apply : cons_detail::deref_traits_impl {}; }; template struct next_impl; template <> struct next_impl { template struct apply : cons_detail::next_traits_impl {}; }; template struct value_impl; template <> struct value_impl { template struct apply : cons_detail::value_traits_impl {}; }; template struct begin_impl; template <> struct begin_impl { template struct apply : cons_detail::begin_traits_impl {}; }; template struct end_impl; template <> struct end_impl { template struct apply : cons_detail::end_traits_impl {}; }; } // namespace meta template struct cons_iterator : iterator_base > { typedef cons_iterator_tag tag; typedef Cons cons_type; explicit cons_iterator(cons_type& cons_) : cons(cons_) {} cons_type& cons; }; template <> struct cons_iterator : iterator_base > { typedef cons_iterator_tag tag; typedef nil cons_type; cons_iterator() {} explicit cons_iterator(nil const&) {} }; template <> struct cons_iterator : iterator_base > { typedef cons_iterator_tag tag; typedef nil const cons_type; cons_iterator() {} explicit cons_iterator(nil const&) {} }; struct nil : sequence_base { typedef cons_tag tag; typedef void_t car_type; typedef void_t cdr_type; }; template struct cons : sequence_base > { typedef cons_tag tag; typedef typename call_traits::value_type car_type; typedef Cdr cdr_type; cons() : car(), cdr() {} explicit cons( typename call_traits::param_type car_ , typename call_traits::param_type cdr_ = Cdr()) : car(car_), cdr(cdr_) {} car_type car; cdr_type cdr; }; template inline cons make_cons(Car const& car) { return cons(car); } template inline cons make_cons(Car const& car, Cdr const& cdr) { return cons(car, cdr); } }} // namespace boost::fusion namespace boost { namespace mpl { template struct begin_impl; template struct end_impl; template <> struct begin_impl : fusion::meta::begin_impl { }; template <> struct end_impl : fusion::meta::end_impl { }; }} // namespace boost::mpl #endif // Before Boost v1.33.1, Fusion cons lists were not valid MPL sequences. #if BOOST_VERSION < 103301 namespace boost { namespace mpl { template struct next; template struct next > : fusion::cons_detail::next_traits_impl > { }; template struct deref; template struct deref > : fusion::cons_detail::value_traits_impl > { }; }} // namespace boost::mpl #endif #endif