1// Copyright 2008 Christophe Henry
2// henry UNDERSCORE christophe AT hotmail DOT com
3// This is an extended version of the state machine available in the boost::mpl library
4// Distributed under the same license as the original.
5// Copyright for the original version:
6// Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
7// under the Boost Software License, Version 1.0. (See accompanying
8// file LICENSE_1_0.txt or copy at
9// http://www.boost.org/LICENSE_1_0.txt)
10
11#ifndef BOOST_MSM_BACK_HISTORY_POLICIES_H
12#define BOOST_MSM_BACK_HISTORY_POLICIES_H
13
14#include <boost/mpl/contains.hpp>
15
16namespace boost { namespace msm { namespace back
17{
18
19// policy classes
20
21// Default: no history used
22template <int NumberOfRegions>
23class NoHistoryImpl
24{
25public:
26 NoHistoryImpl(){}
27 ~NoHistoryImpl(){}
28 void set_initial_states(int* const initial_states)
29 {
30 for (int i=0;i<NumberOfRegions;++i)
31 m_initialStates[i] = initial_states[i];
32 }
33 void history_exit(int* const )
34 {
35 // ignore
36 }
37 // returns the state where the state machine should be at start
38 template <class Event>
39 const int* history_entry(Event const& )
40 {
41 // always come back to the original state
42 return m_initialStates;
43 }
44 NoHistoryImpl<NumberOfRegions>& operator=(NoHistoryImpl<NumberOfRegions> const& rhs)
45 {
46 for (int i=0; i<NumberOfRegions;++i)
47 {
48 m_initialStates[i] = rhs.m_initialStates[i];
49 }
50 return *this;
51 }
52 // this policy deletes all waiting deferred events
53 template <class Event>
54 bool process_deferred_events(Event const&)const
55 {
56 return false;
57 }
58 template<class Archive>
59 void serialize(Archive & ar, const unsigned int)
60 {
61 ar & m_initialStates;
62 }
63private:
64 int m_initialStates[NumberOfRegions];
65};
66
67// not UML standard. Always activates history, no matter which event generated the transition
68template <int NumberOfRegions>
69class AlwaysHistoryImpl
70{
71public:
72 AlwaysHistoryImpl(){}
73 ~AlwaysHistoryImpl(){}
74 void set_initial_states(int* const initial_states)
75 {
76 for (int i=0;i<NumberOfRegions;++i)
77 m_initialStates[i] = initial_states[i];
78 }
79 void history_exit(int* const current_states)
80 {
81 for (int i=0;i<NumberOfRegions;++i)
82 m_initialStates[i] = current_states[i];
83 }
84 // returns the state where the state machine should be at start
85 template <class Event>
86 const int* history_entry(Event const& )
87 {
88 // always load back the last active state
89 return m_initialStates;
90 }
91 AlwaysHistoryImpl<NumberOfRegions>& operator=(AlwaysHistoryImpl<NumberOfRegions> const& rhs)
92 {
93 for (int i=0; i<NumberOfRegions;++i)
94 {
95 m_initialStates[i] = rhs.m_initialStates[i];
96 }
97 return *this;
98 }
99 // the history policy keeps all deferred events until next reentry
100 template <class Event>
101 bool process_deferred_events(Event const&)const
102 {
103 return true;
104 }
105
106 template<class Archive>
107 void serialize(Archive & ar, const unsigned int)
108 {
109 ar & m_initialStates;
110 }
111private:
112 int m_initialStates[NumberOfRegions];
113};
114
115// UML Shallow history. For deep history, just use this policy for all the contained state machines
116template <class Events,int NumberOfRegions>
117class ShallowHistoryImpl
118{
119public:
120 ShallowHistoryImpl(){}
121 ~ShallowHistoryImpl(){}
122 void set_initial_states(int* const initial_states)
123 {
124 for (int i=0;i<NumberOfRegions;++i)
125 {
126 m_currentStates[i] = initial_states[i];
127 m_initialStates[i] = initial_states[i];
128 }
129 }
130 void history_exit(int* const current_states)
131 {
132 for (int i=0;i<NumberOfRegions;++i)
133 m_currentStates[i] = current_states[i];
134 }
135 // returns the state where the state machine should be at start
136 template <class Event>
137 const int* history_entry(Event const&)
138 {
139 if ( ::boost::mpl::contains<Events,Event>::value)
140 {
141 return m_currentStates;
142 }
143 // not one of our events, no history
144 return m_initialStates;
145 }
146 ShallowHistoryImpl<Events,NumberOfRegions>& operator=(ShallowHistoryImpl<Events,NumberOfRegions> const& rhs)
147 {
148 for (int i=0; i<NumberOfRegions;++i)
149 {
150 m_initialStates[i] = rhs.m_initialStates[i];
151 m_currentStates[i] = rhs.m_currentStates[i];
152 }
153 return *this;
154 }
155 // the history policy keeps deferred events until next reentry if coming from our history event
156 template <class Event>
157 bool process_deferred_events(Event const&)const
158 {
159 return ::boost::mpl::contains<Events,Event>::value;
160 }
161 template<class Archive>
162 void serialize(Archive & ar, const unsigned int)
163 {
164 ar & m_initialStates;
165 ar & m_currentStates;
166 }
167private:
168 int m_initialStates[NumberOfRegions];
169 int m_currentStates[NumberOfRegions];
170};
171
172struct NoHistory
173{
174 typedef int history_policy;
175 template <int NumberOfRegions>
176 struct apply
177 {
178 typedef NoHistoryImpl<NumberOfRegions> type;
179 };
180};
181struct AlwaysHistory
182{
183 typedef int history_policy;
184 template <int NumberOfRegions>
185 struct apply
186 {
187 typedef AlwaysHistoryImpl<NumberOfRegions> type;
188 };
189};
190template <class Events>
191struct ShallowHistory
192{
193 typedef int history_policy;
194 template <int NumberOfRegions>
195 struct apply
196 {
197 typedef ShallowHistoryImpl<Events,NumberOfRegions> type;
198 };
199};
200} } }//boost::msm::back
201#endif //BOOST_MSM_BACK_HISTORY_POLICIES_H
202

source code of boost/libs/msm/include/boost/msm/back/history_policies.hpp