[Boost-commit] svn:boost r59632 - sandbox/msm/boost/msm/front/euml

Subject: [Boost-commit] svn:boost r59632 - sandbox/msm/boost/msm/front/euml
From: christophe.j.henry_at_[hidden]
Date: 2010-02-11 06:12:55

Author: chenry
Date: 2010-02-11 06:12:54 EST (Thu, 11 Feb 2010)
New Revision: 59632
URL: http://svn.boost.org/trac/boost/changeset/59632

Log:
added new eUML syntax (doc not updated yet)
Text files modified: 
   sandbox/msm/boost/msm/front/euml/common.hpp        |   219 ++++++++++++++++++++++++++++++--------- 
   sandbox/msm/boost/msm/front/euml/state_grammar.hpp |    40 ++++++                                  
   2 files changed, 204 insertions(+), 55 deletions(-)

Modified: sandbox/msm/boost/msm/front/euml/common.hpp
==============================================================================
--- sandbox/msm/boost/msm/front/euml/common.hpp	(original)
+++ sandbox/msm/boost/msm/front/euml/common.hpp	2010-02-11 06:12:54 EST (Thu, 11 Feb 2010)
@@ -318,9 +318,27 @@
     }
 };
 
-struct GetSource_ : euml_action<GetSource_ >
+template <class Index=void>
+struct GetSource_ : euml_action<GetSource_<Index> >
+{
+    template <class EVT,class FSM,class SourceState,class TargetState>
+    struct transition_action_result 
+    {
+        typedef typename ::boost::fusion::result_of::at_key<typename SourceState::attributes_type,
+                                                        Index >::type type;
+    };
+    typedef ::boost::mpl::set<action_tag> tag_type;
+
+	template <class EVT,class FSM,class SourceState,class TargetState>
+	typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
+		operator()(EVT const& ,FSM& ,SourceState& src,TargetState&)const
+	{
+        return src.get_attribute(Index());
+	}
+};
+template<>
+struct GetSource_<void> : euml_action<GetSource_<void> >
 {
-    using euml_action<GetSource_ >::operator=;
         template <class EVT,class FSM,class SourceState,class TargetState>
         struct transition_action_result 
         {
@@ -345,14 +363,32 @@
 >
     struct In
     {
-        typedef GetSource_ type;
+        typedef GetSource_<Arg1> type;
     };
 };
 GetSource_Helper const source_;
 
-struct GetTarget_ : euml_action<GetTarget_ >
+template <class Index=void>
+struct GetTarget_ : euml_action<GetTarget_<Index> >
+{
+    template <class EVT,class FSM,class SourceState,class TargetState>
+    struct transition_action_result 
+    {
+        typedef typename ::boost::fusion::result_of::at_key<typename TargetState::attributes_type,
+                                                        Index >::type type;
+    };
+    typedef ::boost::mpl::set<action_tag> tag_type;
+
+	template <class EVT,class FSM,class SourceState,class TargetState>
+	typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
+		operator()(EVT const& ,FSM& ,SourceState& ,TargetState& tgt)const
+	{
+        return tgt.get_attribute(Index());
+	}
+};
+template<>
+struct GetTarget_<void> : euml_action<GetTarget_<void> >
 {
-    using euml_action<GetTarget_ >::operator=;
         template <class EVT,class FSM,class SourceState,class TargetState>
         struct transition_action_result 
         {
@@ -377,12 +413,31 @@
 >
     struct In
     {
-        typedef GetTarget_ type;
+        typedef GetTarget_<Arg1> type;
     };
 };
 GetTarget_Helper const target_;
 
-struct GetState_ : euml_action<GetState_ >
+template <class Index=void>
+struct GetState_ : euml_action<GetState_<Index> >
+{
+    template <class Event,class FSM,class STATE >
+    struct state_action_result 
+    {
+        typedef typename ::boost::fusion::result_of::at_key<typename STATE::attributes_type,
+                                                        Index >::type type;
+    };
+    typedef ::boost::mpl::set<state_action_tag> tag_type;
+
+    template <class Event,class FSM,class STATE>
+    typename state_action_result<Event,FSM,STATE>::type
+        operator()(Event const&,FSM& ,STATE& state )
+	{
+        return state.get_attribute(Index());
+	}
+};
+template<>
+struct GetState_<void> : euml_action<GetState_<void> >
 {
     using euml_action<GetState_ >::operator=;
 
@@ -410,15 +465,46 @@
 >
     struct In
     {
-        typedef GetState_ type;
+        typedef GetState_<Arg1> type;
     };
 };
 GetState_Helper const state_;
 
-struct GetEvent_ : euml_action<GetEvent_ >
+template <class Index=void>
+struct GetEvent_ : euml_action<GetEvent_<Index> >
 {
-    using euml_action<GetEvent_ >::operator=;
+    template <class Event,class FSM,class STATE >
+    struct state_action_result 
+    {
+        typedef typename ::boost::add_const<
+            typename ::boost::fusion::result_of::at_key<typename Event::attributes_type,
+                                                        Index >::type>::type type;
+    };
+    template <class EVT,class FSM,class SourceState,class TargetState>
+    struct transition_action_result 
+    {
+        typedef typename ::boost::add_const<
+            typename ::boost::fusion::result_of::at_key<typename EVT::attributes_type,
+                                                        Index >::type>::type type;
+    };
+    typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
+	template <class Event,class FSM,class STATE>
+	typename state_action_result<Event,FSM,STATE>::type
+		operator()(Event const& evt,FSM& ,STATE& )
+	{
+		return evt.get_attribute(Index());
+	}
+	template <class EVT,class FSM,class SourceState,class TargetState>
+	typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
+		operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const
+	{
+        return evt.get_attribute(Index());
+	}
+};
+template <>
+struct GetEvent_<void> : euml_action<GetEvent_<void> >
+{
         template <class Event,class FSM,class STATE >
         struct state_action_result 
         {
@@ -454,12 +540,43 @@
 >
     struct In
     {
-        typedef GetEvent_ type;
+        typedef GetEvent_<Arg1> type;
     };
 };
 GetEvent_Helper const event_;
 
-struct GetFsm_ : euml_action<GetFsm_>
+template <class Index=void>
+struct GetFsm_ : euml_action<GetFsm_<Index> >
+{
+    template <class Event,class FSM,class STATE >
+    struct state_action_result 
+    {
+        typedef typename ::boost::fusion::result_of::at_key<typename FSM::attributes_type,
+                                                        Index >::type type;
+    };
+    template <class EVT,class FSM,class SourceState,class TargetState>
+    struct transition_action_result 
+    {
+        typedef typename ::boost::fusion::result_of::at_key<typename FSM::attributes_type,
+                                                        Index >::type type;
+    };
+    typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
+
+    template <class Event,class FSM,class STATE>
+    typename state_action_result<Event,FSM,STATE>::type
+        operator()(Event const&,FSM& fsm,STATE& )
+    {
+        return fsm.get_attribute(Index());
+    }
+	template <class EVT,class FSM,class SourceState,class TargetState>
+	typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
+		operator()(EVT const& ,FSM& fsm,SourceState& ,TargetState&)const
+	{
+        return fsm.get_attribute(Index());
+	}
+};
+template<>
+struct GetFsm_<void> : euml_action<GetFsm_<void> >
 {
     using euml_action<GetFsm_>::operator=;
 
@@ -498,7 +615,7 @@
 >
     struct In
     {
-        typedef GetFsm_ type;
+        typedef GetFsm_<Arg1> type;
     };
 };
 GetFsm_Helper const fsm_;
@@ -583,21 +700,21 @@
     struct state_action_result 
     {
                 typedef typename 
-            ::boost::fusion::result_of::at<
+            ::boost::fusion::result_of::at_key<
             typename get_attributes_type<
-            typename ::boost::remove_reference<
-                        typename get_result_type2<Target,Event,FSM,STATE>::type>::type>::type,
-                typename Index::value_type >::type type;
+                    typename ::boost::remove_reference<
+                                typename get_result_type2<Target,Event,FSM,STATE>::type>::type>::type,
+                    Index >::type type;
     };
     template <class EVT,class FSM,class SourceState,class TargetState>
     struct transition_action_result 
     {
                 typedef typename 
-            ::boost::fusion::result_of::at<
+            ::boost::fusion::result_of::at_key<
             typename get_attributes_type<
                     typename ::boost::remove_reference<
                         typename get_result_type<Target,EVT,FSM,SourceState,TargetState>::type>::type>::type,
-                typename Index::value_type >::type type;
+                    Index >::type type;
     };
 
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
@@ -609,7 +726,7 @@
                         typename transition_action_result<EVT,FSM,SourceState,TargetState>::type >::type 
      operator()(EVT const& evt, FSM& fsm,SourceState& src,TargetState& tgt)const
     {
-        return (Target()(evt,fsm,src,tgt)).template get_attribute<Index::value_type::value>();
+        return (Target()(evt,fsm,src,tgt)).get_attribute(Index());
     }
     template <class Event,class FSM,class STATE>
         typename ::boost::enable_if<
@@ -618,7 +735,7 @@
                         typename state_action_result<Event,FSM,STATE>::type >::type 
      operator()(Event const& evt,FSM& fsm,STATE& state )const
     {
-        return (Target()(evt,fsm,state)).template get_attribute<Index::value_type::value>();
+        return (Target()(evt,fsm,state)).get_attribute(Index());
     }
 };
 
@@ -639,7 +756,7 @@
 };
 GetAttribute_Helper const attribute_;
 
-template <int Index>
+template <class Index>
 struct Source_ : euml_action<Source_<Index> >
 {
     using euml_action<Source_<Index> >::operator=;
@@ -647,8 +764,8 @@
         struct transition_action_result 
         {
                 typedef typename 
-			::boost::fusion::result_of::at<typename SourceState::attributes_type,
-			::boost::mpl::int_<Index> >::type type;
+			::boost::fusion::result_of::at_key<typename SourceState::attributes_type,
+			                                   Index >::type type;
         };
         typedef ::boost::mpl::set<action_tag> tag_type;
 
@@ -656,10 +773,10 @@
         typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
                 operator()(EVT const& , FSM&,SourceState& src,TargetState& )const
         {
-        return src.template get_attribute<Index>();
+        return src.get_attribute(Index());
         }
 };
-template <int Index>
+template <class Index>
 struct Target_ : euml_action<Target_<Index> >
 {
     using euml_action<Target_<Index> >::operator=;
@@ -667,8 +784,8 @@
         struct transition_action_result 
         {
                 typedef typename 
-			::boost::fusion::result_of::at<typename TargetState::attributes_type,
-			::boost::mpl::int_<Index> >::type type;
+			::boost::fusion::result_of::at_key<typename TargetState::attributes_type,
+			                                   Index >::type type;
         };
         typedef ::boost::mpl::set<action_tag> tag_type;
 
@@ -676,10 +793,10 @@
         typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
                 operator()(EVT const& ,FSM& ,SourceState& ,TargetState& tgt)const
         {
-        return tgt.template get_attribute<Index>();
+        return tgt.get_attribute(Index());
         }
 };
-template <int Index>
+template <class Index>
 struct State_ : euml_action<State_<Index> >
 {
     using euml_action<State_<Index> >::operator=;
@@ -688,8 +805,8 @@
         struct state_action_result 
         {
                 typedef typename 
-			::boost::fusion::result_of::at<typename STATE::attributes_type,
-			::boost::mpl::int_<Index> >::type type;
+			::boost::fusion::result_of::at_key<typename STATE::attributes_type,
+			                                   Index >::type type;
         };
         typedef ::boost::mpl::set<state_action_tag> tag_type;
 
@@ -697,10 +814,10 @@
         typename state_action_result<Event,FSM,STATE>::type
                 operator()(Event const&,FSM& ,STATE& state )
         {
-        return state.template get_attribute<Index>();
+        return state.get_attribute(Index());
         }
 };
-template <int Index>
+template <class Index>
 struct Event_ : euml_action<Event_<Index> >
 {
     using euml_action<Event_<Index> >::operator=;
@@ -709,15 +826,15 @@
         struct state_action_result 
         {
                 typedef typename ::boost::add_const<
-			typename ::boost::fusion::result_of::at<typename Event::attributes_type,
-                                                    ::boost::mpl::int_<Index> >::type>::type type;
+			typename ::boost::fusion::result_of::at_key<typename Event::attributes_type,
+                                                        Index >::type>::type type;
         };
         template <class EVT,class FSM,class SourceState,class TargetState>
         struct transition_action_result 
         {
                 typedef typename ::boost::add_const<
-            typename ::boost::fusion::result_of::at<typename EVT::attributes_type,
-                                                    ::boost::mpl::int_<Index> >::type>::type type;
+            typename ::boost::fusion::result_of::at_key<typename EVT::attributes_type,
+                                                        Index >::type>::type type;
         };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
@@ -725,16 +842,16 @@
         typename state_action_result<Event,FSM,STATE>::type
                 operator()(Event const& evt,FSM& ,STATE& )
         {
-		return evt.template get_attribute<Index>();
+		return evt.get_attribute(Index());
         }
         template <class EVT,class FSM,class SourceState,class TargetState>
         typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
                 operator()(EVT const& evt ,FSM& ,SourceState& ,TargetState&)const
         {
-		return evt.template get_attribute<Index>();
+		return evt.get_attribute(Index());
         }
 };
-template <class StateType,int Index>
+template <class StateType,class Index>
 struct State_Attribute_ : euml_action<State_Attribute_<StateType,Index> >
 {
     using euml_action<State_Attribute_<StateType,Index> >::operator=;
@@ -743,8 +860,8 @@
         struct state_action_result 
         {
                 typedef typename 
-			::boost::fusion::result_of::at<typename StateType::attributes_type,
-			::boost::mpl::int_<Index> >::type type;
+			::boost::fusion::result_of::at_key<typename StateType::attributes_type,
+			                                   Index >::type type;
         };
     typedef ::boost::mpl::set<state_action_tag> tag_type;
 
@@ -752,11 +869,11 @@
         typename state_action_result<Event,FSM,STATE>::type
                 operator()(Event const&,FSM& fsm,STATE& )
         {
-        return fsm.template get_state<StateType&>().template get_attribute<Index>();
+        return fsm.template get_state<StateType&>().get_attribute(Index());
         }
 };
 
-template <int Index>
+template <class Index>
 struct Fsm_ : euml_action<Fsm_<Index> >
 {
     using euml_action<Fsm_<Index> >::operator=;
@@ -765,15 +882,15 @@
     struct state_action_result 
     {
         typedef typename 
-            ::boost::fusion::result_of::at<typename FSM::attributes_type,
-            ::boost::mpl::int_<Index> >::type type;
+            ::boost::fusion::result_of::at_key<typename FSM::attributes_type,
+                                               Index >::type type;
     };
     template <class EVT,class FSM,class SourceState,class TargetState>
     struct transition_action_result 
     {
         typedef typename 
-            ::boost::fusion::result_of::at<typename FSM::attributes_type,
-            ::boost::mpl::int_<Index> >::type type;
+            ::boost::fusion::result_of::at_key<typename FSM::attributes_type,
+                                               Index >::type type;
     };
     typedef ::boost::mpl::set<state_action_tag,action_tag> tag_type;
 
@@ -781,13 +898,13 @@
     typename state_action_result<Event,FSM,STATE>::type
         operator()(Event const&,FSM& fsm,STATE& )
     {
-        return fsm.template get_attribute<Index>();;
+        return fsm.get_attribute(Index());
     }
     template <class EVT,class FSM,class SourceState,class TargetState>
     typename transition_action_result<EVT,FSM,SourceState,TargetState>::type 
         operator()(EVT const& evt ,FSM& fsm,SourceState& ,TargetState&)const
     {
-        return fsm.template get_attribute<Index>();
+        return fsm.get_attribute(Index());
     }
 };
 

Modified: sandbox/msm/boost/msm/front/euml/state_grammar.hpp
==============================================================================
--- sandbox/msm/boost/msm/front/euml/state_grammar.hpp	(original)
+++ sandbox/msm/boost/msm/front/euml/state_grammar.hpp	2010-02-11 06:12:54 EST (Thu, 11 Feb 2010)
@@ -13,6 +13,9 @@
 
 #include <boost/msm/front/euml/common.hpp>
 #include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/include/pair.hpp>
+#include <boost/fusion/include/as_map.hpp>
+
 #include <boost/mpl/remove_if.hpp>
 #include <boost/mpl/eval_if.hpp>
 
@@ -489,19 +492,43 @@
 {};
 
 // attributes building
+#define BOOST_MSM_EUML_DECLARE_ATTRIBUTE(attr_type,attr_name)                                           \
+struct attr_name ## _                                                                                   \
+    : proto::extends< proto::terminal<msm::front::action_tag>::type, attr_name ## _, sm_domain>         \
+    {                                                                                                   \
+        typedef ::boost::fusion::pair<attr_name ## _,attr_type> attribute_type;                         \
+    };                                                                                                  \
+attr_name ## _ const attr_name;
+
 struct make_attributes_tag
 {
     typedef int attribute_tag;
 };
 
+template <class T>
+struct get_attribute_type
+{
+    typedef typename T::attribute_type type;
+};
+template <class Seq>
+struct transform_to_fusion_pair 
+{
+    typedef typename ::boost::mpl::fold<
+        Seq,::boost::mpl::vector<>,
+        ::boost::mpl::push_back< ::boost::mpl::placeholders::_1, 
+                                 get_attribute_type< ::boost::mpl::placeholders::_2> >
+        >::type type;
+};
+
 template<class X = proto::is_proto_expr>
 struct attribute
 {
    BOOST_PROTO_BASIC_EXTENDS(
        proto::terminal<make_attributes_tag>::type
      , attribute
-     , proto::default_domain
+     , sm_domain
    )
+   typedef ::boost::fusion::pair<int,int> attribute_type;
 };
 
  attribute<> const attributes_ = {{}};
@@ -513,17 +540,22 @@
           proto::fold_tree<
               proto::_
             , ::boost::fusion::vector<>()
-            , ::boost::mpl::push_back<proto::_state, proto::_value>()
+            , ::boost::mpl::push_back<proto::_state, 
+                                      ::boost::mpl::if_< has_attribute_tag< proto::_value>,
+                                                         proto::_value,
+                                                         get_attribute_type<proto::_> > 
+                >()
            >
        >
     >
  {};
+
 struct BuildAttributes 
  : proto::make<
       ::boost::mpl::if_<
           has_attribute_tag< ::boost::mpl::deref< ::boost::mpl::prior< ::boost::mpl::end< BuildAttributesHelper > > > >,
-          ::boost::mpl::pop_back< BuildAttributesHelper >,
-          BuildAttributesHelper > 
+          ::boost::fusion::result_of::as_map< ::boost::mpl::pop_back< BuildAttributesHelper > >,
+          ::boost::fusion::result_of::as_map< BuildAttributesHelper > > 
    > 
 {};