PDG_Types.h File Reference

#include <PDGT/PDGT_BaseType.h>
#include <PDGT/PDGT_RegisteredType.h>
#include <PDGT/PDGT_TypeInstance.h>
#include <UT/UT_Array.h>
#include <UT/UT_ArrayMap.h>
#include <UT/UT_ArraySet.h>
#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_Map.h>
#include <UT/UT_Set.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_Optional.h>
#include <UT/UT_UniquePtr.h>
#include <SYS/SYS_Types.h>
#include <utility>

Include dependency graph for PDG_Types.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
using	PDG_DependencyPtr = UT_SharedPtr< PDG_Dependency >
	Type defs for registered type objects. More...
using	PDG_NodeCallbackPtr = UT_SharedPtr< PDG_NodeCallback >
using	PDG_SchedulerPtr = UT_SharedPtr< PDG_Scheduler >
using	PDG_ServicePtr = UT_SharedPtr< PDG_Service >
using	PDG_WorkItemDataPtr = UT_SharedPtr< PDG_WorkItemData >
using	PDG_WorkItemID = exint
	Type defs for unique work item IDs. More...
using	PDG_WorkItemIDArray = UT_Array< PDG_WorkItemID >
using	PDG_WorkItemIDSet = UT_ArraySet< PDG_WorkItemID >
using	PDG_WorkItemIDMap = UT_ArrayMap< PDG_WorkItemID, bool >
using	PDG_WorkItemArray = UT_Array< PDG_WorkItem * >
	Array, set and map of work items. More...
using	PDG_WorkItemConstArray = UT_Array< const PDG_WorkItem * >
using	PDG_WorkItemSet = UT_ArraySet< PDG_WorkItem * >
using	PDG_WorkItemConstSet = UT_ArraySet< const PDG_WorkItem * >
using	PDG_WorkItemMap = UT_Map< PDG_WorkItem *, PDG_WorkItemSet >
using	PDG_WorkItemConstMap = UT_Map< const PDG_WorkItem *, PDG_WorkItemSet >
using	PDG_WorkItemBoolMap = UT_ArrayMap< PDG_WorkItem *, bool >
using	PDG_WorkItemConstBoolMap = UT_ArrayMap< const PDG_WorkItem *, bool >
using	PDG_WorkItemPair = std::pair< PDG_WorkItem *, PDG_WorkItem * >
	Pair and array of work item pairs. More...
using	PDG_WorkItemPairArray = UT_Array< PDG_WorkItemPair >
using	PDG_BatchWorkItemArray = UT_Array< PDG_BatchWorkItem * >
	Array and set of batch work items. More...
using	PDG_BatchWorkItemSet = UT_ArraySet< PDG_BatchWorkItem * >
using	PDG_NodePtr = UT_UniquePtr< PDG_Node >
	Array, set and map of nodes. More...
using	PDG_NodePtrMap = UT_ArrayStringMap< PDG_NodePtr >
using	PDG_NodeArray = UT_Array< PDG_Node * >
using	PDG_NodeSet = UT_ArraySet< PDG_Node * >
using	PDG_NodeMap = UT_ArrayStringMap< PDG_Node * >
using	PDG_PortArray = UT_Array< PDG_Port * >
	Array of input/output/parameter ports. More...
using	PDG_SchedulerSet = UT_Set< PDG_Scheduler * >
	Set of schedulers. More...
using	PDG_SchedulerArray = UT_Array< PDG_Scheduler * >
typedef UT_Optional< fpreal >	OptionalFrame
using	PDG_BaseType = PDGT_BaseType< PDG_RegistrationType >
	Base type for types registered using PDG_TypeRegistry. More...
template<typename Class , typename Pointer , PDG_RegistrationType type, typename... Args>
using	PDG_RegisteredType = PDGT_RegisteredType< Class, Pointer, PDG_RegistrationType, type, Args...>
using	PDG_TypeInstance = PDGT_TypeInstance< PDG_RegistrationType >

Enumerations
enum	PDG_Platform { PDG_Platform::eUndefined = -1, PDG_Platform::eLinux = 0, PDG_Platform::eMac = 1, PDG_Platform::eWindows = 2 }
	Enumeration of supported platforms, for work item command line array. More...
enum	PDG_BatchActivation { PDG_BatchActivation::eAny, PDG_BatchActivation::eFirst, PDG_BatchActivation::eAll, PDG_BatchActivation::eFixed }
enum	PDG_CallbackResult {   PDG_CallbackResult::eFailure, PDG_CallbackResult::eSuccess, PDG_CallbackResult::eMissing, PDG_CallbackResult::eNone,   PDG_CallbackResult::eAll }
	Enumeration of callback return types. More...
enum	PDG_ServiceBlockCookType { PDG_ServiceBlockCookType::eNever, PDG_ServiceBlockCookType::eMatch, PDG_ServiceBlockCookType::eAlways }
	Enumeration of service block cook modes. More...
enum	PDG_ServiceResetWhen { PDG_ServiceResetWhen::eNone = 0x0, PDG_ServiceResetWhen::eBeforeCook = 0x1, PDG_ServiceResetWhen::eAfterCook = 0x2, PDG_ServiceResetWhen::eBoth = 0x3 }
	When service clients should be reset. More...
enum	PDG_ServiceResetType { PDG_ServiceResetType::eNone, PDG_ServiceResetType::eReset, PDG_ServiceResetType::eRestart }
enum	PDG_ServiceOwner { PDG_ServiceOwner::eScheduler, PDG_ServiceOwner::eSession }
	Enumeration of the different types of service owner. More...
enum	PDG_ServiceState {   PDG_ServiceState::eStopped, PDG_ServiceState::eStopping, PDG_ServiceState::eStarting, PDG_ServiceState::eRunning,   PDG_ServiceState::eError }
	Enumeration of the different states that a service can be in. More...
enum	PDG_ServiceLogType { PDG_ServiceLogType::eNone, PDG_ServiceLogType::eStdout, PDG_ServiceLogType::eFile }
	Enumeration of service log types. More...
enum	PDG_ServiceStartResult { PDG_ServiceStartResult::eError, PDG_ServiceStartResult::eSuccess, PDG_ServiceStartResult::eRunning, PDG_ServiceStartResult::eConnecting }
	Enumeration of possible result values from starting a service. More...
enum	PDG_NodeState {   PDG_NodeState::eUncooked, PDG_NodeState::eCooking, PDG_NodeState::eCooked, PDG_NodeState::eFailed,   PDG_NodeState::eCanceled, PDG_NodeState::eWaiting, PDG_NodeState::eIncomplete }
	Node state, used for UI/progress reporting. More...
enum	PDG_NodeType {   PDG_NodeType::eMapper, PDG_NodeType::ePartitioner, PDG_NodeType::eProcessor, PDG_NodeType::eScheduler,   PDG_NodeType::eUndefined }
	Enumeration of node types in a PDG graph. More...
enum	PDG_NodeSubtype {   PDG_NodeSubtype::eRegular, PDG_NodeSubtype::eFeedbackBegin, PDG_NodeSubtype::eFeedbackEnd, PDG_NodeSubtype::eUtility,   PDG_NodeSubtype::eUndefined }
	Enumeration of node subtypes. More...
enum	PDG_PortDisplayType {   PDG_PortDisplayType::eDefault = 0x0, PDG_PortDisplayType::eMenu = 0x01, PDG_PortDisplayType::eToggle = 0x02, PDG_PortDisplayType::eJoin = 0x04,   PDG_PortDisplayType::eSeparator = 0x08, PDG_PortDisplayType::eNoLabel = 0x10, PDG_PortDisplayType::eOperator = 0x20 }
enum	PDG_PortType { PDG_PortType::eInput, PDG_PortType::eOutput, PDG_PortType::eParameter, PDG_PortType::eCount }
	Enumeration of node port types. More...
enum	PDG_WorkItemEvalState { PDG_WorkItemEvalState::eEvalBlocked, PDG_WorkItemEvalState::eEvalReady, PDG_WorkItemEvalState::eEvalFailed }
enum	PDG_WorkItemLogType { PDG_WorkItemLogType::eLogError, PDG_WorkItemLogType::eLogWarning, PDG_WorkItemLogType::eLogMessage, PDG_WorkItemLogType::eLogRaw }
	Enumeration of work item log message types. More...
enum	PDG_WorkItemSortOrder : uint8 {   PDG_WorkItemSortOrder::eSortNone, PDG_WorkItemSortOrder::eSortIndex, PDG_WorkItemSortOrder::eSortInputOrder, PDG_WorkItemSortOrder::eSortAttribute,   PDG_WorkItemSortOrder::eSortFrame }
enum	PDG_WorkItemState : uint8 {   PDG_WorkItemState::eUndefined, PDG_WorkItemState::eUncooked, PDG_WorkItemState::eWaiting, PDG_WorkItemState::eScheduled,   PDG_WorkItemState::eCooking, PDG_WorkItemState::eCookedSuccess, PDG_WorkItemState::eCookedCache, PDG_WorkItemState::eCookedFail,   PDG_WorkItemState::eCookedCancel, PDG_WorkItemState::eDirty, PDG_WorkItemState::eStateCount }
	Enum of possible work item states. More...
enum	PDG_WorkItemType : uint8 { PDG_WorkItemType::eRegular, PDG_WorkItemType::eBatch, PDG_WorkItemType::ePartition }
	Enum of work item types. More...
enum	PDG_WorkItemExecutionType : uint8 { PDG_WorkItemExecutionType::eRegular, PDG_WorkItemExecutionType::eLongRunning, PDG_WorkItemExecutionType::eCleanup }
	Enum of work item runtime types. More...
enum	PDG_WorkItemCookType : uint8 {   PDG_WorkItemCookType::eGenerate, PDG_WorkItemCookType::eInProcess, PDG_WorkItemCookType::eOutOfProcess, PDG_WorkItemCookType::eService,   PDG_WorkItemCookType::eAutomatic }
	Enumeration of work item cook types. More...
enum	PDG_RegistrationType {   PDG_RegistrationType::eDependency, PDG_RegistrationType::eNode, PDG_RegistrationType::eScheduler, PDG_RegistrationType::eWorkItem,   PDG_RegistrationType::eService, PDG_RegistrationType::eCount }
	Enumeration of entities that can be registered with PDG_TypeRegistry. More...
enum	PDG_AttributeCollision { PDG_AttributeCollision::eKeep, PDG_AttributeCollision::eReplace, PDG_AttributeCollision::eError }
enum	PDG_CommandType { PDG_COMMAND_CHUNK, PDG_USER_COMMAND, PDG_RUNTIME_COMMAND }

Typedef Documentation

typedef UT_Optional<fpreal> OptionalFrame

Definition at line 86 of file PDG_Types.h.

using PDG_BaseType = PDGT_BaseType<PDG_RegistrationType>

Base type for types registered using PDG_TypeRegistry.

Definition at line 550 of file PDG_Types.h.

using PDG_BatchWorkItemArray = UT_Array<PDG_BatchWorkItem*>

Array and set of batch work items.

Definition at line 68 of file PDG_Types.h.

using PDG_BatchWorkItemSet = UT_ArraySet<PDG_BatchWorkItem*>

Definition at line 69 of file PDG_Types.h.

using PDG_DependencyPtr = UT_SharedPtr<PDG_Dependency>

Type defs for registered type objects.

Definition at line 41 of file PDG_Types.h.

using PDG_NodeArray = UT_Array<PDG_Node*>

Definition at line 75 of file PDG_Types.h.

using PDG_NodeCallbackPtr = UT_SharedPtr<PDG_NodeCallback>

Definition at line 42 of file PDG_Types.h.

using PDG_NodeMap = UT_ArrayStringMap<PDG_Node*>

Definition at line 77 of file PDG_Types.h.

using PDG_NodePtr = UT_UniquePtr<PDG_Node>

Array, set and map of nodes.

Definition at line 72 of file PDG_Types.h.

using PDG_NodePtrMap = UT_ArrayStringMap<PDG_NodePtr>

Definition at line 73 of file PDG_Types.h.

using PDG_NodeSet = UT_ArraySet<PDG_Node*>

Definition at line 76 of file PDG_Types.h.

using PDG_PortArray = UT_Array<PDG_Port*>

Array of input/output/parameter ports.

Definition at line 80 of file PDG_Types.h.

template<typename Class , typename Pointer , PDG_RegistrationType type, typename... Args>

using PDG_RegisteredType = PDGT_RegisteredType< Class, Pointer, PDG_RegistrationType, type, Args...>

Specialization type which encapsulates the produced class and construction args, for a type registered in the registry

Definition at line 559 of file PDG_Types.h.

using PDG_SchedulerArray = UT_Array<PDG_Scheduler*>

Definition at line 84 of file PDG_Types.h.

using PDG_SchedulerPtr = UT_SharedPtr<PDG_Scheduler>

Definition at line 43 of file PDG_Types.h.

using PDG_SchedulerSet = UT_Set<PDG_Scheduler*>

Set of schedulers.

Definition at line 83 of file PDG_Types.h.

using PDG_ServicePtr = UT_SharedPtr<PDG_Service>

Definition at line 44 of file PDG_Types.h.

using PDG_TypeInstance = PDGT_TypeInstance<PDG_RegistrationType>

Base class for a concrete instance of a type created by the registry

Definition at line 563 of file PDG_Types.h.

using PDG_WorkItemArray = UT_Array<PDG_WorkItem*>

Array, set and map of work items.

Definition at line 54 of file PDG_Types.h.

using PDG_WorkItemBoolMap = UT_ArrayMap<PDG_WorkItem*, bool>

Definition at line 60 of file PDG_Types.h.

using PDG_WorkItemConstArray = UT_Array<const PDG_WorkItem*>

Definition at line 55 of file PDG_Types.h.

using PDG_WorkItemConstBoolMap = UT_ArrayMap<const PDG_WorkItem*, bool>

Definition at line 61 of file PDG_Types.h.

using PDG_WorkItemConstMap = UT_Map<const PDG_WorkItem*, PDG_WorkItemSet>

Definition at line 59 of file PDG_Types.h.

using PDG_WorkItemConstSet = UT_ArraySet<const PDG_WorkItem*>

Definition at line 57 of file PDG_Types.h.

using PDG_WorkItemDataPtr = UT_SharedPtr<PDG_WorkItemData>

Definition at line 45 of file PDG_Types.h.

using PDG_WorkItemID = exint

Type defs for unique work item IDs.

Definition at line 48 of file PDG_Types.h.

using PDG_WorkItemIDArray = UT_Array<PDG_WorkItemID>

Definition at line 49 of file PDG_Types.h.

using PDG_WorkItemIDMap = UT_ArrayMap<PDG_WorkItemID, bool>

Definition at line 51 of file PDG_Types.h.

using PDG_WorkItemIDSet = UT_ArraySet<PDG_WorkItemID>

Definition at line 50 of file PDG_Types.h.

using PDG_WorkItemMap = UT_Map<PDG_WorkItem*, PDG_WorkItemSet>

Definition at line 58 of file PDG_Types.h.

using PDG_WorkItemPair = std::pair<PDG_WorkItem*, PDG_WorkItem*>

Pair and array of work item pairs.

Definition at line 64 of file PDG_Types.h.

using PDG_WorkItemPairArray = UT_Array<PDG_WorkItemPair>

Definition at line 65 of file PDG_Types.h.

using PDG_WorkItemSet = UT_ArraySet<PDG_WorkItem*>

Definition at line 56 of file PDG_Types.h.

Enumeration Type Documentation

enum PDG_AttributeCollision

strong

Enumeration of merge strategies for handling collisions when deserializing attributes into a map with existing attributes

Enumerator
eKeep	The existing attribute is kept and the deserialized attribute is discarded
eReplace	The existing attribute is replaced with the deserialized attribute.
eError	Deserialization fails when an existing attribute is found with the same name as the one being deserialized

Definition at line 528 of file PDG_Types.h.

enum PDG_BatchActivation

strong

Enumeration of activiation modes for the batch, i.e. the condition under which the batch item is first submitted to the scheduler

Enumerator
eAny	The batch is scheduled once any of the subitems are ready to cook.
eFirst	The batch is scheduled once the first sub item is ready to cook.
eAll	The batch is scheduled once all of the subitems are ready to cook.
eFixed	The batch is scheduled once a specific number of subitems are ready to cook

Definition at line 106 of file PDG_Types.h.

enum PDG_CallbackResult

strong

Enumeration of callback return types.

Enumerator
eFailure	The callback failed to execute.
eSuccess	The callback executed successfully.
eMissing	The callback is missing or undefined.
eNone	Special "None" case – the callback took no action or returned no results
eAll	Special "All" case – the callback returned all results.

Definition at line 123 of file PDG_Types.h.

enum PDG_CommandType

Enumerator
PDG_COMMAND_CHUNK
PDG_USER_COMMAND
PDG_RUNTIME_COMMAND

Definition at line 542 of file PDG_Types.h.

enum PDG_NodeState

strong

Node state, used for UI/progress reporting.

Enumerator
eUncooked	The node is uncooked, either because it wasn't on the cook path or because it chose to generate no items
eCooking	The node is actively cooking work items.
eCooked	The node is completely cooked.
eFailed	One or more work items failed during the cook.
eCanceled	One or more work items were canceled during the cook.
eWaiting	The node is waiting on upstream nodes to make progress.
eIncomplete	The node is partially cooked, and likely won't make any progress during the rest of the active cook

Definition at line 252 of file PDG_Types.h.

enum PDG_NodeSubtype

strong

Enumeration of node subtypes.

Enumerator
eRegular	A regular node – default value.
eFeedbackBegin	A feedback begin node – part of a feedback block.
eFeedbackEnd	A feedback end node – part of a feedback block.
eUtility	A utility node, such as a null or switch.
eUndefined	Placeholder/undefined node subtype.

Definition at line 302 of file PDG_Types.h.

enum PDG_NodeType

strong

Enumeration of node types in a PDG graph.

Enumerator
eMapper	Mapper nodes – add dependencies between upstream and downstream work items [Deprecated]
ePartitioner	Partitioner nodes – group multiple upstream work items into partitions with a common property
eProcessor	Processor nodes – generate zero more more new work items from upstream work items that perform real work
eScheduler	Scheduler nodes – submits work items to some sort of scheduling or farm system
eUndefined	Placeholder/undefined node type.

Definition at line 279 of file PDG_Types.h.

enum PDG_Platform

strong

Enumeration of supported platforms, for work item command line array.

Enumerator
eUndefined	No specified platform.
eLinux	The linux platform index.
eMac	The mac platform index.
eWindows	The windows platform index.

Definition at line 89 of file PDG_Types.h.

enum PDG_PortDisplayType

strong

Enumeration of node port display type, e.g. menus or toggles, for parameters

Enumerator
eDefault	Default display type.
eMenu	Dropdown menu display.
eToggle	Toggle display.
eJoin	Join-next display.
eSeparator	Separator display.
eNoLabel	No label display.
eOperator	Operator path display.

Definition at line 322 of file PDG_Types.h.

enum PDG_PortType

strong

Enumeration of node port types.

Enumerator
eInput	Input connection.
eOutput	Output connection.
eParameter	Parameter.
eCount	Port type guard/count.

Definition at line 347 of file PDG_Types.h.

enum PDG_RegistrationType

strong

Enumeration of entities that can be registered with PDG_TypeRegistry.

Enumerator
eDependency	Custom external dependency.
eNode	Custom node definition.
eScheduler	Custom scheduler definition.
eWorkItem	Custom work item data definition.
eService	Custom service defintion.
eCount

Definition at line 506 of file PDG_Types.h.

enum PDG_ServiceBlockCookType

strong

Enumeration of service block cook modes.

Enumerator
eNever	Work items will never cook using the service associated with the parent block
eMatch	Work items will cook the parent block's service if it matches the service name for the node
eAlways	Work items will always use the parent block's service.

Definition at line 143 of file PDG_Types.h.

enum PDG_ServiceLogType

strong

Enumeration of service log types.

Enumerator
eNone	The service does not do any logging – stdout is routed to /dev/null
eStdout	The service logs to stdout.
eFile	The service logs to a file on disk.

Definition at line 222 of file PDG_Types.h.

enum PDG_ServiceOwner

strong

Enumeration of the different types of service owner.

Enumerator
eScheduler	The service is owned by a scheduler, which means it will be tied to the lifetime of the scheduler node(s).
eSession	The service is owned by the session, which means it will be stopped only if stopped by the user or Houdini is closed.

Definition at line 188 of file PDG_Types.h.

enum PDG_ServiceResetType

strong

Service client reset operation, performed each time work items acquire a new client.

Enumerator
eNone	The service client is not reset.
eReset	The service client is sent the "reset" command.
eRestart	The service client process is restarted.

Definition at line 175 of file PDG_Types.h.

enum PDG_ServiceResetWhen

strong

When service clients should be reset.

Enumerator
eNone	The service client is not reset.
eBeforeCook	The service client is reset at the start of a work item or block cook.
eAfterCook	The service client is reset at the end of a work item or block cook.
eBoth	The service is reset at the beginning and end of a cook.

Definition at line 158 of file PDG_Types.h.

enum PDG_ServiceStartResult

strong

Enumeration of possible result values from starting a service.

Enumerator
eError	An error occured and the service was not started.
eSuccess	The service was successfully started.
eRunning	The service was already running.
eConnecting	The service clients are connecting in the background.

Definition at line 236 of file PDG_Types.h.

enum PDG_ServiceState

strong

Enumeration of the different states that a service can be in.

Enumerator
eStopped
eStopping
eStarting
eRunning
eError

Definition at line 200 of file PDG_Types.h.

enum PDG_WorkItemCookType : uint8

strong

Enumeration of work item cook types.

Enumerator
eGenerate	The work item does its processing during the generation stage, and doesn't "cook" in the traditional sense.
eInProcess	The work item cooks in process.
eOutOfProcess	The work item cooks out of process.
eService	The work item cooks as a service.
eAutomatic	Unspecified/automatic cook type.

Definition at line 486 of file PDG_Types.h.

enum PDG_WorkItemEvalState

strong

Enumeration of evaluation states that a work item can be in. Used when checking if the subitem is able to evaluate yet.

Enumerator
eEvalBlocked	The work item is blocked on a dependency.
eEvalReady	The work item is ready to cook.
eEvalFailed	The work item has a failed dependency.

Definition at line 364 of file PDG_Types.h.

enum PDG_WorkItemExecutionType : uint8

strong

Enum of work item runtime types.

Enumerator
eRegular	A regular work item, with normal running time.
eLongRunning	A long running work item that's process may outlive the cooking state of the work item
eCleanup	A work item that cleans up another long running item.

Definition at line 472 of file PDG_Types.h.

enum PDG_WorkItemLogType

strong

Enumeration of work item log message types.

Enumerator
eLogError	Error log message.
eLogWarning	Warning log message.
eLogMessage	Plain log message.
eLogRaw	Raw log data.

Definition at line 377 of file PDG_Types.h.

enum PDG_WorkItemSortOrder : uint8

strong

Enumeration of sort order types, currently used by the partitionItems method

Enumerator
eSortNone	Explicitly chosen no sorting.
eSortIndex	Index based sorting.
eSortInputOrder	Input ordering.
eSortAttribute	Order by a specific attribute value.
eSortFrame	Order by the work item's frame value.

Definition at line 394 of file PDG_Types.h.

enum PDG_WorkItemState : uint8

strong

Enum of possible work item states.

Enumerator
eUndefined	Undefined state, e.g. for uninitialized data. Work items should never actually have this state
eUncooked	The item is uncooked and no cooked has been attempted yet.
eWaiting	The item is uncooked and waiting on its dependencies to finish cooking
eScheduled	The item has been sent to the scheduler(s), but might not yet be executing
eCooking	The item is cooking.
eCookedSuccess	The item has finished cooking and succeeded.
eCookedCache	The item has was marked as successfully cooked because it a cached file was found on disk
eCookedFail	The item has finished cooking and failed.
eCookedCancel	The item has finished cooking by cancellation.
eDirty	The item was dirty; it may have been cooked before, but not necessarily. This is effectively the same as uncooked, but it gives an indication that item may need additional cleanup or repartitioning.
eStateCount	The number of states.

Definition at line 413 of file PDG_Types.h.

enum PDG_WorkItemType : uint8

strong

Enum of work item types.

Enumerator
eRegular	A static or dynamic work item that does real work, and has one upstream parent
eBatch	A batch item, which consists of one or more subitems that are Regular type items
ePartition	A partition, which has a list of upstream components.

Definition at line 457 of file PDG_Types.h.