StateFlow.cxx

Go to the documentation of this file.

 
#include <climits>
 
#include "executor/StateFlow.hxx"
 
const unsigned StateFlowWithQueue::MAX_PRIORITY_;
 
StateFlowWithQueue::StateFlowWithQueue(Service *service)
  : StateFlowBase(service)
  , queueSize_(0)
  , currentMessage_(nullptr)
  , currentPriority_(MAX_PRIORITY_)
  , isWaiting_(1)
{
    reset_flow(STATE(wait_for_message));
}
 
StateFlowWithQueue::~StateFlowWithQueue()
{
}
 
 
void StateFlowBase::run()
{
    HASSERT(state_);
    do
    {
        Action action = (this->*state_)();
        if (!action.next_state())
        {
            // This action is == wait(). This means we are blocked or asked to
            // yield.
            return;
        }
        state_ = action.next_state();
    } while (1);
}
 
StateFlowBase::Action StateFlowWithQueue::wait_for_message()
{
    AtomicHolder h(this);
    unsigned priority;
    currentMessage_ = static_cast<BufferBase *>(queue_next(&priority));
    if (currentMessage_)
    {
        isWaiting_ = 0;
        currentPriority_ = priority;
        queueSize_--;
        // Yielding here will ensure that we are processing the next message on
        // the current executor according to its priority.
        return yield_and_call(STATE(entry));
    }
    else
    {
        isWaiting_ = 1;
        queueSize_ = 0;
        currentPriority_ = MAX_PRIORITY_;
        return wait();
    }
}
 
void StateFlowBase::notify()
{
    service()->executor()->add(this);
}
 
#if OPENMRN_FEATURE_RTOS_FROM_ISR
void StateFlowBase::notify_from_isr()
{
    service()->executor()->add_from_isr(this, 0);
}
#endif // OPENMRN_FEATURE_RTOS_FROM_ISR
 
void StateFlowWithQueue::notify()
{
    service()->executor()->add(this, currentPriority_);
}
 
#if OPENMRN_FEATURE_RTOS_FROM_ISR
void StateFlowWithQueue::notify_from_isr()
{
    service()->executor()->add_from_isr(this, currentPriority_);
}
#endif // OPENMRN_FEATURE_RTOS_FROM_ISR
 
StateFlowBase::Action StateFlowBase::terminated()
{
    return wait();
}