The type of objects returned when a key-based lookup fails in a transform environment. The type of an object that represents a transform environment with no key/value pairs in it. proto::key_not_found unspecified The type of the argument to this function has a user-defined implicit conversion from any type. Value const & The value to be associated with the Key. Env const & Env() Another key/value store. see-below see-below If called with an object that is implicitly convertible to type Key, this function returns the Value passed to the constructor. Otherwise, it returns the result of calling operator[] on the Env passed to the constructor. mpl::bool_<true-or-false> A Boolean metafuntion for determining whether or not a type is a Proto transform environment. is_env<T> inherits from mpl::true_ under the following conditions: If T is proto::empty_env. If T is a specialization of proto::env<>. If T is derived from any of the above. If T is a cv-qualified variant of any of the above. If T is a reference to any of the above. Otherwise, is_env<T> inherits from mpl::false_. The type of proto::data, a key for use when creating a transform environment that associates a piece of data with this type. The proto::data_type type, along with the proto::data global, are declared using the BOOST_PROTO_DEFINE_ENV_VAR() macro. env<data_type, see-below> Value & env<data_type, see-below> Value const & If Value is a specialization boost::reference_wrapper<T>, this function returns env<data_type, T &>(value.get()). Else, if the type Value is non-copyable (i.e., a function, an array, abstract, or an ostream), this function returns env<data_type, Value cv &>(value), where cv is const for the second overload, and empty for the first. Otherwise, this function returns env<data_type, Value>(value). A key used for creating a transform environment. proto::data_type const proto::callable A unary PolymorphicFunctionObject for ensuring that an object is a transform environment. If it isn't already, it is turned into one such that the object is associated with the proto::data_type key. see-below See proto::functional::as_env::operator(). Encodes the return type of proto::functional::as_env::operator(). The presence of this member template makes proto::functional::as_env a valid TR1-style function object type usable with boost::result_of<>. see-below T & see-below T const & If proto::is_env<T>::value is false, this function returns the result of (proto::data = t). See proto::data_type::operator= for details. Otherwise, this function returns t by reference. proto::callable A unary boolean PolymorphicFunctionObject used for determining whether a particular transform environment has a value associated with a particular key. see-below See proto::functional::has_env_var::operator(). Encodes the return type of proto::functional::has_env_var::operator(). The presence of this member template makes proto::functional::has_env_var a valid TR1-style function object type usable with boost::result_of<>. see-below Env const & This function behaves as follows: If proto::is_env<Env>::value is true: If e[Key()] returns an instance of proto::key_not_found, return mpl::false_. See proto::env::operator[] for more information. Otherwise, return mpl::true_. Otherwise: If Key is proto::data_type, return mpl::true_. Otherwise, return mpl::false_. proto::callable A unary PolymorphicFunctionObject used for fetching the value associated with a particular key in a transform environment. see-below See proto::functional::env_var::operator(). Encodes the return type of proto::functional::env_var::operator(). The presence of this member template makes proto::functional::env_var a valid TR1-style function object type usable with boost::result_of<>. see-below Env const & This function behaves as follows: If Key is proto::data_type: If proto::is_env<Env>::value is true, return e[proto::data]. Otherwise, return e. Otherwise, return e[Key()]. See proto::env::operator[] for additional information. boost::result_of<proto::functional::as_env(T)> Metafunction for computing the return type of proto::as_env(). boost::result_of<proto::functional::has_env_var<Key>(Env)>::type Metafunction for computing the return type of proto::has_env_var(). boost::result_of<proto::functional::env_var<Key>(Env)> Metafunction for computing the return type of proto::env_var(). typename proto::result_of::as_env<T &>::type T & typename proto::result_of::as_env<T const &>::type T const & For ensuring that the given argument is a transform environment. If it is not already, it is made one as if by (proto::data = t). See also: proto::data_type::operator= proto::functional::as_env::operator() proto::functional::as_env()(t) typename proto::result_of::has_env_var<Env &, Key>::type Env & typename proto::result_of::has_env_var<Env const &, Key>::type Env const & For testing to see whether a value exists in a transform environment corresponding to the specified Key. See also: proto::functional::has_env_var::operator() proto::functional::has_env_var<Key>()(e) typename proto::result_of::env_var<Env &, Key>::type Env & typename proto::result_of::env_var<Env const &, Key>::type Env const & For fetching the value from a transform environment corresponding to the specified Key. See also: proto::functional::env_var::operator() proto::functional::env_var<Key>()(e) proto::env<Key, Value, UNCVREF(typename proto::result_of::as_env<Env &>::type)> Env & proto::env<Key, Value> const & proto::env<Key, Value, UNCVREF(typename proto::result_of::as_env<Env const &>::type)> Env const & proto::env<Key, Value> const & For composing a larger transform environment from two smaller ones. The effect of this function is to take two transform environments and compose them into a larger environment that contains the key/values pairs of the two. The first argument is allowed to not be a transform environment, in which case it is turned into one with the proto::as_env() function before composition with the second argument. The second argument is required to be a transform environment with exactly one key/value pair. Example: Given user-defined keys key0 and key1 of types key0_type and key1_type, the following code demonstrates how the chained use of operator, can build a composite transform environment containing a number of key/value pairs: proto::env< key1_type , int , proto::env< key0_type , char const (&)[6] , proto::env<proto::data_type, int> > > myenv = (proto::data = 1, key0 = "hello", key1 = 42); // NOTE: operator, here --^ and here --^ // Check the results: assert(1 == myenv[proto::data]); assert(0 == std::strcmp(myenv[key0], "hello")); assert(42 == myenv[key1]); Note: In the return type and the "Returns" clause, UNCVREF(X) is the type X stripped of top-level reference and cv-qualifiers. Note: In the "Returns" clause, cv is replaced with const for the second overload, and nothing for the first. See also: proto::env::operator[] proto::env<Key, Value, UNCVREF(typename proto::result_of::as_env<Env cv &>::type)>(head[Key()], proto::as_env(other)) A primitive transform that returns the value associated with a particular Key in the current transform environment. proto::transform<_env_var<Key> > proto::transform_impl<Expr, State, Data> > typename proto::result_of::env_var<Data, Key>::type result_type typename impl::expr_param typename impl::state_param typename impl::data_param The current transform environment Fetches the value associated with Key from the transform environment passed in the data (third) parameter. proto::is_env<Data>::value is true. proto::env_var(data) See proto::_env_var::impl for the full details. A primitive transform that returns the current transform environment unmodified. proto::transform<_env> proto::transform_impl<Expr, State, Data> Data result_type typename impl::expr_param typename impl::state_param typename impl::data_param The current transform environment Returns the current transform environment passed in the data (third) parameter. data See proto::_env::impl for the full details. Define a type and a global variable of that type that can be used to initialize a slot in a Proto transform environment. Proto primitive transforms can optionally accept an environment in their third parameter which is a key/value store of environment variables. Use the BOOST_PROTO_DEFINE_ENV_VAR() macro to define the keys. See the description for proto::data_type for an example of the class interface created by this macro. Example: BOOST_PROTO_DEFINE_ENV_VAR(mykey_type, mykey); struct FetchMyKey : proto::when< _, proto::_env_var<mykey_type> > {}; int main() { proto::terminal<int>::type i = {42}; char const * sz = FetchMyKey()(i, 0, (mykey = "hello!")); assert(0 == std::strcmp(sz, "hello!"); }