PDG_Event.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_EVENT_H__
#define __PDG_EVENT_H__

#include "PDG_API.h"

#include "PDG_AttributeTypes.h"
#include "PDG_NodeTypes.h"
#include "PDG_WorkItem.h"
#include "PDG_WorkItemTypes.h"

#include <UT/UT_StringHolder.h>
#include <SYS/SYS_Hash.h>

class PDG_GraphContext;
class PDG_Node;
class PDG_Scheduler;

/*
 * Generic event that contains all of the fields needed for all PDG events
 * types. To keep the event object small, string fields are stored in one
 * of two string variables, which are reused depending on the event type.
 */
class PDG_API PDG_Event
{
public:
    /// Empty, null-initialized event that can be used when clear constructing
    /// event data structures, or passing a default value to an event reference
    /// parameter
    static PDG_Event            theEmptyEvent;

public:
    /// Constructs an event for node creation [node]
    static PDG_Event            NodeCreate(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);
    /// Constructs an event for node deletion [node]
    static PDG_Event            NodeRemove(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);
    /// Constructs an event that indicates that a node was renamed
    /// [node, oldname, newname]
    static PDG_Event            NodeRename(
                                    PDG_GraphContext * context,
                                    const PDG_Node* node,
                                    const UT_StringHolder& old_name,
                                    const UT_StringHolder& new_name);
    /// Constructs an event for two node being connected [node1, node2]
    static PDG_Event            NodeConnect(
                                    PDG_GraphContext* context,
                                    const PDG_Node* input,
                                    const PDG_Node* output);
    /// Constructs an event for two node being disconnected [node1, node2]
    static PDG_Event            NodeDisconnect(
                                    PDG_GraphContext* context,
                                    const PDG_Node* input,
                                    const PDG_Node* output);
    /// Constructs an event that indicates a node cooked for the first
    /// time [node]
    static PDG_Event            NodeFirstCook(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);
    /// Constructs an event that indicates a node finished generating work
    /// items [node]
    static PDG_Event            NodeGenerated(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);
    /// Constructs an event that indicates a node finished cooking work
    /// items [node]
    static PDG_Event            NodeCooked(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);
    /// Constructs an event that indicates a node has all of its work
    /// items dirtied [node]
    static PDG_Event            NodeClear(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);
    /// Constructs an event that indicates a node generated new work items,
    /// but may still have more to generate in the future [node]
    static PDG_Event            NodeProgressUpdate(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);


    /// Constructs an event that indicates a node began dirtying work
    /// items [node]
    static PDG_Event            DirtyStart(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);
    /// Constructs an event that indicates a node finished dirtying work
    /// items [node]
    static PDG_Event            DirtyStop(
                                    PDG_GraphContext* context,
                                    const PDG_Node* node);
    /// Constructs an event that indicates that all work items in the graph
    /// are being dirtied []
    static PDG_Event            DirtyAll(PDG_GraphContext* context);


    /// Constructs an event that indicates an error occured in a node while
    /// cooking [node, message]
    static PDG_Event            CookError(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    const UT_StringHolder &message);
    /// Constructs an event that indicates an error occured in a scheduler
    /// while cooking [node, message]
    static PDG_Event            CookError(
                                    PDG_GraphContext *context,
                                    const PDG_Scheduler *scheduler,
                                    const UT_StringHolder &message);
    /// Constructs an event that indicates a warning occured in a node while
    /// cooking [node, message]
    static PDG_Event            CookWarning(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    const UT_StringHolder &message);
    /// Constructs an event that indicates a warningoccured in a scheduler
    /// while cooking [node, message]
    static PDG_Event            CookWarning(
                                    PDG_GraphContext *context,
                                    const PDG_Scheduler *scheduler,
                                    const UT_StringHolder &message);
    /// Creates an event that indicates that cooking has started [?node]
    static PDG_Event            CookStart(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node=nullptr);
    /// Creates an event that indicates that cooking has finished [?node]
    static PDG_Event            CookComplete(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node=nullptr);


    /// Creates an event that indicates that a dependency was added between
    /// two work items [workitem, dependency]
    static PDG_Event            WorkItemAddDep(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item,
                                    PDG_WorkItemID dependency);
    /// Creates an event that indicates that a dependency was removed between
    /// two work items [workitem, dependency]
    static PDG_Event            WorkItemRemoveDep(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item,
                                    PDG_WorkItemID depdendency);
    /// Creates an event that indicates a work item's cook progress was
    /// updated [node, workitem]
    static PDG_Event            WorkItemCookPercentUpdate(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item);
    /// Creates an event that indicates that a work item changed states
    /// [node, oldstate, newstate]
    static PDG_Event            WorkItemStateChange(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item,
                                    PDG_WorkItemState old_state,
                                    PDG_WorkItemState new_state);
    /// Creates an event that indicates that a work item was added to a
    /// node [node, workitem]
    static PDG_Event            WorkItemAdd(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item);
    /// Creates an event that indicates that a list of work items was added to
    /// a node [node, workitemArray]
    static PDG_Event            WorkItemAddList(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    const PDG_WorkItemIDArray& work_items);
    /// Constructs an event that indicates a work item was removed from a
    /// node [node, workitem, state]
    static PDG_Event            WorkItemRemove(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item,
                                    PDG_WorkItemState state);
    /// Constructs an event that indicates a list of work item was removed
    /// from a node [node, workitemArray]
    static PDG_Event            WorkItemRemoveList(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    const PDG_WorkItemIDArray& work_items);
    /// Constructs an event that indicates a work item was selected in the
    /// UI [node, workitem]
    static PDG_Event            WorkItemSelect(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item);
    /// Constructs an event that indicates a work item's attribute data was
    /// updated [node, workitem]
    static PDG_Event            WorkItemMergeData(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item);
    /// Constructs an event that indicates a work item's output files were
    /// updated [node, workitem]
    static PDG_Event            WorkItemOutputFiles(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item);
    /// Constructs an event that indicates an attribute was changed
    /// on a work item [node, workitem, attribname]
    static PDG_Event            WorkItemSetAttrib(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item,
                                    PDG_AttributeType attr_type,
                                    const UT_StringHolder &attr_name);
    /// Constructs an event that indicates an integer attribute was changed
    /// on a work item [node, workitem, attribname]
    static PDG_Event            WorkItemSetIntAttrib(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item,
                                    const UT_StringHolder &attr_name);
    /// Constructs an event that indicates a float attribute was changed
    /// on a work item [node, workitem, attribname]
    static PDG_Event            WorkItemSetFloatAttrib(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item,
                                    const UT_StringHolder &attr_name);
    /// Constructs an event that indicates a string attribute was changed
    /// on a work item [node, workitem, attribname]
    static PDG_Event            WorkItemSetStringAttrib(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item,
                                    const UT_StringHolder &attr_name);
    /// Constructs an event that indicates a work item's priority changed
    /// [node, workitem]
    static PDG_Event            WorkItemPriority(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    PDG_WorkItemID work_item);
    /// Constructs an event that indicates that a batch work item was
    /// initialized [node, workitems]
    static PDG_Event            WorkItemBatchInitialized(
                                    PDG_GraphContext *context,
                                    const PDG_Node* node,
                                    PDG_WorkItemID work_item,
                                    const PDG_WorkItemIDArray& work_items);


    /// Constructs an event for scheduler creation [scheduler]
    static PDG_Event            SchedulerAdded(
                                    PDG_GraphContext *context,
                                    const PDG_Scheduler *scheduler);
    /// Constructs an event for scheduler removal [scheduler]
    static PDG_Event            SchedulerRemoved(
                                    PDG_GraphContext *context,
                                    const PDG_Scheduler *scheduler);
    /// Constructs an event for a scheduler being assigned to a node
    /// [node, scheduler]
    static PDG_Event            SetScheduler(
                                    PDG_GraphContext *context,
                                    const PDG_Node *node,
                                    const PDG_Scheduler *scheduler);


    /// Constructs an event that indicates services have been modified[]
    static PDG_Event            ServiceManagerAll();
    /// Constructs an event that indicates that a specific service has
    /// started [service]
    static PDG_Event            ServiceStartBegin(
                                    const UT_StringHolder& service_name);
    /// Constructs an event that indicates that a specific service has
    /// stopped [service]
    static PDG_Event            ServiceStartEnd(
                                    const UT_StringHolder& service_name);
    /// Constructs an event that indicates that a service client has
    /// stopped [service, client]
    static PDG_Event            ServiceClientStarted(
                                    const UT_StringHolder& service_name,
                                    const UT_StringHolder& client_name);
    /// Constructs an event that indicates that a service client has
    /// been modified [service, client]
    static PDG_Event            ServiceClientChanged(
                                    const UT_StringHolder& service_name,
                                    const UT_StringHolder& client_name);

    /// Returns the string name of an event
    static const char*          eventName(PDG_EventType type);

public:
    /// Constructs a default initialized null event
                                PDG_Event();

    /// Constructs an event for use with services, without a graph context as
    /// services are global to the session
                                PDG_Event(
                                    PDG_EventType type,
                                    bool can_consolidate,
                                    const UT_StringHolder& service_name =
                                        UT_StringHolder::theEmptyString,
                                    const UT_StringHolder& service_client_name =
                                        UT_StringHolder::theEmptyString);

    /// Constructs an event for a specific graph context
                                PDG_Event(
                                    PDG_EventType type,
                                    bool can_consolidate,
                                    PDG_GraphContext* context,
                                    const PDG_Node* node = nullptr,
                                    const PDG_Node* node2 = nullptr,
                                    PDG_WorkItemID work_item =
                                        PDG_WorkItem::theInvalidId,
                                    PDG_WorkItemID dependency =
                                        PDG_WorkItem::theInvalidId,
                                    PDG_WorkItemState current_state =
                                        PDG_WorkItemState::eUndefined,
                                    PDG_WorkItemState last_state =
                                        PDG_WorkItemState::eUndefined);

    PDG_EventType               type() const
                                    { return myEventType; }
    bool                        canConsolidate() const
                                    { return myCanConsolidate; }

    PDG_GraphContext*           context() const
                                    { return myContext; }

    PDG_Node*                   node() const;
    PDG_Node*                   node2() const;
    PDG_Scheduler*              scheduler() const;

    PDG_WorkItemID              workItemId() const
                                    { return myWorkItemId; }
    PDG_WorkItemID              dependencyId() const
                                    { return myDependencyId; }

    PDG_WorkItemState           currentState() const
                                    { return myCurrentState; }
    PDG_WorkItemState           lastState() const
                                    { return myLastState; }
    const UT_StringHolder&      message() const
                                    { return myStringData[theMessage]; }

    const UT_StringHolder&      attrName() const
                                    { return myStringData[theAttributeName]; }

    const UT_StringHolder&      oldName() const
                                    { return myStringData[theNodeOldName]; }
    const UT_StringHolder&      newName() const
                                    { return myStringData[theNodeNewName]; }

    const UT_StringHolder&      serviceName() const
                                    { return myStringData[theServiceName]; }
    const UT_StringHolder&      serviceClientName() const
                                    { return myStringData[theServiceClientName]; }

    const PDG_WorkItemIDArray&  workItemArray() const
                                    { return myWorkItemArray; }

    PDG_NodeID                  nodeId() const
                                    { return myNodeId; }
    PDG_NodeID                  node2Id() const
                                    { return myNode2Id; }
    const UT_StringHolder&      schedulerName() const
                                    { return myStringData[theSchedulerName]; }

    SYS_HashType                hash() const;
    bool                        operator==(const PDG_Event& other) const;

    UT_StringHolder             toString() const;
    void                        consolidate(const PDG_Event& other);

private:
    static int                  theNodeOldName;
    static int                  theNodeNewName;
    static int                  theAttributeName;
    static int                  theMessage;
    static int                  theServiceName;
    static int                  theServiceClientName;
    static int                  theSchedulerName;

private:
    UT_StringHolder             myStringData[2];
    PDG_WorkItemIDArray         myWorkItemArray;
    
    PDG_GraphContext*           myContext;

    PDG_WorkItemID              myWorkItemId;
    PDG_WorkItemID              myDependencyId;

    PDG_NodeID                  myNodeId;
    PDG_NodeID                  myNode2Id;

    PDG_EventType               myEventType;
    PDG_WorkItemState           myCurrentState;
    PDG_WorkItemState           myLastState;

    bool                        myCanConsolidate;
};

SYS_FORCE_INLINE size_t hash_value(const PDG_Event& event)
{
    return event.hash();
}

namespace UT
{
    template <typename T>
    struct DefaultClearer;

    template <>
    struct DefaultClearer<PDG_Event>
    {
        static void         clear(PDG_Event& event)
                                { event = PDG_Event::theEmptyEvent; }
        static bool         isClear(const PDG_Event& event)
                                { return (event == PDG_Event::theEmptyEvent); }
        static void         clearConstruct(PDG_Event *p)
                                { new ((void *)p) PDG_Event(); }
        static const bool   clearNeedsDestruction = false;
    };
}

#endif