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
|
//////////////////////////////////////////////////////////////////////////////
// Copyright 2004-2006 Andreas Huber Doenni
// Distributed under the Boost Software License, Version 1.0. (See accompany-
// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//////////////////////////////////////////////////////////////////////////////
#include <boost/statechart/state_machine.hpp>
#include <boost/statechart/event.hpp>
#include <boost/statechart/simple_state.hpp>
#include <boost/statechart/transition.hpp>
#include <boost/statechart/deferral.hpp>
#include <boost/statechart/custom_reaction.hpp>
#include <boost/mpl/list.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/test/test_tools.hpp>
namespace sc = boost::statechart;
namespace mpl = boost::mpl;
template< class T >
boost::intrusive_ptr< T > MakeIntrusive( T * pT )
{
return boost::intrusive_ptr< T >( pT );
}
struct EvLeafDeferred : sc::event< EvLeafDeferred > {};
struct EvNodeDeferred : sc::event< EvNodeDeferred > {};
struct EvSwitch : sc::event< EvSwitch > {};
struct EvDestroy : sc::event< EvDestroy > {};
struct Active;
struct DeferralTest : sc::state_machine< DeferralTest, Active >
{
//////////////////////////////////////////////////////////////////////////
DeferralTest() : processedCount_( 0 ) {}
void IncrementProcessedCount()
{
++processedCount_;
}
unsigned int ProcessedCount() const
{
return processedCount_;
}
private:
//////////////////////////////////////////////////////////////////////////
unsigned int processedCount_;
};
struct Dead : sc::simple_state< Dead, DeferralTest >
{
typedef sc::custom_reaction< EvNodeDeferred > reactions;
sc::result react( const EvNodeDeferred & )
{
outermost_context().IncrementProcessedCount();
return discard_event();
}
};
struct Idle;
struct Active : sc::simple_state< Active, DeferralTest, Idle >
{
typedef mpl::list<
sc::custom_reaction< EvLeafDeferred >,
sc::deferral< EvNodeDeferred >,
sc::transition< EvDestroy, Dead >
> reactions;
sc::result react( const EvLeafDeferred & )
{
outermost_context().IncrementProcessedCount();
return discard_event();
}
};
struct Running : sc::simple_state< Running, Active >
{
typedef sc::transition< EvSwitch, Idle > reactions;
};
struct Idle : sc::simple_state< Idle, Active >
{
typedef mpl::list<
sc::transition< EvSwitch, Running >,
sc::deferral< EvLeafDeferred >
> reactions;
};
struct EvToX2 : sc::event< EvToX2 > {};
struct EvToX3 : sc::event< EvToX3 > {};
struct X1;
struct DeferralEventBaseTest : sc::state_machine< DeferralEventBaseTest, X1 >
{
};
struct X3 : sc::simple_state< X3, DeferralEventBaseTest > {};
struct X2 : sc::simple_state< X2, DeferralEventBaseTest >
{
typedef sc::transition< EvToX3, X3 > reactions;
};
struct X1 : sc::simple_state< X1, DeferralEventBaseTest >
{
typedef mpl::list<
sc::transition< EvToX2, X2 >,
sc::deferral< sc::event_base >
> reactions;
};
int test_main( int, char* [] )
{
DeferralTest machine;
machine.initiate();
machine.process_event( *MakeIntrusive( new EvSwitch() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 0 );
machine.process_event( *MakeIntrusive( new EvSwitch() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 0 );
machine.process_event( *MakeIntrusive( new EvLeafDeferred() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 0 );
machine.process_event( *MakeIntrusive( new EvSwitch() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 1 );
machine.process_event( *MakeIntrusive( new EvSwitch() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 1 );
machine.process_event( *MakeIntrusive( new EvLeafDeferred() ) );
machine.process_event( *MakeIntrusive( new EvLeafDeferred() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 1 );
machine.process_event( *MakeIntrusive( new EvSwitch() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 3 );
machine.process_event( *MakeIntrusive( new EvSwitch() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 3 );
machine.process_event( *MakeIntrusive( new EvNodeDeferred() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 3 );
machine.process_event( *MakeIntrusive( new EvSwitch() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 3 );
machine.process_event( EvNodeDeferred() );
BOOST_REQUIRE( machine.ProcessedCount() == 3 );
machine.process_event( *MakeIntrusive( new EvDestroy() ) );
BOOST_REQUIRE( machine.ProcessedCount() == 5 );
DeferralEventBaseTest eventBaseMachine;
// state_cast sanity check
BOOST_REQUIRE_THROW( eventBaseMachine.state_cast< const X1 & >(), std::bad_cast );
eventBaseMachine.initiate();
BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X1 & >() );
// Deferral must work with heap-allocated and stack-allocated events
eventBaseMachine.process_event( EvToX3() );
BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X1 & >() );
eventBaseMachine.process_event( EvToX2() );
BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X3 & >() );
eventBaseMachine.initiate();
BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X1 & >() );
eventBaseMachine.process_event( EvToX2() );
BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X2 & >() );
return 0;
}
|
