PDG_WorkItemOptions.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.
 *
 * COMMENTS:
 */

#ifndef PDG_WORK_ITEM_OPTIONS_H
#define PDG_WORK_ITEM_OPTIONS_H

#include "PDG_API.h"
#include "PDG_Types.h"

#include <UT/UT_Optional.h>
#include <UT/UT_StringHolder.h>
 
/**
 * Options available to configure the construction of a PDG work item
 */
struct PDG_API PDG_WorkItemOptions
{
    /// Behavior that controls whether or not data is cloned when generating
    /// a work item from a parent item
    enum CloneMode
    {
        /// Uses the work item data type to determine whether or not data
        /// should be cloned
        eCloneDefault,

        /// Always clones the upstream data regardless of the data type's
        /// preference
        eCloneAlways,

        /// Never clones the data, regardless of the data type's 
        /// preference
        eCloneNever
    };

    /// Default initialization
    PDG_WorkItemOptions()
        : PDG_WorkItemOptions("", -1)
    {
    }

    /// Simple name/index initialization
    PDG_WorkItemOptions(const UT_StringHolder& name, int index)
        : myName(name)
        , myTypeName("")
        , myCloneTarget(nullptr)
        , myParent(nullptr)
        , myParentArray(nullptr)
        , myParentArrayOffset(0)
        , myIndex(index)
        , myCloneMode(eCloneDefault)
        , myCookType(PDG_WorkItemCookType::eAutomatic)
        , myBatchSize(0)
        , myBatchOffset(0)
        , myBatch(false)
        , myInProcess(false)
        , myIsNoGenerate(false)
        , myPreserveDataType(false)
        , myCloneOutputFiles(false)
        , myIsServiceMode(false)
        , myIsPartialCook(false)
        , myIsDynamicBatch(false)
        , myPriority()
    {
    }

    /// The name of the work item. This field is no longer used as work
    /// items cannot have custom names.
    UT_StringHolder             myName;

    /// The name of the type name - if this is null/empty string, the 
    /// node's default work item data type is used
    UT_StringHolder             myTypeName;

    /// The parent array, used when generating static items with a batch to hook
    /// up dependencies between subitems and upstream items
    const PDG_WorkItemArray*    myParentArray;

    /// A locally stored version of the parent array, when the more efficient
    /// reference-based version is not suitable.
    PDG_WorkItemArray           myLocalParentArray;

    /// The parent item, only valid when generating static items when the parent 
    /// is not already determined
    PDG_WorkItem*               myParent;

    /// The item from which data should be cloned. If this is null, defaults to
    /// the parent as computed by the workitem holder.
    const PDG_WorkItem*         myCloneTarget;

    /// The parent array offset, used when adding dependencies from the parent
    /// array. Batch sub item 0 goes with parent_array[parent_offset], and so
    /// forth.
    int                         myParentArrayOffset;

    /// The work items index. If this is < 0, the upstream item index is
    /// used
    int                         myIndex;

    /// The work item priority.  By default it is 'unset' and will inherit the
    /// parent priority. setPriority will cause the priority to override that
    /// behavior.  getPriority will return 0 when the value is unset.
    int                         getPriority() const
                                    { return myPriority.value_or(0); }
    void                        setPriority(int priority)
                                    { myPriority = priority;  }
    bool                        isPrioritySet() const
                                    { return myPriority.has_value(); }

    /// Clone behavior
    CloneMode                   myCloneMode;

    /// Work item cook type
    PDG_WorkItemCookType        myCookType;

    /// Batch size, only used when Batch is true
    int                         myBatchSize;

    /// Batch offset, only used when Batch is true
    int                         myBatchOffset;

    /// Indicates that this is a batch work item
    bool                        myBatch;

    /// Indicates that this is an in-process work item
    bool                        myInProcess;

    /// Indicates that this item cannot be used for downstream generation
    bool                        myIsNoGenerate;

    /// Indicates that the data type should be preserved when cloning
    bool                        myPreserveDataType;

    /// Indicates that output results should be copied when cloning
    bool                        myCloneOutputFiles;

    // Indicates whether this work item will be cooked by a service
    bool                        myIsServiceMode;

    /// Indicates whether or not the work item supports partial cooking of
    /// batches. Only used when Batch is true.
    bool                        myIsPartialCook;

    /// Indicates whether or not a batch work item can dynamically add sub
    /// items while it cooks. Only used when Batch is true.
    bool                        myIsDynamicBatch;

private:
    UT_Optional<int>            myPriority;
};

#endif