4

まもなく取り組むプロジェクトのコンセプト コードをいくつか開発しました。このプロジェクトはステート マシンの設計に適しています。boost::statechart はうまく機能すると思います。ただし、 context() を使用しようとすると、障害が発生しました。以下にサンプルを示します (さらに多くのコードを掲載できることを嬉しく思いますが、これが重要な部分だと思います)。

struct Wait : fsm::simple_state< Wait, Active > {

  typedef mpl::list<fsm::transition< UnderflowEvent, Exec> > reactions;

 public:
  Wait()
    : m_wait_op() {
    std::cout << "entering wait state." << std::endl;
    wait();
  }
  ~Wait() { std::cout << "exiting wait state." << std::endl; }

 private:
  default_wait m_wait_op;
  fsm::result wait() {
    if(context<Active>().underflow_condition()) {
      m_wait_op();
      return transit<Wait>();
    }
    else if(context<Active>().overflow_condition()) {
      return transit<Exec>();
    }
    else {
      // undefined - keep waiting                                                                                                                                                
    }
  }

};

ステート Active には「[over|under]flow_condition」と呼ばれるメソッドがあり、この時点で true を返します。設計の問題はさておき、このようにインスタンス化すると、次のアサーション エラーが発生します。

int main(void) {

  Throttler my_throttler;

  my_throttler.initiate();

  return 0;

}

そしてここに主張があります：

アサーション "get_pointer( stt.pContext_ ) != 0" が失敗しました

このアサーションをファイル「/usr/include/boost/statechart/simple_state.hpp」の 689 行目 (boost 1.45) で調べたところ、simple_state がコンテキストを使用するのを防ぐためにあるとコメントがありました。ストップウォッチの例を再訪したとき、これは私を当惑させました。だから私はそれをコンパイルしましたが、このアサーションは当然のことながらストップウォッチ コードによって違反されていません。何か不足していますか？たぶん、コードのどこかに私が見逃したものがありますか? これがヘッダー全体です (概念コードであることを覚えておいてください...完全に一般化されるまで、これを公開しません):

    #ifndef _THROTTLER_H_
#define _THROTTLER_H_

#include<queue>
#include<vector>
#include<ctime>

#include<boost/statechart/event.hpp>
#include<boost/statechart/transition.hpp>
#include<boost/statechart/state_machine.hpp>
#include<boost/statechart/simple_state.hpp>

#include<boost/mpl/list.hpp>

#include<iostream>


namespace mpl = boost::mpl;
namespace fsm = boost::statechart;

namespace {

  unsigned int DEFAULT_WAIT_TIME(1000);

}

struct noop {
public:

  noop() { m_priority = (1 << sizeof(int)); }
  noop(unsigned int priority) { m_priority = priority; }
  virtual ~noop() {}

  bool operator()(void) {
    return true;
  }
  friend bool operator<(noop a, noop b);

private:
  unsigned int m_priority;
};



bool operator<(noop a, noop b) {
  return a.m_priority < b.m_priority;
}

struct compare_noops {
  bool operator()(noop a, noop b) {
  }
};


struct default_wait {
  void operator()(unsigned long msecs = DEFAULT_WAIT_TIME) {
    std::clock_t endtime =
      std::clock() + (msecs*1000*CLOCKS_PER_SEC);
    while(clock() < endtime);
  }
};



struct OverflowEvent : fsm::event< OverflowEvent > {};
struct UnderflowEvent : fsm::event< UnderflowEvent > {};
struct ResetEvent : fsm::event< ResetEvent > {};

struct Active;
struct Throttler : fsm::state_machine< Throttler, Active > {};

struct Wait;
struct Active : fsm::simple_state< Active, Throttler, Wait > {

 public:

  typedef mpl::list<fsm::transition< ResetEvent, Active> > reactions;

  bool overflow_condition(void) { return true; }
  bool underflow_condition(void) { return true; }

  void queue_operation(noop op) {
    m_operation_queue.push(op);
  }
  void perform_operation(void) {
    noop op(m_operation_queue.top());
    if(op())
      m_operation_queue.pop();
    else
      throw;
  }

 private:

  std::priority_queue<noop, std::vector<noop>, compare_noops > m_operation_queue;
 private:

  std::priority_queue<noop, std::vector<noop>, compare_noops > m_operation_queue;

};

struct Exec : fsm::simple_state< Exec, Active > {

  typedef mpl::list<fsm::transition< OverflowEvent, Wait> > reactions;

  Exec() { std::cout << "entering exec state." << std::endl; }
  ~Exec() { std::cout << "exiting exec state." << std::endl; }

};

struct Wait : fsm::simple_state< Wait, Active > {

  typedef mpl::list<fsm::transition< UnderflowEvent, Exec> > reactions;

 public:
  Wait()
    : m_wait_op() {
    std::cout << "entering wait state." << std::endl;
    wait();
  }
  ~Wait() { std::cout << "exiting wait state." << std::endl; }

 private:
  default_wait m_wait_op;
  fsm::result wait() {
    if(context<Active>().underflow_condition()) {
      m_wait_op();
      return transit<Wait>();
    }
    else if(context<Active>().overflow_condition()) {
      return transit<Exec>();
    }
    else {
      // undefined - keep waiting                                                                                                                                                
    }
  }

};


#endif
4

1 に答える 1

4

コメントで指摘したように、これはコンストラクター内から外部コンテキストにアクセスしようとすることに関連しています。これは、では許可されていませんsimple_state。

差出人simple_state.hpp：

  // This assert fails when an attempt is made to access the state machine
  // from a constructor of a state that is *not* a subtype of state<>.
  // To correct this, derive from state<> instead of simple_state<>.
  BOOST_ASSERT( get_pointer( pContext_ ) != 0 );

stateしたがって、状態を（ではなく）クラスに基づいている場合は、コンストラクターから外部コンテキストにアクセスできるはずですsimple_state。

とはいえ、これがあなたの州にどのような影響や影響を与えるかはわかりません。この質問が答えを得た場合、それはあなたにも役立つかもしれません（：

私が理解していることから、あなたは以下Waitから派生するように変更する必要がありますstate：

 struct Wait : fsm::state< Wait, Active > {

次に、Wait()コンストラクターを次のようなものに変更します

typedef fsm::state< Wait, Active > my_base;
Wait( my_context ctx ) : my_base( ctx )
// and any other pre-constructor initialisation...

my_contextタイプは、内で（保護されたものとして）定義されてstate<>おり、派生クラスのコンストラクターから渡す必要があります。

于 2011-06-30T05:48:56.950 に答える