// Copyright (c) Reece H Dunn 2004

#ifndef BOOST_SPIRIT_TypeConstructors
#define BOOST_SPIRIT_TypeConstructors
#  include <boost/spirit/core.hpp>
#  include <boost/spirit/utility/chset.hpp>

#  include <boost/mpl/if.hpp>
#  include <boost/mpl/void.hpp>
#  include <boost/type_traits/is_same.hpp>

   namespace boost { namespace spirit
   {
      // character/string constructs

      template< typename StringT = const char * >
      struct strlit_nocase_t
      {
         typedef inhibit_case< strlit< StringT > >                   type;
      };

      template< typename CharT = char >
      struct chset_nocase_t
      {
         typedef inhibit_case< chset< CharT > >                      type;
      };

      // number constructs

      template< typename RealT = double >
      struct real_t
      {
         typedef real_parser< RealT, real_parser_policies< RealT > > type;
      };

      typedef boost::spirit::uint_parser< unsigned int, 16 >         hex_t;
      typedef boost::spirit::uint_parser< unsigned int, 8 >          oct_t;

      // alternative constructs

      template< typename T1, typename T2, typename T3 = mpl::void_, typename 
T4 = mpl::void_ >
      struct alternative_t: public boost::mpl::if_
             <
                boost::is_same< T3, mpl::void_ >,
                alternative< T1, T2 >,
                typename boost::mpl::if_
                <
                   boost::is_same< T4, mpl::void_ >,
                   alternative< alternative< T1, T2 >, T3 >,
                   alternative< alternative< alternative< T1, T2 >, T3 >, T4 
 >
                >::type
             >
      {
      };

      // alternative constructs

      template< typename T1, typename T2, typename T3 = mpl::void_, typename 
T4 = mpl::void_ >
      struct sequence_t: public boost::mpl::if_
             <
                boost::is_same< T3, mpl::void_ >,
                sequence< T1, T2 >,
                typename boost::mpl::if_
                <
                   boost::is_same< T4, mpl::void_ >,
                   sequence< sequence< T1, T2 >, T3 >,
                   sequence< sequence< sequence< T1, T2 >, T3 >, T4 >
                >::type
             >
      {
      };

      // contiguous constructs

      template< typename T1, typename T2, typename T3 = mpl::void_, typename 
T4 = mpl::void_ >
      struct contiguous_sequence_t
      {
         typedef contiguous
         <
            typename sequence_t< T1, T2, T3, T4 >::type
         > type;
      };

      template< typename T1, typename T2, typename T3 = mpl::void_, typename 
T4 = mpl::void_ >
      struct contiguous_alternative_t
      {
         typedef contiguous
         <
            typename alternative_t< T1, T2, T3, T4 >::type
         > type;
      };

      // kleene star constructs

      template< typename T1, typename T2, typename T3 = mpl::void_, typename 
T4 = mpl::void_ >
      struct kleene_sequence_t
      {
         typedef kleene_star
         <
            typename sequence_t< T1, T2, T3, T4 >::type
         > type;
      };

      template< typename T1, typename T2, typename T3 = mpl::void_, typename 
T4 = mpl::void_ >
      struct kleene_alternative_t
      {
         typedef kleene_star
         <
            typename alternative_t< T1, T2, T3, T4 >::type
         > type;
      };

      // confix constructs -- T1 >> *( CompositeT - T2 ) >> T2

      template< typename CompositeT, typename T1 = strlit<>, typename T2 = 
T1 >
      struct confix_t
      {
         typedef typename sequence_t
         <
            T1,
            kleene_star< difference< CompositeT, T2 > >,
            T2
         >::type type;
      };

      template< typename T2 = strlit< const char * >, typename T1 = strlit<> 
 >
      struct comment_t
      {
         typedef typename confix_t< anychar_parser, T1, T2 >::type   type;
      };

      typedef comment_t< chlit<> >::type                             
line_comment;
      typedef comment_t<>::type                                      
range_comment;
   }}
#endif