Line data    Source code

       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_DIFFERENCE_IPP)
      12             : #define BOOST_SPIRIT_DIFFERENCE_IPP
      13             : 
      14             : namespace boost { namespace spirit {
      15             : 
      16             : BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
      17             : 
      18             :     ///////////////////////////////////////////////////////////////////////////
      19             :     //
      20             :     //  difference class implementation
      21             :     //
      22             :     ///////////////////////////////////////////////////////////////////////////
      23             :     template <typename A, typename B>
      24             :     inline difference<A, B>
      25           0 :     operator-(parser<A> const& a, parser<B> const& b)
      26             :     {
      27           0 :         return difference<A, B>(a.derived(), b.derived());
      28             :     }
      29             :     
      30             :     template <typename A>
      31             :     inline difference<A, chlit<char> >
      32             :     operator-(parser<A> const& a, char b)
      33             :     {
      34             :         return difference<A, chlit<char> >(a.derived(), b);
      35             :     }
      36             :     
      37             :     template <typename B>
      38             :     inline difference<chlit<char>, B>
      39             :     operator-(char a, parser<B> const& b)
      40             :     {
      41             :         return difference<chlit<char>, B>(a, b.derived());
      42             :     }
      43             :     
      44             :     template <typename A>
      45             :     inline difference<A, strlit<char const*> >
      46             :     operator-(parser<A> const& a, char const* b)
      47             :     {
      48             :         return difference<A, strlit<char const*> >(a.derived(), b);
      49             :     }
      50             :     
      51             :     template <typename B>
      52             :     inline difference<strlit<char const*>, B>
      53             :     operator-(char const* a, parser<B> const& b)
      54             :     {
      55             :         return difference<strlit<char const*>, B>(a, b.derived());
      56             :     }
      57             :     
      58             :     template <typename A>
      59             :     inline difference<A, chlit<wchar_t> >
      60             :     operator-(parser<A> const& a, wchar_t b)
      61             :     {
      62             :         return difference<A, chlit<wchar_t> >(a.derived(), b);
      63             :     }
      64             :     
      65             :     template <typename B>
      66             :     inline difference<chlit<wchar_t>, B>
      67             :     operator-(wchar_t a, parser<B> const& b)
      68             :     {
      69             :         return difference<chlit<wchar_t>, B>(a, b.derived());
      70             :     }
      71             :     
      72             :     template <typename A>
      73             :     inline difference<A, strlit<wchar_t const*> >
      74             :     operator-(parser<A> const& a, wchar_t const* b)
      75             :     {
      76             :         return difference<A, strlit<wchar_t const*> >(a.derived(), b);
      77             :     }
      78             :     
      79             :     template <typename B>
      80             :     inline difference<strlit<wchar_t const*>, B>
      81             :     operator-(wchar_t const* a, parser<B> const& b)
      82             :     {
      83             :         return difference<strlit<wchar_t const*>, B>(a, b.derived());
      84             :     }
      85             : 
      86             : BOOST_SPIRIT_CLASSIC_NAMESPACE_END
      87             : 
      88             : }} // namespace boost::spirit
      89             : 
      90             : #endif