/usr/include/boost/proto/domain.hpp is in libboost1.62-dev 1.62.0+dfsg-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 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)
# 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)
# pragma warning(pop)
#endif
#endif
|