acsThreadManager.h

Go to the documentation of this file.

#ifndef _ACS_THREAD_MANAGER_H
#define _ACS_THREAD_MANAGER_H
/*******************************************************************************
* E.S.O. - VLT project
*
* "@(#) $Id: acsThreadManager.h,v 1.19 2008/10/13 23:15:12 bjeram Exp $"
*
* who       when        what
* --------  ----------  ----------------------------------------------
* bjeram  yyyy-mm-dd  created
*/

/************************************************************************
 *
 *----------------------------------------------------------------------
 */

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include "acsThread.h"
#include "loggingLoggable.h"
#include <ACSErrTypeCommon.h>

namespace ACS
{

    class ThreadManager : public ACS::ThreadManagerBase,
                          public Logging::Loggable
    {
        friend class Thread;

      public:

        ThreadManager() :
            ACS::ThreadManagerBase(),
            Logging::Loggable() {}

        ThreadManager(Logging::Logger::LoggerSmartPtr logger) :
            ACS::ThreadManagerBase(),
            Logging::Loggable(logger) {}

        template <class T>
        T* create(const ACE_CString name);

    /*
     * @throw acsthreadErrType::ThreadAlreadyExistExImpl
     * @throw acsthreadErrType::CanNotCreateThreadExImpl
         */
        template <class T>
        T* create(const ACE_CString name,
                  const TimeInterval responseTime,
                  const TimeInterval sleepTime);
    /*
     * @throw acsthreadErrType::ThreadAlreadyExistExImpl
     * @throw acsthreadErrType::CanNotCreateThreadExImpl
         */
        template <class T>
        T* create(const ACE_CString name,
                  const TimeInterval responseTime,
                  const TimeInterval sleepTime,
                  bool del);

    /*
     * @throw acsthreadErrType::ThreadAlreadyExistExImpl
     * @throw acsthreadErrType::CanNotCreateThreadExImpl
         */
        template <class T>
        T* create(const ACE_CString name,
                  const TimeInterval responseTime,
                  const TimeInterval sleepTime,
                  bool del,
                  const long thrFlags);

    /*
     * @throw acsthreadErrType::ThreadAlreadyExistExImpl
     * @throw acsthreadErrType::CanNotCreateThreadExImpl
         */
        template <class T>
        T* create(const ACE_CString name,
                  const TimeInterval responseTime,
                  const TimeInterval sleepTime,
                  bool del,
                  const long thrFlags,
                  const size_t stackSize);

        template <class T, class P>
        T* create(const ACE_CString name, P&);

    /*
     * @throw acsthreadErrType::ThreadAlreadyExistExImpl
     * @throw acsthreadErrType::CanNotCreateThreadExImpl
         */
        template <class T, class P>
        T* create(const ACE_CString name, P&,
                  const TimeInterval responseTime,
                  const TimeInterval sleepTime);
    /*
     * @throw acsthreadErrType::ThreadAlreadyExistExImpl
     * @throw acsthreadErrType::CanNotCreateThreadExImpl
         */
        template <class T, class P>
        T* create(const ACE_CString name, P&,
                  const TimeInterval responseTime,
                  const TimeInterval sleepTime,
                  bool del);

    /*
     * @throw acsthreadErrType::ThreadAlreadyExistExImpl
     * @throw acsthreadErrType::CanNotCreateThreadExImpl
         */
        template <class T, class P>
        T* create(const ACE_CString name, P&,
                  const TimeInterval responseTime,
                  const TimeInterval sleepTime,
                  bool del,
                  const long thrFlags);

        /*
         * @throw acsthreadErrType::ThreadAlreadyExistExImpl
         * @throw acsthreadErrType::CanNotCreateThreadExImpl
         */
        template <class T, class P>
        T* create(const ACE_CString name, P&,
                        const TimeInterval responseTime,
                        const TimeInterval sleepTime,
                        bool del,
                        const long thrFlags,
                        const size_t stackSize);

        void destroy(ACS::Thread* thr)
            {
                if (thr!=NULL)
                    {
                    removeFromMap (thr->getName());
                    delete thr;
                    thr = 0;
                    }//if
            }//destroy

      private:

        void operator=(const ThreadManager&);

        ThreadManager(const ThreadManager&);

        class ThreadManagerTSS
        {
          public:
            ThreadManagerTSS() : m_tm(0){}

            void setThreadManager(ThreadManager* _tm){ m_tm = _tm; }

            ThreadManager* getThreadManager(bool _reset)
                {
                    ThreadManager* tmp_tm = m_tm;
                    if (_reset)
                        m_tm = 0;
                    return tmp_tm;
                }

            void resetThreadManager() {m_tm = 0;}

          protected:
            ThreadManager* m_tm;
        };

        static ACE_TSS<ThreadManagerTSS> threadManagerTSS;

    };//class ThreadManager

/* implementation for template functions*/
#include "acsThreadManager.i"

};//namespace ACS

#endif