OperationThread.h

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library 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
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSG_OPERATIONTHREAD
#define OSG_OPERATIONTHREAD 1

#include <osg/observer_ptr>
#include <osg/Object>

#include <OpenThreads/Thread>
#include <OpenThreads/Barrier>
#include <OpenThreads/Condition>
#include <OpenThreads/Block>

#include <list>
#include <set>

namespace osg {

class RefBlock : virtual public osg::Referenced, public OpenThreads::Block
{
    public:

        RefBlock():
            osg::Referenced(true) {}

};

class RefBlockCount : virtual public osg::Referenced, public OpenThreads::BlockCount
{
    public:

        RefBlockCount(unsigned blockCount):
            osg::Referenced(true),
            OpenThreads::BlockCount(blockCount) {}

};

class Operation : virtual public Referenced
{
    public:

        Operation(const std::string& name, bool keep):
            _name(name),
            _keep(keep) {}


        void setName(const std::string& name) { _name = name; }

        const std::string& getName() const { return _name; }

        void setKeep(bool keep) { _keep = keep; }

        bool getKeep() const { return _keep; }

        virtual void release() {}

        virtual void operator () (Object*) = 0;

protected:

        Operation():
            _keep(false) {}

        Operation(const Operation& op):
            _name(op._name),
            _keep(op._keep) {}

        virtual ~Operation() {}

        std::string _name;
        bool        _keep;
};

class OperationThread;

class OSG_EXPORT OperationQueue : public Referenced
{
    public:

        OperationQueue();

        osg::ref_ptr<Operation> getNextOperation(bool blockIfEmpty = false);

        bool empty();

        unsigned int getNumOperationsInQueue();

        void add(Operation* operation);

        void remove(Operation* operation);

        void remove(const std::string& name);

        void removeAllOperations();

        void runOperations(Object* callingObject=0);

        void releaseAllOperations();

        void releaseOperationsBlock();

        typedef std::set<OperationThread*> OperationThreads;

        const OperationThreads& getOperationThreads() const { return _operationThreads; }

    protected:

        virtual ~OperationQueue();

        friend class OperationThread;

        void addOperationThread(OperationThread* thread);
        void removeOperationThread(OperationThread* thread);

        typedef std::list< osg::ref_ptr<Operation> > Operations;

        OpenThreads::Mutex          _operationsMutex;
        osg::ref_ptr<osg::RefBlock> _operationsBlock;
        Operations                  _operations;
        Operations::iterator        _currentOperationIterator;

        OperationThreads            _operationThreads;
};

class OSG_EXPORT OperationThread : public Referenced, public OpenThreads::Thread
{
    public:
        OperationThread();

        void setParent(Object* parent) { _parent = parent; }

        Object* getParent() { return _parent.get(); }

        const Object* getParent() const { return _parent.get(); }


        void setOperationQueue(OperationQueue* opq);

        OperationQueue* getOperationQueue() { return _operationQueue.get(); }

        const OperationQueue* getOperationQueue() const { return _operationQueue.get(); }


        void add(Operation* operation);

        void remove(Operation* operation);

        void remove(const std::string& name);

        void removeAllOperations();


        osg::ref_ptr<Operation> getCurrentOperation() { return _currentOperation; }

        virtual void run();

        void setDone(bool done);

        bool getDone() const { return _done!=0; }

        virtual int cancel();

    protected:

        virtual ~OperationThread();

        observer_ptr<Object>            _parent;

        OpenThreads::Atomic             _done;

        OpenThreads::Mutex              _threadMutex;
        osg::ref_ptr<OperationQueue>    _operationQueue;
        osg::ref_ptr<Operation>         _currentOperation;

};

typedef OperationThread OperationsThread;

}

#endif