mthread.hpp

Go to the documentation of this file.

/** ************************************************************************************************
 * \file
 * This header file is part of module \alib_threads of the \aliblong.
 *
 * \emoji :copyright: 2013-2019 A-Worx GmbH, Germany.
 * Published under \ref mainpage_license "Boost Software License".
 **************************************************************************************************/
#ifndef HPP_AWORX_ALIB_THREADS_MODEL_MTHREAD
#define HPP_AWORX_ALIB_THREADS_MODEL_MTHREAD
 
 
#if !defined(ALIB_DOX)  // todo remove
 
#if !defined(HPP_ALIB_THREADS_SLEEPER)
#   include "alib/threads/sleeper.hpp"
#endif
 
#if !defined (HPP_ALIB_THREADS_THREADLOCK)
#   include "alib/threads/threadlock.hpp"
#endif
 
#if !defined (HPP_AWORX_ALIB_THREADS_MODEL_TRIGGERED)
#   include "alib/threads/model/triggered.hpp"
#endif
 
#if !defined (HPP_ALIB_BOXING_ENUM)
#   include "alib/boxing/enum.hpp"
#endif
 
#include <vector>
#include <list>
#include <map>
#include <semaphore.h>
 
namespace alib { namespace threads::model {
 
class TRequest;
class ThreadManager;
 
/** ************************************************************************************************
 * TODOX
 * Implements a distinct thread communication model...with priority queues...
 **************************************************************************************************/
class MThread : public alib::Thread
{
    friend class ThreadManager;
 
    protected:
    enum class InternalCommands
    {
       NoCommand    , ///< Returned when peeked pipe is empty.
       Stop         , ///< Stop this thread.
    };
 
 
    /**
     * A priority queue that holds the commands to be processed.
     * Commands are of type  internal commands
     */
    class CmdPipe  : public alib::Sleeper
    {
        friend class ThreadManager;
        public:
 
        /**
         * Commands that a thread may receive. Values of this type are pushed (copied) and popped
         * into the \ref CmdPipe.
         */
        class Command
        {
          public:
            /** Constructor.  */
            Command(alib::Enum pCmd, int pPriority, Box pData, Box pData2= nullptr)
            {
                cmd=        pCmd;
                priority=   pPriority;
                data=       pData;
                data2=      pData2;
            }
 
            /** ************************************************************************************
             * Deleted copy constructor.
             **************************************************************************************/
            Command( const Command& ) = default;
 
            virtual ~Command() {}
 
            /** Simply compares fields #priority of this and the \b rhs object.
             * \param rhs The object to compare this object's priority with.
             * \c true if this object's priority is lower or equal as the priority of \b other.  */
            bool operator<=(const Command& rhs ) const        { return (priority<= rhs.priority);  }
 
            /** Simply compares fields #priority of this and the \b rhs object.
             * \param rhs The object to compare this object's priority with.
             * \c true if this object's priority is higher as the priority of \b other.  */
            bool operator> (const Command& rhs ) const        { return ( priority < rhs.priority); }
 
            alib::Enum    cmd;        ///< Command identifier.
            int           priority;   ///< Priority of message.
            Box           data;       ///< Data packet transferred with the message.
            Box           data2;      ///< Data packet transferred with the message.
 
        }; // class Command
 
        protected:
            std::list<Command>  pipe;
 
 
        public:
            alib::uinteger            usageCounter;
 
    public:
         /** Constructor.  */
         CmdPipe() : usageCounter(0)    {}
 
         /** Destructor.  */
        ~CmdPipe()                      {}
 
 
    public:
        void        Push(alib::Enum cmd, int priority, Box data= nullptr, Box data2= nullptr);
        Command     Pop();
 
        int         PeekSize()                      { return static_cast<int>( pipe.size());  }
        Command     PeekCmd(int n);
 
    };
 
 
    //----------------------------------------------------------------------------------------------
    // The MThread part
    // Todo: The whole pipe should probably be a superclass (multi inheritance) or
    //       just being integrated here. The advantage of the latter could be that the pipe
    //       "knows" the thread internals, e.g. a future monomem
    //----------------------------------------------------------------------------------------------
    MThread(const alib::String& threadName);
    virtual ~MThread()                                                                     override;
 
        ALIB_API
        virtual
        bool            IsStopped() { return stoppedFlag; }
        void            Stop();
 
    public:
        virtual void        Run()                                                    final override;
 
    protected:
 
    /** ****************************************************************************************
     * This method is overwritten as protected, and thus removed from the interface.
     * <b>MThread</b>s are started by registering them with the #link ThreadManager
     * singleton.
     ******************************************************************************************/
    ALIB_API
    virtual void            Start()                              override   { Thread::Start(); }
 
    protected:
        virtual void    processCommand( CmdPipe::Command& cmd )                                  =0;
 
        // thread management:
        alib::Ticks               lastStatusChange;     // when the thread started the last task
 
 
    // protected fields
        protected:
            bool                stoppedFlag;
            CmdPipe             cmdPipe;          ///< The thread's communication tool.
 
}; // class MThread
 
 
} // namespace alib[::threads::model]
 
/// Type alias in namespace #alib.
using      MThread          = alib::threads::model::MThread;
 
}  // namespace [alib]
 
 
#endif // !defined(ALIB_DOX)
 
#endif // HPP_AWORX_ALIB_THREADS_MODEL_MTHREAD