UThread.h

/*
*  utilite is a cross-platform library with
*  useful utilities for fast and small developing.
*  Copyright (C) 2010  Mathieu Labbe
*
*  utilite is free library: you can redistribute it and/or modify
*  it under the terms of the GNU Lesser General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  utilite 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 Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public License
*  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef UTHREADNODE_H
#define UTHREADNODE_H
 
#include "rtabmap/utilite/utilite_export.h" // DLL export/import defines
 
#include "rtabmap/utilite/UThreadC.h"
 
class UTILITE_EXPORT UThread : public UThreadC<void>
{
public:
    enum Priority{kPLow, kPBelowNormal, kPNormal, kPAboveNormal, kPRealTime};
 
public:
    //return caller thread id
    static unsigned long currentThreadId() {return (unsigned long)UThreadC<void>::Self();}
 
public:
    UThread(Priority priority = kPNormal);
 
    virtual ~UThread();
 
    void start();
 
  void kill();
 
  void join(bool killFirst = false);
 
    void setPriority(Priority priority);
 
  void setAffinity(int cpu = 0);
 
    bool isCreating() const;
 
    bool isRunning() const;
 
    bool isIdle() const;
 
    bool isKilled() const;
 
    Handle getThreadHandle() const {return handle_;}
    unsigned long getThreadId() const {return threadId_;}
 
protected:
 
private:
  virtual void mainLoopBegin() {}
 
  virtual void mainLoop() = 0;
 
  virtual void mainLoopKill() {}
 
  virtual void mainLoopEnd() {}
 
    /*
     * Inherited method ThreadMain() from Thread.
     * @see Thread<void>
     */
    void ThreadMain();
 
    /*
   * Apply thread priority. This is called when starting the thread.
   * *@todo : Support pthread
   */
  void applyPriority();
 
  /*
   * Apply cpu affinity. This is called when starting the thread.
   * *@todo : Support Windows
   */
  void applyAffinity();
 
    /*
     * Inherited method Create() from Thread.
     * Here we force this function to be private so the
     * inherited class can't have access to it.
     * @see Thread<void>
     */
    int Create(
      Handle  * const     & H               = 0,
      const bool          & CreateDetached  = false,
      const unsigned int  & StackSize       = 0,
      const bool          & CancelEnable    = false,   // UNUSED
      const bool          & CancelAsync     = false    // UNUSED
    ) const;
 
    //Methods from UThread<void> class hided
    static int Join( Handle H )
    { return UThreadC<void>::Join(H); }
#ifndef ANDROID
  static int Kill( Handle H )
    { return UThreadC<void>::Kill(H); }
#endif
  static int Detach( Handle H )
    { return UThreadC<void>::Detach(H); }
 
private:
  void operator=(UThread &) {}
  UThread( const UThread &) : state_(kSIdle) {}
 
private:
    enum State{kSIdle, kSCreating, kSRunning, kSKilled}; /* Enum of states. */
    State state_;       /* The thread state. */
    Priority priority_;   /* The thread priority. */
    Handle handle_;   /* The thread handle. */
    unsigned long threadId_; /* The thread id. */
    int cpuAffinity_; /* The cpu affinity. */
    UMutex killSafelyMutex_;  /* Mutex used to protect the kill() method. */
    UMutex runningMutex_;     /* Mutex used to notify the join method when the thread has finished. */
};
 
#endif // UTHREADNODE_H