Classes
struct	ActivationInfo

struct	ActiveEntityStatus

struct	ActiveGraphStatus

struct	AnnotateNodeSignal

struct	AnnotateNodeSignalTag

class	AssetDescription

class	AssetRegistry

class	AssetRegistryRequests

class	BatchOperationNotifications
	Sends out event for when a batch operation happens on the ScriptCanvas side. More...

class	BehaviorContextObject

struct	BehaviorContextResultTag

class	BehaviorContextUtils

struct	BreakpointTag

struct	BreakTag

class	ComboBoxPropertyInterface

class	Connection

class	ConnectionLimitContract

class	ConnectionRequests

struct	ContinueTag

class	Contract

struct	ContractDescriptor

class	ContractRTTI

class	CopiedVariableData

struct	DataRegistry

struct	DataSlotConfiguration

class	DataUtils

class	Datum

class	DatumNotifications

class	DatumSystemNotifications

struct	DatumValue

struct	DependencyReport

struct	DescriptorHelper

class	DisallowReentrantExecutionContract

class	DisplayGroupConnectedSlotLimitContract

struct	DynamicDataSlotConfiguration

class	DynamicTypeContract

class	EBusHandler

class	EBusHandlerNodeRequests

struct	EditableVariableConfiguration

class	EditableVariableData

class	Endpoint

class	EndpointNotifications

class	EnumComboBoxNodePropertyInterface

class	ErrorReporter
	Execution RequestBus for interfacing with a running graph. More...

class	ExecutionLogAsset

class	ExecutionLogAssetBus

struct	ExecutionLogData

class	ExecutionNotifications

struct	ExecutionSlotConfiguration

class	ExecutionState

struct	ExecutionStateConfig

class	ExecutionStateInterpreted

class	ExecutionStateInterpretedPerActivation

class	ExecutionStateInterpretedPerActivationOnGraphStart

class	ExecutionStateInterpretedPure

class	ExecutionStateInterpretedPureOnGraphStart

class	ExecutionStateInterpretedSingleton

struct	ExecutionThreadBeginning

struct	ExecutionThreadBeginTag

struct	ExecutionThreadEndTag

class	FocusOnEntityEffect

struct	GetActiveEntitiesTag

struct	GetActiveGraphsTag

struct	GetAvailableScriptTargetsTag

struct	GetVariableValuesTag

struct	GetVariableValueTag

class	Graph
	Graph is the execution model of a ScriptCanvas graph. More...

struct	GraphActivationTag

class	GraphConfigurationNotifications

class	GraphConfigurationRequests

struct	GraphData
	Structure for maintaining GraphData. More...

struct	GraphDeactivationTag

struct	GraphIdentifier

struct	GraphInfo

struct	GraphInfoEventBase

class	GraphNotifications

class	GraphRequests
	These are public graph requests. More...

class	GraphScopedIdentifier

struct	GraphUpdateSlotReport

class	GraphVariable

class	GraphVariableManagerComponent

class	GraphVariableManagerNotifications

class	GraphVariableManagerRequests

class	GreyOutNodeEffect

class	HighlightEntityEffect

class	HighlightVariableEffect

class	InactiveGraph

struct	InputSignalTag

class	InvalidExpressionEvent

class	InvalidFunctionCallNameValidation

class	InvalidPropertyEvent

class	InvalidRandomSignalEvent

class	InvalidReferenceEvent

class	InvalidVariableTypeEvent

class	IsReferenceTypeContract

struct	LoggableEvent

class	LoggableEventVisitor

class	LogNotifications

class	MathOperatorContract

struct	MethodConfiguration

struct	MethodOutputConfig

class	ModifiableDatumView

class	MultipleExecutionOutConnections

struct	MultipleOutputInvoker

class	MultipleStartNodes

class	NamedEndpoint

class	NamedId

struct	NamespacePathHasher

class	Node

class	Nodeable

struct	NodeConfiguration

class	NodeFunctionGeneric

class	NodeFunctionGenericMultiReturn

class	NodelingNotifications

class	NodelingRequests

class	NodeNotifications

class	NodePropertyInterface

class	NodePropertyInterfaceListener

struct	NodeRegistry

class	NodeRequests

struct	NodeStateChange

struct	NodeUpdateSlotReport

class	NodeUtils

class	NotYetImplemented

struct	OrderedDependencies

struct	OutputSignalTag

struct	OverloadConfiguration

class	OverloadContract

class	OverloadContractInterface

struct	OverloadSelection

class	ParserValidation

class	RegistrarGeneric

struct	ReplicaNetworkProperties
	Properties that govern Datum replication. More...

struct	RequestByNodeIdTraits

class	RestrictedTypeContract

class	RuntimeAsset

class	RuntimeAssetDescription

class	RuntimeAssetHandler

class	RuntimeComponent

struct	RuntimeData

struct	RuntimeDataOverrides

struct	RuntimeVariable

class	ScopedAuxiliaryEntityHandler

class	ScopedBatchOperation

class	ScopedDataConnectionEvent

class	ScriptCanvasData

class	ScriptCanvasModule
	The ScriptCanvas::Module class coordinates with the application to reflect classes and create system components. More...

class	ScriptCanvasModuleCommon

class	ScriptCanvasSettingsRequests

class	ScriptEventNodeRequests

class	ScriptEventVersionMismatch

class	SerializationListener

class	SerializationUtils

struct	SetDefaultValuesByIndex

struct	Signal

class	Slot

struct	SlotConfiguration

struct	SlotDescriptor

struct	SlotDescriptors

struct	SlotId

struct	SlotMetadata

class	SlotTypeContract

class	SlotTypeUtils

struct	SlotVersionCache

class	StatusRequests

struct	StepOverTag

class	StringMethods

class	SubgraphInterfaceAsset

class	SubgraphInterfaceAssetDescription

class	SubgraphInterfaceAssetHandler

struct	SubgraphInterfaceData

class	SupportsMethodContract

class	SystemComponent

struct	SystemComponentConfiguration

class	SystemRequests

struct	TaggedDataValue

struct	TaggedParent

struct	TransientSlotIdentifier

class	TypedComboBoxNodePropertyInterface

class	TypedNodePropertyInterface

struct	TypeProperties

class	UnknownEndpointEvent

class	UnknownSourceEndpointEvent

class	UnknownTargetEndpointEvent

class	UnspecifiedDynamicDataTypeEvent

class	UnusedNodeEvent

class	ValidationEvent

class	ValidationRequests

class	ValidationResults

struct	VariableChangeTag

class	VariableData
	Variable Data structure for storing mappings of variable names to variable objects. More...

struct	VariableId

struct	VariableIdentifier

class	VariableNodeNotifications

class	VariableNodeRequests

class	VariableNotifications

class	VariableRequests
	Bus Interface for adding, removing and finding exposed Variable datums associated with a ScriptCanvas Graph. More...

class	VersionConverters

struct	VersionData

class	VersioningUtils

struct	VisualExtensionSlotConfiguration

Typedefs
using	AssetRegistryRequestBus = AZ::EBus< AssetRegistryRequests >

using	ExecutionLogAssetEBus = AZ::EBus< ExecutionLogAssetBus >

using	ConnectionRequestBus = AZ::EBus< ConnectionRequests >

using	ContractCreationFunction = AZStd::function< Contract *()>
	Function which will be invoked when a slot is created to allow the creation of a slot contract object.

typedef AZStd::unordered_set< ScriptCanvas::Data::Type >	DataTypeSet

typedef AZStd::unordered_map< size_t, DataTypeSet >	DataSetIndexMapping

typedef AZStd::unordered_map< size_t, ScriptCanvas::Data::Type >	DataIndexMapping

using	GraphOwnerIdType = AZ::EntityId

using	RuntimeIdType = AZ::EntityId

using	GraphPtr = Graph *

using	GraphPtrConst = const Graph *

using	ID = AZ::EntityId

using	NamespacePath = AZStd::vector< AZStd::string >

using	NodeIdList = AZStd::vector< ID >

using	NodePtrList = AZStd::vector< Node * >

using	NodePtrConstList = AZStd::vector< const Node * >

using	PropertyFields = AZStd::vector< AZStd::pair< AZStd::string_view, SlotId > >

using	NamedActiveEntityId = AZ::NamedEntityId

using	NamedNodeId = NamedId< AZ::EntityId >

using	NamedSlotId = NamedId< SlotId >

using	NodeTypeIdentifier = AZStd::size_t

using	EBusEventId = AZ::Crc32

using	EBusBusId = AZ::Crc32

using	ScriptCanvasId = AZ::EntityId

using	DependencySet = AZStd::unordered_set< NamespacePath, NamespacePathHasher >

using	ScriptCanvasSettingsRequestBus = AZ::EBus< ScriptCanvasSettingsRequests >

using	DataPtr = AZStd::intrusive_ptr< ScriptCanvasData >

using	DataPtrConst = AZStd::intrusive_ptr< const ScriptCanvasData >

using	ComparisonOutcome = AZ::Outcome< bool, AZStd::string >

using	DatumNotificationBus = AZ::EBus< DatumNotifications >

using	DatumSystemNotificationBus = AZ::EBus< DatumSystemNotifications >

using	EBusHandlerNodeRequestBus = AZ::EBus< EBusHandlerNodeRequests >

using	Timestamp = AZ::u64

using	ActiveGraphStatusMap = AZStd::unordered_map< AZ::Data::AssetId, ActiveGraphStatus >

using	EntityActiveGraphStatusMap = AZStd::unordered_map< GraphIdentifier, ActiveGraphStatus >

using	ActiveEntityStatusMap = AZStd::unordered_map< AZ::EntityId, ActiveEntityStatus >

using	ActiveEntitiesAndGraphs = AZStd::pair< ActiveEntityStatusMap, ActiveGraphStatusMap >

using	SlotDataMap = AZStd::unordered_map< NamedSlotId, DatumValue >

using	VariableValues = AZStd::unordered_map< VariableId, AZStd::pair< AZStd::string, DatumValue > >

using	Breakpoint = TaggedParent< BreakpointTag, Signal >

using	ExecutionThreadEnd = TaggedParent< ExecutionThreadEndTag, GraphInfo >

using	GraphActivation = TaggedParent< GraphActivationTag, ActivationInfo >

using	GraphDeactivation = TaggedParent< GraphDeactivationTag, ActivationInfo >

using	InputSignal = TaggedParent< InputSignalTag, Signal >

using	OutputSignal = TaggedParent< OutputSignalTag, Signal >

using	VariableChange = TaggedDataValue< VariableChangeTag >

using	ExecutionNotificationsBus = AZ::EBus< ExecutionNotifications >

using	EndpointMapConstIterator = AZStd::unordered_multimap< Endpoint, Endpoint >::const_iterator

using	GraphRequestBus = AZ::EBus< GraphRequests >

using	GraphNotificationBus = AZ::EBus< GraphNotifications >

using	GraphConfigurationRequestBus = AZ::EBus< GraphConfigurationRequests >

using	GraphConfigurationNotificationBus = AZ::EBus< GraphConfigurationNotifications >

using	EndpointNotificationBus = AZ::EBus< EndpointNotifications >

typedef GraphScopedIdentifier< VariableId >	GraphScopedVariableId

typedef GraphScopedIdentifier< AZ::EntityId >	GraphScopedNodeId

typedef GraphScopedIdentifier< Endpoint >	GraphScopedEndpoint

using	ExecutionNameMap = AZStd::unordered_multimap< AZStd::string, AZStd::string >

using	ConstSlotsOutcome = AZ::Outcome< AZStd::vector< const Slot * >, AZStd::string >

using	SlotsOutcome = AZ::Outcome< AZStd::vector< Slot * >, AZStd::string >

using	EndpointResolved = AZStd::pair< const Node , const Slot >

using	EndpointsResolved = AZStd::vector< EndpointResolved >

using	NodeRequestBus = AZ::EBus< NodeRequests >

using	LogNotificationBus = AZ::EBus< LogNotifications >

using	NodeNotificationsBus = AZ::EBus< NodeNotifications >

using	NodelingRequestBus = AZ::EBus< NodelingRequests >

using	NodelingNotificationBus = AZ::EBus< NodelingNotifications >

using	SystemRequestBus = AZ::EBus< SystemRequests >

using	BatchOperationNotificationBus = AZ::EBus< BatchOperationNotifications >

using	SerializationListeners = AZStd::vector< SerializationListener * >

using	BehaviorContextObjectPtr = AZStd::intrusive_ptr< BehaviorContextObject >

using	StatusRequestBus = AZ::EBus< StatusRequests >

using	ValidationRequestBus = AZ::EBus< ValidationRequests >

using	ValidationPtr = AZStd::intrusive_ptr< ValidationEvent >

using	ValidationConstPtr = AZStd::intrusive_ptr< const ValidationEvent >

using	VariableDatum = Deprecated::VariableDatum

using	ErrorReporterBus = AZ::EBus< ErrorReporter >

using	ExecutionStateConstPtr = AZStd::shared_ptr< const ExecutionState >

using	ExecutionStatePtr = AZStd::shared_ptr< ExecutionState >

using	ExecutionStateWeakConstPtr = const ExecutionState *

using	ExecutionStateWeakPtr = ExecutionState *

using	ExecutionStateInterpretedConstPtr = AZStd::shared_ptr< const ExecutionStateInterpreted >

using	ExecutionStateInterpretedPtr = AZStd::shared_ptr< ExecutionStateInterpreted >

using	ExecutionStateInterpretedPureConstPtr = AZStd::shared_ptr< const ExecutionStateInterpretedPure >

using	ExecutionStateInterpretedPurePtr = AZStd::shared_ptr< ExecutionStateInterpretedPure >

using	ExecutionStateInterpretedSingletonConstPtr = AZStd::shared_ptr< const ExecutionStateInterpretedSingleton >

using	ExecutionStateInterpretedSingletonPtr = AZStd::shared_ptr< ExecutionStateInterpretedSingleton >

using	VariableIdMap = AZStd::unordered_map< VariableId, VariableId >

using	ReplacementEndpointPairs = AZStd::unordered_set< AZStd::pair< Endpoint, Endpoint > >

using	ReplacementConnectionMap = AZStd::unordered_map< AZ::EntityId, ReplacementEndpointPairs >

using	GraphVariableMapping = AZStd::unordered_map< VariableId, GraphVariable >

using	VariableRequestBus = AZ::EBus< VariableRequests >

using	VariableValidationOutcome = AZ::Outcome< void, GraphVariableValidationErrorCode >

using	GraphVariableManagerRequestBus = AZ::EBus< GraphVariableManagerRequests >

using	VariableNodeRequestBus = AZ::EBus< VariableNodeRequests, RequestByNodeIdTraits >

using	ScriptEventNodeRequestBus = AZ::EBus< ScriptEventNodeRequests, RequestByNodeIdTraits >

using	GraphVariableManagerNotificationBus = AZ::EBus< GraphVariableManagerNotifications >

using	VariableNotificationBus = AZ::EBus< VariableNotifications >

using	VariableNodeNotificationBus = AZ::EBus< VariableNodeNotifications >

using	NamedVariabledId = NamedId< VariableId >

Enumerations
enum	PropertyStatus : AZ::u8 { Getter, None, Setter }

enum	GrammarVersion : int { Initial = -1, BackendSplit = 0, Current }

enum	RuntimeVersion : int { Initial = -1, DirectTraversal = 0, Current }

enum	FileVersion : int { Initial = -1, JSON = 0, Current }

enum	EventType { Broadcast, BroadcastQueue, Event, EventQueue, Count }

enum	ExecutionMode : AZ::u8 { Interpreted, Native, COUNT }

enum	AzEventIdentifier : size_t

enum	MethodType { Event, Free, Member, Getter, Setter, Count }

enum	UpdateResult { DirtyGraph, DeleteNode, DisableNode, Unknown }

enum	NodeDisabledFlag : int { None = 0, User = 1 << 0, ErrorInUpdate = 1 << 1, NonUser = ErrorInUpdate }

enum	CombinedSlotType : AZ::s32 { None = 0, ExecutionIn, ExecutionOut, DataIn, DataOut, LatentOut }

enum	ConnectionType : AZ::s32 { Unknown = 0, Input, Output }

enum	SlotTypeDescriptor : AZ::s32 { Unknown = 0, Execution, Data }

enum	DynamicDataType : AZ::s32 { None = 0, Value, Container, Any }

enum	ValidationSeverity { Unknown = -1, Error, Warning, Informative }

enum	BuildConfiguration { Release, Performance, Debug }

enum	ExecutionConfiguration { Release, Performance, Debug, Traced }

enum	GraphVariableValidationErrorCode { Duplicate, Invalid, Unknown }

enum	ExposeOption : AZ::s32 { None = 0, None, None = 0, None = 0, None = 0, ComponentInput = 1 << 0, ComponentOutput = 1 << 1 }

Functions
	AZ_CVAR_EXTERNED (bool, g_saveRuntimeAssetsAsPlainTextForDebug)

	AZ_CVAR_EXTERNED (bool, g_saveEditorAssetsAsPlainTextForDebug)

bool	IsNamespacePathEqual (const NamespacePath &lhs, const NamespacePath &rhs)

	DATUM_GET_NUMBER_SPECIALIZE (char)

	DATUM_GET_NUMBER_SPECIALIZE (short)

	DATUM_GET_NUMBER_SPECIALIZE (int)

	DATUM_GET_NUMBER_SPECIALIZE (long)

	DATUM_GET_NUMBER_SPECIALIZE (AZ::s8)

	DATUM_GET_NUMBER_SPECIALIZE (AZ::s64)

	DATUM_GET_NUMBER_SPECIALIZE (unsigned char)

	DATUM_GET_NUMBER_SPECIALIZE (unsigned int)

	DATUM_GET_NUMBER_SPECIALIZE (unsigned long)

	DATUM_GET_NUMBER_SPECIALIZE (unsigned short)

	DATUM_GET_NUMBER_SPECIALIZE (AZ::u64)

	DATUM_GET_NUMBER_SPECIALIZE (float)

	DATUM_SET_NUMBER_SPECIALIZE (char)

	DATUM_SET_NUMBER_SPECIALIZE (short)

	DATUM_SET_NUMBER_SPECIALIZE (int)

	DATUM_SET_NUMBER_SPECIALIZE (long)

	DATUM_SET_NUMBER_SPECIALIZE (AZ::s8)

	DATUM_SET_NUMBER_SPECIALIZE (AZ::s64)

	DATUM_SET_NUMBER_SPECIALIZE (unsigned char)

	DATUM_SET_NUMBER_SPECIALIZE (unsigned int)

	DATUM_SET_NUMBER_SPECIALIZE (unsigned long)

	DATUM_SET_NUMBER_SPECIALIZE (unsigned short)

	DATUM_SET_NUMBER_SPECIALIZE (AZ::u64)

	DATUM_SET_NUMBER_SPECIALIZE (float)

	DATUM_SET_VECTOR_SPECIALIZE (AZ::Vector2)

	DATUM_SET_VECTOR_SPECIALIZE (AZ::Vector3)

	DATUM_SET_VECTOR_SPECIALIZE (AZ::Vector4)

void	ReflectExecutionBusArguments (AZ::ReflectContext *context)

AZStd::string	ToString (const SlotDataMap &map)

AZStd::string	ToString (const VariableValues &variableValues)

AZ_INLINE void	NoDefaultArguments (Node &)

constexpr bool	IsExecutionOut (CombinedSlotType slotType)

AZ_INLINE AZStd::string_view	GetInputSlotName ()

AZ_INLINE AZStd::string_view	GetOutputSlotName ()

AZ_INLINE AZStd::string_view	GetSourceSlotName ()

template<AZStd::size_t Capacity>
bool	CompareSignature (AZ::BehaviorMethod *method, const AZStd::array< AZ::Uuid, Capacity > &typeIds)

template<size_t startIndex, typename ArrayType , typename... Args, size_t... Indices>
void	UnpackParameterAtIndex (ArrayType &outArray, AZStd::index_sequence< Indices... >, Args &&... args)

void	BehaviorContextObjectPtrReflect (AZ::ReflectContext *context)

void	InitDataRegistry ()

void	ResetDataRegistry ()

AZ::EnvironmentVariable< DataRegistry >	GetDataRegistry ()

GraphInfo	CreateGraphInfo (ScriptCanvasId executionId, const GraphIdentifier &graphIdentifier)

AZ::Outcome< void, AZStd::string >	IsExposable (const AZ::BehaviorMethod &method)

Grammar::FunctionPrototype	ToSignature (const AZ::BehaviorMethod &method)

void	InitNodeRegistry ()

void	ResetNodeRegistry ()

AZ::EnvironmentVariable< NodeRegistry >	GetNodeRegistry ()

void	ReflectLibraries (AZ::ReflectContext *)

AZStd::vector< AZ::ComponentDescriptor * >	GetLibraryDescriptors ()

void	MergeUpdateSlotReport (const AZ::EntityId &scriptCanvasNodeId, GraphUpdateSlotReport &report, const NodeUpdateSlotReport &source)

AZStd::vector< AZStd::pair< Endpoint, Endpoint > >	CollectEndpoints (const AZStd::vector< AZ::Entity * > &connections, bool logEntityNames=false)

void	UpdateConnectionStatus (Graph &graph, const GraphUpdateSlotReport &report)

Variables
static const GraphOwnerIdType	GraphOwnerId = AZ::EntityId(0xacedc0de)

static const RuntimeIdType	UniqueId = AZ::EntityId(0xfee1baad)

constexpr const char *	k_EventOutPrefix = "ExecutionSlot:"

constexpr const char *	k_OnVariableWriteEventName = "OnVariableValueChanged"

constexpr const char *	k_OnVariableWriteEbusName = "VariableNotification"

constexpr const AZStd::string_view	k_VersionExplorerWindow = "VersionExplorerWindow"

const BehaviorContextResultTag	s_behaviorContextResultTag {}

static const char *	s_dataRegistryName = "ScriptCanvasDataRegistry"

constexpr const char *	NotYetImplementedId = "SC-0000"

static const AZ::Crc32	NotYetImplementedCrc = AZ_CRC(NotYetImplementedId)

static const char *	s_nodeRegistryName = "ScriptCanvasNodeRegistry"

Detailed Description

The EditContext and other facilities give script users, especially ScriptCanvas users the ability to create and initialize objects that cannot be easily created with a sequence of C++ code. Some Editor facilities give users access to private variables in objects that cannot be modified or initialized directly via their public C++ interface.

This ExecutionCloneSource objects exists to facilitate fast construction and initialization of the such objects when needed to execute compiled ScriptCanvas graphs properly.

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description