threadmanager.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_THREADMANAGER
#define HPP_AWORX_ALIB_THREADS_MODEL_THREADMANAGER
 
 
#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_AWORX_ALIB_THREADS_MODEL_MTHREAD)
#   include "alib/threads/model/mthread.hpp"
#endif
 
 
//todo: This introduces a dependency to ALib Boxing.
//      Without this, we have no general enum type in piped commands.
//      What do we do? Shouldn't we drop all these minor modules and say
//      "Hey, this is ALib core: Characters, Boxing, Memory, Singletons, Time, Boxing, Enum, Strings "
//      Optional remain: Threads (due to performance if left out)
//      Optional remain: Resources (People dont need it?): Otherwise: if it was there...
//      Well, I do not know. If we keep the current resulution, we have a problem here.
 
#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 ThreadManager;
 
 
 
/** ************************************************************************************************
 * TODOX
 **************************************************************************************************/
class ThreadManager :   public  alib::Thread,
                        public  alib::Sleeper,
                        public  alib::Singleton<ThreadManager>
{
    protected:
        struct TriggerEntry
        {
            Triggered *               triggered;
            alib::Ticks               nextWakeup;
        };
 
 
        std::map<std::thread::id,   MThread* > threadMap;   // todo: make (monomem-)list. No need for searching
        
        std::list<TriggerEntry>     triggerList;            // the registered clients // todo: make monomem list
 
        int             nameSize;
        int             tabSize;
 
        bool            mStoppedFlag;
 
    private:
 
        /**
         * Private constructor to implement strict singleton concept.
         */
        ALIB_API
                 ThreadManager();
        friend alib::Singleton<ThreadManager>;
 
    public:
        ALIB_API
        virtual ~ThreadManager()                                                           override;
 
        ALIB_API
        virtual void    Run()                                                              override;
 
        ALIB_API
        bool            IsStopped() { return mStoppedFlag; }
 
        /**
         * Add a managed thread.
         * @param thread The thread to add.
         */
        ALIB_API
        void            Add( MThread& thread );
 
        /**
         * Remove a managed thread.
         * @param thread The thread to remove.
         */
        ALIB_API
        bool            Remove( MThread& thread );
 
        /**
         * Add a thread to be triggered.
         * @param triggered  The object to be triggered.
         */
        ALIB_API
        void            AddTriggered( Triggered& triggered);
 
        /**
         * Remove a previously added triggered object.
         * @param triggered  The object to be removed from the list.
         */
        ALIB_API
        void            RemoveTriggered( Triggered& triggered);
 
        ALIB_API
        void            StopAndTerminateAll();
 
    public:
 
    protected:
        /**
         * This method is overwritten as protected, and thus removed from the interface.
         * The thread manager should be stopped and terminated using #StopAndTerminateAll.
         */
        ALIB_API
        virtual void            Terminate()                     override    { Thread::Terminate(); }
};
 
 
} // namespace alib[::threads::model]
 
/// Type alias in namespace #alib.
using      MThread          = alib::threads::model::MThread;
 
/// Type alias in namespace #alib.
using      ThreadManager    = alib::threads::model::ThreadManager;
 
 
}  // namespace [alib]
 
 
#endif // !defined(ALIB_DOX)
 
#endif // HPP_AWORX_ALIB_THREADS_MODEL_THREADMANAGER