ThreadClass.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef __THREADCLASS_H__
#define __THREADCLASS_H__
#if defined(_PS2)
#include <list>
#endif

#if defined(_XBOX)
#include <xtl.h>            // For XBox builds
#else
#if defined(_WIN32)
#include <windows.h>        // For Windows builds
#endif
#endif

#if defined(RN_UNIX_LIKE)
#include <pthread.h>
#endif

namespace RNReplicaNet
{

class Thread;
const unsigned int kTIME_INFINITE = 0xFFFFFFFF;

class MutexClass
{
public:
    MutexClass();

    virtual ~MutexClass();

    void Lock(void);

    void UnLock(void);

    enum
    {
        kNoOwnerThread = -1
    };

private:
#if defined(_PS2)
    // A binary semaphore created to lock all critical sections inside any mutex class
    // A mutex per class could be used however the PS2 does not allow many to be created
    static int mMutex;
    // The count of the lock, for recursive locks
    int mCount;
    // The owner thread of this mutex, kNoOwnerThread means no thread currently owns the mutex and the mCount should then be 0
    volatile int mOwnerThread;
    // A linked list of waiting threads for this mutex
    std::list<int> mWaitingThreadIDs;
#else
    void *mMutex;   // A pointer to a mutex/critical section/handle depending on the internal implementation.

#if defined(_WIN32)
    CRITICAL_SECTION mSection;  // Local storage
#endif

#if defined(RN_UNIX_LIKE)
    pthread_mutex_t mLocalMutex;
#endif

#endif
};

class ThreadClass : public MutexClass
{
public:
    ThreadClass();

    virtual ~ThreadClass();

    void Sleep(int milliseconds);

protected:
friend class Thread;
    void DoQuitNow(const int returnCode);

    virtual int ThreadEntry(void) = 0;

    virtual void ThreadExiting(const int returnCode);

    void CheckQuit(void);

    static size_t GetNumAllocated(void)
    {
        return mNumAllocated;
    }

private:
    void CallThreadExiting(const int returnCode);

    volatile bool mQuitNow;

    Thread *mBoundThread;
    volatile bool mThreadExitingCalled;

    static volatile size_t mNumAllocated;
};

class LockingMechanism
{
public:
    LockingMechanism(MutexClass *lockee);

    virtual ~LockingMechanism();

private:
    MutexClass *mLockee;
};

class CurrentThread
{
public:
    static void Sleep(int milliseconds);
};

#define THREADSAFELOCK() RNReplicaNet::LockingMechanism _lock(this);
#define THREADSAFELOCKCLASS(x) RNReplicaNet::LockingMechanism _class_lock(&(x));
#define THREADSAFELOCKCLASSp(x) RNReplicaNet::LockingMechanism _class_lockp(x);
#define THREADSAFELOCKCLASSNAMED(x) RNReplicaNet::LockingMechanism _class_lock##x (&(x));
#define THREADSAFELOCKCLASSNAMEDp(x) RNReplicaNet::LockingMechanism _class_lockp##x (x);

} // namespace RNReplicaNet

#endif