Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.

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;
}