ceph/src/boost/boost/spirit/home/classic/core/composite/impl/exclusive_or.ipp

   1 /*=============================================================================
   2     Copyright (c) 1998-2003 Joel de Guzman
   3     Copyright (c) 2001 Daniel Nuffer
   4     Copyright (c) 2002 Hartmut Kaiser
   5     http://spirit.sourceforge.net/
   6
   7     Use, modification and distribution is subject to the Boost Software
   8     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   9     http://www.boost.org/LICENSE_1_0.txt)
  10 =============================================================================*/
  11 #if !defined(BOOST_SPIRIT_EXCLUSIVE_OR_IPP)
  12 #define BOOST_SPIRIT_EXCLUSIVE_OR_IPP
  13
  14 namespace boost { namespace spirit {
  15
  16 BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
  17
  18     ///////////////////////////////////////////////////////////////////////////
  19     //
  20     //  exclusive_or class implementation
  21     //
  22     ///////////////////////////////////////////////////////////////////////////
  23     template <typename A, typename B>
  24     inline exclusive_or<A, B>
  25     operator^(parser<A> const& a, parser<B> const& b)
  26     {
  27         return exclusive_or<A, B>(a.derived(), b.derived());
  28     }
  29
  30     template <typename A>
  31     inline exclusive_or<A, chlit<char> >
  32     operator^(parser<A> const& a, char b)
  33     {
  34         return exclusive_or<A, chlit<char> >(a.derived(), b);
  35     }
  36
  37     template <typename B>
  38     inline exclusive_or<chlit<char>, B>
  39     operator^(char a, parser<B> const& b)
  40     {
  41         return exclusive_or<chlit<char>, B>(a, b.derived());
  42     }
  43
  44     template <typename A>
  45     inline exclusive_or<A, strlit<char const*> >
  46     operator^(parser<A> const& a, char const* b)
  47     {
  48         return exclusive_or<A, strlit<char const*> >(a.derived(), b);
  49     }
  50
  51     template <typename B>
  52     inline exclusive_or<strlit<char const*>, B>
  53     operator^(char const* a, parser<B> const& b)
  54     {
  55         return exclusive_or<strlit<char const*>, B>(a, b.derived());
  56     }
  57
  58     template <typename A>
  59     inline exclusive_or<A, chlit<wchar_t> >
  60     operator^(parser<A> const& a, wchar_t b)
  61     {
  62         return exclusive_or<A, chlit<wchar_t> >(a.derived(), b);
  63     }
  64
  65     template <typename B>
  66     inline exclusive_or<chlit<wchar_t>, B>
  67     operator^(wchar_t a, parser<B> const& b)
  68     {
  69         return exclusive_or<chlit<wchar_t>, B>(a, b.derived());
  70     }
  71
  72     template <typename A>
  73     inline exclusive_or<A, strlit<wchar_t const*> >
  74     operator^(parser<A> const& a, wchar_t const* b)
  75     {
  76         return exclusive_or<A, strlit<wchar_t const*> >(a.derived(), b);
  77     }
  78
  79     template <typename B>
  80     inline exclusive_or<strlit<wchar_t const*>, B>
  81     operator^(wchar_t const* a, parser<B> const& b)
  82     {
  83         return exclusive_or<strlit<wchar_t const*>, B>(a, b.derived());
  84     }
  85
  86 BOOST_SPIRIT_CLASSIC_NAMESPACE_END
  87
  88 }} // namespace boost::spirit
  89
  90 #endif