Thread.cpp

Go to the documentation of this file.

/*
 * ThreadBase.cpp
 *
 *  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/>.
 */

#include <HSEP/Thread.h>

#include <system_error>
#include <iostream>
#include <unistd.h> /*< for the sleep method */

using namespace std;
namespace HSEP {

    /*
     * This construction was required prior to C++ 11, and it is
     * a direct requirement from the POSIX standard.
     *
     * Has been replaced by a Lambda function.
     *
    void threadFunction(void* pThread) {
        ((Thread*)pThread)->run();
    }
    */

    inline void Thread::run() {

        bool vContinue;
        bool vMoving;

        if (prepare()) {
            do {
                {
                    ExclusiveScope vScope((Mutex*)&aMutex);
                    vContinue = aFlags.aContinue;
                    vMoving   = aFlags.aMoving;
                }
                if (vContinue) {
                    if (vMoving) {
                        string vPackagedState;
                        d_packState(vPackagedState);
                        if (d_sendToDestination(vPackagedState)) {
                            finish();
                        }
                    }
                    else {
                        aExitCode = perform();
                    }
                }
            }
            while (vContinue);
            dispose();
        }
    } // ThreadBase::run

    bool Thread::dispatch() {

        bool vDone = false;

        if (!aFlags.aDispatched) {

            //
            // The old POSIX construction is replaced by a
            // direct in context Lambda function
            //
            //    aHandler = thread(threadFunction,this);
            //
            int  vAttempts = 0;

            while (!vDone && (10 > vAttempts)) {

                try {
                    aHandler = thread(
                        [&](void* xThreadPtr) {
                            ((Thread*)xThreadPtr)->run();
                        },
                        this
                    );
                    vDone = true;
                    aFlags.aDispatched = true;
                }
                // The code 11 represents that the resource is
                // temporarily unavailable, so the thread must
                // wait to have enough resources to work
                //
                catch (system_error& vException) {
                    error_code vCode = vException.code();
                    if (11 == vCode.value()) {
                        usleep(10);
                        vAttempts++;
                    }
                }
            }
            if (!vDone) {
                aExitCode = NON_DISPATCHED;
            }
        }

        return vDone;

    } // Thread::dispatch

    int Thread::join() {

        if (aFlags.aDispatched) {
            aHandler.join();
        }
        return aExitCode;
    } // Thread::join

    void Thread::relocate(string pDestination) {

        {
            ExclusiveScope vScope(&aMutex);
            aFlags.aMoving   = true;
        }

    } // Thread::relocate

} // HSEP namespace