[Boost-commit] svn:boost r66199 - in trunk/boost/proto: . transform

Subject: [Boost-commit] svn:boost r66199 - in trunk/boost/proto: . transform
From: eric_at_[hidden]
Date: 2010-10-25 20:53:54

Author: eric_niebler
Date: 2010-10-25 20:53:39 EDT (Mon, 25 Oct 2010)
New Revision: 66199
URL: http://svn.boost.org/trac/boost/changeset/66199

Log:
s/external/external_transform/ and s/action_map/external_transforms/
Text files modified: 
   trunk/boost/proto/proto_fwd.hpp      |     2 +-                                      
   trunk/boost/proto/transform/when.hpp |    28 ++++++++++++++--------------            
   2 files changed, 15 insertions(+), 15 deletions(-)

Modified: trunk/boost/proto/proto_fwd.hpp
==============================================================================
--- trunk/boost/proto/proto_fwd.hpp	(original)
+++ trunk/boost/proto/proto_fwd.hpp	2010-10-25 20:53:39 EDT (Mon, 25 Oct 2010)
@@ -653,7 +653,7 @@
         BOOST_PROTO_CALLABLE()
     };
 
-    struct external;
+    struct external_transform;
 
     template<typename PrimitiveTransform, typename X = void>
     struct transform;

Modified: trunk/boost/proto/transform/when.hpp
==============================================================================
--- trunk/boost/proto/transform/when.hpp	(original)
+++ trunk/boost/proto/transform/when.hpp	2010-10-25 20:53:39 EDT (Mon, 25 Oct 2010)
@@ -102,19 +102,19 @@
         {};
 
         /// \brief This specialization uses the Data parameter as a collection
-        /// of actions that can be indexed by the specified rule.
+        /// of transforms that can be indexed by the specified rule.
         ///
-        /// Use <tt>when\<T, external\></tt> in your code when you would like
+        /// Use <tt>when\<T, external_transform\></tt> in your code when you would like
         /// to define a grammar once and use it to evaluate expressions with
         /// many different sets of transforms. The transforms are found by
         /// using the Data parameter as a map from rules to transforms.
         ///
         /// See \c action_map for an example.
         template<typename Grammar>
-        struct when<Grammar, external>
+        struct when<Grammar, external_transform>
         {
             typedef Grammar first;
-            typedef external second;
+            typedef external_transform second;
             typedef typename Grammar::proto_grammar proto_grammar;
 
             template<typename Expr, typename State, typename Data>
@@ -129,11 +129,11 @@
         };
 
         /// \brief For defining a map of Rule/Transform pairs for use with
-        /// <tt>when\<T, external\></tt> to make transforms external to the grammar
+        /// <tt>when\<T, external_transform\></tt> to make transforms external to the grammar
         ///
         /// The following code defines a grammar with a couple of external transforms.
         /// It also defines an action_map that maps from rules to transforms. It then
-        /// passes that action_map at the Data parameter to the grammar. In this way,
+        /// passes that transforms map at the Data parameter to the grammar. In this way,
         /// the behavior of the grammar can be modified post-hoc by passing a different
         /// action_map.
         ///
@@ -148,8 +148,8 @@
         /// 
         /// struct my_grammar
         ///   : proto::or_<
-        ///         proto::when< int_terminal, proto::external >
-        ///       , proto::when< char_terminal, proto::external >
+        ///         proto::when< int_terminal, proto::external_transform >
+        ///       , proto::when< char_terminal, proto::external_transform >
         ///       , proto::when<
         ///             proto::plus< my_grammar, my_grammar >
         ///           , proto::fold< _, int(), my_grammar >
@@ -157,8 +157,8 @@
         ///     >
         /// {};
         /// 
-        /// struct my_actions
-        ///   : proto::action_map<
+        /// struct my_transforms
+        ///   : proto::external_transforms<
         ///         proto::when<int_terminal, print(proto::_value)>
         ///       , proto::when<char_terminal, print(proto::_value)>
         ///     >
@@ -166,13 +166,13 @@
         ///
         /// proto::literal<int> i(1);
         /// proto::literal<char> c('a');
-        /// my_actions actions;
+        /// my_transforms trx;
         ///
-        /// // Evaluate "i+c" using my_grammar with the specified actions:
-        /// my_grammar()(i + c, 0, actions);
+        /// // Evaluate "i+c" using my_grammar with the specified transforms:
+        /// my_grammar()(i + c, 0, trx);
         /// \endcode
         template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_LIMIT_MAP_SIZE, typename T, mpl::na)>
-        struct action_map
+        struct external_transforms
         {
             typedef mpl::map<BOOST_PP_ENUM_PARAMS(BOOST_MPL_LIMIT_MAP_SIZE, T)> map_type;