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
|
// Copyright 2008 Christophe Henry
// henry UNDERSCORE christophe AT hotmail DOT com
// This is an extended version of the state machine available in the boost::mpl library
// Distributed under the same license as the original.
// Copyright for the original version:
// Copyright 2005 David Abrahams and Aleksey Gurtovoy. 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_MSM_BACK_HISTORY_POLICIES_H
#define BOOST_MSM_BACK_HISTORY_POLICIES_H
#include <boost/mpl/contains.hpp>
namespace boost { namespace msm { namespace back
{
// policy classes
// Default: no history used
template <int NumberOfRegions>
class NoHistoryImpl
{
public:
NoHistoryImpl(){}
~NoHistoryImpl(){}
void set_initial_states(int* const initial_states)
{
for (int i=0;i<NumberOfRegions;++i)
m_initialStates[i] = initial_states[i];
}
void history_exit(int* const )
{
// ignore
}
// returns the state where the state machine should be at start
template <class Event>
const int* history_entry(Event const& )
{
// always come back to the original state
return m_initialStates;
}
NoHistoryImpl<NumberOfRegions>& operator=(NoHistoryImpl<NumberOfRegions> const& rhs)
{
for (int i=0; i<NumberOfRegions;++i)
{
m_initialStates[i] = rhs.m_initialStates[i];
}
return *this;
}
// this policy deletes all waiting deferred events
template <class Event>
bool process_deferred_events(Event const&)const
{
return false;
}
template<class Archive>
void serialize(Archive & ar, const unsigned int)
{
ar & m_initialStates;
}
private:
int m_initialStates[NumberOfRegions];
};
// not UML standard. Always activates history, no matter which event generated the transition
template <int NumberOfRegions>
class AlwaysHistoryImpl
{
public:
AlwaysHistoryImpl(){}
~AlwaysHistoryImpl(){}
void set_initial_states(int* const initial_states)
{
for (int i=0;i<NumberOfRegions;++i)
m_initialStates[i] = initial_states[i];
}
void history_exit(int* const current_states)
{
for (int i=0;i<NumberOfRegions;++i)
m_initialStates[i] = current_states[i];
}
// returns the state where the state machine should be at start
template <class Event>
const int* history_entry(Event const& )
{
// always load back the last active state
return m_initialStates;
}
AlwaysHistoryImpl<NumberOfRegions>& operator=(AlwaysHistoryImpl<NumberOfRegions> const& rhs)
{
for (int i=0; i<NumberOfRegions;++i)
{
m_initialStates[i] = rhs.m_initialStates[i];
}
return *this;
}
// the history policy keeps all deferred events until next reentry
template <class Event>
bool process_deferred_events(Event const&)const
{
return true;
}
template<class Archive>
void serialize(Archive & ar, const unsigned int)
{
ar & m_initialStates;
}
private:
int m_initialStates[NumberOfRegions];
};
// UML Shallow history. For deep history, just use this policy for all the contained state machines
template <class Events,int NumberOfRegions>
class ShallowHistoryImpl
{
public:
ShallowHistoryImpl(){}
~ShallowHistoryImpl(){}
void set_initial_states(int* const initial_states)
{
for (int i=0;i<NumberOfRegions;++i)
{
m_currentStates[i] = initial_states[i];
m_initialStates[i] = initial_states[i];
}
}
void history_exit(int* const current_states)
{
for (int i=0;i<NumberOfRegions;++i)
m_currentStates[i] = current_states[i];
}
// returns the state where the state machine should be at start
template <class Event>
const int* history_entry(Event const&)
{
if ( ::boost::mpl::contains<Events,Event>::value)
{
return m_currentStates;
}
// not one of our events, no history
return m_initialStates;
}
ShallowHistoryImpl<Events,NumberOfRegions>& operator=(ShallowHistoryImpl<Events,NumberOfRegions> const& rhs)
{
for (int i=0; i<NumberOfRegions;++i)
{
m_initialStates[i] = rhs.m_initialStates[i];
m_currentStates[i] = rhs.m_currentStates[i];
}
return *this;
}
// the history policy keeps deferred events until next reentry if coming from our history event
template <class Event>
bool process_deferred_events(Event const&)const
{
return ::boost::mpl::contains<Events,Event>::value;
}
template<class Archive>
void serialize(Archive & ar, const unsigned int)
{
ar & m_initialStates;
ar & m_currentStates;
}
private:
int m_initialStates[NumberOfRegions];
int m_currentStates[NumberOfRegions];
};
struct NoHistory
{
typedef int history_policy;
template <int NumberOfRegions>
struct apply
{
typedef NoHistoryImpl<NumberOfRegions> type;
};
};
struct AlwaysHistory
{
typedef int history_policy;
template <int NumberOfRegions>
struct apply
{
typedef AlwaysHistoryImpl<NumberOfRegions> type;
};
};
template <class Events>
struct ShallowHistory
{
typedef int history_policy;
template <int NumberOfRegions>
struct apply
{
typedef ShallowHistoryImpl<Events,NumberOfRegions> type;
};
};
} } }//boost::msm::back
#endif //BOOST_MSM_BACK_HISTORY_POLICIES_H
|
