PDG_WorkItemHolder.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_HOLDER_H__
#define __PDG_WORK_ITEM_HOLDER_H__

#include "PDG_API.h"

#include "PDG_AttributeTypes.h"
#include "PDG_DependencyHolder.h"
#include "PDG_WorkItemTypes.h"

#include <PDGT/PDGT_ValueArgs.h>

#include <UT/UT_Map.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_StringHolder.h>

class PDG_BatchWorkItem;
class PDG_GraphContext;
class PDG_Processor;
class PDG_WorkItemDataType;
struct PDG_WorkItemOptions;
class PDG_WorkItemSerialization;
class PDG_WorkItem;

class UT_OptionsHolder;
class UT_WorkBuffer;

/**
 * Factory object that constructs and validates work items, for use with
 * onGenerate.. The items are held in the Holder until the callbacks and
 * committed to the node after the callback returns.
 *
 **/
class PDG_API PDG_WorkItemHolder : public PDG_DependencyHolder
{
public:
    /// Enumeration of possible commit result
    enum CommitResult
    {
        // Unable to commit work items, either because it was attempted as part
        // of a non-static generation or a root injection during a cook. At
        // some point we might lift the restriction for dynamic generation, but
        // for now we return this. NOT an error - the callback will just continue
        // on its way
        eCommitUnable,

        // Commit failed due to some sort of actual error
        eCommitFail,

        // Commit failed due to a cancel - a "success", but we've been
        // interrupted
        eCommitCancel,

        // Commit completed successfully, the callback can carry on
        eCommitSuccess,

        // Commit was not attempted since the item count required to do so was
        // not reached.
        eCommitNone
    };

public:
                                    PDG_WorkItemHolder(
                                            PDG_GraphContext* context,
                                            PDG_Processor* processor,
                                            bool commitable,
                                            bool is_static);
                                    ~PDG_WorkItemHolder();

                                    UT_NON_COPYABLE(PDG_WorkItemHolder)

    PDG_WorkItem*                   addWorkItem(
                                            CommitResult& result,
                                            UT_WorkBuffer& errors);
    PDG_WorkItem*                   addWorkItem(
                                            CommitResult& result,
                                            const PDG_WorkItemOptions& options,
                                            UT_WorkBuffer& errors);
    PDG_WorkItem*                   addWorkItem(
                                            CommitResult& result,
                                            const PDG_WorkItemOptions& options,
                                            const PDGT_ValueArgs& extra_args,
                                            UT_WorkBuffer& errors);

    PDG_WorkItem*                   addWorkItemFromJSONString(
                                            CommitResult& result,
                                            const UT_StringHolder& json_data,
                                            PDG_WorkItem* parent,
                                            PDG_AttributeCollision strategy,
                                            bool preserve_type,
                                            bool preserve_index,
                                            bool add_attributes,
                                            UT_WorkBuffer& errors);
    bool                            addWorkItemArrayFromJSONString(
                                            CommitResult& result,
                                            PDG_WorkItemArray& work_items,
                                            const UT_StringHolder& json_data,
                                            PDG_WorkItem* parent,
                                            PDG_AttributeCollision strategy,
                                            bool preserve_type,
                                            bool preserve_index,
                                            bool add_attributes,
                                            UT_WorkBuffer& errors);

    PDG_WorkItem*                   addWorkItemFromDict(
                                            CommitResult& result,
                                            const UT_OptionsHolder& dict,
                                            PDG_WorkItem* parent,
                                            PDG_AttributeCollision strategy,
                                            bool preserve_type,
                                            bool preserve_index,
                                            bool add_attributes,
                                            UT_WorkBuffer& errors);
    bool                            addWorkItemArrayFromDict(
                                            CommitResult& result,
                                            PDG_WorkItemArray& work_items,
                                            const UT_OptionsHolder& dict,
                                            PDG_WorkItem* parent,
                                            PDG_AttributeCollision strategy,
                                            bool preserve_type,
                                            bool preserve_index,
                                            bool add_attributes,
                                            UT_WorkBuffer& errors);
 
    PDG_WorkItem*                   addWorkItemFromJSONFile(
                                            CommitResult& result,
                                            const UT_StringHolder& file_path,
                                            PDG_WorkItem* parent,
                                            PDG_AttributeCollision strategy,
                                            bool preserve_type,
                                            bool preserve_index,
                                            bool add_attributes,
                                            UT_WorkBuffer& errors);
    bool                            addWorkItemArrayFromJSONFile(
                                            CommitResult& result,
                                            PDG_WorkItemArray& work_items,
                                            const UT_StringHolder& file_path,
                                            PDG_WorkItem* parent,
                                            PDG_AttributeCollision strategy,
                                            bool preserve_type,
                                            bool preserve_index,
                                            bool add_attributes,
                                            UT_WorkBuffer& errors);

    PDG_WorkItem*                   addWorkItemFromWorkItem(
                                            CommitResult& result,
                                            const PDG_WorkItem* work_item,
                                            PDG_WorkItem* parent,
                                            PDG_AttributeCollision strategy,
                                            bool preserve_type,
                                            bool preserve_index,
                                            bool add_attributes,
                                            UT_WorkBuffer& errors);

    const PDG_Processor*            node() const
                                        { return myProcessor; }
    const PDG_WorkItemPtrArray&     addedWorkItems() const
                                        { return myAddedWorkItems; }
    const PDG_BatchWorkItemPtrArray&
                                    addedBatchItems() const
                                        { return myAddedBatchItems; }
    const PDG_WorkItemArray&        allWorkItems() const
                                        { return myAllWorkItems; }
    const PDG_BatchWorkItemArray&   allBatchItems() const
                                        { return myAllBatchItems; }

    void                            addExtraWorkItems(
                                        const PDG_WorkItemArray& items);

    bool                            isEmpty() const
                                        { return myAddedWorkItems.isEmpty(); }
    bool                            isCommitable() const
                                        { return myIsCommitable; }

    int                             commitCount() const
                                        { return myCommitCount; }
    void                            setCommitCount(int count)
                                        { myCommitCount = count; }

    bool                            useNodePriority() const;

    CommitResult                    commit();

    void                            setExistingWorkItems(
                                            const PDG_WorkItemArray& items);
    void                            claimAddedWorkItems(
                                            PDG_WorkItemPtrArray& work_items,
                                            PDG_BatchWorkItemPtrArray& batches);

private:
    PDG_WorkItem*                   addWorkItemFromSerialization(
                                        CommitResult& result,
                                        const PDG_WorkItemSerialization& serialization,
                                        PDG_WorkItem* parent,
                                        PDG_AttributeCollision strategy,
                                        bool preserve_type,
                                        bool preserve_index,
                                        bool add_attributes,
                                        UT_WorkBuffer& errors);

    CommitResult                    autoCommit();
    PDG_WorkItem*                   claimExistingItem(PDG_WorkItem* parent,
                                                      int index);
private:
    struct ExistingTable
    {
        ExistingTable() : myFirstIndex(0) {}

        int                 myFirstIndex;
        PDG_WorkItemArray   myWorkItems;
    };

    using ExistingMap = UT_Map<PDG_WorkItemID, UT_Map<int, ExistingTable>>;

    static UT_StringHolder          theItemNameAttrib;
    static UT_StringHolder          theItemIdAttrib;
    static UT_StringHolder          theCookedStatusAttrib;

private:
    PDG_WorkItemArray               myAllWorkItems;
    PDG_WorkItemPtrArray            myAddedWorkItems;

    PDG_BatchWorkItemArray          myAllBatchItems;
    PDG_BatchWorkItemPtrArray       myAddedBatchItems;

    ExistingMap                     myExistingWorkItems;

    PDG_GraphContext*               myContext;
    PDG_Processor*                  myProcessor;
    PDG_WorkItemDataType*           myWorkItemDataType;

    int                             myCommitCount;
    bool                            myIsCommitable;
    bool                            myIsStatic;
    bool                            myHasExisting;
};

#endif