Boost的狀態機庫教程(3)

1.2 增加動作

    此時我們將只用一種動作：transitions，我們在下面的代碼中插入了黑體的部分。

 

 

1. #include <boost/statechart/transition.hpp>  
2.  
3. // ... 
4.  
5. struct  Stopped; 
6. struct  Active : sc::simple_state< Active, StopWatch, Stopped > 
7. { 
8.    typedef  sc::transition< EvReset, Active > reactions;  
9. }; 
10.  
11. struct  Running : sc::simple_state< Running, Active > 
12. { 
13.    typedef  sc::transition< EvStartStop, Stopped > reactions;  
14. }; 
15.  
16. struct  Stopped : sc::simple_state< Stopped, Active > 
17. { 
18.    typedef  sc::transition< EvStartStop, Running > reactions; 
19. }; 
20.  
21. //一個狀態可以定義任意數量的動作。這就是爲什麼當多於一個時，
22. //我們不得不將它們放到一個mpl::list<> 裏。 
23.  
24. int  main() 
25. { 
26.   StopWatch myWatch; 
27.   myWatch.initiate(); 
28.   myWatch.process_event( EvStartStop() ); 
29.   myWatch.process_event( EvStartStop() ); 
30.   myWatch.process_event( EvStartStop() ); 
31.   myWatch.process_event( EvReset() );  
32.    return  0; 
33. } 

    現在我們有了所有的狀態，並在適當的位置增加了所有的遷移動作，同時我們也向StopWatch發送了一些事件。這個狀態機會盡職盡責的按我們的希望進行狀態遷移，但依然現在還沒有其它的動作。

1.3 State-local存儲

    下一步我們將讓這個Stop watch真正的記錄時間了。根據stop watch所處不同的狀態，我們需要不同的變量。

l  Stopped狀態：需要一個保存逝去時間的變量。

l Running狀態：需要一個保存逝去時間的變量，還需要一個保存上一次啓動的時間點的變量。

    無論狀態機在什麼狀態下，我們都必須觀察逝去時間這個變量。此外，當我們向狀態機發送EvReSet事件時，這個變量應該被置爲0。其它的變量只是狀態機在Running狀態時需要。無論何時我們進入Running狀態時，它應該被置爲系統時鐘的當前時間。當我們退出Running狀態時，我們僅僅從系統時鐘的當前時間減去開始時間（進入時記錄的時間），將結果加到逝去時間裏就可以了。

 

1. #include <ctime> 
2.  
3. // ... 
4.  
5. struct  Stopped; 
6. struct  Active : sc::simple_state< Active, StopWatch, Stopped > 
7. { 
8.    public :  
9.      typedef  sc::transition< EvReset, Active > reactions; 
10.  
11.     Active() : elapsedTime_( 0.0 ) {} 
12.      double  ElapsedTime()  const  {  return  elapsedTime_; } 
13.      double  & ElapsedTime() {  return  elapsedTime_; } 
14.    private : 
15.      double  elapsedTime_ ; 
16. }; 
17.  
18. struct  Running : sc::simple_state< Running, Active > 
19. { 
20.    public :  
21.      typedef  sc::transition< EvStartStop, Stopped > reactions; 
22.  
23.     Running() : startTime_( std::time( 0 ) ) {} 
24.     ~Running() 
25.     { 
26.        // 與派生類可以訪問它的基類相似，
27.        //context<>() 用來獲得一個狀態的直接或間接的上下文的訪問權。
28.        // 這可以是直接或間接的外層狀態或狀態機本身
29.        // (例如，像這樣: context< StopWatch >()). 
30.       context< Active >().ElapsedTime() += 
31.         std::difftime( std::time( 0 ), startTime_ ); 
32.     } 
33.    private : 
34.     std:: time_t  startTime_;  
35. };

    這個狀態機現在可以測量時間了，但是我們還不能看到結果。

在這裏，State-local storage的優勢還沒有完成顯現出來。在FAQ項目“State-local storage酷在哪裏？”中，會通過與一個沒有用State-local storage的Stop Watch的比較來說明。

1.4 在狀態機外得到狀態信息

    爲了取得測量的時間，我們需要一個從狀態機外得到狀態信息的機制。按我們現在的狀態機設計，可以有兩種方法。爲簡單起見，我們在這裏用一個低效的方式：state_cast<>()(在StopWatch2.cpp中我們會用一個稍複雜一點的替代方法)（譯者注：在StopWatch2.cpp中是向狀態機發送一個取得逝去時間的事件，從事件成員量中將逝去時間帶回來 ），從字面意思就可以看出，它在語義上與dynamic_cast有點相似。例如，當我們調用myWatch.state_cast<const Stpped&>()時，當狀態機在Stopped狀態時，我們會得到一個Stopped狀態類的引用。否則，會拋出std::bad_cast異常。我們可以利用這個功能來實現一個StopWatch的成員函數，讓它的結果返回逝去的時間。然而，我們不是先問一下狀態機在什麼狀態，然後再去用不同的方法計算逝去時間，而是將計算放到Stopped和Running狀態中，用一個接口來獲得逝去逝去時間。

 

1. #include <iostream> 
2.  
3. // ... 
4.  
5. struct  IElapsedTime 
6. { 
7.    virtual   double  ElapsedTime()  const  = 0; 
8. }; 
9.  
10. struct  Active; 
11. struct  StopWatch : sc::state_machine< StopWatch, Active > 
12. { 
13.    double  ElapsedTime()  const  
14.   { 
15.      return  state_cast<  const  IElapsedTime & >().ElapsedTime(); 
16.   } 
17. }; 
18.  
19. // ... 
20.  
21. struct  Running : IElapsedTime,  
22.   sc::simple_state< Running, Active > 
23. { 
24.    public : 
25.      typedef  sc::transition< EvStartStop, Stopped > reactions; 
26.  
27.     Running() : startTime_( std::time( 0 ) ) {} 
28.     ~Running() 
29.     { 
30.       context< Active >().ElapsedTime() = ElapsedTime(); 
31.     }
32.      virtual   double  ElapsedTime()  const  
33.         { 
34.            return  context< Active >().ElapsedTime() + 
35.             std::difftime( std::time( 0 ), startTime_ ); 
36.         } 
37.        private : 
38.         std:: time_t  startTime_; 
39.     };  
40.      
41.      struct  Stopped : IElapsedTime,  
42.       sc::simple_state< Stopped, Active > 
43.     { 
44.        typedef  sc::transition< EvStartStop, Running > reactions; 
45.      
46.        virtual   double  ElapsedTime()  const  
47.       { 
48.          return  context< Active >().ElapsedTime(); 
49.       }  
50.     }; 
51.      
52.      int  main() 
53.     { 
54.       StopWatch myWatch; 
55.       myWatch.initiate(); 
56.       std::cout << myWatch.ElapsedTime() <<  "/n" ;  
57.       myWatch.process_event( EvStartStop() ); 
58.       std::cout << myWatch.ElapsedTime() <<  "/n" ; 
59.       myWatch.process_event( EvStartStop() ); 
60.       std::cout << myWatch.ElapsedTime() <<  "/n" ; 
61.       myWatch.process_event( EvStartStop() ); 
62.       std::cout << myWatch.ElapsedTime() <<  "/n" ; 
63.       myWatch.process_event( EvReset() ); 
64.       std::cout << myWatch.ElapsedTime() <<  "/n" ; 
65.        return  0; 
66.     }

爲了確實看到被測量的時間，你應該想辦法在main()中單步執行。StopWatch例子將這個程序擴展爲一個交互式的終端程序了。