Tanl Linguistic Pipeline

search/ixe/Common/Thread.h

/*
**      IXE C++ Library
**      Common/Thread.h
** ----------------------------------------------------------------------
**      Copyright (c) 2002  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE 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 IXE_Thread_h
#define IXE_Thread_h

// Library
#include "Common/Lock.h"
#include "Common/Runnable.h"
#include "include/error.h"

// standard
#include <string>
#include <vector>

namespace IXE {

class ThreadGroup;

#ifdef Yield
#undef Yield                    // _WIN32
#endif


class InvalidThreadStateError : public RuntimeError {
 public:
  InvalidThreadStateError(std::string const& msg) : RuntimeError(msg) {}
};

class Thread : public Runnable, public Lock
{
public:
  enum State 
  {
    Created,
    Running,
    Terminated,
    Detached,
    Destroying
  };

  Thread(char const* name = "");
  
  Thread(Runnable* target, char const* name = "");

  Thread(ThreadGroup* group, Runnable* target = 0, char const* name = "");

  virtual ~Thread();
  
  virtual void          Join(int millis = -1, int nanos = 0);
    // throw (InvalidArgumentError, Exception);

  // Properties

  std::string           Name() { return name; }
  virtual void          Name(std::string str) { name = str; }
  virtual int           Priority();
  virtual void          Priority(int newPriority);
  ThreadGroup*          Group() { return group; }

  // Methods
  bool                  IsAlive();

  virtual void          Start();

  virtual void          Run();

  int                   ActiveCount();

  static void           Yield();

  static void           Sleep(int ms, int ns = 0);

  static Thread*        CurrentThread();

private:
  bool                  inCurrentThread();

# ifdef _WIN32
  HANDLE                thread;                 // our thread
  static HANDLE         CurrentThreadId();
# else
  pthread_t             thread;                 // our POSIX thread
  static pthread_t      CurrentThreadId();
# endif
  std::string           name;
  Runnable*             runnable;
  State                 state;
  ThreadGroup*          group;
# ifndef _WIN32

  Lock                  starting;
# endif
  Condition             termination;

  static TRESULT        Main(void*);
};

} // namespace IXE

#endif // IXE_Thread_h

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.