include/utilite/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 "utilite/UtiLiteExp.h" // DLL export/import defines

#include "utilite/UThreadC.h"

class UTILITE_EXP UThread : public UThreadC<void>
{
public:
    enum Priority{kPLow, kPBelowNormal, kPNormal, kPAboveNormal, kPRealTime};

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_;}


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); }
        static int Kill( Handle H )
          { return UThreadC<void>::Kill(H); }
        static int Detach( Handle H )
          { return UThreadC<void>::Detach(H); }

private:
        void operator=(UThread & t) {}
        UThread( const UThread & t ) {}

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. */
#ifdef WIN32
    int threadId_;                      /* The thread id. */
#else
    unsigned long threadId_; /* The thread id. */
#endif
    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