Thread.h

Go to the documentation of this file.

/*
 * Thread.h
 *
 *  This file is part of the HausmiSEP project
 *
 *  Copyright (C) 2012, 2013 Marco Alvarado (malvcr@gmail.com)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 THREAD_H_
#define THREAD_H_

#include <HSEP/HSEP.h>
#include <HSEP/HSEPObject.h>
#include <HSEP/Mutex.h>

#include <thread>
#include <list>
#include <cstring>

using namespace std;

namespace HSEP {

#define THREADNAME_LEN 24
#define NON_DISPATCHED -10

    class Thread : public HSEPObject {

        thread aHandler;  /*< The standard thread handler */
        int    aExitCode; /*< Exit code emitted by the perform method and recoverable on the join one */
          char   aThreadName[THREADNAME_LEN+1]; /*< Unique string representation for the thread */

          struct Flags {

              bool aMoving     : 1; /*< Flag that advice the thread to move to another process or computer */
              bool aContinue   : 1; /*< Flag that advice the thread to continue processing or not */
              bool aDispatched : 1; /*< Flat that advice the thread was dispatched */

              Flags() {
                  memset(this,0,sizeof(*this));
                  aContinue = true;
              }

          } aFlags;

        void run();

    public:
        Thread(const char* pType) : HSEPObject(pType) {
            aExitCode = -1;
            memset(aThreadName,0,THREADNAME_LEN+1);
            sprintf(aThreadName,"%p",(void*)this);
        }

        virtual ~Thread() {}

        const char* namePtr() const {
            return aThreadName;
        }

        bool dispatch();


        int join();

        void finish() {
            ExclusiveScope vArea(&aMutex);
            aFlags.aContinue = false;
        }

        bool finishRequested() const {
            ExclusiveScope vScope(&aMutex);
            return !aFlags.aContinue;
        }

        void relocate(string pDestination);


    protected:

        Thread(const char* pType, string& pReceivedState) : HSEPObject(pType) {
            aFlags.aContinue = true;
            aExitCode = -1;
            aFlags.aMoving   = false;
            memset(aThreadName,0,THREADNAME_LEN+1);
            sprintf(aThreadName,"%p",(void*)this);

            d_restoreState(pReceivedState);
        }

        mutable Mutex aMutex; /*< Internal concurrency protected handler */

        virtual bool prepare() = 0;

        virtual int perform() = 0;

        virtual void dispose() = 0;

        /*
         * THIS WAS REPLACED BY AN INTERNAL LAMBDA FUNCTION
         *
         * Internal body function (internal use, registered as a friend function).
         * @param pThreadBase pointer to "this".
         */
        //friend void threadFunction(void* pThread);

        // These are placeholders for the forthcoming distributed functionality

        virtual void d_packState(string& pStateData) {
        }

        virtual bool d_sendToDestination(string& pStateData) {
            return false;
        }

        virtual void d_restoreState(string& pSource) {
        }

    }; // Thread

    typedef list<Thread*> ThreadPtrList;
    typedef ThreadPtrList::iterator ThreadPtrListIterator;

    class LThread : public Thread {
        function< bool () > aWorker;
    protected:

        bool prepare() {
            return true;
        }

        int perform() {
            if (!aWorker()) {
                finish();
            }
            return 0;
        }

        void dispose() {
        }

    public:
        LThread(function < bool () > pWorker) : Thread("LThread"), aWorker(pWorker) {}

    }; // LThread class

} // HSEP namespace

#endif /* THREAD_H_ */