libs/msm/doc/HTML/examples/CompilerStressTestEuml.cpp
// Copyright 2010 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)
#include <vector>
#include <list>
#include <set>
#include <map>
#include <iostream>
// we need more than the default 10 states
#define FUSION_MAX_VECTOR_SIZE 15
#include <boost/msm/back/state_machine.hpp>
#include <boost/msm/front/euml/euml.hpp>
#include <boost/msm/front/euml/stl.hpp>
using namespace std;
using namespace boost::msm::front::euml;
namespace msm = boost::msm;
// how long the timer will ring when countdown elapsed.
#define RINGING_TIME 5
namespace // Concrete FSM implementation
{
// flag
BOOST_MSM_EUML_FLAG(SomeFlag)
// declares attributes with type and name. Can be used anywhere after
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,m_song)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int,m_song_id)
// declare that a type inheriting from OneSongDef will get these 2 attributes
BOOST_MSM_EUML_ATTRIBUTES((attributes_ << m_song << m_song_id ), OneSongDef)
// events
// this event is done "manually", not using any predefined macro
struct OneSong_impl : euml_event<OneSong_impl>,OneSongDef
{
OneSong_impl(){}
OneSong_impl(const string& asong)
{
get_attribute(m_song)=asong;
get_attribute(m_song_id)=1;
}
OneSong_impl(const OneSong_impl& asong)
{
get_attribute(m_song)=asong.get_attribute(m_song);
get_attribute(m_song_id)=1;
}
const string& get_data() const {return get_attribute(m_song);}
};
// declare an instance for use in the transition table
OneSong_impl const OneSong;
struct SongComparator : euml_action<SongComparator>
{
bool operator()(const OneSong_impl& lhs,const OneSong_impl& rhs)const
{
return lhs.get_data() == rhs.get_data();
}
};
struct SongLessComparator : euml_action<SongLessComparator>
{
bool operator()(const OneSong_impl& lhs,const OneSong_impl& rhs)const
{
return lhs.get_data() < rhs.get_data();
}
};
struct Comparator
{
template <class T>
bool operator()(const T& lhs,const T& rhs)const
{
return lhs < rhs;
}
};
struct RemoveDummy
{
bool operator()(const OneSong_impl& lhs)const
{
return (lhs.get_attribute(m_song).compare(std::string("She-Dummy. Remove this one"))==0 );
}
};
template <int val>
struct LookFor
{
template <class T>
bool operator()(const T& lhs)const
{
return lhs == val;
}
};
template <int val>
struct LessThan
{
template <class T>
bool operator()(const T& lhs)const
{
return lhs < val;
}
};
BOOST_MSM_EUML_ACTION(SongDeleter)
{
bool operator()(const OneSong_impl& lhs)const
{
return lhs.get_data() == "Twist and Shout";
}
};
struct Generator
{
int operator()()const
{
return 1;
}
};
struct Print
{
template <class T>
void operator()(const T& lhs)const
{
std::cout << "Song:" << lhs.get_data() << endl;
}
};
BOOST_MSM_EUML_ATTRIBUTES((attributes_ << m_song ), NotFoundDef)
// declare an event instance called NotFound with the defined attributes
// these attributes can then be referenced anywhere (stt, state behaviors)
BOOST_MSM_EUML_EVENT_WITH_ATTRIBUTES(NotFound,NotFoundDef)
BOOST_MSM_EUML_ATTRIBUTES((attributes_ << m_song ), FoundDef)
struct Found_impl : euml_event<Found_impl>,FoundDef
{
Found_impl(){}
Found_impl (const string& data)
{
get_attribute(m_song)=data;
}
int foo()const {std::cout << "foo()" << std::endl; return 0;}
int foo(int i)const {std::cout << "foo(int):" << i << std::endl; return 1;}
int foo(int i,int j)const {std::cout << "foo(int,int):" << i <<"," << j << std::endl; return 2;}
};
Found_impl const Found;
// some functions to call
// this macro creates a functor and an eUML function wrapper. Now, foo_ can be used anywhere
BOOST_MSM_EUML_METHOD(FoundFoo_ , foo , foo_ , int , int )
template <class T>
int do_print(T& t ) {std::cout << "print(T):" << typeid(T).name() << std::endl;return 1;}
BOOST_MSM_EUML_FUNCTION(PrintState_ , do_print , print_ , int , int )
BOOST_MSM_EUML_EVENT(Done)
// Concrete FSM implementation
struct some_base
{
int foobar()const {std::cout << "foobar()" << std::endl; return 0;}
int foobar(int i)const {std::cout << "foobar(int):" << i << std::endl; return 1;}
int foobar(int i,int j)const {std::cout << "foobar(int,int):" << i <<"," << j << std::endl; return 2;}
};
// some functions to call
BOOST_MSM_EUML_METHOD(FooBar_ , foobar , foobar_ , int , int )
// fsm attributes
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(vector<OneSong_impl>,m_src_container)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(list<OneSong_impl>,m_tgt_container)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(list<int>,m_var2)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(list<int>,m_var3)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(set<int>,m_var4)
typedef std::map<int,int> int_int_map;
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int_int_map,m_var5)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,m_var6)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,m_var7)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(vector<int>,m_var8)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(vector<int>,m_var9)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(int,m_var10)
// The list of FSM states
BOOST_MSM_EUML_STATE(( ( insert_(fsm_(m_tgt_container),end_(fsm_(m_tgt_container)),
append_(event_(m_song),fsm_(m_var7)) ),//foo_(event_,Int_<0>()) ,
//foo_(event_,Int_<0>(),Int_<1>()),print_(state_),
process_(Done/*,fsm_*/),if_then_(true_,true_) ),
no_action
),Insert)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(std::string,m_letters)
BOOST_MSM_EUML_STATE(( if_then_else_( (string_find_(event_(m_song),state_(m_letters),Size_t_<0>()) != Npos_<string>()&&
string_find_(event_(m_song),Char_<'S'>(),Size_t_<0>()) != Npos_<string>()&&
string_find_first_of_(event_(m_song),Char_<'S'>()) == Size_t_<0>() &&
string_compare_(event_(m_song),Int_<0>(),size_(event_(m_song)),event_(m_song)) == Int_<0>()
//&& is_flag_(SomeFlag(),fsm_())
//&& ( event_(m_song_id) == Int_<1>())
//&& string_find_(event_(m_song),String_<mpl::string<'Sh','e'> >())
// != Npos_<string>()
),
process2_(Found,
//string_insert_(event_(m_song),Size_t_<0>(),fsm_(m_var6)) ),
string_replace_(
string_assign_(
string_erase_(
string_insert_(
substr_(event_(m_song),Size_t_<1>()),
Size_t_<0>(),
Size_t_<1>(),
Char_<'S'>()),
Size_t_<0>(),
Size_t_<1>() ),
event_(m_song) ),
Size_t_<0>(),
Size_t_<1>(),
c_str_(fsm_(m_var6))
/*Size_t_<1>(),
Char_<'s'>()*/ ) ),
process2_(NotFound,event_(m_song),fsm_) ) ,
no_action,
attributes_ << m_letters,
configure_<< SomeFlag ),StringFind)
BOOST_MSM_EUML_DECLARE_ATTRIBUTE(vector<OneSong_impl>::iterator,m_src_it)
BOOST_MSM_EUML_STATE(( if_then_( (state_(m_src_it) != end_(fsm_(m_src_container)) &&
//associative_find_(fsm_(m_var4),Int_<9>()) != end_(fsm_(m_var4))&&
//associative_count_(fsm_(m_var4),Int_<9>()) == Size_t_<1>() &&
//*associative_upper_bound_(fsm_(m_var4),Int_<8>()) == Int_<9>()&&
//*associative_lower_bound_(fsm_(m_var4),Int_<9>()) == Int_<9>() &&
//second_(associative_equal_range_(fsm_(m_var4),Int_<8>())) == associative_upper_bound_(fsm_(m_var4),Int_<8>()) &&
//first_(associative_equal_range_(fsm_(m_var4),Int_<8>())) == associative_lower_bound_(fsm_(m_var4),Int_<8>())&&
//second_(*associative_lower_bound_(fsm_(m_var5),Int_<0>())) == Int_<0>() && //map => pair as return
//find_if_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Predicate_<LookFor<8> >()) != end_(fsm_(m_var4))&&
//*lower_bound_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>(),Predicate_<std::less<int> >()) == Int_<9>()&&
//*upper_bound_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<8>(),Predicate_<std::less<int> >()) == Int_<9>() &&
//second_(equal_range_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<8>()))
// == upper_bound_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<8>()) &&
//first_(equal_range_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>(),Predicate_<std::less<int> >()))
// == lower_bound_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>(),Predicate_<std::less<int> >())&&
//binary_search_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>(),Predicate_<std::less<int> >())&&
//binary_search_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>())&&
//count_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Int_<9>()) == Int_<1>()&&
//count_if_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Predicate_<LookFor<9> >()) == Int_<1>()&&
//distance_(begin_(fsm_(m_var4)),end_(fsm_(m_var4))) == Int_<2>()&&
//*min_element_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Predicate_<std::less<int> >()) == Int_<8>()&&
//*max_element_(begin_(fsm_(m_var4)),end_(fsm_(m_var4)),Predicate_<std::less<int> >()) == Int_<9>()&&
//adjacent_find_(begin_(fsm_(m_var4)),end_(fsm_(m_var4))) == end_(fsm_(m_var4))&&
//*find_end_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),begin_(fsm_(m_var9)),end_(fsm_(m_var9)))
// == Int_<1>()&&
//*find_first_of_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),begin_(fsm_(m_var9)),end_(fsm_(m_var9)))
// == Int_<1>()&&
//equal_(begin_(fsm_(m_var9)),end_(fsm_(m_var9)),begin_(fsm_(m_var8)))&&
//*search_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),begin_(fsm_(m_var9)),end_(fsm_(m_var9)))
// == Int_<1>()&&
//includes_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),begin_(fsm_(m_var9)),end_(fsm_(m_var9)))&&
//!lexicographical_compare_(begin_(fsm_(m_var8)),end_(fsm_(m_var8)),
// begin_(fsm_(m_var9)),end_(fsm_(m_var9)))&&
//first_(mismatch_(begin_(fsm_(m_var9)),end_(fsm_(m_var9)),begin_(fsm_(m_var8))))
// == end_(fsm_(m_var9)) &&
accumulate_(begin_(fsm_(m_var9)),end_(fsm_(m_var9)),Int_<1>(),
Predicate_<std::plus<int> >()) == Int_<1>()
),
(process2_(OneSong,*(state_(m_src_it)++))/*,foobar_(fsm_,Int_<0>())*/ ) ),
no_action,
attributes_ << m_src_it
, configure_<< SomeFlag ),Foreach)
// replaces the old transition table
BOOST_MSM_EUML_TRANSITION_TABLE((
StringFind == Foreach + OneSong[if_then_else_(true_,true_,true_)],
Insert == StringFind + Found / (if_then_(true_,no_action)),
Foreach == StringFind + NotFound ,
Foreach == Insert + Done
// +------------------------------------------------------------------------------+
),transition_table )
BOOST_MSM_EUML_ACTION(Log_No_Transition)
{
template <class FSM,class Event>
void operator()(Event const& e,FSM&,int state)
{
std::cout << "no transition from state " << state
<< " on event " << typeid(e).name() << std::endl;
}
};
// create a state machine "on the fly"
BOOST_MSM_EUML_DECLARE_STATE_MACHINE(( transition_table, //STT
init_ << Foreach, // Init
//insert_(state_(m_var4),begin_(state_(m_var2)),end_(state_(m_var2))),
(insert_(state_(m_var4),Int_<5>()),insert_(state_(m_var4),Int_<6>()),insert_(state_(m_var4),Int_<7>()),
insert_(state_(m_var4),Int_<8>()),insert_(state_(m_var4),Int_<9>()),
associative_erase_(state_(m_var4),Int_<6>()),associative_erase_(state_(m_var4),begin_(state_(m_var4))),
associative_erase_(state_(m_var4),begin_(state_(m_var4)),++begin_(state_(m_var4))),
insert_(state_(m_var2),begin_(state_(m_var2)),begin_(state_(m_var3)),end_(state_(m_var3))),
state_(m_var5)[Int_<0>()]=Int_<0>(),state_(m_var5)[Int_<1>()]=Int_<1>()
,attribute_(substate_(Foreach,fsm_),m_src_it)
= begin_(fsm_(m_src_container))
//,fill_(begin_(state_(m_var9)),end_(state_(m_var9)),Int_<0>())
//,fill_n_(begin_(state_(m_var9)),Size_t_<2>(),Int_<0>())
//,transform_(begin_(state_(m_var4)),end_(state_(m_var4)),begin_(state_(m_var2)),begin_(state_(m_var4)),
// Predicate_<std::plus<int> >())
//,process_(Done,fsm_(),fsm_)
//,process_(Done,fsm_)
//,fsm_
//,foobar_(state_,Int_<0>(),Int_<1>())
//,nth_element_(begin_(state_(m_var9)),++begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
//,partial_sort_(begin_(state_(m_var9)),end_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
//,partial_sort_copy_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
//,list_sort_(state_(m_var2))
//,sort_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
//,inner_product_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),Int_<1>())
//,replace_copy_(begin_(state_(m_var4)),end_(state_(m_var4)),begin_(state_(m_var4)),Int_<8>(),Int_<7>())
//,replace_copy_if_(begin_(state_(m_var4)),end_(state_(m_var4)),begin_(state_(m_var4)),Predicate_<LookFor<9> >(),Int_<8>())
//,replace_(begin_(state_(m_var4)),end_(state_(m_var4)),Int_<8>(),Int_<7>())
//,replace_if_(begin_(state_(m_var4)),end_(state_(m_var4)),Predicate_<LookFor<9> >(),Int_<8>())
//,adjacent_difference_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)))
//,partial_sum_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)))
//,inner_product_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),Int_<1>())
//,next_permutation_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
//,prev_permutation_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
//,set_union_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)))
//,inplace_merge_(begin_(state_(m_var9)),end_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
//,merge_(begin_(state_(m_var9)),end_(state_(m_var9)),begin_(state_(m_var9)),end_(state_(m_var9))
// ,begin_(state_(m_var9)),Predicate_<std::less<int> >())
//,stable_sort_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<std::less<int> >())
//,partition_(begin_(state_(m_var2)),end_(state_(m_var2)),Predicate_<LessThan<3> >())
//,stable_partition_(begin_(state_(m_var2)),end_(state_(m_var2)),Predicate_<LessThan<3> >())
//,rotate_copy_(begin_(state_(m_var2)),++begin_(state_(m_var2)),end_(state_(m_var2)),begin_(state_(m_var2)))
//,rotate_(begin_(state_(m_var2)),++begin_(state_(m_var2)),end_(state_(m_var2)))
//,unique_(begin_(state_(m_var2)),end_(state_(m_var2)))
//,unique_copy_(begin_(state_(m_var2)),end_(state_(m_var2)),begin_(state_(m_var2)))
//,random_shuffle_(begin_(state_(m_var9)),end_(state_(m_var9)))
//,generate_(begin_(state_(m_var9)),end_(state_(m_var9)),Predicate_<Generator>())
//,generate_n_(begin_(state_(m_var9)),Int_<2>(),Predicate_<Generator>())
//,reverse_copy_(begin_(state_(m_var2)),end_(state_(m_var2)),begin_(state_(m_var2)))
//erase_(state_(m_src_container),
// remove_if_(begin_(state_(m_src_container)),end_(state_(m_src_container)),
// Predicate_<RemoveDummy>()),
// end_(state_(m_src_container))),
//list_remove_(state_(m_var2),Int_<3>()),
//remove_copy_if_(begin_(state_(m_var9)),end_(state_(m_var9)),back_inserter_(state_(m_var2)),
// Predicate_<LookFor<2> >() )
//for_each_(begin_(state_(m_src_container)),end_(state_m_src_container()),
// Predicate_<Print>() ),
//copy_(begin_(state_(m_var9)),end_(state_(m_var9)),inserter_(state_(m_var2),end_(state_(m_var2)))),
//reverse_(begin_(state_(m_var2)),end_(state_(m_var2)))
),
//no_action, // Entry
//splice_(state_(m_var2),begin_(state_(m_var2)),state_(m_var3),begin_(state_(m_var3)),end_(state_(m_var3))),
//(list_remove_(state_(m_var2),Int_<3>()),list_merge_(state_(m_var2),state_(m_var3),Comparator())),//no_action, // Entry
no_action, // Exit
attributes_ << m_src_container // song list
<< m_tgt_container // result
<< m_var2
<< m_var3
<< m_var4
<< m_var5
<< m_var6
<< m_var7
<< m_var8
<< m_var9
<< m_var10,
configure_<< no_configure_,
Log_No_Transition
),iPodSearch_helper)
struct iPodSearch_ : public iPodSearch_helper, public some_base
{
};
// choice of back-end
typedef msm::back::state_machine<iPodSearch_> iPodSearch;
void test()
{
iPodSearch search;
// fill our song list
//search.get_attribute<m_src_container>().push_back(OneSong("She-Dummy. Remove this one"));
search.get_attribute(m_src_container).push_back(OneSong_impl("Let it be"));
search.get_attribute(m_src_container).push_back(OneSong_impl("Yellow submarine"));
search.get_attribute(m_src_container).push_back(OneSong_impl("Twist and Shout"));
search.get_attribute(m_src_container).push_back(OneSong_impl("She Loves You"));
search.get_attribute(m_var2).push_back(1);
search.get_attribute(m_var2).push_back(3);
search.get_attribute(m_var2).push_back(4);
search.get_attribute(m_var3).push_back(2);
search.get_attribute(m_var3).push_back(4);
search.get_attribute(m_var6) = "S";
search.get_attribute(m_var7) = "- Some text";
search.get_attribute(m_var8).push_back(1);
search.get_attribute(m_var8).push_back(2);
search.get_attribute(m_var8).push_back(3);
search.get_attribute(m_var8).push_back(4);
search.get_attribute(m_var9).push_back(1);
search.get_attribute(m_var9).push_back(2);
// look for "She Loves You" using the first letters
// BOOST_MSM_EUML_STATE_NAME returns the name of the event type of which StringFind is an instance
search.get_state<BOOST_MSM_EUML_STATE_NAME(StringFind)&>().get_attribute(m_letters)="Sh";
// needed to start the highest-level SM. This will call on_entry and mark the start of the SM
search.start();
// display all the songs
for (list<OneSong_impl>::const_iterator it = search.get_attribute(m_tgt_container).begin();
it != search.get_attribute(m_tgt_container).end();++it)
{
cout << "candidate song:" << (*it).get_data() << endl;
}
for (list<int>::const_iterator iti = search.get_attribute(m_var2).begin();
iti != search.get_attribute(m_var2).end();++iti)
{
cout << "int in attribute m_var2:" << (*iti) << endl;
}
for (set<int>::const_iterator its = search.get_attribute(m_var4).begin();
its != search.get_attribute(m_var4).end();++its)
{
cout << "int in attribute m_var4:" << (*its) << endl;
}
cout << "search using more letters" << endl;
// look for "She Loves You" using more letters
search.get_state<BOOST_MSM_EUML_STATE_NAME(StringFind)&>().get_attribute(m_letters)="She";
search.get_attribute(m_tgt_container).clear();
search.start();
// display all the songs
for (list<OneSong_impl>::const_iterator it = search.get_attribute(m_tgt_container).begin();
it != search.get_attribute(m_tgt_container).end();++it)
{
cout << "candidate song:" << (*it).get_data() << endl;
}
}
}
int main()
{
test();
return 0;
}