typeof.hpp

support vector clustering for vc++

/*=============================================================================
    Copyright (c) 2006 Tobias Schwinger
    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_UTILITY_TYPEOF_HPP)
#define BOOST_SPIRIT_UTILITY_TYPEOF_HPP

#include <boost/typeof/typeof.hpp>

#include <boost/spirit/core/typeof.hpp>

#include <boost/spirit/utility/escape_char_fwd.hpp>
#include <boost/spirit/utility/confix_fwd.hpp>
#include <boost/spirit/utility/lists_fwd.hpp>
#include <boost/spirit/utility/distinct_fwd.hpp>
#include <boost/spirit/utility/grammar_def_fwd.hpp>

namespace boost { namespace spirit {

    // chset.hpp
    template<typename CharT> class chset;        

    // functor_parser.hpp
    template<typename FunctorT> struct functor_parser;

    // loops.hpp
    template<class ParserT, typename ExactT> class fixed_loop;
    template<class ParserT, typename MinT, typename MaxT> class finite_loop;
    template<class ParserT, typename MinT> class infinite_loop;

    // regex.hpp
    template<typename CharT> struct rxstrlit;

    // flush_multi_pass.hpp
    class flush_multi_pass_parser;  

    // scoped_lock.hpp
    template<class MutexT, class ParserT> struct scoped_lock_parser;

}} // namespace boost::spirit


#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()


// chset.hpp

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::chset,1)

BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::chset<char>)
BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::chset<wchar_t>)


// escape_char.hpp (has forward header)

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::escape_char_parser,(BOOST_TYPEOF_INTEGRAL(unsigned long))(typename))
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::escape_char_action,(class)(typename)(BOOST_TYPEOF_INTEGRAL(unsigned long))(typename))

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::escape_char_parser,(BOOST_TYPEOF_INTEGRAL(unsigned long)))
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::escape_char_action,(class)(typename)(BOOST_TYPEOF_INTEGRAL(unsigned long)))


// functor_parser.hpp

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::functor_parser,1)


// loops.hpp

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::fixed_loop,2)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::finite_loop,3)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::infinite_loop,2)


// regex.hpp

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::rxstrlit,1)

BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::rxstrlit<char>)
BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::rxstrlit<wchar_t>)


// confix.hpp (has forward header)

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::confix_parser, 6)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::confix_parser, 5)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::confix_parser, 4)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::confix_parser, 3)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::comment_nest_parser, 2)
BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::is_nested)
BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::non_nested)
BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::is_lexeme)
BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::non_lexeme)


// lists.hpp (has forward header)

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::list_parser,4)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::list_parser,3)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::list_parser,2)
BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::no_list_endtoken)


// distinct.hpp (has forward header)

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::distinct_parser,2)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::distinct_parser,1)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::dynamic_distinct_parser,1)
BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::distinct_parser<>)


// flush_multi_pass.hpp

BOOST_TYPEOF_REGISTER_TYPE(boost::spirit::flush_multi_pass_parser)


// scoped_lock.hpp

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::scoped_lock_parser,2)


// grammar_gen.hpp (has forward header)

BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::grammar_def,BOOST_SPIRIT_GRAMMAR_STARTRULE_TYPE_LIMIT)

#if BOOST_SPIRIT_GRAMMAR_STARTRULE_TYPE_LIMIT > 12
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::grammar_def,12)
#endif
#if BOOST_SPIRIT_GRAMMAR_STARTRULE_TYPE_LIMIT >  9
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::grammar_def, 9)
#endif
#if BOOST_SPIRIT_GRAMMAR_STARTRULE_TYPE_LIMIT >  6
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::grammar_def, 6)
#endif
#if BOOST_SPIRIT_GRAMMAR_STARTRULE_TYPE_LIMIT >  3
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::spirit::grammar_def, 3)
#endif


#endif