PDG_WorkItemDirty.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_WORKITEM_DIRTY_H__
#define __PDG_WORKITEM_DIRTY_H__

#include "PDG_API.h"

#include "PDG_File.h"
#include "PDG_NodeTypes.h"
#include "PDG_WorkItemTypes.h"

#include <UT/UT_ArrayStringSet.h>
#include <UT/UT_ArrayMap.h>
#include <UT/UT_Map.h>

class PDG_GraphContext;
class PDG_Node;
class PDG_WorkItem;

class PDG_API PDG_WorkItemDirty
{
public:
    /// Enumeration of dirty types
    enum Type
    {
        /// Invalid/uninitialized dirty operation
        eDirtyInvalid,

        /// Dirty of a single work iem
        eDirtyWorkItem,

        /// Dirty of a single node
        eDirtyNode,

        /// Dirty of the entire graph
        eDirtyGraph
    };

public:
                            PDG_WorkItemDirty()
                                : myContext(nullptr)
                                , myDirtyNode(nullptr)
                                , myDirtyType(eDirtyInvalid)
                                , myEmitGraphEvents(false)
                                , myIsDelete(false) {}
                            PDG_WorkItemDirty(
                                    PDG_GraphContext* context,
                                    bool is_delete,
                                    Type dirty_type=eDirtyInvalid)
                                : myContext(context)
                                , myDirtyNode(nullptr)
                                , myDirtyType(dirty_type)
                                , myEmitGraphEvents(false)
                                , myIsDelete(is_delete) {}
                            PDG_WorkItemDirty(
                                    PDG_GraphContext* context,
                                    PDG_Node* node,
                                    bool is_delete,
                                    bool emit_graph_events)
                                : myContext(context)
                                , myDirtyNode(node)
                                , myDirtyType(eDirtyNode)
                                , myEmitGraphEvents(emit_graph_events)
                                , myIsDelete(is_delete) {}

    /// Returns the dirty type
    inline Type             dirtyType() const
                                { return myDirtyType; }

    /// Returns the list of files from dirty work items
    inline const PDG_File::Set&
                            dirtyFiles() const
                                { return myDirtyFiles; }

    /// Returns the list of files that are prevented from being deleted
    inline const UT_ArrayStringSet&
                            keepFiles() const
                                { return myKeepFiles; }

    /// Returns the set of work items marked for deletiong
    PDG_WorkItemSet         dirtySet() const;

    /// Returns the set of work items marked for dirtying
    PDG_WorkItemSet         deleteSet() const;

    /// Returns true if the item is marked for deletion
    bool                    isDeleted(const PDG_WorkItem* work_item) const;

    /// Returns true if the item is marked for any kind of dirtying operation
    bool                    isDirty(const PDG_WorkItem* work_item) const;

    /// Returns true if the data for the work item is dirty
    bool                    isDataDirty(const PDG_WorkItem* work_item) const;

    /// Adds a work item to the dirty set(s)
    void                    dirtyWorkItem(
                                const PDG_WorkItem* work_item,
                                bool is_delete);

    /// Resets this object to a clean state
    void                    reset();

    /// Adds a work item and its dependencies to the dirty sets
    void                    prepareDirty(PDG_WorkItem* work_item);

    /// Adds a node to the pending dirty operation
    void                    prepareDirty(
                                PDG_Node* node,
                                bool will_remove_outputs);

    /// Applies the stored dirty operation
    void                    applyDirty(bool remove_outputs);

    /// Updates the dirty data map for the work item, and returns true if the
    /// dirtying operaton should proceed. Returns false if no dirtying should
    /// occur.
    bool                    updateDirtyData(
                                const PDG_WorkItem* work_item,
                                bool is_dirty_data);

    /// Updates the cache ID of the work item for a dependency
    void                    updateCacheId(
                                const PDG_WorkItem* dependent,
                                const PDG_WorkItem* dependency);

    /// Flags a dependency relationship for removal. This is necessary because
    /// it's possible for only some dependencies of a partition to be deleted
    /// during a dependency operation, which still leaves the partition behind.
    /// This method returns true if the removal corresponds to the last entry
    /// in the partition, which indicates that the partition itself should
    /// also be deleted
    bool                    removeDependency(
                                const PDG_WorkItem* dependent,
                                const PDG_WorkItem* dependency);

    /// Adds a request to preserve a file, even if the file would normally be
    /// deleted by a dirty operation.
    void                    keepFilePath(const UT_StringHolder& file_path);

private:
    /// Dirties the work items stored in this object
    void                    applyWorkItemDirty(bool remove_outputs);

private:
    /// Enumeration of dirty state states
    enum class DirtyData
    {
        eUnset,
        eClean,
        eDirty
    };

    /// Helper struct that stores information about a work item that
    /// will be dirtied, but not deleted
    struct DirtyInfo
    {
                                DirtyInfo()
                                    : myCacheId(-1)
                                    , myDataDirty(DirtyData::eUnset) {}

        const PDG_WorkItem*     myDependent;
        PDG_WorkItemIDSet       myDependencyIDs;
        PDG_WorkItemConstArray  myDependencies;

        PDG_CacheID             myCacheId;
        DirtyData               myDataDirty;
    };

    using DirtyInfoMap      = UT_Map<PDG_WorkItemID, DirtyInfo>;
    using DirtyNodeMap      = UT_ArrayMap<PDG_Node*, PDG_WorkItemConstArray>;
    using DirtyWorkItemMap  = UT_ArrayMap<PDG_WorkItemID, const PDG_WorkItem*>;

private:
    DirtyWorkItemMap        myDeleteMap;
    DirtyNodeMap            myDeleteNodeMap;

    DirtyWorkItemMap        myDirtyMap;
    DirtyInfoMap            myDirtyInfoMap;

    PDG_File::Set           myDirtyFiles;
    UT_ArrayStringSet       myKeepFiles;

    PDG_GraphContext*       myContext;
    PDG_Node*               myDirtyNode;
    Type                    myDirtyType;

    bool                    myIsDelete;
    bool                    myEmitGraphEvents;
};

#endif