Public API Reference

csutil/thread.h

Go to the documentation of this file.

/*
    Copyright (C) 2002 by Norman Kraemer
  
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
  
    This library 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
    Library General Public License for more details.
  
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSSYS_THREAD_H__
#define __CS_CSSYS_THREAD_H__

#include "csutil/ref.h"
#include "csutil/refcount.h"

enum
{
  CS_THREAD_NO_ERROR = 0,
  CS_THREAD_UNKNOWN_ERROR,
  CS_THREAD_OUT_OF_RESOURCES,
  CS_THREAD_ERR_ATTRIBUTE,
  CS_THREAD_NO_PERMISSION,
  CS_THREAD_UNKNOWN_THREAD,
  CS_THREAD_DEADLOCK,
  CS_THREAD_OPERATION_PENDING,
  CS_THREAD_MUTEX_NOT_INITIALIZED,
  CS_THREAD_MUTEX_BUSY,
  CS_THREAD_MUTEX_UNKNOWN,
  CS_THREAD_CONDITION_TIMEOUT,
  CS_THREAD_CONDITION_BUSY,
  CS_THREAD_CONDITION_WAIT_INTERRUPTED,
  CS_THREAD_SIGNAL_UNKNOWN,
  CS_THREAD_SEMA_VALUE_TOO_LARGE,
  CS_THREAD_SEMA_BUSY
};

/* Priority values indicate how frequently a thread runs compared to other threads.
 *
 * Thread scheduling is handled by the underlying OS, and so the true meaning of these
 *  values will vary depending on platform.  A minimal set of values is defined for CS
 *  so that chances of support of the full range of values by the platform are greater.
*/
typedef enum
{
  // IDLE priority is the lowest priority.  Threads with this priority are scheduled to
  //  run only when no other thread would be running anyway - or as close as the platform
  //  allows.
  CS_THREAD_PRIORITY_IDLE=0,
  // NORMAL priority is the default priority.
  CS_THREAD_PRIORITY_NORMAL,
  // TIMECRITICAL is the highest priority.
  CS_THREAD_PRIORITY_TIMECRITICAL
} csThreadPriority;


class csRunnable
{
protected:
  virtual ~csRunnable() {}
public:
  virtual void Run () = 0;

  /* maybe we could add those for smoother exit/cancel/detroy operations
  virtual void PrepareExit () = 0;
  virtual void PrepareJoin () = 0;
  virtual void PrepareKill () = 0;
  virtual void PrepareCancel () = 0;
  virtual void PrepareDestroy () = 0;
  */

  virtual void IncRef() = 0;
  virtual void DecRef() = 0;
  virtual int GetRefCount() = 0;
};


class CS_CRYSTALSPACE_EXPORT csThread : public csRefCount
{
public:
  static csRef<csThread> Create (csRunnable*, uint32 options = 0);

  virtual bool Start () = 0;

  virtual bool Stop () = 0;

  virtual bool Wait () = 0;

  virtual void Yield () = 0;

  virtual csThreadPriority GetPriority() = 0;

  virtual bool SetPriority(csThreadPriority Priority) = 0;

  virtual char const* GetLastError () const = 0;
};


class CS_CRYSTALSPACE_EXPORT csMutex : public csRefCount
{
public:
  static csRef<csMutex> Create (bool recursive = false);

  virtual bool LockWait() = 0;

  virtual bool LockTry () = 0;

  virtual bool Release () = 0;

  virtual char const* GetLastError () const = 0;

  virtual bool IsRecursive () const = 0;
};


class CS_CRYSTALSPACE_EXPORT csSemaphore : public csRefCount
{
public:
  static csRef<csSemaphore> Create (uint32 value = 0);

  virtual bool LockWait () = 0;

  virtual bool LockTry () = 0;

  virtual bool Release () = 0;

  virtual uint32 Value () = 0;

  virtual char const* GetLastError () const = 0;
};


class CS_CRYSTALSPACE_EXPORT csCondition : public csRefCount
{
public:
  static csRef<csCondition> Create (uint32 conditionAttributes = 0);

  virtual void Signal (bool WakeAll = false) = 0;

  virtual bool Wait (csMutex* mutex, csTicks timeout = 0) = 0;

  virtual char const* GetLastError () const = 0;
};

#endif // __CS_CSSYS_THREAD_H__

---