source: experimental/Threading/Threading/ThreadedWorker.cpp

#include "ThreadedWorker.h"
#include <osg/Notify>
#include <OpenThreads/ScopedLock>


ThreadedWorker::ThreadedWorker()
 : _done(false)
{
        OSG_ALWAYS<<"ThreadedWorker instantiated."<<std::endl;
}

ThreadedWorker::~ThreadedWorker()
{
        cancel();
}

void ThreadedWorker::run()
{
        OSG_ALWAYS<<"Starting Thread "<<getThreadId()<<"!"<<std::endl;

        // Do the work
        do
        {
                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_threadWorkerMutex);

                if( _threadWorker.valid() )
                        (*_threadWorker)(this);
                
        } while (_threadWorker!=NULL && !testCancel() && !_done);       // repeat as long as a functor is set and it is not canceled or set as Done
}

void ThreadedWorker::setDone(bool done)
{
        _done = done;
}

int ThreadedWorker::cancel()
{
    OSG_ALWAYS<<"Cancelling ThreadedWorker "<<this<<" isRunning()="<<isRunning()<<std::endl;

    if( isRunning() )
    {
        _done = true;

        OSG_ALWAYS<<"   Doing cancel "<<this<<std::endl;

        // then wait for the the thread to stop running.
        while(isRunning())
        {
            // commenting out debug info as it was cashing crash on exit, presumable
            // due to OSG_NOTIFY or std::cout destructing earlier than this destructor.
            //OSG_ALWAYS<<"   Waiting for ThreadedWorker to cancel "<<this<<std::endl;
            OpenThreads::Thread::YieldCurrentThread();
        }
    }

    OSG_ALWAYS<<"  ThreadedWorker::cancel() thread cancelled "<<this<<" isRunning()="<<isRunning()<<std::endl;

    return 0;
}

void ThreadedWorker::setThreadWorker( ThreadWorkerBase* tworker)
{
        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_threadWorkerMutex);

        _threadWorker = tworker;
}