The Boost Statechart Library - Reference

Boost , ,

The Boost Statechart Library

Reference

Contents

Concepts

Scheduler

FifoWorker

ExceptionTranslator

StateBase

SimpleState

State

Event

state_machine.hpp

Class template state_machine

asynchronous_state_machine.hpp

Class template asynchronous_state_machine

event_processor.hpp

Class template event_processor

fifo_scheduler.hpp

Class template fifo_scheduler

exception_translator.hpp

Class template exception_translator

null_exception_translator.hpp

Class null_exception_translator

 

simple_state.hpp

Enum history_mode

Class template simple_state

state.hpp

Class template state

shallow_history.hpp

Class template shallow_history

deep_history.hpp

Class template deep_history

 

event_base.hpp

Class event_base

event.hpp

Class template event

 

transition.hpp

Class template transition

in_state_reaction.hpp

Class template in_state_reaction

termination.hpp

Class template termination

deferral.hpp

Class template deferral

custom_reaction.hpp

Class template custom_reaction

result.hpp

Class result

Concepts

Scheduler concept

A Тип планировщика определяет следующее:

• Что передается конструкторам подтиповevent_processor<>и как управляется срок службы таких объектов
• Может ли несколько объектов подтипаevent_processor<>разделять одну и ту же нить очереди и планировщика
• Как события добавляются в очередь планировщиков
• Как и стоит ли ждать новых событий, когда очередь планировщиков пустует
• Используется ли и какой тип блокировки для обеспечения безопасности резьбы
• Возможна ли очередь событий для уже не существующихevent_processor<>объектов подтипа и что происходит при обработке такого события
• Что происходит, когда один из обслуживаемыхevent_processor<>объектов подтипа распространяет исключение

Для списка типа S и объекта cpc типа const S::processor_context следующие выражения должны быть хорошо сформированы и иметь указанные результаты:

Чтобы защитить от злоупотреблений, все члены S::processor_context должны быть объявлены частными. В результате event_processor<> должен быть другом S::processor_context.

FifoWorker concept

Тип FifoWorker определяет следующее:

• Как и когда ждать новых рабочих мест, когда внутренняя рабочая очередь пустует
• Используется ли и какой тип блокировки для обеспечения безопасности резьбы

Для типа FifoWorker F объект f этого типа, const объект cf этого типа, объект функции без параметра w произвольного типа и неподписанный длинный значение n следующие выражения/ведомости должны быть хорошо сформированы и иметь указанные результаты:

ExceptionTranslator concept

Тип Исключения Транслятора определяет, как исключения C++, происходящие во время работы государственной машины, переводятся на события исключения.

Для объекта Исключения Транслятора et, объект без параметра функции a произвольного типа, возвращающегося результат и объект функции eh произвольного типа, принимающего const event_base & параметр и возвращающийся результ, следующее выражение должно быть хорошо сформировано и иметь указанные результаты:

StateBase concept

Тип StateBase является общей базой всех состояний данного типа машины состояния. state_machine<>::state_base_type является моделью концепции StateBase.

Для типа StateBase S и const объект cs этого типа следующие выражения должны быть хорошо сформированы и иметь указанные результаты:

SimpleState concept

Тип простого состояния определяет одно состояние определенной государственной машины.

Для простого государства типа S и указателя pS, указывающего на объект типа S, выделенный new, следующие выражения/ведомости должны быть хорошо сформированы и иметь указанные эффекты/результаты:

State concept

Государство - это улучшение простое состояние (то есть, за исключением конструктора по умолчанию, государственный тип также должен удовлетворять требованиям простого государства). Для государственного типа S указатель pS типа S * указывающий на объект типа S, выделенный с new, и объект mc типа состояние< S, C, I, h >::my_context Должны быть четко сформулированы следующие выражения/заявления:

Event concept

A Тип события определяет событие, для которого государственные машины могут определять реакции.

Для события типа E и указателя pCE типа const E *, указывающего на объект типа E, выделенный с new, следующие выражения/ведомости должны быть хорошо сформированы и иметь указанные эффекты/результаты:

Header <boost/statechart/state_machine.hpp>

Class template state_machine

Это шаблон базового класса всех синхронных государственных машин.

Class template state_machine parameters

Class template state_machine synopsis

namespace boost
{
namespace statechart
{
  template<
    class MostDerived,
    class InitialState,
    class Allocator = std::allocator< void >,
    class ExceptionTranslator = null_exception_translator >
  class state_machine : noncopyable
  {
    public:
      typedef MostDerived outermost_context_type;
      void initiate();
      void terminate();
      bool terminated() const;
      void process_event( const event_base & );
      template< class Target >
      Target state_cast() const;
      template< class Target >
      Target state_downcast() const;
      // a model of the StateBase concept
      typedef implementation-defined state_base_type;
      // a model of the standard Forward Iterator concept
      typedef implementation-defined state_iterator;
      state_iterator state_begin() const;
      state_iterator state_end() const;
      void unconsumed_event( const event_base & ) {}
    protected:
      state_machine();
      ~state_machine();
      void post_event(
        const intrusive_ptr< const event_base > & );
      void post_event( const event_base & );
      const event_base * triggering_event() const;
  };
}
}

Class template state_machine constructor and destructor

state_machine();

Эффекты: Конструирует непрокатную государственную машину

~state_machine();

Эффекты: Разлагает действующее в настоящее время внешнее состояние и все его прямые и косвенные внутренние состояния. Самые внутренние состояния сначала разрушены. Другие состояния разрушаются, как только разрушаются все их прямые и косвенные внутренние состояния. Внутренние состояния каждого государства разрушаются по количеству их ортогональной области. Состояние в ортогональной области с наибольшим числом всегда разрушается сначала, затем государство в регионе со вторым по величине числом и так далее
Note: Не пытается назвать какие-либо функции exit

Class template state_machine modifier functions

void initiate();

Следы:

1. Звонкиterminate()
2. Конструирует функциональный объектactionс возвращающимся без параметраoperator()()result, который
   1. входит (конструирует) состояние, указанное с параметром шаблонаInitialState
   2. В древо, образованное прямыми и косвенными внутренними начальными состояниямиInitialStateглубины, входит первое. Внутренние состояния каждого состояния вводятся по числу их ортогональной области. Государство в ортогональной области 0 всегда вводится сначала, затем государство в области 1 и так далее.
3. Конструирует объект функцииexceptionEventHandlerсoperator()()возвращающимсяresultи принимающим параметр события исключения, который обрабатывает пройденное событие исключения, со следующими отличиями от обработки нормальных событий:
   • С момента, когда исключение было брошено до момента непосредственно после выполнения реакции события исключения, состояния, которые должны быть выведены, только разрушаются, но не называются функции членаexit.
   • Реакциявсегда начинается с самого внешнегонестабильного состояния.
   • Что касается обычных событий, то поиск реакции движется наружу, когда текущее состояние не может справиться с событием. Однако если внешнее состояние отсутствует (достигнутовнешнее состояние), поиск реакции считается безуспешным. То есть события исключения никогда не будут отправлены в ортогональные регионы, кроме той, которая вызвала событие исключения.
   • Если исключение выбрасывается во время поиска реакции на исключение или выполнения реакции, то исключение распространяется из объекта функцииexceptionEventHandler(то естьExceptionTranslatorявляется, а не, используемым для перевода исключений, выбрасываемых при обработке события исключения).
   • Если реакция на событие исключения не может быть найдена или если машина состояния не стабильна после обработки события исключения, первоначальное исключение переносится. В противном случаеresultобъект возвращается равным возвращенномуsimple_state<>::discard_event().
4. actionиexceptionEventHandlerдоExceptionTranslator::operator()(). ЕслиExceptionTranslator::operator()()бросает исключение, исключение распространяется на вызывающего. Если абонент улавливает исключение, то в настоящее время активное внешнее состояние и все его прямые и косвенные внутренние состояния разрушаются. Сначала уничтожаются внутренние состояния. Другие состояния разрушаются, как только уничтожаются все их прямые и косвенные внутренние состояния. Внутренние состояния каждого состояния разрушаются по числу их ортогональной области. Государство в ортогональной области с наибольшим числом всегда сначала разрушается, затем государство в области со вторым по величине числом и так далее. Продолжение этапа 5 в противном случае (возвратное значение отбрасывается)
5. Обработка всех опубликованных событий (см.process_event()). Возвращается к абоненту, если больше нет опубликованных событий

Throws: Любые исключения распространяются из ExceptionTranslator::operator(). Исключения никогда не происходят в самой библиотеке, но только в коде, поставляемом через параметры шаблона:

• Allocator::rebind<>::other::allocate()
• государственные строители
• reactФункции членов
• exitФункции членов
• переходные действия

void terminate();

Следы:

1. Построение функционального объектаactionс возвратом без параметраoperator()()result, которыйзавершаетв настоящее время активное внешнее состояние, отбрасывает все оставшиеся события и очищает всю информацию об истории.
2. Конструирует объект функцииexceptionEventHandlerсoperator()()возвратомresultи принятием параметра события исключения, который обрабатывает пройденное событие исключения, со следующими отличиями от обработки нормальных событий:
   • С момента, когда исключение было брошено до момента непосредственно после выполнения реакции события исключения, состояния, которые необходимо выйти, только разрушаются, но не называются функции членаexit.
   • Реакциявсегда начинается с самого внешнегонестабильного состояния.
   • Что касается обычных событий, то поиск реакции движется наружу, когда текущее состояние не может справиться с событием. Однако если внешнее состояние отсутствует (достигнутовнешнее состояние), поиск реакции считается безуспешным. То есть события исключения никогда не будут отправлены в ортогональные регионы, кроме той, которая вызвала событие исключения.
   • Если исключение выбрасывается во время поиска реакции на исключение или выполнения реакции, то исключение распространяется из объекта функцииexceptionEventHandler(то естьExceptionTranslatorявляется, а не, используемым для перевода исключений, выбрасываемых при обработке события исключения).
   • Если реакция на событие исключения не может быть найдена или если машина состояния не стабильна после обработки события исключения, первоначальное исключение переносится. В противном случаеresultобъект возвращается равным возвращенномуsimple_state<>::discard_event().
3. actionиexceptionEventHandlerдоExceptionTranslator::operator()(). ЕслиExceptionTranslator::operator()()бросает исключение, исключение распространяется на вызывающего. Если абонент улавливает исключение, то в настоящее время активное внешнее состояние и все его прямые и косвенные внутренние состояния разрушаются. Сначала уничтожаются внутренние состояния. Другие состояния разрушаются, как только уничтожаются все их прямые и косвенные внутренние состояния. Внутренние состояния каждого состояния разрушаются по числу их ортогональной области. Государство в ортогональной области с наибольшим числом всегда сначала разрушается, затем государство в области со вторым по величине числом и так далее. В противном случае возвращается к абоненту

Throws: Любые исключения распространяются из ExceptionTranslator::operator(). Исключения никогда не происходят в самой библиотеке, но только в коде, поставляемом через параметры шаблона:

• Allocator::rebind<>::other::allocate()
• государственные строители
• reactФункции членов
• exitФункции членов
• переходные действия

void process_event( const event_base & );

Следы:

1. Выберите пройденное событие в качестве текущего события (отсюда именуемоеcurrentEvent)
2. Начало новойреакциипоиска
3. Выбирает произвольное, но в этой реакции поиск еще не посетил состояние из всех ныне активныхвнутренних состояний. Если такого состояния не существует, то продолжается шаг 10.
4. Конструирует функциональный объектactionс возвращающимсяresultбез параметровoperator()(), который делает следующее:
   1. Поиск реакции, подходящей дляcurrentEvent, начиная с текущего внутреннего состояния и двигаясь наружу, пока не будет найдено состояние, определяющее реакцию для события. Возвращениеsimple_state<>::forward_event(), если не было найдено никакой реакции
   2. Выполняет найденную реакцию. Если результат реакции равен возвратному значениюsimple_state<>::forward_event(), то возобновляется поиск реакции (этап а). Возвращает результат реакции в противном случае
5. Конструирует объект функцииexceptionEventHandler, возвращающийresultи принимающий параметр события исключения, который обрабатывает пройденное событие исключения, со следующими отличиями от обработки нормальных событий:
   • С того момента, когда исключение было отброшено сразу после выполнения реакции события исключения, состояния, которые должны быть выведены, только разрушаются, но не называются функции членаexit.
   • Если машина состояния стабильна при обработке события исключения, то поиск реакции события исключения начинается с самого внутреннего состояния, которое последний раз посещалось во время последнего поиска реакции события (событие исключения было создано в результате этого обычного поиска реакции).
   • Если машина состоянийнестабильнапри обработке события исключения, то поиск реакции события исключения начинается с самого внешнегонестабильного состояния.
   • Что касается обычных событий, то поиск реакции движется наружу, когда текущее состояние не может справиться с событием. Однако если внешнее состояние отсутствует (достигнутовнешнее состояние), поиск реакции считается безуспешным. То есть события исключения никогда не будут отправлены в ортогональные регионы, кроме той, которая вызвала событие исключения.
   • Если исключение выбрасывается во время поиска реакции на исключение или выполнения реакции, то исключение распространяется из объекта функцииexceptionEventHandler(то естьExceptionTranslatorявляется, а не, используемым для перевода исключений, выбрасываемых при обработке события исключения).
   • Если реакция на событие исключения не может быть найдена или если машина состояния не стабильна после обработки события исключения, первоначальное исключение переносится. В противном случаеresultобъект возвращается равным возвращенномуsimple_state<>::discard_event().
6. actionиexceptionEventHandlerдоExceptionTranslator::operator()(). ЕслиExceptionTranslator::operator()()бросает исключение, исключение распространяется на вызывающего. Если абонент улавливает исключение, то в настоящее время активное внешнее состояние и все его прямые и косвенные внутренние состояния разрушаются. Сначала уничтожаются внутренние состояния. Другие состояния разрушаются, как только уничтожаются все их прямые и косвенные внутренние состояния. Внутренние состояния каждого состояния разрушаются по числу их ортогональной области. Государство в ортогональной области с наибольшим числом всегда сначала разрушается, затем государство в области со вторым по величине числом и так далее. Далее следует шаг 7
7. Если величина возвратаExceptionTranslator::operator()()равна единицеsimple_state<>::forward_event(), то этап 3 продолжается.
8. Если значение возвратаExceptionTranslator::operator()()равноsimple_state<>::defer_event(), то значение возвратаcurrentEvent.intrusive_from_this()сохраняется в очереди отложенных событий. Продолжение шага 11
9. Если величина возвратаExceptionTranslator::operator()()равна единицеsimple_state<>::discard_event(), то она продолжается с шагом 11.
10. Звонкиstatic_cast< MostDerived * >( this )->unconsumed_event( currentEvent ). Еслиunconsumed_event()бросает исключение, исключение распространяется на вызывающего. Такое исключение никогда не приводит к разрушению каких-либо государств (в отличие от исключений, распространяемых изExceptionTranslator::operator()()).
11. Если выложенная очередь событий не пуста, то выстраивает очередь первого события, выбирает его какcurrentEventи продолжает шаг. 2.Возврат к абоненту в противном случае

Throws: Любые исключения, распространяемые из Большинство заведенных::unconsumed_event() или ExceptionTranslator(). Исключения никогда не происходят в самой библиотеке, но только в коде, поставляемом через параметры шаблона:

• Allocator::rebind<>::other::allocate()
• государственные строители
• reactФункции членов
• exitФункции членов
• переходные действия
• MostDerived::unconsumed_event()

void post_event(
  const intrusive_ptr< const event_base > & );

Эффекты: вставляет прошедшее событие в очередь событий
Throws: Любые исключения, распространяемые из Аллокат()

void post_event( const event_base & evt );

Effects: post_event(evt.intrusive_from_this() );
Throws: Любые исключения, распространяемые из Allocator::allocate()

void unconsumed_event( const event_base & evt );

Эффекты: Нет
Note: Эта функция (или, если она присутствует, так же называемая производная функция члена класса) называется процесс_event() всякий раз, когда отправленное событие не вызвало реакцию, см. процесс_event() эффекты, точка 10 для получения дополнительной информации.

Class template state_machine observer functions

bool terminated() const;

Возвращение:Правда, если машина прекращается. Returns false в противном случае
Note: эквивалентно state_begin() == state_end()

template< class Target >
Target state_cast() const;

Возвращение: В зависимости от формы Target либо ссылка, либо указатель на const если по крайней мере одно из действующих в настоящее время состояний может быть успешно динамическое_cast на Target. Возвращает 0 для указателей и бросков std::bad_cast для справочных целей в противном случае. Target может принимать любую из следующих форм: const Class * или const Class &
Throws: std::bad_cast, если Target не является исходным типом, и ни одно из активных состояний не может быть dynamic_cast на Target
Note: последовательность поиска такая же, как для процесс_event

template< class Target >
Target state_downcast() const;

Requires: Для справочных целей компилятор должен поддерживать частичную специализацию шаблонов класса, в противном случае будет получена ошибка компиляции-времени. Тип обозначается Target должно быть моделью Симплуатация или Государство понятий
Возвращение: В зависимости от формы Таргет либо ссылка, либо указатель на const, если Таргет равен наиболее выдающемуся типу действующего состояния. Возвращает 0 для указателей и бросков std::bad_cast для справочных целей в противном случае. Target может принимать любую из следующих форм: const Class * или const Class &
Throws: std::bad_cast если Target является исходным типом, и ни одно из активных состояний не имеет наиболее производного типа, равного Target
Note: Последовательность поиска такая же, как и для процесс_event()

state_iterator state_begin() const;

state_iterator state_end() const;

Возвращение: Итератор объектов, диапазон [ состояния_begin(), состояния_end()) относится ко всем действующим в настоящее время внутренним состояниям. Для объекта i типа state_iterator, *i возвращает const state_base_type & и i.operator->() возвращает const state_base_type *
Note: положение самого внутреннего состояния в диапазоне произвольно. Он может меняться с каждым вызовом к функции модулятора. Более того, все итераторы аннулируются всякий раз, когда функция модулятора называется

const event_base * triggering_event();

Возвращения: Указание на событие, вызвавшее реакцию, которая в настоящее время выполняется. Возвращает 0, если не выполняется реакция или если текущая реакция была спровоцирована либо инициатом() или термин()

Header <boost/statechart/
asynchronous_state_machine.hpp>

Class template asynchronous_state_machine

Это шаблон базового класса всех асинхронных государственных машин.

Class template asynchronous_state_machine parameters

Class template asynchronous_state_machine synopsis

namespace boost
{
namespace statechart
{
  template<
    class MostDerived,
    class InitialState,
    class Scheduler = fifo_scheduler<>,
    class Allocator = std::allocator< void >,
    class ExceptionTranslator = null_exception_translator >
  class asynchronous_state_machine :
    public state_machine<
      MostDerived, InitialState, Allocator, ExceptionTranslator >,
    public event_processor< Scheduler >
  {
    protected:
      typedef asynchronous_state_machine my_base;
      asynchronous_state_machine(
        typename event_processor< Scheduler >::my_context ctx );
      ~asynchronous_state_machine();  
  };
}
}

Class template asynchronous_state_machine constructor and destructor

asynchronous_state_machine(
  typename event_processor< Scheduler >::my_context ctx );

Эффекты: Строит нерующуюся асинхронную машину состояния
Note: Пользователи не могут создавать объекты asynchronous_state_machine> подтипа непосредственно. Это можно сделать только через объект класса Scheduler

~asynchronous_state_machine();

Эффекты: Деструктурирует государственную машину
Note: Пользователи не могут уничтожить asynchronous_state_machine> объекты подтипа напрямую. Это можно сделать только через объект класса Scheduler

Header <boost/statechart/event_processor.hpp>

Class template event_processor

Это шаблон базового класса всех типов, которые обрабатывают события. asynchronous_state_machine<> - это всего лишь одна возможная реализация процессора событий.

Class template event_processor parameters

Class template event_processor synopsis

namespace boost
{
namespace statechart
{
  template< class Scheduler >
  class event_processor
  {
    public:
      virtual ~event_processor();
      Scheduler & my_scheduler() const;
      typedef typename Scheduler::processor_handle
        processor_handle;
      processor_handle my_handle() const;
      void initiate();
      void process_event( const event_base & evt );
      void terminate();
    protected:
      typedef const typename Scheduler::processor_context &
        my_context;
      event_processor( my_context ctx );
    private:
      virtual void initiate_impl() = 0;
      virtual void process_event_impl(
        const event_base & evt ) = 0;
      virtual void terminate_impl() = 0;
  };
}
}

Class template event_processor constructor and destructor

event_processor( my_context ctx );

Эффекты: Конструирует объект процессора событий и хранит копии ссылки, возвращенной myContext.my_tabler(), и объект, возвращенный myContext.my_handle()
Note: Пользователи не могут создавать объекты event_processor<> подтипа непосредственно. Это можно сделать только через объект Scheduler класс

virtual ~event_processor();

Эффекты: Деструктурирует объект процессора событий
Note: Пользователи не могут уничтожить event_процессор<> объекты подтипа непосредственно. Это можно сделать только через объект класса Scheduler

Class template event_processor modifier functions

void initiate();

Эффекты: инициат_impl();
Throws: Любые исключения, распространяемые из реализации инициат_impl()

void process_event( const event_base & evt );

Эффекты: процесс_event_impl(evt);
Throws: Любые исключения, распространяемые из реализации процесс_event_impl()

void terminate();

Эффекты: terminate_impl();
Throws: Любые исключения, распространяемые из реализации terminate_impl()

Class template event_processor observer functions

Scheduler & my_scheduler() const;

Возвраты: Шетулер ссылка получена в конструкторе

processor_handle my_handle() const;

Возвращения: процессор_ручка объект, полученный в конструкторе

Header <boost/statechart/fifo_scheduler.hpp>

Class template fifo_scheduler

Этот шаблон класса является моделью концепции Scheduler.

Class template fifo_scheduler parameters

Class template fifo_scheduler synopsis

namespace boost
{
namespace statechart
{
  template<
    class FifoWorker = fifo_worker<>,
    class Allocator = std::allocator< void > >
  class fifo_scheduler : noncopyable
  {
    public:
      fifo_scheduler( bool waitOnEmptyQueue = false );
      typedef implementation-defined processor_handle;
      class processor_context : noncopyable
      {
        processor_context(
          fifo_scheduler & scheduler,
          const processor_handle & theHandle );
        fifo_scheduler & my_scheduler() const;
        const processor_handle & my_handle() const;
        friend class fifo_scheduler;
        friend class event_processor< fifo_scheduler >;
      };
      template< class Processor >
      processor_handle create_processor();
      template< class Processor, typename Param1 >
      processor_handle create_processor( Param1 param1 );
      // More create_processor overloads
      void destroy_processor( processor_handle processor );
      void initiate_processor( processor_handle processor );
      void terminate_processor( processor_handle processor );
      typedef intrusive_ptr< const event_base > event_ptr_type;
      void queue_event(
        const processor_handle & processor,
        const event_ptr_type & pEvent );
      typedef typename FifoWorker::work_item work_item;
      void queue_work_item( const work_item & item );
      void terminate();
      bool terminated() const;
      unsigned long operator()(
        unsigned long maxEventCount = 0 );
  };
}
}

Class template fifo_scheduler constructor

fifo_scheduler( bool waitOnEmptyQueue = false );

Effects: Строит объект fifo_tabler<>. В многослойных сборках waitOnEmptyQue направляется конструктору элемента данных типа FifoWorker. В однонаправленных сборках FifoWorker элемент данных по умолчанию структурирован по умолчанию
Note: В однонаправленных сборках fifo_tabler<> конструктор не принимает никаких параметров и operator() таким образом всегда возвращается к звонителю, когда очередь события пуста

Class template fifo_scheduler modifier functions

template< class Processor >
processor_handle create_processor();

Требования: Процедур тип должен быть прямым или косвенным подтипом event_процессора шаблон класса
Эффекты: Создает и переходит к ФифоРабочий::queue_work_item() объект типа ФифоРабочник_пункт, когда позднее он выполняется в Фифооператор(оператор), приводит к вызову объект как единственный аргумент
Возвращение: процессор_handle объект, который отныне идентифицирует созданный объект процессора событий
Throws: Любые исключения, распространяемые из FifoWorker::work_item() и FifoWorker::queue_work_item()
Caution: Нынешнее выполнение этой функции вызывает глобальный оператор новый(3> Если глобальный оператор новый() не заменяется, необходимо позаботиться о том, когда можно назвать эту функцию в приложениях с жесткими требованиями в реальном времени

template< class Processor, typename Param1 >
processor_handle create_processor( Param1 param1 );

void destroy_processor( processor_handle processor );

void initiate_processor( processor_handle processor );

void terminate_processor( processor_handle processor );

void queue_event(
  const processor_handle & processor,
  const event_ptr_type & pEvent );

void queue_work_item( const work_item & item );

void terminate();

unsigned long operator()( unsigned long maxEventCount = 0 );

bool terminated() const;

namespace boost
{
namespace statechart
{
  class exception_thrown : public event< exception_thrown > {};
  template< class ExceptionEvent = exception_thrown >
  class exception_translator
  {
    public:
      template< class Action, class ExceptionEventHandler >
      result operator()(
        Action action,
        ExceptionEventHandler eventHandler )
      {
        try
        {
          return action();
        }
        catch( ... )
        {
          return eventHandler( ExceptionEvent() );
        }
      }
  };
}
}

namespace boost
{
namespace statechart
{
  class null_exception_translator
  {
    public:
      template< class Action, class ExceptionEventHandler >
      result operator()(
        Action action, ExceptionEventHandler )
      {
        return action();
      }
  };
}
}

namespace boost
{
namespace statechart
{
  enum history_mode
  {
    has_no_history,
    has_shallow_history,
    has_deep_history,
    has_full_history // shallow & deep
  };
}
}

void post_event(
  const intrusive_ptr< const event_base > & );
void post_event( const event_base & );
template<
  class HistoryContext,
  implementation-defined-unsigned-integer-type
    orthogonalPosition >
void clear_shallow_history();
template<
  class HistoryContext,
  implementation-defined-unsigned-integer-type
    orthogonalPosition >
void clear_deep_history();
outermost_context_type & outermost_context();
const outermost_context_type & outermost_context() const;
template< class OtherContext >
OtherContext & context();
template< class OtherContext >
const OtherContext & context() const;
template< class Target >
Target state_cast() const;
template< class Target >
Target state_downcast() const;
state_iterator state_begin() const;
state_iterator state_end() const;
const event_base * triggering_event() const;

namespace boost
{
namespace statechart
{
  template<
    class MostDerived,
    class Context,
    class InnerInitial = unspecified,
    history_mode historyMode = has_no_history >
  class simple_state : implementation-defined
  {
    public:
      // by default, a state has no reactions
      typedef mpl::list<> reactions;
      // see template parameters
      template< implementation-defined-unsigned-integer-type
        innerOrthogonalPosition >
      struct orthogonal
      {
        // implementation-defined
      };
      typedef typename Context::outermost_context_type
        outermost_context_type;
      outermost_context_type & outermost_context();
      const outermost_context_type & outermost_context() const;
      template< class OtherContext >
      OtherContext & context();
      template< class OtherContext >
      const OtherContext & context() const;
      template< class Target >
      Target state_cast() const;
      template< class Target >
      Target state_downcast() const;
      // a model of the StateBase concept
      typedef implementation-defined state_base_type;
      // a model of the standard Forward Iterator concept
      typedef implementation-defined state_iterator;
      state_iterator state_begin() const;
      state_iterator state_end() const;
      const event_base * triggering_event() const;
      void post_event(
        const intrusive_ptr< const event_base > & );
      void post_event( const event_base & );
      result discard_event();
      result forward_event();
      result defer_event();
      template< class DestinationState >
      result transit();
      template<
        class DestinationState,
        class TransitionContext,
        class Event >
      result transit(
        void ( TransitionContext::* )( const Event & ),
        const Event & );
      result terminate();
      template<
        class HistoryContext,
        implementation-defined-unsigned-integer-type
          orthogonalPosition >
      void clear_shallow_history();
      template<
        class HistoryContext,
        implementation-defined-unsigned-integer-type
          orthogonalPosition >
      void clear_deep_history();
      static id_type static_type();
      template< class CustomId >
      static const CustomId * custom_static_type_ptr();
      template< class CustomId >
      static void custom_static_type_ptr( const CustomId * );
      // see transit() or terminate() effects
      void exit() {}
    protected:
      simple_state();
      ~simple_state();
  };
}
}

simple_state();

~simple_state();

void post_event(
  const intrusive_ptr< const event_base > & pEvt );

void post_event( const event_base & evt );

result discard_event();

result forward_event();

result defer_event();

template< class DestinationState >
result transit();

template<
  class DestinationState,
  class TransitionContext,
  class Event >
result transit(
  void ( TransitionContext::* )( const Event & ),
  const Event & );

result terminate();

template<
  class HistoryContext,
  implementation-defined-unsigned-integer-type
    orthogonalPosition >
void clear_shallow_history();

template<
  class HistoryContext,
  implementation-defined-unsigned-integer-type
    orthogonalPosition >
void clear_deep_history();

outermost_context_type & outermost_context();

const outermost_context_type & outermost_context() const;

template< class OtherContext >
OtherContext & context();

template< class OtherContext >
const OtherContext & context() const;

template< class Target >
Target state_cast() const;

template< class Target >
Target state_downcast() const;

state_iterator state_begin() const;

state_iterator state_end() const;

const event_base * triggering_event();

static id_type static_type();

template< class CustomId >
static const CustomId * custom_static_type_ptr();

template< class CustomId >
static void custom_static_type_ptr( const CustomId * );

void post_event(
  const intrusive_ptr< const event_base > & );
void post_event( const event_base & );
template<
  class HistoryContext,
  implementation-defined-unsigned-integer-type
    orthogonalPosition >
void clear_shallow_history();
template<
  class HistoryContext,
  implementation-defined-unsigned-integer-type
    orthogonalPosition >
void clear_deep_history();
outermost_context_type & outermost_context();
const outermost_context_type & outermost_context() const;
template< class OtherContext >
OtherContext & context();
template< class OtherContext >
const OtherContext & context() const;
template< class Target >
Target state_cast() const;
template< class Target >
Target state_downcast() const;
state_iterator state_begin() const;
state_iterator state_end() const;
const event_base * triggering_event() const;

namespace boost
{
namespace statechart
{
  template<
    class MostDerived,
    class Context,
    class InnerInitial = unspecified,
    history_mode historyMode = has_no_history >
  class state : public simple_state<
    MostDerived, Context, InnerInitial, historyMode >
  {
    protected:
      struct my_context
      {
        // implementation-defined
      };
      typedef state my_base;
      state( my_context ctx );
      ~state();
  };
}
}

namespace boost
{
namespace statechart
{
  template< class DefaultState >
  class shallow_history
  {
    // implementation-defined
  };
}
}

namespace boost
{
namespace statechart
{
  template< class DefaultState >
  class deep_history
  {
    // implementation-defined
  };
}
}

namespace boost
{
namespace statechart
{
  class event_base
  {
    public:
      intrusive_ptr< const event_base >
        intrusive_from_this() const;
      typedef implementation-defined id_type;
      id_type dynamic_type() const;
      template< typename CustomId >
      const CustomId * custom_dynamic_type_ptr() const;
      
    protected:
      event_base( unspecified-parameter );
      virtual ~event_base();
  };
}
}

event_base( unspecified-parameter );

virtual ~event_base();

intrusive_ptr< const event_base > intrusive_from_this() const;

id_type dynamic_type() const;

template< typename CustomId >
const CustomId * custom_dynamic_type_ptr() const;

namespace boost
{
namespace statechart
{
  template< class MostDerived, class Allocator = std::allocator< void > >
  class event : implementation-defined
  {
    public:
      static void * operator new( std::size_t size );
      static void * operator new( std::size_t size, void * p );
      static void operator delete( void * pEvent );
      static id_type static_type();
      template< class CustomId >
      static const CustomId * custom_static_type_ptr();
      template< class CustomId >
      static void custom_static_type_ptr( const CustomId * );
    protected:
      event();
      virtual ~event();
  };
}
}

event();

virtual ~event();

static void * operator new( std::size_t size );

static void * operator new( std::size_t size, void * p );

static void operator delete( void * pEvent );

static id_type static_type();

template< class CustomId >
static const CustomId * custom_static_type_ptr();

template< class CustomId >
static void custom_static_type_ptr( const CustomId * );

namespace boost
{
namespace statechart
{
  template<
    class Event,
    class Destination,
    class TransitionContext = unspecified,
    void ( TransitionContext::*pTransitionAction )(
      const Event & ) = unspecified >
  class transition
  {
    // implementation-defined
  };
}
}

namespace boost
{
namespace statechart
{
  template<
    class Event,
    class ReactionContext = unspecified,
    void ( ReactionContext::*pAction )(
      const Event & ) = unspecified >
  class in_state_reaction
  {
    // implementation-defined
  };
}
}

namespace boost
{
namespace statechart
{
  template< class Event >
  class termination
  {
    // implementation-defined
  };
}
}

namespace boost
{
namespace statechart
{
  template< class Event >
  class deferral
  {
    // implementation-defined
  };
}
}

namespace boost
{
namespace statechart
{
  template< class Event >
  class custom_reaction
  {
    // implementation-defined
  };
}
}

result react( const Event & );

result discard_event();
result forward_event();
result defer_event();
template< class DestinationState >
result transit();
template<
  class DestinationState,
  class TransitionContext,
  class Event >
result transit(
  void ( TransitionContext::* )( const Event & ),
  const Event & );
result terminate();

namespace boost
{
namespace statechart
{
  class result
  {
    public:
      result( const result & other );
      ~result();
    private:
      // Result objects are not assignable
      result & operator=( const result & other );
  };
}
}

result( const result & other );

~result();