diff options
author | Kevin Smith <git@kismith.co.uk> | 2013-01-04 19:42:37 (GMT) |
---|---|---|
committer | Kevin Smith <git@kismith.co.uk> | 2013-04-06 13:36:54 (GMT) |
commit | 3333ab69d62d1be7ae7dd7a4e56cc4bb608d3add (patch) | |
tree | 5ee630b666ae21dd4c4202703c158383de1faf91 /3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp | |
parent | b9ef4566d31219d66a615b1eae042a01828c8b7d (diff) | |
download | swift-3333ab69d62d1be7ae7dd7a4e56cc4bb608d3add.zip swift-3333ab69d62d1be7ae7dd7a4e56cc4bb608d3add.tar.bz2 |
Add boost serialization library
We'll need it before too long
Change-Id: Ia34c7f26e1aedbc13a2fc10c980994cbcb7cb348
Diffstat (limited to '3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp')
-rw-r--r-- | 3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp | 374 |
1 files changed, 374 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp b/3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp new file mode 100644 index 0000000..b25b25f --- /dev/null +++ b/3rdParty/Boost/src/boost/spirit/home/classic/core/composite/impl/directives.ipp @@ -0,0 +1,374 @@ +/*============================================================================= + Copyright (c) 1998-2003 Joel de Guzman + Copyright (c) 2001 Daniel Nuffer + Copyright (c) 2001 Bruce Florman + Copyright (c) 2002 Raghavendra Satish + http://spirit.sourceforge.net/ + + Use, modification and distribution is subject to the 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(BOOST_SPIRIT_DIRECTIVES_IPP) +#define BOOST_SPIRIT_DIRECTIVES_IPP + +/////////////////////////////////////////////////////////////////////////////// +#include <boost/spirit/home/classic/core/scanner/skipper.hpp> + +namespace boost { namespace spirit { + +BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN + + template <typename BaseT> + struct no_skipper_iteration_policy; + + template <typename BaseT> + struct inhibit_case_iteration_policy; + + template <typename A, typename B> + struct alternative; + + template <typename A, typename B> + struct longest_alternative; + + template <typename A, typename B> + struct shortest_alternative; + + namespace impl + { + template <typename RT, typename ST, typename ScannerT, typename BaseT> + inline RT + contiguous_parser_parse( + ST const& s, + ScannerT const& scan, + skipper_iteration_policy<BaseT> const&) + { + typedef scanner_policies< + no_skipper_iteration_policy< + BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, + BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, + BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t + > policies_t; + + scan.skip(scan); + RT hit = s.parse(scan.change_policies(policies_t(scan))); + // We will not do a post skip!!! + return hit; + } + + template <typename RT, typename ST, typename ScannerT, typename BaseT> + inline RT + contiguous_parser_parse( + ST const& s, + ScannerT const& scan, + no_skipper_iteration_policy<BaseT> const&) + { + return s.parse(scan); + } + + template <typename RT, typename ST, typename ScannerT> + inline RT + contiguous_parser_parse( + ST const& s, + ScannerT const& scan, + iteration_policy const&) + { + return s.parse(scan); + } + + template < + typename RT, + typename ParserT, + typename ScannerT, + typename BaseT> + inline RT + implicit_lexeme_parse( + ParserT const& p, + ScannerT const& scan, + skipper_iteration_policy<BaseT> const&) + { + typedef scanner_policies< + no_skipper_iteration_policy< + BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, + BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, + BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t + > policies_t; + + scan.skip(scan); + RT hit = p.parse_main(scan.change_policies(policies_t(scan))); + // We will not do a post skip!!! + return hit; + } + + template < + typename RT, + typename ParserT, + typename ScannerT, + typename BaseT> + inline RT + implicit_lexeme_parse( + ParserT const& p, + ScannerT const& scan, + no_skipper_iteration_policy<BaseT> const&) + { + return p.parse_main(scan); + } + + template <typename RT, typename ParserT, typename ScannerT> + inline RT + implicit_lexeme_parse( + ParserT const& p, + ScannerT const& scan, + iteration_policy const&) + { + return p.parse_main(scan); + } + + template <typename RT, typename ST, typename ScannerT> + inline RT + inhibit_case_parser_parse( + ST const& s, + ScannerT const& scan, + iteration_policy const&) + { + typedef scanner_policies< + inhibit_case_iteration_policy< + BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>, + BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t, + BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t + > policies_t; + + return s.parse(scan.change_policies(policies_t(scan))); + } + + template <typename RT, typename ST, typename ScannerT, typename BaseT> + inline RT + inhibit_case_parser_parse( + ST const& s, + ScannerT const& scan, + inhibit_case_iteration_policy<BaseT> const&) + { + return s.parse(scan); + } + +#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + + /////////////////////////////////////////////////////////////////////// + // + // from spirit 1.1 (copyright (c) 2001 Bruce Florman) + // various workarounds to support longest and shortest directives + // + /////////////////////////////////////////////////////////////////////// + template <typename T> + struct is_alternative + { + // Determine at compile time (without partial specialization) + // whether a given type is an instance of the alternative<A,B> + + static T t(); + template <typename A, typename B> + static char test_(alternative<A, B> const&); // no implementation + static int test_(...); // no implementation + enum { r = sizeof(char) == sizeof(test_(t())) }; + typedef mpl::bool_<r> value; + }; + + template <typename T> struct select_to_longest; + + template <typename T> + struct to_longest_alternative + { + typedef typename select_to_longest<T>::result_t result_t; + typedef typename select_to_longest<T>::plain_t plain_t; + typedef typename select_to_longest<T>::choose_t choose_t; + static result_t convert(T const& a); + }; + + template <typename T> + struct to_longest_generic + { + typedef T const& result_t; + typedef T plain_t; + typedef mpl::false_ choose_t; + }; + + template <typename T> + inline T const& + to_longest_convert(T const& a, mpl::false_) + { return a; } + + template <typename T> + struct to_longest_recursive + { + typedef typename to_longest_alternative< + typename T::left_t>::plain_t a_t; + typedef typename to_longest_alternative< + typename T::right_t>::plain_t b_t; + + typedef longest_alternative<a_t, b_t> result_t; + + typedef result_t plain_t; + typedef mpl::true_ choose_t; + }; + + template <typename A, typename B> + inline typename to_longest_alternative<alternative<A, B> >::result_t + to_longest_convert(alternative<A, B> const& alt, mpl::true_) + { + typedef typename to_longest_alternative< + alternative<A, B> >::result_t result_t; + return result_t( + to_longest_alternative<A>::convert(alt.left()), + to_longest_alternative<B>::convert(alt.right())); + } + + template <typename T> + inline typename to_longest_alternative<T>::result_t + to_longest_alternative<T>::convert(T const& a) + { + return to_longest_convert( + a, to_longest_alternative<T>::choose_t()); + } + + template <typename T> + struct select_to_longest + { + typedef typename mpl::if_< + is_alternative<T> // IF + , to_longest_recursive<T> // THEN + , to_longest_generic<T> // ELSE + >::type type; + + typedef typename select_to_longest::type::result_t result_t; + typedef typename select_to_longest::type::plain_t plain_t; + typedef typename select_to_longest::type::choose_t choose_t; + }; + + template <typename T> struct select_to_shortest; + + template <typename T> + struct to_shortest_alternative + { + typedef typename select_to_shortest<T>::result_t result_t; + typedef typename select_to_shortest<T>::plain_t plain_t; + typedef typename select_to_shortest<T>::choose_t choose_t; + static result_t convert(T const& a); + }; + + template <typename T> + struct to_shortest_generic + { + typedef T const& result_t; + typedef T plain_t; + typedef mpl::false_ choose_t; + }; + + template <typename T> + inline T const& + to_shortest_convert(T const& a, mpl::false_) { return a; } + + template <typename T> + struct to_shortest_recursive + { + typedef typename to_shortest_alternative< + typename T::left_t>::plain_t a_t; + typedef typename to_shortest_alternative< + typename T::right_t>::plain_t b_t; + + typedef shortest_alternative<a_t, b_t> result_t; + + typedef result_t plain_t; + typedef mpl::true_ choose_t; + }; + + template <typename A, typename B> + inline typename to_shortest_alternative<alternative<A, B> >::result_t + to_shortest_convert(alternative<A, B> const& alt, mpl::true_) + { + typedef typename to_shortest_alternative< + alternative<A, B> >::result_t result_t; + return result_t( + to_shortest_alternative<A>::convert(alt.left()), + to_shortest_alternative<B>::convert(alt.right())); + } + + template <typename T> + inline typename to_shortest_alternative<T>::result_t + to_shortest_alternative<T>::convert(T const& a) + { + return to_shortest_convert( + a, to_shortest_alternative<T>::choose_t()); + } + + template <typename T> + struct select_to_shortest + { + typedef typename mpl::if_< + is_alternative<T> // IF + , to_shortest_recursive<T> // THEN + , to_shortest_generic<T> // ELSE + >::type type; + + typedef typename select_to_shortest::type::result_t result_t; + typedef typename select_to_shortest::type::plain_t plain_t; + typedef typename select_to_shortest::type::choose_t choose_t; + }; +#else + template <typename T> + struct to_longest_alternative + { + typedef T result_t; + static result_t const& + convert(T const& a) // Special (end) case + { return a; } + }; + + template <typename A, typename B> + struct to_longest_alternative<alternative<A, B> > + { + typedef typename to_longest_alternative<A>::result_t a_t; + typedef typename to_longest_alternative<B>::result_t b_t; + typedef longest_alternative<a_t, b_t> result_t; + + static result_t + convert(alternative<A, B> const& alt) // Recursive case + { + return result_t( + to_longest_alternative<A>::convert(alt.left()), + to_longest_alternative<B>::convert(alt.right())); + } + }; + + template <typename T> + struct to_shortest_alternative + { + typedef T result_t; + static result_t const& + convert(T const& a) // Special (end) case + { return a; } + }; + + template <typename A, typename B> + struct to_shortest_alternative<alternative<A, B> > + { + typedef typename to_shortest_alternative<A>::result_t a_t; + typedef typename to_shortest_alternative<B>::result_t b_t; + typedef shortest_alternative<a_t, b_t> result_t; + + static result_t + convert(alternative<A, B> const& alt) // Recursive case + { + return result_t( + to_shortest_alternative<A>::convert(alt.left()), + to_shortest_alternative<B>::convert(alt.right())); + } + }; +#endif + } + +BOOST_SPIRIT_CLASSIC_NAMESPACE_END + +}} // namespace boost::spirit + +#endif + |