IArchMultithread.h

/*
 * synergy -- mouse and keyboard sharing utility
 * Copyright (C) 2012 Bolton Software Ltd.
 * Copyright (C) 2002 Chris Schoeneman
 * 
 * This package is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * found in the file COPYING that should have accompanied this file.
 * 
 * This package is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef IARCHMULTITHREAD_H
#define IARCHMULTITHREAD_H

#include "IInterface.h"

class CArchCondImpl;

typedef CArchCondImpl* CArchCond;

class CArchMutexImpl;

typedef CArchMutexImpl* CArchMutex;

class CArchThreadImpl;

typedef CArchThreadImpl* CArchThread;


class IArchMultithread : public IInterface {
public:
    typedef void* (*ThreadFunc)(void*);
    typedef unsigned int ThreadID;

    enum ESignal {
        kINTERRUPT,     
        kTERMINATE,     
        kHANGUP,        
        kUSER,          
        kNUM_SIGNALS
    };
    typedef void        (*SignalFunc)(ESignal, void* userData);



    //
    // condition variable methods
    //


    virtual CArchCond   newCondVar() = 0;

    virtual void        closeCondVar(CArchCond) = 0;


    virtual void        signalCondVar(CArchCond) = 0;


    virtual void        broadcastCondVar(CArchCond) = 0;


    virtual bool        waitCondVar(CArchCond, CArchMutex, double timeout) = 0;

    //
    // mutex methods
    //


    virtual CArchMutex  newMutex() = 0;

    virtual void        closeMutex(CArchMutex) = 0;

    virtual void        lockMutex(CArchMutex) = 0;

    virtual void        unlockMutex(CArchMutex) = 0;

    //
    // thread methods
    //


    virtual CArchThread newThread(ThreadFunc func, void* userData) = 0;


    virtual CArchThread newCurrentThread() = 0;


    virtual CArchThread copyThread(CArchThread thread) = 0;


    virtual void        closeThread(CArchThread) = 0;


    virtual void        cancelThread(CArchThread thread) = 0;


    virtual void        setPriorityOfThread(CArchThread, int n) = 0;


    virtual void        testCancelThread() = 0;


    virtual bool        wait(CArchThread thread, double timeout) = 0;


    virtual bool        isSameThread(CArchThread, CArchThread) = 0;


    virtual bool        isExitedThread(CArchThread thread) = 0;


    virtual void*       getResultOfThread(CArchThread thread) = 0;


    virtual ThreadID    getIDOfThread(CArchThread thread) = 0;


    virtual void        setSignalHandler(ESignal, SignalFunc func,
                            void* userData) = 0;


    virtual void        raiseSignal(ESignal signal) = 0;

};

#endif