#define IS_ZERRO(VALUE)   (0 == (VALUE))
#define MORE_ZERRO(VALUE) (0 < (VALUE))
#define LESS_ZERRO(VALUE) (0 > (VALUE))
#define NOT_ZERRO(VALUE)  (!IS_ZERRO(VALUE))

#define IS_NULL(PTR)      (Q_NULLPTR == (PTR))
#define NOT_NULL(PTR)     (!IS_NULL(PTR))

#define BETWEEN(VALUE,LOW,HIGH) ( ((VALUE) > (LOW)) && ((VALUE) < (HIGH)) )
#define BETWEEN_L(VALUE,LOW,HIGH) (((VALUE) >= (LOW)) && ((VALUE) < (HIGH)))
#define BETWEEN_H(VALUE,LOW,HIGH) (((VALUE) > (LOW)) && ((VALUE) <= (HIGH)))
#define BETWEEN_ALL(VALUE,LOW,HIGH) (((VALUE) >= (LOW)) && ((VALUE) <= (HIGH)))

#define EQUAL(VALUE,EXPR) ((VALUE) == (EXPR))
#define NOT_EQUAL(VALUE,EXPR) (!EQUAL(VALUE,EXPR))

//На планете Земля (основной процесс main()) некая древняя цивилизация основала город Кафа 
// с вполне определёнными географическими координатами.
City/*::QObject*/* city = City();
city->setObjectName(“Кафа”);
std::out << qPrintable(city) << std::endl;
. . .
//Через века цивилизация утратила своё влияние на город, и город стал принадлежать Крымскому ханству,
QThread* Girey = new QThread(); 
city->setParent(Q_NULLPTR); 
city->moveToThread(Girey);

//  но географические координаты города не изменились.
std::out << qPrintable(city) << std::endl;
. . .
// Что бы ни происходило 
city->setParent(Q_NULLPTR); 
city->moveToThread(RussionImperia); 
. . . 
city->setParent(Q_NULLPTR); 
city->moveToThread(USSR);
. . .
city->setObjectName(“Феодосия”);

// и т.д. 

class FW_LIBRARY FWItem : public QObject
{
  private:
    QPointer<FWStateMachine> m_machine;

  protected:
    /**
     * @brief Метод MachineExists проверяет наличие в объекте класса конечного
     * автомата класса @sa FWStateMachine.
     * @return Булево значение:
     * @value TRUE Автомат присутствует в объекте класса;
     * @value FALSE Конечный автомат не используется.
     */
    virtual bool
    MachineExists () const { return !m_machine.isNull (); }

    /**
     * @brief Метод Machine возвращает указатель на встроенный детерминированный
     * конечный автомат (КА) типа @sa FWStateMachine.
     * @return Указатель на встроенный КА.
     *
     * Класс @sa FWStateMachine является наследником @sa QStateMachine.
     *
     * Метод предназначен для перегрузки при использовании в классах, производных
     * от @sa FWItem, конечного автомата, созданного на основе классас @sa FWStateMachine.
     */
    virtual FWStateMachine*
    Machine () const;
  public:
    /**
     * @brief Метод SetMachine назначает объекту класса конечный автомат.
     * @param aMachine Указатель на объект КА.
     */
    void
    SetMachine (FWStateMachine* aMachine);
}

void
FWStateMachine::Initialisation()
{
  bool v_active = IsActive ();
  if(v_active)
    stop ();

  /// @name Определение группы состояний КА
  /// @{
  if(!StateGroupExists ())
    m_state_group.reset (new FWState(this));

  FWState* sIdle = new FWState(StateGroup ());
  StateGroup ()->setInitialState (sIdle);
  /// @}

  /// @name Назначение правил работы исторического состояния КА
  /// @{

  if(!StateHistoryExists ())
    // переход с историческим состоянием, в качестве цели, закончится в наиболее
    // глубоко вложенном состоянии-потомке @sa m_state_group (@sa QHistoryState::DeepHistory), 
    // в котором родительское
    // находилось в последний раз, когда из него вышли.
    m_state_history.reset (new QHistoryState(QHistoryState::DeepHistory,StateGroup ()));

  /// @}

  /// @name Определение состояниz завершения работы КА
  /// @{

  if(!StateFinalExists ())
    m_state_final.reset (new QFinalState(this));

  /// @}

  /// @name Определение ошибочного состояния КА
  /// @{

  if(!StateErrorExists ())
    m_state_error.reset (new FWState(this));

  /// @}

  /// @name Назначение переходов для основного состояния КА
  /// @{

  AddBranch(FWEvent::ET_INTERNAL,FWInternalEvent::OEI_Stop,
            StateGroup (), StateFinal ());
  AddBranch(FWEvent::ET_INTERNAL,FWInternalEvent::OEI_Error,
            StateGroup (), StateError ());

  /// @}

  /// @name Назначение переходов для состояния приостановки работы
  /// @{

  FWState* sPause = new FWState(this);
  AddBranch(FWEvent::ET_INTERNAL,FWInternalEvent::OEI_Pause,
            StateGroup (), sPause);
  AddBranch(FWEvent::ET_INTERNAL,FWInternalEvent::OEI_Resume,
            sPause, StateHistory ());

  /// @}

  /// @name Назначение переходов для состояния ошибки
  /// @{
  AddBranch(StateError (), StateFinal ());
  /// @}

  /// @name Назначение обработчиков переходов между состояниями КА
  /// @{

  connect( sPause,&FWState::        entered,
           this,  &FWStateMachine:: slot_OnPaused,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  connect( sPause,&FWState::        exited,
           this,  &FWStateMachine:: slot_OnResume,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  connect( StateFinal (),&QFinalState::    entered,
           this,         &FWStateMachine:: slot_OnStop,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  connect( StateError (),&FWErrorState::   entered,
           this,         &FWStateMachine:: slot_OnError,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  connect( StateHistory(),&QHistoryState::defaultStateChanged,
           this,          &FWStateMachine::slot_OnDefaultHistoryChanged,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  /// @}

  if(NOT_EQUAL(initialState (),StateGroup ()))
    setInitialState (StateGroup ());

  StateGroup ()->   setObjectName("State GROUP");
  StateHistory ()-> setObjectName("State HISTORY");
  StateError()->    setObjectName("State ERROR");
  StateFinal()->    setObjectName("State FINAL");
  sPause->          setObjectName("State PAUSE");
  sIdle->           setObjectName("State IDLE");

  if(v_active) start ();
}

  . . .
  protected Q_SLOTS:

    virtual void
    slot_OnLoging ()
    { qDebug() << qPrintable(Q_FUNC_INFO); }

    virtual void
    slot_OnError ()
    { qDebug() << qPrintable(Q_FUNC_INFO); }

    virtual void
    slot_OnPaused ()
    {
      qDebug() << qPrintable(Q_FUNC_INFO);
      if(thread ())
        thread ()->yieldCurrentThread ();
      emit sign_Paused();
    }

    virtual void
    slot_OnResume ()
    {
      qDebug() << qPrintable(Q_FUNC_INFO);
      emit sign_Resumed();
    }

    virtual void
    slot_OnStop ()
    {
      qDebug() << qPrintable(Q_FUNC_INFO);
    }

    virtual void
    slot_OnDefaultHistoryChanged()
    {
      if(StateHistoryExists ())
        if(NOT_NULL(StateHistory()->defaultState()))
          qDebug() << "-H-" << StateHistory()->defaultState()->objectName();
    }
};

void
FWThread::Reconnect()
{
  if(IsAutoDeleted ())
    // Уничтожение экземпляра потока после завершения работы
    connect( this, &QThread::finished,
             this, &QThread::deleteLater,
             Qt::ConnectionType(Qt::QueuedConnection | Qt::UniqueConnection));

  if(MachineExists ())
  {
    // Завершение цикла обработки событий потока при достижении конечным
    // автоматом состояния завершения работы
    connect( Machine (),&FWStateMachine:: finished,
             this,      &QThread::        quit,
             Qt::ConnectionType(Qt::AutoConnection | Qt::UniqueConnection));

    // Завершение работы конечного автомата после согнала потока о
    // завершении работы.
    connect( this,      &QThread::        finished,
             Machine (),&FWStateMachine:: stop,
             Qt::ConnectionType(Qt::AutoConnection | Qt::UniqueConnection));

    /// @name Немедленная ретрансляция сигналов конечного автомата из @sa FWThread
    /// @{
    connect (Machine (),&FWStateMachine:: started,
             this,      &FWThread::       sign_MachineStarted,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));

    connect (Machine (),&FWStateMachine:: stopped,
             this,      &FWThread::       sign_MachineStopped,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));

    connect (Machine (),&FWStateMachine:: sign_Paused,
             this,      &FWThread::       sign_MachinePaused,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));

    connect (Machine (),&FWStateMachine:: sign_Resumed,
             this,      &FWThread::       sign_MachineResumed,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
    /// @}

    // обязать объект потока выполнить некоторые действия немедленно после
    // запуска конечного автомата
    connect (Machine (),&FWStateMachine:: started,
             this,      &FWThread::       slot_AfterMachineStart,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  }
}

///
/// \language Russian
///

#ifndef FW_THREAD_H
#define FW_THREAD_H

#include <FWTypes>

FW_BEGIN_NAMESPACE

//------------------------------------------------------------------------------
/**
 * @brief Внешняя переменная FW_THREAD_WAIT_TIMEOUT содержит значение
 * задержки ожидания для метода @sa QThread::wait.
 *
 * @see QThread
 */
extern unsigned long FW_THREAD_WAIT_TIMEOUT;

//------------------------------------------------------------------------------
class FWThread_helper;
class FWStateMachine;

//------------------------------------------------------------------------------
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWThread : public QThread
{
    friend class FWThread_helper;

    Q_OBJECT

    Q_CLASSINFO("brief",          "Framework Thread Class with QStateMashine")
    Q_CLASSINFO("created",        "03-JUN-2015")
    Q_CLASSINFO("modified",       "23-JUN-2015")
    //
    Q_CLASSINFO("project",        "Common Qt-based Framework")
    //
    Q_CLASSINFO("info_ru",        "http://doc.crossplatform.ru/qt/4.7.x/qthread.html#")

//    Q_DISABLE_COPY(FWThread)

    /// @name Локальные типы класса.
    /// @{
    /// приведение типа базового класса для независимости реализации
    typedef QThread BaseClass;
    /// @}

  public:
    enum FWThreadFlag
    {
      THF_Empty       = 0x00,
      THF_Ready       = 0x01,
      THF_Working     = 0x02,
      THF_Paused      = 0x04,
      THF_AutoDelete  = 0x08,
      THF_Error       = 0x80,
    };
    Q_DECLARE_FLAGS(FWThreadFlags, FWThreadFlag)

  private:

    QPointer<FWThread_helper> m_helper;

    ///
    /// @brief Атрибут m_flags представляет флаги состояния экземпляра потока.
    /// @see FWThreadFlags.
    ///
    QAtomicInt   m_flags;

    /// @name Закрытые (служебные) методы работы с флагами класса
    /// @{

    void
    SetEmpty ()
    {
      m_flags.fetchAndStoreOrdered (THF_Empty);
    }

    void
    SetReady ()
    {
      FWThreadFlags v_flags = Flags () | THF_Ready;
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    void UnsetReady ()
    {
      FWThreadFlags v_flags = Flags () & (~THF_Ready);
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    void
    SetWorking ()
    {
      FWThreadFlags v_flags = Flags () | THF_Working;
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    void
    SetStop ()
    {
      FWThreadFlags v_flags = Flags () & (~THF_Working);
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    void
    SetPause ()
    {
      FWThreadFlags v_flags = Flags () | THF_Paused;
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    void
    SetResume ()
    {
      FWThreadFlags v_flags = Flags () & (~THF_Paused);
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    void
    SetAutoDelete ()
    {
      FWThreadFlags v_flags = Flags () | THF_AutoDelete;
      m_flags.fetchAndStoreOrdered (v_flags);
      Reconnect();
    }

    void
    UnsetAutoDelete ()
    {
      FWThreadFlags v_flags = Flags () & (~THF_AutoDelete);
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    void
    SetError ()
    {
      FWThreadFlags v_flags = Flags () | THF_Error;
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    void
    UnsetError ()
    {
      FWThreadFlags v_flags = Flags () & (~THF_Error);
      m_flags.fetchAndStoreOrdered (v_flags);
    }

    /// @}

    /**
     * @brief Метод InternalRun производит подключение правил взаимодействий
     * экземпляра класса и конечного автомата с установкой признака готовности.
     */
    void
    InternalRun();

  public:

    /**
     * @static
     * @brief Метод SetThreaWaitTimeout назначает новое значение
     * задержки ожидания для метода @sa QThread::wait.
     * @param aValue новое значение задержки ожидания для метода @sa QThread::wait.
     *
     * @see QThread
     */
    static void
    SetThreaWaitTimeout( unsigned long aValue)
    {
      if(NOT_EQUAL(FW_THREAD_WAIT_TIMEOUT,aValue))
        FW_THREAD_WAIT_TIMEOUT = aValue;
    }

    /**
     * @brief Конструктор объекта @sa FWThread
     * @param aAutoDelete Признак автоматического разрушения объекта класса по
     * окончании работы потока.
     * @param aParent указатель на объект-родитель класса.
     *
     * @note Если указатель @sa aParent на объект-родитель класса не пуст,
     * значение параметра @sa aAutoDelete игнорируется, и поток не разрушается
     * автоматически после завершения работы потока выполнения.
     */
    explicit
    FWThread(const bool aAutoDelete = true, QObject* aParent = Q_NULLPTR);

    ~FWThread();

    /**
     * @brief Метод AsBaseClass представляеь указатель на экземпляр (оюъект)
     * класса @sa FWThread как указатель на базовый класс @sa QThread.
     * @return указатель типа @sa QThread на экземпляр дапнного класса.
     */
    BaseClass*
    AsBaseClass () { return qobject_cast<BaseClass*>(this); }

    ///
    /// @brief Метод setParent перегружает базовый метод @sa QObject::setParent.
    /// @param aParent Указатель на объект "родителя"
    /// Метод введён в класс с целью предотвращения вызова автоматического
    /// разрушения объекта класса в случае начальной установки флага @sa aAutoDelete
    /// в значение TRUE.
    /// @see FWThread::FWThread
    ///
    virtual void
    setParent(QObject* aParent);

    /**
     * @brief Метод Flags позволяет получить список флагов экземпляра FWThread.
     * @return Значение флагов потока типа @sa FWThread::FWThreadFlags
     */
    inline FWThreadFlags
    Flags () const { return FWThreadFlags(m_flags.loadAcquire ()); }

    /**
     * @brief Метод Machine возвращает указатель на КА, упроавляющий работой
     * потока.
     * @return указатель на КА текущего экземпляра класса.
     *
     * @warning Конечный автомат выполняется в адресном пространстве рабочего
     * потока, не совпадающем с адресным пространством объекта текущего
     * класса.
     */
    FWStateMachine*
    Machine ();

    /**
     * @brief Метод MachineExists проверяет доступность указатела на КА.
     * @return Булево значение:
     * @value TRUE сообщает о наличии КА;
     * @value FALSE сообщает о том, что экземпляр КА не создан.
     */
    inline bool
    MachineExists () { return NOT_NULL(Machine ()); }

    /**
     * @brief Метод IsValid сообщает об соответствии экземпляра данного класса
     * условиям применения во внешних к объекту класса вычислениях.
     * @return Булево значение:
     * @value TRUE сообщает о выполнении условий валидности экземпляра класса;
     * @value FALSE сообщает о неготовности экземпляра класса к применению.
     */
    virtual bool
    IsValid ();

    /**
     * @brief Метод IsReady информирует о готовности объекта класса к запуску.
     * @return Булево значение:
     * @value TRUE сообщает о готовности объекта потка к запуску;
     * @value FALSE сообщает о неготовности объекта класса к запуску.
     */
    inline bool
    IsReady () const { return Flags ().testFlag (THF_Ready); }

    /**
     * @brief Метод IsAutoDeleted информирует об автоматическом уничтожении
     * экземпляра данного класса после завершения работы основного метода потока.
     * @return Булево значение:
     * @value TRUE сообщает, что объект данного класса будет разрушен автоматически;
     * @value FALSE сообщает, что объект данного класса не будет разрушен автоматически.
     *
     * Например,
     *  @<code>
     *  void foo ()
     *  {
     *    FWTread* v_thread = new FWTread(true);
     *    bool v_with_timeout = <условие>;
     *    ...
     *    thread.quit ();
     *
     *    if(v_with_timeout)
     *    {
     *      if(!thread.wait (FW_THREAD_WAIT_TIMEOUT) )
     *      {
     *      // например,
     *      //  terminate ();
     *      //  wait(1000);,
     *
     *      //  Хотя terminate() не рекомендуется, но наш класс его
     *      //  переопределил как quit() ;)
     *      ...
     *      }
     *    }
     *    else
     *      v_thread->Machine()->stop ();
     *      //Останов конечного автомата вызовет FWTread::quit, FWTread::finished
     *      //вызовет FWTread::deleteLater, произойдёт разрушение v_thread, и
     *      //вызовется деструктор класса @sa FWThread_helper атрибута FWTread::m_helper.
     *  }
     * @</code>
     */
    inline bool
    IsAutoDeleted () const { return Flags ().testFlag (THF_AutoDelete); }

    inline bool
    IsError () const { return Flags ().testFlag (THF_Error); }

    inline bool
    IsWorking () const { return Flags ().testFlag (THF_Working); }

    inline bool
    IsPaused () const { return Flags ().testFlag (THF_Paused); }

    /**
     * @brief Метод AttachObject перемещает объект в адресное пространство
     * потока выполнения.
     * @param aObject Указатель на объект.
     * @return Булево значение:
     * @value TRUE сообщает, что объект перемещён успешно;
     * @value FALSE сообщает, что перемещение объекта вызвало ошибки.
     */
    bool
    AttachObject (QObject* aObject);

    /// @name Перегруженные методы класса @sa QThread
    /// @{

    /**
     * @brief Переопределённый метод класса @sa QThread::terminate.
     * Перед выходом из потока выполнения останавливает КА, если тот активен.
     */
    void terminate();

    /**
     * @brief Переопределённый метод класса @sa QThread::quit.
     * Перед выходом из потока выполнения останавливает КА, если тот активен.
     */
    void quit();

    /// @}

  protected:

    /**
     * @brief Метод Reconnect определяет взаимодействие экземпляра конечного
     * автомата и потока.
     *
     * Посредством привязки сигналов потока и экземпляра КА к слотам потока и КА
     * определяется логика запуска и завершения работы КА. Также порядок
     * разрушения экземпляра КА и экземпляра потока.
     */
    void
    Reconnect ();

    /**
     * @brief Метод run перегружает базовый метод @sa QThread::run.
     * Данный метод инициализирует объект @sa m_helper и начальную настройку
     * класса методом @sa InternalRun
     *
     * До запуска метода цикла обработки событий методом @sa exec() данный метод
     * перенмещает экземпляр КА в адресное пространство потока.
     * Все зависимык от КА объекты, определённые как дочерние, так же автоматически
     * перемещаются в адресное пространство потока.
     * После этого происходит запуск цикла обработки событий методом @sa exec().
     *
     * Метод запускакт Конечный Автомат и цикл обработки событий потока на
     * выполнение.
     * Перед этим вызывается метод @sa BeforeMachineStart.
     *
     * @note Переопределите метод @sa BeforeMachineStart для добавления
     * некоторых состояний и переходов КА.
     *
     * @warning При переопределении не забывайте переместить необходимые объекты
     * в адресное пространство потока выполнения вызовом метода @sa AttachObject.
     *
     * @see QThreadPrivate::start, QThread::start, QThread::exec, QThread::exit.
     */
    void
    run() Q_DECL_OVERRIDE;

  public:

    /**
     * @brief Метод BeforeMachineStart позволяет выполнить некоторые особые
     * действия перед запуском КА и основного алгоритма потока на выполнение.
     *
     * Изначально, КА запрограммирован на работу основных состояний и переходов
     * между ними.
     * Перегрузка данного метода позволяет, скажем, перед запуском КА внести
     * дополнительные состояния КА и переходы между ними или перенаправить
     * существующие.
     *
     * @note Используйте перегрузку данного метода для определения собственных
     * состояний и переходов КА в дополнение к базовым. В классе @sa FWStateMachine
     * определено начальное состояние как группа для возможных пользовательских
     * состояний. Доступ к нему можно получить методом вызова последовательности
     * методов Machine ()->StateGroup (). В самой группе изначально определено
     * собственное начальное состояние, которое можно использовать для начала
     * переходов. Доступ к начальному состоянию группы можно получить вызовом
     * метода Machine ()->StateIdle ().
     *
     * Пример перегрузки метода @sa BeforeMachineStart в классе FWUsbScanner
     * определения подключения/отключения USB-устройств:
     * @<code>
     *
     * @<code>
     *
     * @see FWStateMachine, FWState
     * @see QStateMachine, QState, QAbstractTransition
     */
    virtual void
    BeforeMachineStart () {}

    /**
     * @brief Метод BeforeThreadDone позволят выполнить некоторые особые
     * действия перед завершением работы основного алгоритма потока.
     *
     * Необходимость в таком методе возникает потому, что у процедуры потока
     * есть только одна точка входа, но может быть много точек выхода.
     *
     * Метод @sa BeforeThreadDone() избавляет от необходимости дублировать код.
     *
     * Для внесения специфичных действий необходимо перегрузить данный метод.
     *
     * @note Важно помнить: тело метода будет выполняться в адреадресном
     * пространстве потока, но не в адресном пространстве экземпляра
     * данного класса @sa FWThread!
     *
     * @note Важно помнить: тело метода будет выполняться в адреадресном
     * пространстве потока, но не в адресном пространстве экземпляра
     * данного класса @sa FWThread!
     *
     * Данный метод будет вызван даже в случае возникновения исключительной
     * ситуации в методе @sa FWThread::run.
     */
    virtual void
    BeforeThreadDone() {}

    /**
     * @brief Метод AfterThreadDone позволят выполнить некоторые особые действия
     * после завершения работы основного алгоритма потока.
     *
     * Необходимость в таком методе возникает потому, что у процедуры потока
     * есть только одна точка входа, но может быть много точек выхода.
     *
     * Метод @sa AfterThreadDone, как и метод @sa BeforeThreadDone(), избавляет
     * от необходимости дублировать код.
     *
     * Для внесения специфичных действий необходимо перегрузить данный метод.
     *
     * @note Важно помнить: тело метода будет выполняться, всё еще,в адреадресном
     * пространстве потока, но не в адресном пространстве экземпляра
     * данного класса @sa FWThread!
     *
     * Данный метод будет вызван даже в случае возникновения исключительной
     * ситуации в методе @sa FWThread::run.
     */
    virtual void
    AfterThreadDone() {}

    /**
     * @brief Метод ThreadDone выполняет действия, связанные с завершением
     * работы потока.
     *
     * Этот метод нужно вызывать тогда, когда завершается работа потока без
     * участия @sa IsBreak (например, в конце процедуры потока).
     * Метод @sa IsBreak , при необходимости, вызовет этот метод сам.
     */
    void
    ThreadDone ();

  Q_SIGNALS:

    /**
     * @brief Сигнал sign_MachineChanged оповещает об изменении адреса объекта
     * КА после создания его в потоке или удаления (разрушения).
     * @param aPointer указатель на объект Конечного автомата (КА).
     */
    void
    sign_MachineChanged(const FWStateMachine* aPointer);

    /**
     * @brief Сигнал sign_MachineStarted оповещает о запуске КА на выполнение.
     * @note Является ретрансляцией сигнала @sa QStateMachine::started;
     */
    void
    sign_MachineStarted();

    /**
     * @brief Сигнал sign_MachineStopped оповещает о хавершении работы КА.
     * @note Является ретрансляцией сигнала @sa QStateMachine::finished;
     */
    void
    sign_MachineStopped();

    /**
     * @brief Сигнал sign_MachinePaused оповещает о приостановке работы КА.
     */
    void
    sign_MachinePaused ();

    /**
     * @brief Сигнал sign_MachineResumed оповещает о возобновлении работы КА.
     */
    void
    sign_MachineResumed ();

    /**
     * @brief Сигнал sign_ObjectAddress ретранслирует сигнал @sa FWItem::sign_ObjectAddress
     * от объектов, принадлежащих адресному пространству потока выполнения.
     * @param aMyAddress указатель на объект (значение адреса)
     */
    void
    sign_ObjectAddress (QObject* aMyAddress);

  public Q_SLOTS:

    /**
     * @brief Слот slot_AfterMachineStart позволяет выполнить некоторые действия
     * после запуска КА на выполнение.
     *
     * Действия, описанные данным слотом, выполняться лишь после запуска цикла
     * обработчика события потока методом @sa QThread::exec. Таким образом, метод
     * @sa FWStateMachine::start не запустит данный слот на выполнение до
     * вызова @sa QThread::exec.
     *
     * Перегруженный в данном классе метод QThread::run сперва вызывает метод
     * @sa FWStateMachine::start, а затем и  @sa QThread::exec.
     *
     * @note Важно помнить: тело метода будет выполняться в адреадресном
     * пространстве потока, но не в адресном пространстве экземпляра
     * данного класса @sa FWThread!
     */
    virtual void
    slot_AfterMachineStart () { if(!IsError ()) SetWorking (); }

    /**
     * @brief Слот slot_Pause запускает на выполнение
     * слот @sa FWStateMachine::slot_Pause.
     */
    void
    slot_Pause ();

    /**
     * @brief Слот slot_Resume  запускает на выполнение
     * слот @sa FWStateMachine::slot_Resume
     */
    void
    slot_Resume ();
};

//------------------------------------------------------------------------------

FW_END_NAMESPACE

Q_DECLARE_OPERATORS_FOR_FLAGS(FW_NAMESPACE::FWThread::FWThreadFlags)

#endif // FW_THREAD_H

#include "FWThread.h"
#include "FWStateMachine.h"
#include <FWItem>
#include <QException>

FW_BEGIN_NAMESPACE

//------------------------------------------------------------------------------
unsigned long FW_THREAD_WAIT_TIMEOUT  = 7000;

//------------------------------------------------------------------------------
/**
 * @brief Класс FWThread_helper представляет воспомогательные действия по
 * корректному завершению рабочего потока класса @sa FQThread.
 *
 * Объект класса формируется в адресном пространстве рабочего потока объекта
 * класса @sa FQThread. Для этого переопределяется метод @sa Qthread::run :
 * @<code>
 * FWThread::run()
 * {
 *    QScopedPointer<FWThread_helper> v_helper(new FWThread_helper(this));
 *
 * }
 * @</code>
 *
 * "Умный" указатель v_helper на объект класса @sa FWThread_helper гарантирует
 * разрушение объекта после завершения выполнения рабочего потока даже при
 * возникновении исключительной ситуации.
 *
 * Класс опознаёт поток-хозяин типа @sa FWThread по содержимому атрибута
 * @sa m_ext_thread.
 *
 * В классе объявлен атрибут @sa m_fsm, представляющий детерминированный
 * конечный автомат типа @sa FWStateMachine как потомок класса @sa QStateMachine.
 *
 * Деструктор @sa ~FWThread_helper класса произведёт корректный останов
 * конечного автомата и разрушение всех зависимых объектов из контейнера
 * @sa FWThread_helper::m_objects_container.
 *
 * @warning Необходимо помнить, что указатель @sa FWThread_helper::m_ext_thread
 * на объект класса @sa FWThread остаётся неизменным. Разрушение объекта-потока
 * в даннолм классе не происходит. Поток можно перезапустить на выполнение.
 */
class
  #ifdef FW_LIBRARY
      FW_SHARED_EXPORT
  #else
      Q_DECL_EXPORT
  #endif
FWThread_helper : public QObject
{
//    Q_OBJECT

    /**
     * @brief Тип TSharedObject представляет ссылку на объект класса @sa QObject
     * как общий "умный" указатель.
     *
     * @see QSharedPointer, QObject
     */
    typedef QSharedPointer<QObject> TSharedObject;

    /**
     * @brief Тип TObjectsList определяет структуру списка объектов, используемых
     * рабочим потоком объекта @sa m_ext_thread.
     *
     * @value TObjectsList::at(<i>) обвёрнутый типом @sa TSharedObject указатель
     * на объект, используемый рабочим потоком атрибута @sa m_ext_thread.
     */
    typedef QList<TSharedObject>  TObjectsList;

  private:
    /**
     * @brief Атрибут m_ext_thread содержит ссылку на объект @sa FWThread.
     */
    QPointer<FWThread> m_ext_thread;

    /**
     * @brief Атрибут m_fsm представляет детерминированный конечный автомат,
     * управляющий последовательностью действий в рабочем потоке объекта
     * @sa m_ext_thread.
     */
    QPointer<FWStateMachine>  m_fsm;

    /**
     * @brief Атрибут m_objects_container представляет список указателей типа
     * @sa TSharedObject на внешние объекты, используемые потоком атрибута
     * @sa m_ext_thread.
     *
     * @note Объекты перемещены в адресноe пространство потока выполнения класса
     * @sa FWThread по значению указателя атрибута @sa m_ext_thread.
     */
    TObjectsList  m_objects_container;

    /**
     * @static
     * @brief Статический метод OnDeleteLater определяет деструктор для
     * очередного объекта из контейнера @sa m_objects_container, используемого
     * рабочим потоком атрибута @sa m_ext_thread.
     * @param aObject Указатель на объект.
     */
    static
    void OnDeleteLater(QObject* aObject)
    {
      if(NOT_NULL(aObject))
        aObject->deleteLater();
    }

  public:

    /**
     * @brief Метод ClearObjects очищает список объектов, используемых
     * рабочим потоком атрибута @sa m_ext_thread.
     */
    void
    ClearObjects ()
    {
      Q_FOREACH(TSharedObject v_obj, m_objects_container)
          v_obj.reset();
      m_objects_container.clear ();
    }

    /**
     * @brief Метод LocateObject проверяет вхождения объекта в контейнер.
     * @param aObject Указатель на проверяемый объект.
     * @return Булево значение:
     * @value TRUE указатель на объект в контейнере;
     * @value FALSE указатель на объект не размещен в контейнере.
     */
    bool
    LocateObject (const QObject* aObject) const
    {
      Q_FOREACH(TSharedObject v_obj, m_objects_container)
          if(EQUAL(v_obj.data (),aObject))
            return true;
      return false;
    }

    /**
     * @brief Конструктор FWThread_helper класса @sa FWThread_helper.
     * @param aThread Указатель на обслуживаемый классом @sa FWThread_helper
     * объекта класса @sa FWThread.
     *
     * @warning Параметр @sa aThread не должен быть NULL, т.к. теряется весь
     * смысл объекта данного класса.
     */
    explicit
    FWThread_helper(FWThread* aThread)
      : QObject     (Q_NULLPTR)
      , m_ext_thread(aThread)
      , m_fsm       (new FWStateMachine)
    {
      Q_ASSERT(NOT_NULL(m_ext_thread));
      m_objects_container.clear ();
    }

    /**
     * @brief Деструктор класса @sa FWThread_helper.
     *
     * Деструктор вызывается перед выходом из метода @sa FWThread::run.
     * Деструктор обеспечивает корректное удаление объектов, используемых
     * рабочим потоком объекта @sa m_ext_thread.
     *
     * Деструктор выполняет набор методов класса @sa FWThread перед какой-либо
     * точкой выхода из потока (прерывание, корректное завершение, выход при
     * возникновении исключительной ситуации)
     */
    ~FWThread_helper()
    {
      if(NOT_NULL(m_ext_thread))
      {
        m_ext_thread->BeforeThreadDone ();
        m_ext_thread->ThreadDone ();
        m_ext_thread->AfterThreadDone ();
      }
      ClearObjects ();
      m_fsm->deleteLater ();
    }

    /**
     * @brief Метод Machine представляет указатель на детерминированный конечный
     * автомат (КА).
     * @return указатель на объект конечного автомата.
     *
     * Объект КА расположен в адресном пространстве рабочего потока, а не
     * объекта класса @sa FWThread.
     */
    FWStateMachine*
    Machine () const { return m_fsm; }

    /**
     * @brief Метод InsertObject добавляет объект класса @sa QObject к потоку
     * выполнения.
     * @param aObject Указатель на объект.
     *
     * Если класс объекта наследуется от класса @sa FWItem фреймворка, то
     * происходит переадресация сигналов запроса указателя на объект.
     *
     * @note Для функции рабочего потока необходимо позаботится о проверке
     * флага @sa FWItem::SF_Active методом @sa FWItem::IsActive, чтобы
     * выйти из неё в какой-либо момент. Cлот @sa FWItem::slot_BreakProcess
     * подключён к сигналу @sa FWStateMachine::finished, что даёт возможность
     * установки флага активности @sa FWItem::SF_Active в нерабочее состояние
     * при вызове переопредеоённых методов @sa FWThread::quit
     * и @sa FWThread::terminate.
     */
    void
    InsertObject (QObject* aObject)
    {
      if(NOT_NULL(aObject) && (!LocateObject(aObject)) )
      {
        aObject->setParent (Q_NULLPTR);
        aObject->moveToThread (m_ext_thread);

        if( aObject->inherits (FW_CLASS_STR(FWItem).toLatin1 ()) )
        {
          // делегирование сигнала запроса адреса объекта
          QObject::connect (qobject_cast<FWItem*>(aObject),
                            &FWItem::   sign_ObjectAddress,
                            m_ext_thread,
                            &FWThread:: sign_ObjectAddress,
                            Qt::ConnectionType(Qt::DirectConnection |
                                               Qt::UniqueConnection));
        }

        m_objects_container.append (TSharedObject(aObject,OnDeleteLater));
      }
    }
};

//------------------------------------------------------------------------------
FWThread::FWThread(const bool aAutoDelete, QObject* aParent)
  : BaseClass (aParent)
  , m_helper  (Q_NULLPTR)
{
  SetEmpty ();
  if(aAutoDelete && IS_NULL(aParent))
    SetAutoDelete ();
}

//------------------------------------------------------------------------------
FWThread::~FWThread()
{
  quit ();
  if(!wait (FW_THREAD_WAIT_TIMEOUT))
  {
    // ну, очень нехороший случай...
    terminate ();
    if(!wait(FW_THREAD_WAIT_TIMEOUT))
      exit(EXIT_FAILURE);
  }
}

//------------------------------------------------------------------------------
void
FWThread::setParent(QObject* aParent)
{
  BaseClass::setParent (aParent);

  bool is_autodelete = bool(Flags () | THF_AutoDelete);
  if(IS_NULL(aParent) && (!is_autodelete))
    SetAutoDelete ();
  else
    if(NOT_NULL(aParent) && (is_autodelete))
      UnsetAutoDelete ();

  if(!IsAutoDeleted ())
    disconnect( this, &QThread::finished, this, &QThread::deleteLater);
}

//------------------------------------------------------------------------------
FWStateMachine*
FWThread::Machine()
{
  return m_helper.isNull () ? Q_NULLPTR : m_helper->Machine ();
}

//------------------------------------------------------------------------------
bool
FWThread::IsValid()
{
  return
      (!IsError()) &&
      (MachineExists () ? Machine ()->IsValid () : false);
}

//------------------------------------------------------------------------------
bool
FWThread::AttachObject(QObject* aObject)
{
  bool v_retval = !m_helper.isNull ();
  if(v_retval)
    m_helper->InsertObject (aObject);

  return v_retval;
}

//------------------------------------------------------------------------------
void
FWThread::terminate()
{
  ThreadDone ();
  BaseClass::terminate ();
}

//------------------------------------------------------------------------------
void
FWThread::quit()
{
  ThreadDone ();
  BaseClass::quit ();
}

//------------------------------------------------------------------------------
void
FWThread::Reconnect()
{
  if(IsAutoDeleted ())
    // Уничтожение экземпляра потока после завершения работы
    connect( this, &QThread::finished,
             this, &QThread::deleteLater,
             Qt::ConnectionType(Qt::QueuedConnection | Qt::UniqueConnection));

  if(MachineExists ())
  {
    // Завершение цикла обработки событий потока при достижении конечным
    // автоматом состояния завершения работы
    connect( Machine (),&FWStateMachine:: finished,
             this,      &QThread::        quit,
             Qt::ConnectionType(Qt::AutoConnection | Qt::UniqueConnection));

    // Завершение работы конечного автомата после согнала потока о
    // завершении работы.
    connect( this,      &QThread::        finished,
             Machine (),&FWStateMachine:: stop,
             Qt::ConnectionType(Qt::AutoConnection | Qt::UniqueConnection));

    /// @name Немедленная ретрансляция сигналов конечного автомата из @sa FWThread
    /// @{
    connect (Machine (),&FWStateMachine:: started,
             this,      &FWThread::       sign_MachineStarted,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));

    connect (Machine (),&FWStateMachine:: stopped,
             this,      &FWThread::       sign_MachineStopped,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));

    connect (Machine (),&FWStateMachine:: sign_Paused,
             this,      &FWThread::       sign_MachinePaused,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));

    connect (Machine (),&FWStateMachine:: sign_Resumed,
             this,      &FWThread::       sign_MachineResumed,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
    /// @}

    // обязать объект потока выполнить некоторые действия немедленно после
    // запуска rонечного автомата
    connect (Machine (),&FWStateMachine:: started,
             this,      &FWThread::       slot_AfterMachineStart,
             Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  }
}

//------------------------------------------------------------------------------
void
FWThread::InternalRun()
{
  QException _e;

  QT_TRY
  {
    if(IsValid ())
    {
      /// подключение правил взаимодействий экземпляра класса и конечного автомата
      Reconnect ();

      SetReady ();

      emit sign_MachineChanged(Machine ());
    }
    else
      _e.raise ();
  }
  QT_CATCH(QException &e)
  {
    UnsetAutoDelete ();
    SetError ();
    qDebug() << qPrintable(e.what ());
  }
}

//------------------------------------------------------------------------------
void
FWThread::run()
{
  FWThread_helper* v_helper = new FWThread_helper(this);
  m_helper = v_helper;

  InternalRun ();

  if(IsValid ())
  {
    BeforeMachineStart ();

    /// Запуск детерминированного Конечного Автомата @sa Machine ().
    Machine ()->start ();

    /// Запуск циклa обработки событий потока. => Начало работы КА.
    BaseClass::exec ();
  }
  else
  {
    if(!IsError ()) SetError ();
    exit (FW_ERR_THREAD_INCOMPLETE);
  }

  m_helper.clear ();
}

//------------------------------------------------------------------------------
void
FWThread::ThreadDone()
{
  SetStop ();

  if(MachineExists ())
  {
    if(Machine ()->IsActive ())
      Machine ()->stop ();
//    QObject::disconnect (Machine ());
  }
}

//------------------------------------------------------------------------------
void
FWThread::slot_Pause()
{
  if(MachineExists())
    Machine ()->slot_Pause();
}

//------------------------------------------------------------------------------
void
FWThread::slot_Resume()
{
  if(MachineExists())
    Machine ()->slot_Resume();
}

//------------------------------------------------------------------------------

FW_END_NAMESPACE

#ifndef FW_EVENT_H
#define FW_EVENT_H

#include <FWConstants>

FW_BEGIN_NAMESPACE

//------------------------------------------------------------------------------
class FWStateMachine;

//------------------------------------------------------------------------------
/**
 * @brief Класс FWEvent описывает структуру событий, принятую в архитектуре
 * данного Фреймворка.
 *
 * Событие может обрабатываться внешним обработчиком (диспетчером) событий
 * или Конечным автоматом (далее -- КА) типа @sa FWStateMachine.
 * Любой объект-наследник класса @sa FWItem может отправлять событие данного
 * формата.
 * Любой объект-наследник класса @sa FWStateMachine КА также может отправлять
 * событие данного формата.
 * Отсутствие указателя на КА-родитель события формирует признак события как
 * системное. Метод @sa FWEvent::IsSystem указывает на данный признак.
 *
 * Объекты класса @sa FWTransition представляют переходы между
 * состояниями КА. Перегруженные методы @sa FWTransition::testEvent отсекают
 * события, не связанные с указанным свойством @sa FWEvent::Machine КА.
 */
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWEvent : public QEvent
{
    Q_GADGET
    Q_ENUMS(FWEventType)

  //----------------------------------------------------------------------------
  private:

    /**
     * @brief Атрибут m_id содержит идентификатор события конкретного типа.
     */
    FWIdentificator m_id;

    /**
     * @brief Атрибут m_params содержит список значений параметров для метода
     * объекта (если таковой назначен), вызываемого обработчиком события.
     */
    QVariantList m_params;

  //----------------------------------------------------------------------------
  public:

    /**
     * @brief Перечисление FWEvent::FWEvents определяет типы событий для
     * работы Конечного автомата.
     */
    enum FWEventType
    {
      ET_SYSTEM,  ///< тип системного события

      /// @name Специфичные для @sa FWEvent Типы событий
      /// @{
      ET_GLOBAL   = QEvent::User  + 1,  ///< тип внешнего (но не системного) события
      ET_INTERNAL = ET_GLOBAL     + 1,  ///< тип служебного события
//TODO: Тип события в разработке...
//      ET_SIGNAL   = ET_INTERNAL + 1,  ///< тип события "Сигнал"
      ET_TASK     = ET_INTERNAL   + 1,  ///< тип события текущей задачи

      /// @}
      ET_MAX      = ET_TASK       + 1,  ///< тип сигнализатор допустимой верхней
                                      ///< границы типов событий
    };

    //--------------------------------------------------------------------------
    /// @name Конструкторы и деструктор класса.
    /// @{

    /**
     * @brief Конструктор FWEvent создаёт инициализированный объект данного класса.
     * @param aEvent Тип события;
     * @param aID Идентификатор события. Для системных событий устанавливается в
     * значение @sa EMPTY_ID.
     * @param aParams Некий дополнительный набор параметров.
     *
     * @note При вызове конструктора без параметров, производится инициализация
     * атрибутов значениями по-умолчанию: неиспользуемым типом события и
     * пустыми ссылками для всех атрибутов-указателей. При этом объект не несёт
     * смысловой нагрузки.
     *
     * @see QEvent, QEvent::Type, FWIdentificator, QVariantList.
     */
    explicit
    FWEvent(QEvent::Type        aEvent,
            FWIdentificator     aID     = EMPTY_ID,
            const QVariantList& aParams = QVariantList())
      : QEvent(aEvent)
      , m_id  (aID)
    {
      SetParams (aParams);
    }

    /**
     * @brief Конструктор FWEvent создаёт инициализированный объект данного
     * класса.
     * @param aEvent Тип события, определённый в терминах @sa FWEvent::FWEventType;
     * @param aID Идентификатор события;
     * @param aParams Некий дополнительный набор параметров.
     */
    explicit
    FWEvent(FWEvent::FWEventType  aEvent,
            FWIdentificator       aID,
            const QVariantList&   aParams = QVariantList())
      :FWEvent(static_cast<QEvent::Type>(aEvent), aID, aParams)
    {}

    /**
     * @brief Конструктор FWEvent с копированием значений некоторого события.
     * @param aEvent Cсылка на объект-собфтие источник.
     */
    explicit
    FWEvent(const FWEvent& aEvent)
      : FWEvent (aEvent.type (), aEvent.Identificator (), aEvent.Params ())
    {}

    /// @}

    //--------------------------------------------------------------------------
    /**
     * @brief Метод AsBaseClass приводит указатель на объект класса к указателю
     * типа базового класса.
     * @return Указатель на объект класса как базовый типа QEvent.
     */
    QEvent*
    AsBaseClass () { return static_cast<QEvent*>(this); }

    static bool
    IsValidType (QEvent::Type aType)
    { return BETWEEN(int(aType),QEvent::None, ET_MAX); }

    /**
     * @brief Метод IsValid проверяет событие на принадлежность диапазону типов,
     * обслуживаемых классом.
     * @param aEvent Указатель на событие
     * @return Булево значение:
     * @value TRUE Событие удовлетворяет условиям класса;
     * @value FALSE Событие не удовлетворяет условиям класса.
     */
    static bool
    IsValid (QEvent* aEvent)
    {
      if(NOT_NULL(aEvent))
        return IsValidType(aEvent->type());
      return false;
    }

    /**
     * @static
     * @brief Метод IsType проверяет принадлежность типа события к типу из
     * набора @sa FWEvent::FWEventType.
     * @param aEvent Проверяемое событие;
     * @param aType Значение типа события для проверки.
     * @return Булево значение:
     * @value TRUE Событие принадлежит к типу для проверки;
     * @value FALSE Событие не принадлежит к типу для проверки;
     */
    static bool
    IsType (QEvent* aEvent, FWEvent::FWEventType aType)
    {
      bool v_retval = IsValid (aEvent);

      if(v_retval)
      {
        v_retval =
            BETWEEN (int(aEvent->type ()),QEvent::None,ET_GLOBAL) ||
            EQUAL   (aType,ET_SYSTEM);

        if(!v_retval)
          v_retval =  EQUAL(static_cast<FWEvent::FWEventType>(aEvent->type ()),
                           aType);
      }

      return v_retval;
    }

    /**
     * @brief Метод IsSystem проверки события на принадлежность к набору системных
     * событий (определённых в наборе @sa QEvent::Type до QEvent::User)
     * @param aEvent Проверяемое событие.
     * @return Булево значение:
     * @value TRUE Событие системное;
     * @value FALSE Событие не системное.
     */
    static bool
    IsSystem (QEvent* aEvent)
    { return IsType (aEvent, ET_SYSTEM); }

    /**
     * @brief Метод IsGlobal проверки события на принадлежность к набору общих
     * событий, определённых как @sa FWEventType::ET_GLOBAL
     * @param aEvent Проверяемое событие.
     * @return Булево значение:
     * @value TRUE Событие общего назначения;
     * @value FALSE Событие не общего назначения.
     */
    static bool
    IsGlobal (QEvent* aEvent)
    { return IsType (aEvent, ET_GLOBAL); }

    /**
     * @brief Метод IsGlobal проверки события на принадлежность к набору служебных
     * событий, определённых как @sa FWEventType::ET_INTERNAL
     * @param aEvent Проверяемое событие.
     * @return Булево значение:
     * @value TRUE Событие служебное;
     * @value FALSE Событие не служебное.
     */
    static bool
    IsInternal (QEvent* aEvent)
    { return IsType (aEvent, ET_INTERNAL); }

    /**
     * @brief Метод IsGlobal проверки события на принадлежность к набору
     * событий отдельных задач, определённых как @sa FWEventType::ET_TASK
     * @param aEvent Проверяемое событие.
     * @return Булево значение:
     * @value TRUE Событие из набра задач;
     * @value FALSE Событие не из набра задач.
     */
    static bool
    IsTask (QEvent* aEvent)
    { return IsType (aEvent, ET_TASK); }

    /**
     * @brief Метод Identificator отображает идентификатор события
     * конкретного типа @sa FWEvent::FWEventType
     * @return Значение идентификатора события.
     */
    inline FWIdentificator
    Identificator () const { return m_id; }

    inline QVariantList
    Params () const { return m_params; }

    inline void
    SetIdentificator (const FWIdentificator aID)
    {
      if(NOT_EQUAL(Identificator (), aID) )
        m_id = aID;
    }

    inline void
    SetParams (const QVariantList& aParams)
    {
      m_params.clear ();
      m_params.append (aParams);
    }

    inline virtual bool
    IsValid ()
    { return IsValid (AsBaseClass ()) && NOT_EQUAL(Identificator (),EMPTY_ID); }

    virtual FWEvent&
    operator = (const FWEvent& aFrom)
    {
      AsBaseClass ()->operator = (aFrom);

      SetIdentificator(aFrom.Identificator ());
      SetParams       (aFrom.Params ());

      return (*this);
    }

    inline virtual bool
    operator == (const FWEvent& aFrom)
    { return
          EQUAL(type (),          aFrom.type ()         ) &&
          EQUAL(Identificator (), aFrom.Identificator ());
    }

    inline virtual bool
    operator == (const QEvent& aFrom)
    { return EQUAL(type (), aFrom.type ());  }

    inline virtual bool
    operator != (const FWEvent& aFrom) { return NOT_EQUAL(*this, aFrom); }

    inline virtual bool
    operator != (const QEvent& aFrom) { return NOT_EQUAL(*this, aFrom); }
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWSystemEvent : public FWEvent
{
    Q_GADGET
  public:
    explicit
    FWSystemEvent(FWIdentificator     aID,
                  const QVariantList& aParams = QVariantList())
      : FWEvent(FWEvent::ET_SYSTEM, aID, aParams)
    { Q_ASSERT(IsSystem (AsBaseClass ())); }
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWGlobalEvent : public FWEvent
{
    Q_GADGET
  public:
    explicit
    FWGlobalEvent(FWIdentificator     aID,
                  const QVariantList& aParams = QVariantList())
      : FWEvent(FWEventType::ET_GLOBAL, aID, aParams) {}
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWInternalEvent : public FWEvent
{
    Q_GADGET
    Q_ENUMS(FWInternalIdentificators)

  public:

    enum FWInternalIdentificators
    {
      OEI_None  = FWIdentificator(0x00),
      OEI_Start = FWIdentificator(0x01),
      OEI_Stop  = FWIdentificator(0x02),
      OEI_Pause = FWIdentificator(0x04),
      OEI_Resume= FWIdentificator(0x08),
      OEI_Log   = FWIdentificator(0x10),
      OEI_Error = FWIdentificator(0x20),
    };

    explicit
    FWInternalEvent(FWIdentificator     aID     = OEI_None,
                    const QVariantList& aParams = QVariantList())
      : FWEvent(FWEventType::ET_INTERNAL, aID, aParams)
    {}

    bool
    IsValid () Q_DECL_OVERRIDE
    { return FWEvent::IsValid () && NOT_EQUAL(Identificator (),OEI_None); }
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWTaskEvent : public FWEvent
{
    Q_GADGET
  public:
    enum FWUsbTask
    {
      TEI_None      = FWIdentificator(0),
      TEI_Open,
      TEI_Opened,
      TEI_Close,
      TEI_Closed,
      TEI_NewStatus,
      TEI_NewFileName,
      TEI_Write,
      TEI_Writed,
      TEI_Read,
      TEI_Readed,
      TEI_Log,
      TEI_Error,
    };

    explicit
    FWTaskEvent(FWIdentificator     aID     = EMPTY_ID,
                const QVariantList& aParams = QVariantList())
      : FWEvent(FWEventType::ET_TASK, aID, aParams)
    {}

    bool
    IsValid () Q_DECL_OVERRIDE
    { return FWEvent::IsValid () && NOT_EQUAL(Identificator (),EMPTY_ID); }
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWUsbEvent : public FWTaskEvent
{
    Q_GADGET

  private:
    quint16 m_VID;
    quint16 m_PID;
    quint8  m_BusNumber;
    quint8  m_Address;
    quint8  m_Port;

  public:

    enum FWUsbTask
    {
      UEI_None      = FWIdentificator(0),
      UEI_Attached,
      UEI_Detached,
      UEI_ContextChanged,
      UEI_Open,
      UEI_Opened,
      UEI_Close,
      UEI_Closed,
      UEI_WriteBulk,
      UEI_WriteBulkComplete,
      UEI_ReadBulk,
      UEI_ReadBulkComplete,
      UEI_Log,
      UEI_Warning,
      UEI_Error,
    };

    explicit
    FWUsbEvent(quint16              aVendorID,
               quint16              aProductID,
               quint8               aBusNumber,
               quint8               aAddress,
               quint8               aPort,
               FWIdentificator      aID     = FWUsbEvent::UEI_None,
               const QVariantList&  aParams = QVariantList())
      : FWTaskEvent (FWIdentificator(aID), aParams)
      , m_VID       (aVendorID)
      , m_PID       (aProductID)
      , m_BusNumber (aBusNumber)
      , m_Address   (aAddress)
      , m_Port      (aPort)
    {}

    explicit
    FWUsbEvent(FWIdentificator      aID,
               const QVariantList&  aParams = QVariantList())
      : FWUsbEvent(0,0,0,0,0,aID,aParams)
    {}

    inline quint16  VID       () const { return m_VID; }
    inline quint16  PID       () const { return m_PID; }
    inline quint8   BusNumner () const { return m_BusNumber; }
    inline quint8   Address   () const { return m_Address; }
    inline quint8   Port      () const { return m_Port; }

    FWUsbEvent&
    operator = (const FWUsbEvent& aFrom)
    {
      FWEvent::operator = (static_cast<FWEvent>(aFrom));
      m_VID       = aFrom.VID ();
      m_PID       = aFrom.PID ();
      m_BusNumber = aFrom.BusNumner ();
      m_Address   = aFrom.Address ();
      m_Port      = aFrom.Port ();
      return (*this);
    }

    bool
    operator == (const FWUsbEvent& aFrom)
    { return
          FWEvent::operator == (static_cast<FWEvent>(aFrom)) &&
          EQUAL(VID (), aFrom.VID ()) &&
          EQUAL(PID (), aFrom.PID ()) &&
          EQUAL(BusNumner (), aFrom.BusNumner ()) &&
          EQUAL(Address (), aFrom.Address ()) &&
          EQUAL(Port (), aFrom.Port ());
    }
};

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
///
/// @brief FWEventTypeMap
/// @see FWEvent, QEvent, QEvent::Type
///
typedef QMap<FWEvent::FWEventType, FWEvent*> FWEventTypeMap;

typedef QMapIterator<FWEvent::FWEventType, FWEvent*> FWEventTypeMap_I1;
typedef FWEventTypeMap::Iterator FWEventTypeMap_I2;
typedef FWEventTypeMap::ConstIterator FWEventTypeMap_CI;

///
/// @brief FWEventMap
/// @see FWEvent, QEvent, QEvent::Type, FWIdentificator
///
typedef QMap<FWIdentificator, FWEvent*> FWEventMap;

typedef QMapIterator<FWIdentificator, FWEvent*> FWEventMap_I1;
typedef FWEventMap::Iterator FWEventMap_I2;
typedef FWEventMap::ConstIterator FWEventMap_CI;
//------------------------------------------------------------------------------

FW_END_NAMESPACE

//------------------------------------------------------------------------------
Q_DECLARE_METATYPE(FW_NAMESPACE::FWEventTypeMap)
Q_DECLARE_METATYPE(FW_NAMESPACE::FWEventMap)
//------------------------------------------------------------------------------

#endif // FW_EVENT_H

bool
FWTransition::eventTest(QEvent* aEvent)
{
  bool v_retval = FWEvent::IsValid (aEvent);

  if(v_retval)
    v_retval = EQUAL(aEvent->type (),EventType ());

  if(v_retval)
  {
      FWEvent* v_e = static_cast<FWEvent*>(aEvent);
      v_retval =
          EQUAL(v_e->type (),         EventType ()) &&
          EQUAL(v_e->Identificator (),EventID   ());
  }

  return v_retval;
}

class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWUsbEvent : public FWTaskEvent
{
    Q_GADGET

  private:
    quint16 m_VID;
    quint16 m_PID;
    quint8  m_BusNumber;
    quint8  m_Address;
    quint8  m_Port;

  public:

    enum FWUsbTask
    {
      UEI_None      = FWIdentificator(0),
      UEI_Attached,
      UEI_Detached,
      UEI_ContextChanged,
      UEI_Open,
      UEI_Opened,
      UEI_Close,
      UEI_Closed,
      UEI_WriteBulk,
      UEI_WriteBulkComplete,
      UEI_ReadBulk,
      UEI_ReadBulkComplete,
      UEI_Log,
      UEI_Warning,
      UEI_Error,
    };

    explicit
    FWUsbEvent(quint16              aVendorID,
               quint16              aProductID,
               quint8               aBusNumber,
               quint8               aAddress,
               quint8               aPort,
               FWIdentificator      aID     = FWUsbEvent::UEI_None,
               const QVariantList&  aParams = QVariantList())
      : FWTaskEvent (FWIdentificator(aID), aParams)
      , m_VID       (aVendorID)
      , m_PID       (aProductID)
      , m_BusNumber (aBusNumber)
      , m_Address   (aAddress)
      , m_Port      (aPort)
    {}

    explicit
    FWUsbEvent(FWIdentificator      aID,
               const QVariantList&  aParams = QVariantList())
      : FWUsbEvent(0,0,0,0,0,aID,aParams)
    {}

    inline quint16  VID       () const { return m_VID; }
    inline quint16  PID       () const { return m_PID; }
    inline quint8   BusNumner () const { return m_BusNumber; }
    inline quint8   Address   () const { return m_Address; }
    inline quint8   Port      () const { return m_Port; }

    FWUsbEvent&
    operator = (const FWUsbEvent& aFrom)
    {
      FWEvent::operator = (static_cast<FWEvent>(aFrom));
      m_VID       = aFrom.VID ();
      m_PID       = aFrom.PID ();
      m_BusNumber = aFrom.BusNumner ();
      m_Address   = aFrom.Address ();
      m_Port      = aFrom.Port ();
      return (*this);
    }

    bool
    operator == (const FWUsbEvent& aFrom)
    { return
          FWEvent::operator == (static_cast<FWEvent>(aFrom)) &&
          EQUAL(VID (), aFrom.VID ()) &&
          EQUAL(PID (), aFrom.PID ()) &&
          EQUAL(BusNumner (), aFrom.BusNumner ()) &&
          EQUAL(Address (), aFrom.Address ()) &&
          EQUAL(Port (), aFrom.Port ());
    }
};

#ifndef FW_EXECUTE_INSTANCE_H
#define FW_EXECUTE_INSTANCE_H

#include <FWDocument>

FW_BEGIN_NAMESPACE

//------------------------------------------------------------------------------
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWExecuteInstance : public FWDocument
{
    Q_OBJECT

    Q_CLASSINFO("brief",          "FW Execute Instance Class")
    Q_CLASSINFO("created",        "12-MAY-2015")
    Q_CLASSINFO("modified",       "12-MAY-2015")
    //
    Q_CLASSINFO("project",        "Common Qt-based Framework")

    /// @name Локальные типы класса.
    /// @{

    typedef FWDocument BaseClass;

    /// @}

  private:
    ///
    /// @brief m_timer
    ///
    QTimer m_timer;

    ///
    /// @brief m_timer_mode
    ///
    bool m_timer_mode;

  public:
    Q_INVOKABLE explicit
    FWExecuteInstance(bool      aTimerMode = false,
                      QObject*  aParent    = Q_NULLPTR);

    bool
    IsTimerMode() const { return m_timer_mode; }

    void
    Open () Q_DECL_OVERRIDE;

    void
    Close () Q_DECL_OVERRIDE;

    inline void
    StartTimer (int aMSec = 10)
    {
      if((!m_timer.isActive ()) && IsTimerMode ())
        m_timer.start (aMSec);
    }

    inline void
    StopTimer ()
    {
    if(m_timer.isActive ())
      m_timer.stop ();
    }

    inline bool
    IsTiming () const
    { return m_timer.isActive () && IsTimerMode (); }

    void
    SetTimerMode (bool aTimerMode)
    {
      if(EQUAL(m_timer_mode, aTimerMode))
        return;

      bool is_timing = IsTiming ();
      if(is_timing)
        StopTimer ();
      m_timer_mode = aTimerMode;
      if(is_timing || IsTimerMode ())
        StartTimer ();
    }

  public slots:

    virtual void
    slot_OnExecute () {}

    void
    slot_BreakProcess () Q_DECL_OVERRIDE;

    virtual void
    slot_ResumeProcess ()
    {
      Open ();//SetStatus (SF_Active);
      if(IsTimerMode ())
        StartTimer ();
    }
};
//------------------------------------------------------------------------------

FW_END_NAMESPACE

#endif // FW_EXECUTE_INSTANCE_H

#ifndef FW_USB_INSTANCE_H
#define FW_USB_INSTANCE_H

#include "FWUsbTypes.h"
#include "FWExecuteInstance.h"

FW_BEGIN_NAMESPACE

//------------------------------------------------------------------------------
class FWUsbInstance;
class FWUsbConnection;

//------------------------------------------------------------------------------
///
/// \language Russian
/// @brief Класс FWUsbInstance очередной определяет контекст подключения к
/// библиотеке libusb
///
/// При работе с библшиотекой libusb используется понятие libusb сессии.
/// Понятие индивидуальной libusb сессии позволяет программе использовать несколько
/// подключений к библиотеке libusb (или динамически загружать несколько модулей)
/// Это позволит избежать интерференции между отдельными пользователями
/// libusb - например, libusb_set_debug () не будет влиять на другого пользователя
/// библиотеки, и libusb_exit () не будет уничтожать ресурсы, которые другие
/// пользователи по-прежнему используют.
///
/// Сессии создаются libusb_init () и уничтожил через libusb_exit ().
///
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWUsbInstance : public FWExecuteInstance
{
    Q_OBJECT

    Q_CLASSINFO("brief",          "FW LibUSB Instance Class")
    Q_CLASSINFO("created",        "27-MAR-2015")
    Q_CLASSINFO("modified",       "12-MAY-2015")
    //
    Q_CLASSINFO("project",        "Common Qt-based Framework")

    /// @name Локальные типы класса.
    /// @{

    typedef FWExecuteInstance BaseClass;

    /// @}

  private:
    /// @name Сервисные атрибуты внутреннего применения
    /// @{
    ///

    /// @brief m_context контекст подключения к libusb
    /// @see libusb_context, TUsbContext*
    ///
    TUsbContext*  m_context;

    ///
    /// @brief m_log_level уровень отладочной информации
    /// @see libusb_log_levelб TUsbLogLevel
    ///
    TUsbLogLevel    m_log_level;

    QList<QVector<int> > m_attached_list;
    /// @}

  public:

    /// @name Конструкторы и деструктор класса.
    /// @{

    Q_INVOKABLE explicit
    FWUsbInstance(bool          aTimerMode = false /* Thread or Manual*/,
                  TUsbLogLevel  aLogLevel  = LIBUSB_LOG_LEVEL_ERROR /*LIBUSB_LOG_LEVEL_DEBUG*/,
                  QObject*      aParent    = Q_NULLPTR);

    /// @}

    BaseClass*
    AsBaseClass () Q_DECL_OVERRIDE
    { return AsClass<BaseClass>(); }

    bool
    IsValid () const Q_DECL_OVERRIDE
    { return BaseClass::IsValid() && ContextExists (); }

    bool
    IsActive () const  Q_DECL_OVERRIDE
    { return IsValid() && BaseClass::IsActive(); }

    virtual void
    OpenUsbContext (bool aCloseOldContext = false);

    virtual void
    CloseUsbContext ();

    void
    SetContext (TUsbContext* aContext);

    virtual bool
    ContextExists () const { return NOT_ZERRO(UsbContextAsID ()); }

    TUsbContext*
    UsbContext () const { return m_context; }

    void
    MakeUsbDeviceList();

    void
    Open () Q_DECL_OVERRIDE;

    void
    Close () Q_DECL_OVERRIDE;

    void
    Reload ();

  protected:

    void
    Initialisation () Q_DECL_OVERRIDE;

    inline FWIdentificator
    UsbContextAsID () const { return FWIdentificator(UsbContext()); }

    void
    ClearUsbDeviceList ();

  Q_SIGNALS:

    void
    sign_ContextChanged (const QObject*);

    ///
    void
    sign_UsbDeviceAttached (quint8 aBus, quint8 aAddr, quint8 aPort,
                            quint16 aVendorID, quint16 aProductID);

    ///
    /// @brief sign_UsbDeviceDeleted
    /// @param aDevice
    ///
    void
    sign_UsbDeviceDetached(quint8 aBus, quint8 aAddr, quint8 aPort,
                           quint16 aVendorID, quint16 aProductID);

//    void
//    sign_DeviceListChanged (const TUsbDeviceList& aList,
//                            const FWUsbInstance*  aInstance);
//    void
//    sign_UsbDeviceStarted (const FWThreadController* aController);

  public Q_SLOTS:

    void
    slot_OnExecute () Q_DECL_OVERRIDE;

    void
    slot_OnPause ();

    void
    slot_OnResume ();

    bool
    slot_ApplyFilter () Q_DECL_OVERRIDE;

    void
    slot_OnLoop ();
};

//------------------------------------------------------------------------------
///
/// @brief FWSharedUsbInstance Тип @a QSharedPointer контейнер для
/// класса @a FWUsbInstance
///
typedef QSharedPointer<FWUsbInstance> FWSharedUsbInstance;

//------------------------------------------------------------------------------

FW_END_NAMESPACE

#endif // FW_USB_INSTANCE_H

void
FWUsbInstance::Reload()
{
  if(!IsActive()) return;

  libusb_set_debug (m_context, LIBUSB_LOG_LEVEL_NONE);

  // запомнить текущий список устройств
  QList<QVector<int> >  _list_prev = m_attached_list;

  // сформировать актуальный список устройств ...
  MakeUsbDeviceList();

  // ... и поместить в контейнер
  QList<QVector<int> >  _list_now = m_attached_list;

  // удаление отсоединённых устройств
  if(!_list_prev.isEmpty ())
    for(register int i = 0; i < _list_prev.size (); ++i)
      if(_list_now.indexOf (_list_prev.at (i)) < 0)
      {
        slot_OnMachineEvent(
              new FWUsbEvent(
                quint16(_list_prev.at (i).at (3)),//VID
                quint16(_list_prev.at (i).at (4)),//PID
                quint8 (_list_prev.at (i).at (0)),//Bus Number
                quint8 (_list_prev.at (i).at (1)),//Address
                quint8 (_list_prev.at (i).at (2)),//Port Number
                FWUsbEvent::UEI_Detached,));// идентификатор события
      }

  // добавление новых удаление устройств
  if(!_list_now.isEmpty ())
    for(register int i = 0; i < _list_now.size (); ++i)
      if(!_list_prev.contains (_list_now.at (i)))
      {
        slot_OnMachineEvent(
              new FWUsbEvent(
                quint16(_list_prev.at (i).at (3)),//VID
                quint16(_list_prev.at (i).at (4)),//PID
                quint8 (_list_prev.at (i).at (0)),//Bus Number
                quint8 (_list_prev.at (i).at (1)),//Address
                quint8 (_list_prev.at (i).at (2)),//Port Number
                FWUsbEvent::UEI_Attached));// идентификатор события
      }

  libusb_set_debug (m_context, m_log_level);
}

void
FWUsbScanner::BeforeMachineStart()
{
  if(!IsValid ()) return;

  if(m_usb.isNull())
    m_usb = new FWUsbInstance(m_timer_mode);
  m_usb->SetMachine(Machine());

  /// @name Пересылка сигналов о состоянии подключения USB-устройств
  /// @{
  QObject::connect(m_usb,&FWUsbInstance::sign_UsbDeviceAttached,
                   this, &FWUsbScanner:: sign_UsbDeviceAttached,
                   Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  QObject::connect(m_usb,&FWUsbInstance::sign_UsbDeviceDetached,
                   this, &FWUsbScanner:: sign_UsbDeviceDetached,
                   Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  QObject::connect(m_usb,&FWUsbInstance::sign_ContextChanged,
                   this, &FWUsbScanner:: sign_ContextChanged,
                   Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));

  /// @}

  // перемещение в адресное пространство рабочего потока
  if(AttachObject (m_usb.data()))
    QT_TRY
    {
      /// @name Добавление к КА алгоритма сканирования USB-устройств
      /// @{

      QState* sIdle  = Machine ()->StateIdle ();

      // добавление состояния КА "Открыть порт"
      FWState* sOpen  = new FWState(Machine ()->StateGroup ());

      // добавление состояния КА "Сканирование"
      FWState* sScan  = new FWState(Machine ()->StateGroup ());
      sScan->setObjectName("USB Scan");

      // переход на "Открыть порт" после запуска КА
      Machine()->AddBranch(sIdle, sOpen);
      QObject::connect(sOpen, &FWState::entered,
                       m_usb, &FWUsbInstance:: slot_Open,
                       Qt::ConnectionType(Qt::DirectConnection |
                                          Qt::UniqueConnection));

      // переход на "Сканирование" после запуска КА
      Machine()->AddBranch(FWTaskEvent::ET_TASK, FWTaskEvent::TEI_Opened,
                           sOpen, sScan);

      if(!m_usb->IsTimerMode())
      {
        // сканирование не по таймеру: разбить цикл проверки на отдельные
        // состояния и переходы
        FWState* sLoop  = new FWState(Machine ()->StateGroup ());
        Machine()->AddBranch(sScan, sLoop);
        Machine()->AddBranch(FWEvent::ET_TASK,FWTaskEvent::TEI_Read,
                  sLoop, sScan);
        QObject::connect(sLoop, &FWState::entered,
                         m_usb, &FWUsbInstance:: slot_OnLoop,
                         Qt::ConnectionType(Qt::DirectConnection |
                                            Qt::UniqueConnection));
      }

      // выполнить проверку в состоянии "Сканирование"
      QObject::connect(sScan, &FWState::entered,
                       m_usb, &FWUsbInstance:: slot_OnExecute,
                       Qt::ConnectionType(Qt::DirectConnection |
                                          Qt::UniqueConnection));

      // переход на "Пауза" после "Сканирование" по событию
      QObject::connect(Machine(),&FWStateMachine::sign_Paused,
                       m_usb,    &FWUsbInstance:: slot_OnPause,
                       Qt::DirectConnection);

      // возобновить работу после "Пауза" по команде события
      QObject::connect(Machine(),&FWStateMachine::sign_Resumed,
                       m_usb,    &FWUsbInstance:: slot_OnResume,
                       Qt::DirectConnection);

      /// @}
      return; // всё в порядке
    }
    QT_CATCH(QException& e)
    {
      e.what ();
    }

  // сканер не переместился в поток, или призошло исключение
  SetAutoDelete();        // уничтожить поток после exit()
  m_usb->deleteLater ();  // прибрать за собой
  m_usb = Q_NULLPTR;

  exit (EXIT_FAILURE);    // выход из рабочего потока
}

#ifndef FWSTATEMACHINE_H
#define FWSTATEMACHINE_H

#ifndef QSTATEMACHINE_DEBUG
#   define QSTATEMACHINE_DEBUG
#endif

#include "FWState.h"

FW_BEGIN_NAMESPACE


//------------------------------------------------------------------------------
///
/// @brief Класс FWStateMachine представляет объект "Конечный автомат".
/// @see QStateMachine
///
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWStateMachine : public QStateMachine
{
    friend class FWThread;
    Q_OBJECT

    Q_CLASSINFO("brief",          "Finite-state machine Class")
    Q_CLASSINFO("created",        "03-JUN-2015")
    Q_CLASSINFO("modified",       "03-JUN-2015")
    //
    Q_CLASSINFO("project",        "Common Qt-based Framework")
    //
    Q_CLASSINFO("info_en",        "https://en.wikipedia.org/wiki/Finite-state_machine")
    Q_CLASSINFO("info_ru",        "https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D0%B5%D1%87%D0%BD%D1%8B%D0%B9_%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%B0%D1%82")

    /// @name Локальные типы класса.
    /// @{
    /// приведение типа базового класса для независимости реализации
    typedef QStateMachine BaseClass;
    /// @}

  //----------------------------------------------------------------------------
  private:
    ///
    /// @brief Атрибут m_final_signals представляет карту объектов как ключей
    /// с сигналами как значения, переводящими объект данного класса (конечный
    /// автомат) в состояние завершения работы.
    /// @value FWFinalSignalsMap::key() Ключ карты. Указатель на объект,
    /// инициирующий сигнал для завершения работы конечного автомата как
    /// экземпляра данного класса;
    /// @value FWFinalSignalsMap::value () Значение для ключа карты. Сигнал
    /// завершения работы конечного автомата как экземпляра данного класса,
    /// посылаемого объектом-ключом карты.
    ///
    QScopedPointer<FWState> m_state_group;

    ///
    /// @brief Объект m_history_state представляет средство возврата в предыдущее
    /// активное подсостояние для текущего состояния.
    /// Используется для  механизма "прерываний" текущего КА. Суть механизма в том,
    /// чтобы конечный автомат мог выполнить некоторую не связанную задачу,
    /// после чего конечный автомат должен продолжить делать то, что он делал
    /// раньше (т.е. вернутся в прежнее состояние, которое, в этом случае,
    /// является @sa m_state_main)
    ///
    /// @note Историческое состояние создаётся как дочернее состоянию, для
    /// которого мы хотим записать текущее дочернее состояние; когда автомат
    /// обнаруживает присутствие такого состояние во время
    /// выполнения, он автоматически записывает текущее (действительное) дочернее
    /// состояние, когда происходит выход из родительского состояния.
    /// Переход в историческое состояние - это, на самом деле, переход в
    /// дочернее состояние, в котором автомат был ранее сохранён;
    /// автомат, автоматически "направляет" переход к действительному дочернему
    /// состоянию. (\a http://doc.crossplatform.ru/qt/4.7.x/statemachine-api.html)
    ///
    QScopedPointer<QHistoryState> m_state_history;

    ///
    /// @brief Атрибут m_final_state представляет прикреплённый к экземпляру
    /// данного класса указатель на состояние завершения работы конечного
    /// автомата как экземпляра данного класса.
    ///
    QScopedPointer<QFinalState> m_state_final;

    ///
    /// @brief Атрибут m_state_error представляет прикреплённый к экземпляру
    /// данного класса указатель на состояние ошибки.
    ///
    QScopedPointer<FWState> m_state_error;

  //----------------------------------------------------------------------------
  public:

    explicit
    FWStateMachine(QObject* aParent = Q_NULLPTR);

    explicit
    FWStateMachine(QState::ChildMode  aChildMode,
                   QObject*           aParent = Q_NULLPTR);


    BaseClass*
    AsBaseClass() { return qobject_cast<BaseClass*>(this); }

    bool
    StateGroupExists () const { return !m_state_group.isNull (); }

    FWState*
    StateGroup () const
    { return StateGroupExists () ? m_state_group.data () : Q_NULLPTR; }

    inline FWState*
    StateIdle () const
    {
      return
          StateGroupExists () ?
            qobject_cast<FWState*>(StateGroup()->initialState ()):
            Q_NULLPTR;
    }

    inline bool
    StateHistoryExists () const { return !m_state_history.isNull (); }

    inline QHistoryState*
    StateHistory () const
    { return StateHistoryExists () ? m_state_history.data () : Q_NULLPTR; }

    inline bool
    StateFinalExists () const { return !m_state_final.isNull (); }

    inline QFinalState*
    StateFinal () const
    { return StateFinalExists () ? m_state_final.data () : Q_NULLPTR; }

    inline bool
    StateErrorExists () const { return !m_state_error.isNull (); }

    inline FWState*
    StateError () const
    { return StateErrorExists () ? m_state_error.data () : Q_NULLPTR; }

    ///
    /// @brief Метод IsValid сообщает о готовности экземпляра класса как
    /// конечного автомата к работе.
    /// @note Не имеет смысла запускать автомат на выполнение, если у него нет хотя
    /// бы одного условия завершения работы.
    /// @return Булево значение признака готовности к работе:
    /// @value TRUE автомат готов к работе;
    /// @value FALSE автомат не готов к работе: требуется назначение хотя бы
    /// одного условия завершения работы c помощью метода @sa SubscribeFinalSignal;
    /// @see SubscribeFinalSignal
    ///
    virtual bool
    IsValid () const { return NOT_NULL(initialState ()); }

    virtual bool
    IsActive () const { return isRunning (); }

    /**
     * @brief Метод PostEvent ставит событие класса @sa FWEvent в очередь
     * обработчика событияй КА.
     * @param aEvent Указатель на событие типа @sa FWEvent;
     * @param priority Приоритет обслуживания события.
     */
    inline void
    PostEvent(FWEvent* aEvent, EventPriority priority = NormalPriority)
    {
      if(NOT_NULL(aEvent))
        BaseClass::postEvent (aEvent->AsBaseClass (), priority) ;
    }

    /**
     * @brief Метод PostEvent ставит событие типа @sa FWEventType с о значением
     * определённого идентиыикатора в очеоедь обработчика событияй КА.
     * @param aEventType
     * @param aID
     * @param priority
     */
    inline void
    PostEvent(FWEvent::FWEventType aEventType, FWIdentificator aID,
              EventPriority priority = NormalPriority)
    {
      PostEvent (new FWEvent(aEventType,aID), priority) ;
    }

    /**
     * @brief Метод postDelayedEvent перелпределяет базовый
     * метод @sa QStateMachine::postDelayedEvent по постановке события
     * типа @sa FWEvent в очередь обработчика событияй КА c определённой
     * задержкой обслуживания.
     * @param aEvent Указатель на событие типа @sa FWEvent;
     * @param aDelay Значение задержки в милисекундах.
     * @return Идентификатор, ассоциированный с событием, или -1 в случае
     * невозможности отправки сообщения.
     */
    inline int
    PostDelayedEvent(FWEvent* aEvent, int aDelay)
    {
      if(NOT_NULL(aEvent))
        return BaseClass::postDelayedEvent (aEvent->AsBaseClass (), aDelay) ;
      return -1;
    }

    /**
     * @brief PostDelayedEvent
     * @param aEventType
     * @param aID
     * @param aDelay
     */
    inline void
    PostDelayedEvent(FWEvent::FWEventType aEventType, FWIdentificator aID,
              int aDelay)
    {
      PostDelayedEvent(new FWEvent(aEventType,aID), aDelay) ;
    }

    /**
     * @brief Метод Configuration дополняет базовый @sa QStateMachine::configuration
     * ограничением по типу @sa FWState результирующего списка состояний.
     * @return Множество состояний типа @sa FWState КА.
     */
    QSet<FWState*>
    Configuration() const;

    /// @name Группа методов добавления ветвей графа Конечного автомата
    /// @{

    /**
     * @brief AddBranch
     * @param aSource
     * @param aTarget
     * @return
     */
    virtual bool
    AddBranch ( QState* aSource, QAbstractState* aTarget )
    {
      if(NOT_NULL(aSource))
        return aSource->addTransition(aTarget);
      return false;
    }

    /**
     * @brief AddBranch
     * @param aEventType
     * @param aID
     * @param aSource
     * @param aTarget
     * @return
     */
    virtual bool
    AddBranch ( QEvent::Type    aEventType,
                FWIdentificator aID,
                QState* aSource, QAbstractState* aTarget = Q_NULLPTR );

    /**
     * @brief AddBranch
     * @param aEventType
     * @param aID
     * @param aSource
     * @param aTarget
     * @return
     */
    virtual bool
    AddBranch ( FWEvent::FWEventType  aEventType,
                FWIdentificator       aID,
                QState* aSource, QAbstractState* aTarget = Q_NULLPTR );

    /**
     * @brief AddBranch
     * @param aEvent
     * @param aSource
     * @param aTarget
     * @return
     */
    virtual bool
    AddBranch ( FWEvent* aEvent,
                QState* aSource, QAbstractState* aTarget = Q_NULLPTR );

    /// @}
  //----------------------------------------------------------------------------
  protected:

    ///
    /// @brief Метод Initialisation
    ///
    virtual void
    Initialisation ();

  //----------------------------------------------------------------------------
  Q_SIGNALS:

    ///
    /// @brief Сигнал sign_Paused оповещает о переходе КА в режим ожидания.
    ///
    void
    sign_Paused ();

    ///
    /// @brief Сигнал sign_Resumed оповещает о выходе КА из режим ожидания.
    /// @see QStateMachine::started, QStateMachine::stopped
    ///
    void
    sign_Resumed ();

  //----------------------------------------------------------------------------
  public Q_SLOTS:

    ///
    /// @brief Слот slot_Pause производит попытку перевода КА в режим ожидания.
    ///
    void
    slot_Pause ()
    { postEvent (new FWInternalEvent(FWInternalEvent::OEI_Pause)); }

    ///
    /// @brief Слот slot_Resume производит попытку вывода КА из режима ожидания.
    ///
    void
    slot_Resume ()
    { postEvent (new FWInternalEvent(FWInternalEvent::OEI_Resume)); }

  //----------------------------------------------------------------------------
  protected Q_SLOTS:

    ///
    /// @brief slot_OnLoging
    ///
    virtual void
    slot_OnLoging ()
    { qDebug() << qPrintable(Q_FUNC_INFO); }

    ///
    /// @brief slot_OnError
    ///
    virtual void
    slot_OnError ()
    { qDebug() << qPrintable(Q_FUNC_INFO); }

    ///
    /// @brief slot_OnPaused
    ///
    virtual void
    slot_OnPaused ()
    {
      qDebug() << qPrintable(Q_FUNC_INFO);
      if(thread ())
        thread ()->yieldCurrentThread ();
      emit sign_Paused();
    }

    ///
    /// @brief slot_OnResume
    ///
    virtual void
    slot_OnResume ()
    {
      qDebug() << qPrintable(Q_FUNC_INFO);
      emit sign_Resumed();
    }

    ///
    /// @brief slot_OnStop
    ///
    virtual void
    slot_OnStop ()
    {
      qDebug() << qPrintable(Q_FUNC_INFO);
    }

    ///
    /// @brief slot_OnDefaultHistoryChanged
    ///
    virtual void
    slot_OnDefaultHistoryChanged()
    {
      if(StateHistoryExists ())
        if(NOT_NULL(StateHistory()->defaultState()))
          qDebug() << "-H-" << StateHistory()->defaultState()->objectName();
    }
};
//------------------------------------------------------------------------------

FW_END_NAMESPACE

#endif // FWSTATEMACHINE_H

#include "FWStateMachine.h"
#include "FWTransition.h"
#include <QDebug>

FW_USING_NAMESPACE

//------------------------------------------------------------------------------
FWStateMachine::FWStateMachine(QObject* aParent)
  : BaseClass       (aParent)
  , m_state_group   (Q_NULLPTR)
  , m_state_history (Q_NULLPTR)
  , m_state_final   (Q_NULLPTR)
  , m_state_error   (Q_NULLPTR)
{
  Initialisation ();
}

//------------------------------------------------------------------------------
FWStateMachine::FWStateMachine(QState::ChildMode  aChildMode,
                               QObject*           aParent)
  : FWStateMachine(aParent)
{
  BaseClass::setChildMode (aChildMode);
}

//------------------------------------------------------------------------------
QSet<FWState*>
FWStateMachine::Configuration() const
{
  QSet<FWState*> _retval;

  QSet<QAbstractState*> _as =  BaseClass::configuration ();
  Q_FOREACH(QAbstractState* _s, _as)
    _retval.operator += (qobject_cast<FWState*>(_s));
  return  _retval;
}

bool
FWStateMachine::AddBranch(QEvent::Type aEventType, FWIdentificator aID,
                          QState* aSource, QAbstractState* aTarget)
{
  if(NOT_NULL(aSource))
    if(aSource->inherits(FW_CLASS_STR(FWState).toLatin1 ()))
      return qobject_cast<FWState*>(aSource)->addTransition(aEventType, aID,
                                                           aTarget);
  return false;
}

bool FWStateMachine::AddBranch(FWEvent::FWEventType aEventType,
                               FWIdentificator aID,
                               QState* aSource, QAbstractState* aTarget)
{
  if(NOT_NULL(aSource))
  {
    if(aSource->inherits(FW_CLASS_STR(FWState).toLatin1 ()))
      return qobject_cast<FWState*>(aSource)->addTransition(aEventType, aID,
                                                           aTarget);
    else
    {
      QEventTransition* t = new QEventTransition(
                              (QObject*)aID,
                              static_cast<QEvent::Type>(aEventType), aSource);
      if(NOT_NULL(aTarget))
        t->setTargetState(aTarget);
      return true;
    }
  }
  return false;
}

bool
FWStateMachine::AddBranch(FWEvent* aEvent, QState* aSource, QAbstractState* aTarget)
{
  if(NOT_NULL(aSource))
  {
    if(aSource->inherits(FW_CLASS_STR(FWState).toLatin1 ()))
      return qobject_cast<FWState*>(aSource)->addTransition(aEvent, aTarget);
    else
    {
      QEventTransition* t = new QEventTransition(
                              (QObject*)(aEvent->Identificator()),
                              aEvent->type(), aSource);
      if(NOT_NULL(aTarget))
        t->setTargetState(aTarget);
      return true;
    }
  }
  return false;
}

//------------------------------------------------------------------------------
void
FWStateMachine::Initialisation()
{
  bool v_active = IsActive ();
  if(v_active)
    stop ();

  /// @name Определение группы состояний КА
  /// @{
  if(!StateGroupExists ())
    m_state_group.reset (new FWState(this));

  FWState* sIdle = new FWState(StateGroup ());
  StateGroup ()->setInitialState (sIdle);
  /// @}

  /// @name Назначение правил работы исторического состояния КА
  /// @{
  if(!StateHistoryExists ())
    m_state_history.reset (new QHistoryState(QHistoryState::DeepHistory,StateGroup ()));

  /// переход с историческим состоянием, в качестве цели, закончится в наиболее
  /// глубоко вложенном состоянии-потомке @sa m_state_group, в котором родительское
  /// находилось в последний раз, когда из него вышли.
  StateHistory ()->setHistoryType (QHistoryState::DeepHistory);

  /// @}

  /// @name Определение состояниz завершения работы КА
  /// @{
  if(!StateFinalExists ())
    m_state_final.reset (new QFinalState(this));
  StateFinal()->setObjectName("State FINAL");
  /// @}

  /// @name Определение ошибочного состояния КА
  /// @{
  if(!StateErrorExists ())
    m_state_error.reset (new FWState(this));

  /// @}

  /// @name Назначение переходов для основного состояния КА
  /// @{

  AddBranch(FWEvent::ET_INTERNAL,FWInternalEvent::OEI_Stop,
            StateGroup (), StateFinal ());
  AddBranch(FWEvent::ET_INTERNAL,FWInternalEvent::OEI_Error,
            StateGroup (), StateError ());

  /// @}

  /// @name Назначение переходов для состояния приостановки работы
  /// @{

  FWState* sPause = new FWState(this);
  AddBranch(FWEvent::ET_INTERNAL,FWInternalEvent::OEI_Pause,
            StateGroup (), sPause);
  AddBranch(FWEvent::ET_INTERNAL,FWInternalEvent::OEI_Resume,
            sPause, StateHistory ());

  /// @}

  /// @name Назначение переходов для состояния ошибки
  /// @{
  AddBranch(StateError (), StateFinal ());
  /// @}

  /// @name Назначение обработчиков переходов между состояниями КА
  /// @{

  connect( sPause,&FWState::        entered,
           this,  &FWStateMachine:: slot_OnPaused,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  connect( sPause,&FWState::        exited,
           this,  &FWStateMachine:: slot_OnResume,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  connect( StateFinal (),&QFinalState::    entered,
           this,         &FWStateMachine:: slot_OnStop,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  connect( StateError (),&FWErrorState::   entered,
           this,         &FWStateMachine:: slot_OnError,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  connect( StateHistory(),&QHistoryState::defaultStateChanged,
           this,          &FWStateMachine::slot_OnDefaultHistoryChanged,
           Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
  /// @}

  if(NOT_EQUAL(initialState (),StateGroup ()))
    setInitialState (StateGroup ());

  StateGroup ()->   setObjectName("State GROUP");
  StateHistory ()-> setObjectName("State HISTORY");
  StateError()->    setObjectName("State ERROR");
  StateFinal()->    setObjectName("State FINAL");
  sPause->          setObjectName("State PAUSE");
  sIdle->           setObjectName("State IDLE");

  if(v_active) start ();
}

//------------------------------------------------------------------------------

#ifndef FW_TRANSITION_H
#define FW_TRANSITION_H

#include <FWEvent>
#include <QSignalTransition>

FW_BEGIN_NAMESPACE

//------------------------------------------------------------------------------
class FWState;
class FWStateMachine;

//------------------------------------------------------------------------------
///
/// @brief Класс FWTransition описывает переход между состояниями типа @sa FWState
/// конечного автомата типа @sa FWStateMachine.
/// Класс создан наследованием @sa QEventTransition.
///
class
    #ifdef FW_LIBRARY
        FW_SHARED_EXPORT
    #else
        Q_DECL_EXPORT
    #endif
FWTransition : public QAbstractTransition
{
    Q_OBJECT

    Q_CLASSINFO("brief",          "Exlusive  Finite-state Class")
    Q_CLASSINFO("created",        "03-JUN-2015")
    Q_CLASSINFO("modified",       "24-JUN-2015")
    //
    Q_CLASSINFO("project",        "Common Qt-based Framework")

    Q_PROPERTY(FWIdentificator  eventID
               READ             EventID
               WRITE            SetEventID
               NOTIFY           sign_EventIDChanged)
    Q_PROPERTY(QEvent::Type     eventType
               READ             EventType
               WRITE            SetEventType
               NOTIFY           sign_EventTypeChanged)

    //----------------------------------------------------------------------------
    /// @name Локальные типы класса.
    /// @{
    /// приведение типа базового класса для независимости реализации
    /// @see QEventTransition
    typedef QAbstractTransition BaseClass;
    /// @}

    Q_ENUMS(TransitionState)

  //----------------------------------------------------------------------------
  public:

    /**
     * @brief Перечисление TransitionState содержит типы состояний перехода.
     */
    enum TransitionState
    {
      UndefinedState, ///< неопределённое состояние перехода
      SignalState,    ///< переход вызывется сигналом объекта
      EventState,     ///< переход вызывется наступлением события
      ErrorState      ///< переход содержит ошибки
    };

  //----------------------------------------------------------------------------
  private:

    /**
     * @brief Атрибут m_event содержит эталонный экземпляр события
     * обрабатываемого типа.
     *
     * @see FWIdentificator, QEvent, QEvent::Type.
     */
    QEvent::Type    m_event_type;

    /**
     * @brief Атрибут m_event_id cодержит идентификатор события наследника
     * класса @sa FWEvent. В случае поступления событи типа @sa FWSignalEvent,
     * атрибут содержит ссылку на объект отправитель сигнала, приведённй к
     * типу @sa FWIdentificator выражением FWIdentificator(<QObject*>).
     *
     * @see FWTransition::Object, FWTransition::ObjectExists.
     */
    FWIdentificator m_event_id;

    /**
     * @brief Атрибут m_state описывает состояние перехода
     * @see TransitionState
     */
    TransitionState m_state;

  //----------------------------------------------------------------------------
  public:

    /**
     * @brief Конструктор FWTransition перегружает базовый конструктор
     * @sa QAbstractTransition::QAbstractTransition.
     * @param aSourceState Указатель на исходное состояние конечного автомата.
     */
    explicit
    FWTransition(FWState*  aSourceState = Q_NULLPTR);

    /**
     * @brief Конструктор FWTransition создаёт переход по наступлению
     * определённого события типа @sa FWEvent::FWEvent
     * @param aEvent Указатель на событие, вызывающего переход;
     * @param aSourceState Указатель на исходное состояние конечного автомата.
     *
     * "see FWIdentificator, FWEvent, FWState.
     */
    explicit
    FWTransition(QEvent*  aEvent,
                 FWState* aSourceState = Q_NULLPTR);

    /**
     * @brief Конструктор FWTransition создаёт переход по наступлению
     * определённого события типа @sa QEvent::Type.
     * @param aEventType Тип события, вызывающего переход;
     * @param aID Идентификатор события, вызывающего переход;
     * @param aSourceState указатель на исходное состояние конечного автомата.
     *
     * @see QEvent, FWEvent, FWState, QState.
     */
    explicit
    FWTransition(QEvent::Type     aEventType,
                 FWIdentificator  aID,
                 FWState*         aSourceState = Q_NULLPTR);

    /**
     * @brief Конструктор FWTransition создаёт переход по наступлению
     * определённого события типа @sa FWEvent::FWEventType.
     * @param aEventType Тип события, вызывающего переход;
     * @param aID Идентификатор события, вызывающего переход;
     * @param aSourceState указатель на исходное состояние конечного автомата.
     *
     * @see QEvent, FWEvent, FWState, QState.
     */
    explicit
    FWTransition(FWEvent::FWEventType aEventType,
                 FWIdentificator      aID,
                 FWState*             aSourceState = Q_NULLPTR)
      : FWTransition(static_cast<QEvent::Type>(aEventType), aID, aSourceState)
    {}

    /**
     * @brief Конструктор FWTransition создаёт переход по наступлению
     * служебного события (внутреннего для конечного автомата) типа
     * @sa FWEvent::ET_INTERNAL.
     * @param aID Идентификатор события, вызывающего переход;
     * @param aSourceState указатель на исходное состояние конечного автомата.
     *
     * @see QEvent, FWEvent, FWState, QState.
     */
    explicit
    FWTransition(FWInternalEvent::FWInternalIdentificators aID,
                 FWState*         aSourceState = Q_NULLPTR)
      : FWTransition(static_cast<QEvent::Type>(FWEvent::ET_INTERNAL),aID,
                     aSourceState)
    {}

//    explicit
//    FWTransition(QObject*         aSender,
//                 const char*      aSignalName,
//                 QObject*         aRessiver,
//                 const char*      aSlotName,
//                 FWState*         aSourceState = Q_NULLPTR);

    /**
     * @brief Метод AsBaseClass преобразует объект класса к типу базового класса.
     * @return Указатель на объект класса преобразованный к типу базового класса.
     */
    inline BaseClass*
    AsBaseClass () { return qobject_cast<BaseClass*>(this); }

    /**
     * @brief Метод EventType возвращает тип события как @sa QEvent::Type.
     * @return Значение типа события.
     */
    inline QEvent::Type
    EventType () const { return m_event_type; }

    /**
     * @brief Метод SetEventType устанавливает новое значение типа события.
     * @param aType Новое значение типа события.
     */
    inline void
    SetEventType (const QEvent::Type aType)
    {
      if(NOT_EQUAL(EventType (),aType))
      {
        m_event_type = aType;
        emit sign_EventTypeChanged (EventType ());
      }
    }

    /**
     * @brief Метод Identificator отображает идентификатор события, связанного
     * с данным переходом.
     * @return Значение идентификатора типа @sa FWIdentificator.
     */
    inline FWIdentificator
    EventID () const { return m_event_id; }

    /**
     * @brief Метод setEventID устанавливает значение атрибута @sa m_id в
     * значение параметра.
     * @param aID Новое значение идентификатора события для текущего перехода.
     */
    inline void
    SetEventID (const FWIdentificator aID)
    {
      if(NOT_EQUAL(EventID (),aID))
      {
        m_event_id = aID;
        emit sign_EventIDChanged (EventID ());
      }
    }

    FWStateMachine*
    Machine () const;

    inline bool
    operator == (const FWTransition& aOther)
    {
      return
          EQUAL(EventType   (), aOther.EventType  ()) &&
          EQUAL(EventID     (), aOther.EventID    ()) &&
          EQUAL(sourceState (), aOther.sourceState()) &&
          EQUAL(targetState (), aOther.targetState());
    }

  //----------------------------------------------------------------------------
  protected:

    /**
     * @brief Метод SetState устанавливает новое состояние для объекта класса.
     * @param aState Значение для нового состояния для объекта класса
     * @sa TransitionState
     */
    virtual void
    SetState (TransitionState aState)
    {
      if(m_state != aState)
        m_state = aState;
    }

    /**
     * @brief  Метод FWTransition::eventTest перегружает базовый метод
     * @sa QEventTransition::eventTest для специфичной проверки допустимости
     * срабатывания перехода по приходу события.
     * @param aEvent приходящее из вне событие.
     * @return Признак сравбатывания перехода:
     * @value TRUE событие принято, переход возможен;
     * @value FALSE событие отвергнуто, переход не возможен.
     *
     * Переход всегда связан с каким-либо КА. Поэтому, переход срабатывает по
     * событию для КА, определённого в теле события класса @sa FWEvent.
     * Условия проверки: обработать событие, если оно "обвёрнуто"
     * @sa StateMachine::WrappedEvent или @sa StateMachine::SignalEvent;
     *
     * @see QEvent, QEvent::Type.
     * @see QStateMachine, QStateMachine::WrappedEventб QStateMachine::SignalEvent.
     * @see FWEvent, FWEvent::Machine
     */
    bool
    eventTest(QEvent* aEvent) Q_DECL_OVERRIDE;

    /**
     * @brief Метод onTransition
     * @param aEvent
     */
    void
    onTransition(QEvent* aEvent) Q_DECL_OVERRIDE;

  //----------------------------------------------------------------------------
  Q_SIGNALS:

    /**
     * @brief sign_EventTypeChanged
     * @param aType
     */
    void
    sign_EventTypeChanged (const QEvent::Type aType);

    /**
     * @brief Сигнал sign_eventIDChanged оповещает о смене значения
     * привязанного к переходу идентификатора @sa m_id.
     * @param aID Новое значение идентификатора @sa m_id.
     *
     * @see FWIdentificator
     */
    void
    sign_EventIDChanged (const FWIdentificator aID);

    ///
    /// @brief Сигнал sign_Transiting сообщает о выполнении перехода
    /// @param aSource Указатель на объект-состояние, из которого выполняется
    /// переход;
    /// @param aTarget Указатель на целевое объект-состояние перехода;
    /// @param aTransition Указатель на объект класса @sa FWTransition, который
    /// стал источником перехода.
    ///
    void
    sign_Transiting (QState* aSource, QAbstractState* aTarget,
                     QAbstractTransition* aTransition);
};
//------------------------------------------------------------------------------

FW_END_NAMESPACE

#endif // FWTRANSITION_H

#include "FWTransition.h"
#include "FWState.h"
#include "FWStateMachine.h"

FW_USING_NAMESPACE

//------------------------------------------------------------------------------
FWTransition::FWTransition(FWState* aSourceState)
  : BaseClass     (aSourceState)
{
  SetState(UndefinedState);
  SetEventID (EMPTY_ID);
  SetEventType (static_cast<QEvent::Type>(QEvent::None));
}

//------------------------------------------------------------------------------
FWTransition::FWTransition(QEvent* aEvent, FWState* aSourceState)
  : FWTransition(aSourceState)
{
  if(NOT_NULL(aEvent))
  {
    if(!FWEvent::IsSystem (aEvent))
    {
      SetState(EventState);
      SetEventID (static_cast<FWEvent*>(aEvent)->Identificator ());
      SetEventType (aEvent->type ());
    }
  }
  else
    SetState(ErrorState);
}

//------------------------------------------------------------------------------
FWTransition::FWTransition(QEvent::Type     aEventType,
                           FWIdentificator  aID,
                           FWState*         aSourceState)
  : FWTransition(aSourceState)
{
  SetState    (EventState);
  SetEventID  (aID);
  SetEventType(aEventType);
}

//------------------------------------------------------------------------------
//FWTransition::FWTransition(QObject*     aSender,
//                           const char*  aSignalName,
//                           QObject*     aRessiver,
//                           const char*  aSlotName,
//                           FWState*     aSourceState)
//  : FWTransition  (aSourceState)
//{
//  SetState(SignalState);
//  SetEventID (FWIdentificator (aSender));
//  SetEventType (static_cast<QEvent::Type>(FWEvent::ET_GLOBAL));

//  if(NOT_NULL(aSender) && NOT_NULL(aRessiver))
//  {
//    int v_offset = *aSignalName == '0'+QSIGNAL_CODE ? 1 : 0;
//    int v_signal_index =
//        aSender->metaObject ()->indexOfSignal (
//          QMetaObject::normalizedSignature (aSignalName+v_offset));

//    v_offset = *aSlotName == '0'+QSLOT_CODE ? 1 : 0;
//    int v_slot_idx =
//        aRessiver->metaObject ()->indexOfSlot (
//          QMetaObject::normalizedSignature (aSlotName+v_offset));

//    if(QMetaObject::connect (aSender, v_signal_index,
//                             aRessiver, v_slot_idx,
//                             Qt::DirectConnection))
//    {
//      aRessiver->setParent (Q_NULLPTR);
//      aRessiver->moveToThread (thread ());
//    }
//    else
//      SetState(ErrorState);
//  }
//}

//------------------------------------------------------------------------------
FWStateMachine*
FWTransition::Machine() const
{
  return qobject_cast<FWStateMachine*>(machine ());
}

//------------------------------------------------------------------------------
bool
FWTransition::eventTest(QEvent* aEvent)
{
  bool v_retval = FWEvent::IsValid (aEvent);

  if(v_retval)
    v_retval = EQUAL(aEvent->type (),EventType ());

  if(v_retval)
  {
      FWEvent* v_e = static_cast<FWEvent*>(aEvent);
      v_retval =
          EQUAL(v_e->type (),         EventType ()) &&
          EQUAL(v_e->Identificator (),EventID   ());
  }

  return v_retval;
}

//------------------------------------------------------------------------------
void
FWTransition::onTransition(QEvent* aEvent)
{
  aEvent->accept();
//  qDebug() << "-T- " +
//              sourceState ()->objectName() +
//              " -->> " +
//              targetState()->objectName();
  emit sign_Transiting (sourceState (),targetState (), this->AsBaseClass());
}

//------------------------------------------------------------------------------