Horizon::System::RuntimeContextChain::ContextQueueManager Class Reference

#include <System.hpp>

Collaboration diagram for Horizon::System::RuntimeContextChain::ContextQueueManager:

Public Member Functions
	ContextQueueManager (ContextControlAgent &control_agent, RuntimeContextChain *chain)
virtual void	push (std::shared_ptr< RuntimeContext > seg)
virtual std::shared_ptr< RuntimeContext >	pop ()
virtual bool	process ()
virtual bool	is_paused ()

Public Attributes
ContextControlAgent &	_control_agent
RuntimeContextChain *	_chain
boost::lockfree::spsc_queue< std::shared_ptr< RuntimeContext >, boost::lockfree::capacity< 100 > >	_queue
std::atomic< bool >	_paused {false}

Constructor & Destructor Documentation

ContextQueueManager()

Horizon::System::RuntimeContextChain::ContextQueueManager::ContextQueueManager ( ContextControlAgent &  control_agent, RuntimeContextChain *  chain  )

inline

: _control_agent(control_agent), _chain(chain) { }

Member Function Documentation

is_paused()

virtual bool Horizon::System::RuntimeContextChain::ContextQueueManager::is_paused ( )

inlinevirtual

{ return _paused; }

References _paused.

pop()

virtual std::shared_ptr< RuntimeContext > Horizon::System::RuntimeContextChain::ContextQueueManager::pop ( )

inlinevirtual

        {
            if (_queue.empty())
                return nullptr;
 
            std::shared_ptr<RuntimeContext> ret;
            _queue.pop(ret);
            return ret;
        }

References _queue.

Referenced by Horizon::System::RuntimeContextChain::pop().

Here is the caller graph for this function:

process()

bool Horizon::System::RuntimeContextChain::ContextQueueManager::process ( )

virtual

{
    std::shared_ptr<RuntimeContext> context = nullptr;
    
    _control_agent.start();
 
    bool failed = false;
    while((context = pop()) != nullptr) {
        while (_control_agent.get_status() == RUNTIME_ROUTINE_CHAIN_PAUSED || _control_agent.get_status() == RUNTIME_ROUTINE_CHAIN_STOPPED) {
            if (!_paused)
                _paused = true;
        }
 
        if (_paused == true)
            _paused = false;
 
        if (_control_agent.get_status() == RUNTIME_ROUTINE_CHAIN_CANCELLED)
            return false;
 
        if (context->get_routine_manager().get_module_type() != _chain->get_module_type()) {
            context->dispatch();
 
            if (context->get_synchronization_method() == RUNTIME_SYNC_WAIT_NO_CHECK_STATE) {
                while(context->get_context_result() == RUNTIME_CONTEXT_NO_STATE) {
                    if (context->get_context_state() != RUNTIME_CONTEXT_STATE_WAITING) {
                        context->set_context_state(RUNTIME_CONTEXT_STATE_WAITING);
                    }
                }
 
                if (context->get_context_state() == RUNTIME_CONTEXT_STATE_WAITING) {
                    context->set_context_state(RUNTIME_CONTEXT_STATE_ACTIVE);
                }
                /* Don't check the pass or fail of the context. */
            } else if (context->get_synchronization_method() == RUNTIME_SYNC_WAIT_CHECK_STATE) {
                while(context->get_context_result() == RUNTIME_CONTEXT_NO_STATE) {
                    if (context->get_context_state() != RUNTIME_CONTEXT_STATE_WAITING) {
                        context->set_context_state(RUNTIME_CONTEXT_STATE_WAITING);
                    }
                }
                if (context->get_context_state() == RUNTIME_CONTEXT_STATE_WAITING) {
                    context->set_context_state(RUNTIME_CONTEXT_STATE_ACTIVE);
                }
                /* check context result whether pass or fail. */
                if (context->get_context_result() == RUNTIME_CONTEXT_FAIL) {
                    failed = true;
                    break;
                }
            }
 
        } else if (context->run() == false) {
            failed = true;
            break;
        }
    }
 
    _queue.reset();
 
    if (failed == true) {
        _control_agent.failed();
        return false;
    }
 
    _control_agent.completed();
 
    return true;
}

References Horizon::System::RUNTIME_CONTEXT_FAIL, Horizon::System::RUNTIME_CONTEXT_NO_STATE, Horizon::System::RUNTIME_CONTEXT_STATE_ACTIVE, Horizon::System::RUNTIME_CONTEXT_STATE_WAITING, Horizon::System::RUNTIME_ROUTINE_CHAIN_CANCELLED, Horizon::System::RUNTIME_ROUTINE_CHAIN_PAUSED, Horizon::System::RUNTIME_ROUTINE_CHAIN_STOPPED, Horizon::System::RUNTIME_SYNC_WAIT_CHECK_STATE, and Horizon::System::RUNTIME_SYNC_WAIT_NO_CHECK_STATE.

Referenced by Horizon::System::RuntimeContextChain::process().

Here is the caller graph for this function:

push()

virtual void Horizon::System::RuntimeContextChain::ContextQueueManager::push ( std::shared_ptr< RuntimeContext >  seg )

inlinevirtual

{ _queue.push(std::move(seg)); }

References _queue.

Referenced by Horizon::System::RuntimeContextChain::push().

Here is the caller graph for this function:

Member Data Documentation

_chain

RuntimeContextChain* Horizon::System::RuntimeContextChain::ContextQueueManager::_chain

_control_agent

ContextControlAgent& Horizon::System::RuntimeContextChain::ContextQueueManager::_control_agent

_paused

std::atomic<bool> Horizon::System::RuntimeContextChain::ContextQueueManager::_paused {false}

Referenced by is_paused().

_queue

boost::lockfree::spsc_queue<std::shared_ptr<RuntimeContext>, boost::lockfree::capacity<100> > Horizon::System::RuntimeContextChain::ContextQueueManager::_queue

Referenced by pop(), and push().

---

The documentation for this class was generated from the following files:

• src/Server/Common/System.hpp
• src/Server/Common/System.cpp