operators.hpp File Reference

#include <exception>
#include <ios>
#include <boost/io/ios_state.hpp>
#include <boost/spirit/home/support/utree/utree.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/throw_exception.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/type_traits/is_integral.hpp>

Include dependency graph for operators.hpp:

This graph shows which files directly or indirectly include this file:

Classes
struct	boost::spirit::utree_is_equal
struct	boost::spirit::utree_is_less_than
struct	boost::spirit::utree_print
struct	boost::spirit::logical_function< Base >
struct	boost::spirit::arithmetic_function< Base >
struct	boost::spirit::integral_function< Base >

Namespaces
	boost
	Duration formatting facet for input.
	boost::spirit

Macros
#define	BOOST_SPIRIT_UTREE_CREATE_FUNCTION(name, expr, base)
#define	BOOST_SPIRIT_UTREE_CREATE_ARITHMETIC_FUNCTION(name, expr)
#define	BOOST_SPIRIT_UTREE_CREATE_INTEGRAL_FUNCTION(name, expr)
#define	BOOST_SPIRIT_UTREE_CREATE_LOGICAL_FUNCTION(name, expr)

Functions
bool	boost::spirit::operator== (utree const &a, utree const &b)
bool	boost::spirit::operator< (utree const &a, utree const &b)
bool	boost::spirit::operator!= (utree const &a, utree const &b)
bool	boost::spirit::operator> (utree const &a, utree const &b)
bool	boost::spirit::operator<= (utree const &a, utree const &b)
bool	boost::spirit::operator>= (utree const &a, utree const &b)
std::ostream &	boost::spirit::operator<< (std::ostream &out, utree const &x)
std::ostream &	boost::spirit::operator<< (std::ostream &out, utree::invalid_type const &x)
std::ostream &	boost::spirit::operator<< (std::ostream &out, utree::nil_type const &x)
utree	boost::spirit::operator&& (utree const &a, utree const &b)
utree	boost::spirit::operator|| (utree const &a, utree const &b)
utree	boost::spirit::operator! (utree const &a)
utree	boost::spirit::operator+ (utree const &a, utree const &b)
utree	boost::spirit::operator- (utree const &a, utree const &b)
utree	boost::spirit::operator* (utree const &a, utree const &b)
utree	boost::spirit::operator/ (utree const &a, utree const &b)
utree	boost::spirit::operator% (utree const &a, utree const &b)
utree	boost::spirit::operator- (utree const &a)
utree	boost::spirit::operator& (utree const &a, utree const &b)
utree	boost::spirit::operator| (utree const &a, utree const &b)
utree	boost::spirit::operator^ (utree const &a, utree const &b)
utree	boost::spirit::operator<< (utree const &a, utree const &b)
utree	boost::spirit::operator>> (utree const &a, utree const &b)
utree	boost::spirit::operator~ (utree const &a)
struct	boost::spirit::BOOST_PP_CAT (function_impl_, and_)
logical_function< BOOST_PP_CAT(function_impl_, and_)> const	boost::spirit::BOOST_PP_CAT (logical_function, BOOST_PP_CAT(_, and_))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, or_)
logical_function< BOOST_PP_CAT(function_impl_, or_)> const	boost::spirit::BOOST_PP_CAT (logical_function, BOOST_PP_CAT(_, or_))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, not_)
logical_function< BOOST_PP_CAT(function_impl_, not_)> const	boost::spirit::BOOST_PP_CAT (logical_function, BOOST_PP_CAT(_, not_))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, plus)
arithmetic_function < BOOST_PP_CAT(function_impl_, plus)> const	boost::spirit::BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, plus))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, minus)
arithmetic_function < BOOST_PP_CAT(function_impl_, minus)> const	boost::spirit::BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, minus))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, times)
arithmetic_function < BOOST_PP_CAT(function_impl_, times)> const	boost::spirit::BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, times))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, divides)
arithmetic_function < BOOST_PP_CAT(function_impl_, divides)> const	boost::spirit::BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, divides))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, modulus)
integral_function < BOOST_PP_CAT(function_impl_, modulus)> const	boost::spirit::BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, modulus))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, negate)
arithmetic_function < BOOST_PP_CAT(function_impl_, negate)> const	boost::spirit::BOOST_PP_CAT (arithmetic_function, BOOST_PP_CAT(_, negate))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, bitand_)
integral_function < BOOST_PP_CAT(function_impl_, bitand_)> const	boost::spirit::BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, bitand_))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, bitor_)
integral_function < BOOST_PP_CAT(function_impl_, bitor_)> const	boost::spirit::BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, bitor_))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, bitxor_)
integral_function < BOOST_PP_CAT(function_impl_, bitxor_)> const	boost::spirit::BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, bitxor_))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, shift_left)
integral_function < BOOST_PP_CAT(function_impl_, shift_left)> const	boost::spirit::BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, shift_left))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, shift_right)
integral_function < BOOST_PP_CAT(function_impl_, shift_right)> const	boost::spirit::BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, shift_right))
struct	boost::spirit::BOOST_PP_CAT (function_impl_, invert)
integral_function < BOOST_PP_CAT(function_impl_, invert)> const	boost::spirit::BOOST_PP_CAT (integral_function, BOOST_PP_CAT(_, invert))

Macro Definition Documentation

#define BOOST_SPIRIT_UTREE_CREATE_ARITHMETIC_FUNCTION	(		name,
			expr
	)

Value:

BOOST_SPIRIT_UTREE_CREATE_FUNCTION(name, expr, arithmetic_function)       \
    /***/

#define BOOST_SPIRIT_UTREE_CREATE_FUNCTION	(		name,
			expr,
			base
	)

Value:

struct BOOST_PP_CAT(function_impl_, name)                                 \
    {                                                                         \
        template <typename A, typename B>                                     \
        static utree eval(A const& a, B const& b)                             \
        {                                                                     \
            return utree(expr);                                               \
        }                                                                     \
        template <typename A>                                                 \
        static utree eval(A const& a)                                         \
        {                                                                     \
            static int b;                                                     \
            (void) b;                                                         \
            return utree(expr);                                               \
        }                                                                     \
    };                                                                        \
    base<BOOST_PP_CAT(function_impl_, name)> const                            \
        BOOST_PP_CAT(base, BOOST_PP_CAT(_, name)) = {};                       \
    /***/

#define BOOST_SPIRIT_UTREE_CREATE_INTEGRAL_FUNCTION	(		name,
			expr
	)

Value:

BOOST_SPIRIT_UTREE_CREATE_FUNCTION(name, expr, integral_function)         \
    /***/

#define BOOST_SPIRIT_UTREE_CREATE_LOGICAL_FUNCTION	(		name,
			expr
	)

Value:

BOOST_SPIRIT_UTREE_CREATE_FUNCTION(name, expr, logical_function)          \
    /***/