UT_Task.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_Task.h (UT Library, C++)
 *
 * COMMENTS:    Wrapper for tbb::task
 */

#ifndef __UT_TASK_H_INCLUDED__
#define __UT_TASK_H_INCLUDED__

#include "UT_API.h"
#include "UT_Array.h"
#include "UT_TaskScope.h"
#include <SYS/SYS_Deprecated.h>
#include <tbb/task.h>

class UT_TaskList;

class UT_API UT_Task : private tbb::task
{
    typedef tbb::task   me;

public:

    SYS_DEPRECATED_REPLACE(19.0, UT_TaskGroup or UT_TaskArena)
    UT_Task()
        : myParentScope(nullptr)
    {
    }

    void setParentScope(const UT_TaskScope *parent)
    {
        myParentScope = parent;
    }

    void setRefCount(int count)
    {
        me::set_ref_count(count);
    }
    void incrementRefCount()
    {
        me::increment_ref_count();
    }
    int decrementRefCount()
    { 
        return me::decrement_ref_count();
    }

    void recycleAsContinuation()
    {
        me::recycle_as_continuation();
    }
    void recycleAsSafeContinuation()
    {
        me::recycle_as_safe_continuation();
    }
    void destroy()
    {
        me::destroy(*this);
    }

    static void spawnRootAndWait(UT_Task &task)
    {
        task.setParentScope(UT_TaskScope::getCurrent());
        me::spawn_root_and_wait(task);
    }
    void        enqueue()
    {
        setParentScope(UT_TaskScope::getCurrent());
        me::enqueue(*this);
    }
    void spawnChild(UT_Task &task)
    {
        task.setParentScope(myParentScope);
        me::spawn(task);
    }

    /// Should be overriden by derived classes.
    /// Returns the next task to run, nullptr if none.
    virtual UT_Task *   run() = 0;

    // Methods imported from tbb::task
    using me::allocate_root;
    using me::allocate_child;

    void cancelGroupExecution()
    {
        me::cancel_group_execution();
    }
    bool isCancelled() const
    {
        return me::is_cancelled();
    }
    void waitForAll()
    {
        me::wait_for_all();
    }

private:

    // Wrapper so that we maintain the UT_TaskScope hierarchy for UT_TaskLock
    UT_Task *           execute() override
                        {
                            UT_TaskScope scope(myParentScope);
                            return run();
                        }

    friend class        UT_TaskList;

private:

    const UT_TaskScope *    myParentScope;
};

SYS_DEPRECATED_PUSH_DISABLE()
class UT_API UT_EmptyTask : public UT_Task
{
public:
    UT_Task *run() override
    {
        return nullptr;
    }
};
SYS_DEPRECATED_POP_DISABLE()

#endif // __UT_TASK_H_INCLUDED__