Mercurial > hg > vamp-build-and-test
diff DEPENDENCIES/generic/include/boost/proto/domain.hpp @ 16:2665513ce2d3
Add boost headers
| author | Chris Cannam |
|---|---|
| date | Tue, 05 Aug 2014 11:11:38 +0100 |
| parents | |
| children | c530137014c0 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/DEPENDENCIES/generic/include/boost/proto/domain.hpp Tue Aug 05 11:11:38 2014 +0100 @@ -0,0 +1,337 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file domain.hpp +/// Contains definition of domain\<\> class template and helpers for +/// defining domains with a generator and a grammar for controlling +/// operator overloading. +// +// Copyright 2008 Eric Niebler. Distributed under 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) + +#ifndef BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007 +#define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007 + +#include <boost/ref.hpp> +#include <boost/type_traits/is_same.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/generate.hpp> +#include <boost/proto/detail/as_expr.hpp> +#include <boost/proto/detail/deduce_domain.hpp> + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(push) +# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined +#endif + +namespace boost { namespace proto +{ + + namespace detail + { + struct not_a_generator + {}; + + struct not_a_grammar + {}; + + struct not_a_domain + {}; + } + + namespace domainns_ + { + /// \brief For use in defining domain tags to be used + /// with \c proto::extends\<\>. A \e Domain associates + /// an expression type with a \e Generator, and optionally + /// a \e Grammar. + /// + /// The Generator determines how new expressions in the + /// domain are constructed. Typically, a generator wraps + /// all new expressions in a wrapper that imparts + /// domain-specific behaviors to expressions within its + /// domain. (See \c proto::extends\<\>.) + /// + /// The Grammar determines whether a given expression is + /// valid within the domain, and automatically disables + /// any operator overloads which would cause an invalid + /// expression to be created. By default, the Grammar + /// parameter defaults to the wildcard, \c proto::_, which + /// makes all expressions valid within the domain. + /// + /// The Super declares the domain currently being defined + /// to be a sub-domain of Super. Expressions in sub-domains + /// can be freely combined with expressions in its super- + /// domain (and <I>its</I> super-domain, etc.). + /// + /// Example: + /// \code + /// template<typename Expr> + /// struct MyExpr; + /// + /// struct MyGrammar + /// : or_< terminal<_>, plus<MyGrammar, MyGrammar> > + /// {}; + /// + /// // Define MyDomain, in which all expressions are + /// // wrapped in MyExpr<> and only expressions that + /// // conform to MyGrammar are allowed. + /// struct MyDomain + /// : domain<generator<MyExpr>, MyGrammar> + /// {}; + /// + /// // Use MyDomain to define MyExpr + /// template<typename Expr> + /// struct MyExpr + /// : extends<Expr, MyExpr<Expr>, MyDomain> + /// { + /// // ... + /// }; + /// \endcode + /// + template< + typename Generator // = default_generator + , typename Grammar // = proto::_ + , typename Super // = no_super_domain + > + struct domain + : Generator + { + typedef Generator proto_generator; + typedef Grammar proto_grammar; + typedef Super proto_super_domain; + typedef domain proto_base_domain; + + /// INTERNAL ONLY + typedef void proto_is_domain_; + + /// \brief A unary MonomorphicFunctionObject that turns objects into Proto + /// expression objects in this domain. + /// + /// The <tt>as_expr\<\></tt> function object turns objects into Proto expressions, if + /// they are not already, by making them Proto terminals held by value if + /// possible. Objects that are already Proto expressions are left alone. + /// + /// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr; + /// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T: + /// + /// If \c T is not a Proto expression type the resulting terminal is + /// calculated as follows: + /// + /// If \c T is a function type, an abstract type, or a type derived from + /// \c std::ios_base, let \c A be <tt>T &</tt>. + /// Otherwise, let \c A be the type \c T stripped of cv-qualifiers. + /// Then, the result of applying <tt>as_expr\<T\>()(t)</tt> is + /// <tt>Generator()(E\<tag::terminal, term\<A\> \>::make(t))</tt>. + /// + /// If \c T is a Proto expression type and its generator type is different from + /// \c Generator, the result is <tt>Generator()(t)</tt>. + /// + /// Otherwise, the result is \c t converted to an (un-const) rvalue. + /// + template<typename T, typename IsExpr = void, typename Callable = proto::callable> + struct as_expr + : detail::as_expr< + T + , typename detail::base_generator<Generator>::type + , wants_basic_expr<Generator>::value + > + { + BOOST_PROTO_CALLABLE() + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct as_expr<T, typename T::proto_is_expr_, proto::callable> + { + BOOST_PROTO_CALLABLE() + typedef typename remove_const<T>::type result_type; + + BOOST_FORCEINLINE + result_type operator()(T &e) const + { + return e; + } + }; + + /// \brief A unary MonomorphicFunctionObject that turns objects into Proto + /// expression objects in this domain. + /// + /// The <tt>as_child\<\></tt> function object turns objects into Proto expressions, if + /// they are not already, by making them Proto terminals held by reference. + /// Objects that are already Proto expressions are simply returned by reference. + /// + /// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr; + /// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T: + /// + /// If \c T is not a Proto expression type the resulting terminal is + /// <tt>Generator()(E\<tag::terminal, term\<T &\> \>::make(t))</tt>. + /// + /// If \c T is a Proto expression type and its generator type is different from + /// \c Generator, the result is <tt>Generator()(t)</tt>. + /// + /// Otherwise, the result is the lvalue \c t. + /// + template<typename T, typename IsExpr = void, typename Callable = proto::callable> + struct as_child + : detail::as_child< + T + , typename detail::base_generator<Generator>::type + , wants_basic_expr<Generator>::value + > + { + BOOST_PROTO_CALLABLE() + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct as_child<T, typename T::proto_is_expr_, proto::callable> + { + BOOST_PROTO_CALLABLE() + typedef T &result_type; + + BOOST_FORCEINLINE + result_type operator()(T &e) const + { + return e; + } + }; + }; + + /// \brief The domain expressions have by default, if + /// \c proto::extends\<\> has not been used to associate + /// a domain with an expression. + /// + struct default_domain + : domain<> + {}; + + /// \brief A domain to use when you prefer the use of + /// \c proto::basic_expr\<\> over \c proto::expr\<\>. + /// + struct basic_default_domain + : domain<basic_default_generator> + {}; + + /// \brief A pseudo-domain for use in functions and + /// metafunctions that require a domain parameter. It + /// indicates that the domain of the parent node should + /// be inferred from the domains of the child nodes. + /// + /// \attention \c deduce_domain is not itself a valid domain. + /// + struct deduce_domain + : domain<detail::not_a_generator, detail::not_a_grammar, detail::not_a_domain> + {}; + + /// \brief Given a domain, a tag type and an argument list, + /// compute the type of the expression to generate. This is + /// either an instance of \c proto::expr\<\> or + /// \c proto::basic_expr\<\>. + /// + template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr> + struct base_expr + { + typedef proto::expr<Tag, Args, Args::arity> type; + }; + + /// INTERNAL ONLY + /// + template<typename Domain, typename Tag, typename Args> + struct base_expr<Domain, Tag, Args, true> + { + typedef proto::basic_expr<Tag, Args, Args::arity> type; + }; + + } + + /// A metafunction that returns \c mpl::true_ + /// if the type \c T is the type of a Proto domain; + /// \c mpl::false_ otherwise. If \c T inherits from + /// \c proto::domain\<\>, \c is_domain\<T\> is + /// \c mpl::true_. + template<typename T, typename Void /* = void*/> + struct is_domain + : mpl::false_ + {}; + + /// INTERNAL ONLY + /// + template<typename T> + struct is_domain<T, typename T::proto_is_domain_> + : mpl::true_ + {}; + + /// A metafunction that returns the domain of + /// a given type. If \c T is a Proto expression + /// type, it returns that expression's associated + /// domain. If not, it returns + /// \c proto::default_domain. + template<typename T, typename Void /* = void*/> + struct domain_of + { + typedef default_domain type; + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct domain_of<T, typename T::proto_is_expr_> + { + typedef typename T::proto_domain type; + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct domain_of<T &, void> + { + typedef typename domain_of<T>::type type; + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct domain_of<boost::reference_wrapper<T>, void> + { + typedef typename domain_of<T>::type type; + }; + + /// INTERNAL ONLY + /// + template<typename T> + struct domain_of<boost::reference_wrapper<T> const, void> + { + typedef typename domain_of<T>::type type; + }; + + /// A metafunction that returns \c mpl::true_ + /// if the type \c SubDomain is a sub-domain of + /// \c SuperDomain; \c mpl::false_ otherwise. + template<typename SubDomain, typename SuperDomain> + struct is_sub_domain_of + : is_sub_domain_of<typename SubDomain::proto_super_domain, SuperDomain> + {}; + + /// INTERNAL ONLY + /// + template<typename SuperDomain> + struct is_sub_domain_of<proto::no_super_domain, SuperDomain> + : mpl::false_ + {}; + + /// INTERNAL ONLY + /// + template<typename SuperDomain> + struct is_sub_domain_of<SuperDomain, SuperDomain> + : mpl::true_ + {}; + +}} + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma warning(pop) +#endif + +#endif