IThreader.h

Go to the documentation of this file.

#ifndef _INCLUDE_SOURCEMOD_THREADER_H
#define _INCLUDE_SOURCEMOD_THREADER_H

#include <IShareSys.h>

#define SMINTERFACE_THREADER_NAME               "IThreader"
#define SMINTERFACE_THREADER_VERSION    3

namespace SourceMod
{
        enum ThreadFlags
        {
                Thread_Default = 0,
                Thread_AutoRelease = 1,
                Thread_CreateSuspended = 2,
        };

        enum ThreadPriority
        {
                ThreadPrio_Minimum = -8,
                ThreadPrio_Low = -3,
                ThreadPrio_Normal = 0,
                ThreadPrio_High = 3,
                ThreadPrio_Maximum = 8,
        };

        enum ThreadState
        {
                Thread_Running = 0,
                Thread_Paused = 1,
                Thread_Done = 2,
        };

        struct ThreadParams
        {
                ThreadParams() : 
                        flags(Thread_Default), 
                        prio(ThreadPrio_Normal)
                {
                };
                ThreadFlags flags;              
                ThreadPriority prio;    
        };

        class IThreadCreator;

        class IThreadHandle
        {
        public:
                virtual ~IThreadHandle() { };
        public:
                virtual bool WaitForThread() =0;

                virtual void DestroyThis() =0;

                virtual IThreadCreator *Parent() =0;

                virtual void GetParams(ThreadParams *ptparams) =0;

                virtual ThreadPriority GetPriority() =0;

                virtual bool SetPriority(ThreadPriority prio) =0;

                virtual ThreadState GetState() =0;

                virtual bool Unpause() =0;
        };

        class IThread
        {
        public:
                virtual ~IThread() { };
        public:
                virtual void RunThread(IThreadHandle *pHandle) =0;

                virtual void OnTerminate(IThreadHandle *pHandle, bool cancel) =0;
        };


        class IThreadCreator
        {
        public:
                virtual ~IThreadCreator() { };
        public:
                virtual void MakeThread(IThread *pThread) =0;

                virtual IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags) =0;

                virtual IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params) =0;

                virtual void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min) =0;
        };

        class IMutex
        {
        public:
                virtual ~IMutex() { };
        public:
                virtual bool TryLock() =0;

                virtual void Lock() =0;

                virtual void Unlock() =0;

                virtual void DestroyThis() =0;
        };

        class IEventSignal
        {
        public:
                virtual ~IEventSignal() { };
        public:
                virtual void Wait() =0;

                virtual void Signal() =0;

                virtual void DestroyThis() =0;
        };

        enum WorkerState
        {
                Worker_Invalid = -3,
                Worker_Stopped = -2,
                Worker_Paused = -1,
                Worker_Running,
        };

        class IThreadWorker : public IThreadCreator
        {
        public:
                virtual ~IThreadWorker()
                {
                };
        public:
                virtual unsigned int RunFrame() =0;
        public:
                virtual bool Pause() =0;

                virtual bool Unpause() =0;

                virtual bool Start() =0;

                virtual bool Stop(bool flush) =0;

                virtual WorkerState GetStatus(unsigned int *numThreads) =0;

                virtual void SetMaxThreadsPerFrame(unsigned int threads) =0;

                virtual void SetThinkTimePerFrame(unsigned int thinktime) =0;
        };

        class IThreadWorkerCallbacks
        {
        public:
                virtual void OnWorkerStart(IThreadWorker *pWorker)
                {
                }

                virtual void OnWorkerStop(IThreadWorker *pWorker)
                {
                }
        };

        class IThreader : public SMInterface, public IThreadCreator
        {
        public:
                virtual const char *GetInterfaceName()
                {
                        return SMINTERFACE_THREADER_NAME;
                }
                virtual unsigned int GetInterfaceVersion()
                {
                        return SMINTERFACE_THREADER_VERSION;
                }
                virtual bool IsVersionCompatible(unsigned int version)
                {
                        if (version < 2)
                        {
                                return false;
                        }
                        return SMInterface::IsVersionCompatible(version);
                }
        public:
                virtual IMutex *MakeMutex() =0;

                virtual void ThreadSleep(unsigned int ms) =0;

                virtual IEventSignal *MakeEventSignal() =0;

                virtual IThreadWorker *MakeWorker(IThreadWorkerCallbacks *hooks, bool threaded) =0;

                virtual void DestroyWorker(IThreadWorker *pWorker) =0;
        };
};

#endif //_INCLUDE_SOURCEMOD_THREADER_H