All Classes and Interfaces
Class
Description
Abstract base class for
Container supporting all controls of
ContainerProtocol.Delegate base class to be used inside a wrapper class implementing
Container.A basic property control base class.
A general purpose base implementation of
Root.A configuration object used for customizing
AbstractRoot.Delegate behaviour in
a subclass.The possible states this implementation may transition through.
An abstract
StackFrame for commands that need to make a stack frame
that makes a single call and processes its response.Info object used to define the valid input and output arguments of a Control.
A lightweight holder for a future value, the result of an asynchronous
operation such as an actor call.
A queue for handling Async instances.
A task intended to be run asynchronously and outside of the main
component context.
Audio code utility functions.
Annotate a field or method representing an auxiliary input, such as an
Input or a method with single parameter.Annotate a field representing an auxiliary output, such as
Output.A base implementation of a core root for use with
Hub.A BindingContext will normally have one Binding for each bound address.
Abstract type for binding to a Control.
Possible rates for syncing.
An interface allowing for binding to a Control and (if a property) syncing to
it.
An implementation of BindingContext based around a single Control.
Deprecated.
Service for launching a child process clone of this process, to be provided
to
NetworkCoreFactory.Information about the launched child process.
High-precision nanosecond time source.
A CodeComponent is a Component instance that is rewritable at runtime.
A factory service for code components.
Base class for analysing a
CodeDelegate and creating the resources
required for its wrapping CodeContext.Plugin implementations should be registered via service loader mechanism
to extend behaviour of CodeConnectors.
A CodeContainer is a Container instance that is rewritable at runtime.
CodeConnector subclass for CodeContainers.
CodeContext subclass for CodeContainers.
Base class for user rewritable container code.
Annotation to be used on the
CodeContainerDelegate.init() method of the delegate to
control addition of child port proxying capability.A CodeContext wraps each
CodeDelegate, managing state and the
transition from one iteration of delegate to the next on behalf of a
CodeComponent.Listener for responding to time changes inside the context.
A
Service for creating new CodeContext.Result from service on successful creation of context and delegate.
Task sent to the service to request a context and delegate be created
from the provided source code.
CodeDelegate is the base class for all user rewritable code.
A CodeFactory wraps configuration and task creation for creating code
components and contexts for a given delegate base type.
Base code factory for a given base delegate class.
A task for creating a component or context for a given delegate.
A
Root component instance that is rewritable at runtime.CodeConnector subclass for CodeRoots.
CodeContext subclass for CodeRoots.
A
container instance that is rewritable at runtime.
invalid reference
RootCodeConnector subclass for CodeRootContainers.
CodeContext subclass for CodeRootContainers.
Base class for user rewritable Root container code.
Annotation to add hint to display the component and its children in a
table when editing.
Base class for user rewritable Root code.
Mark a field referencing an interface implementation to be wrapped by an
interface proxy, and used to drive updates of the root.
A factory service for code root components.
A script command.
Service provider interface for other modules to provide commands.
Components are the main building blocks (actors) within Praxis CORE.
Address of a Component.
A provider of component types registered into the system via
ComponentFactoryProvider.Mark a component deprecated (with optional replacement type).
A factory service redirect.
Provider of
ComponentFactory.A
Service for creating new component instances.Information about the controls, ports, protocols and properties of a
Component.
Basic component protocol, providing access to the component info, and
optional support for attaching metadata.
A registry of all the components available in the local system along with
their metadata.
Component results to be returned from
ComponentRegistry.query().Control automatic port creation for properties, triggers, etc.
Mark a feature as "preferred" - particularly important for presenting to
humans.
A type representing a connection between two ports.
Extension to the Component interface for components that can contain other
components as children.
Shared APIs for code root containers and code containers.
Register a custom component type.
Annotation to filter available child types and register custom child
types.
A container protocol that allows for calls to add / remove child components,
and connect / disconnect their ports.
A ControlDescriptor wraps a Control in a CodeContext.
Categories of control, which also affects broad ordering of controls.
Information on the type, inputs, outputs and properties of a
Control.The types of a control.
Core code component utility functions.
Basic core code delegate base class.
Basic core code container delegate base class.
Basic core code root base class.
Support for creating data pipes to work with data of any type.
Input port pipe.
Input port pipe.
A data holder used to wrap data of type T to be passed around a Pipe
graph.
The base type of pipes that can be connected to form processing graphs.
Data sink to drive pipe graph.
Data code component utility functions.
Basic data code delegate base class.
Basic data code root base class.
Default base for code delegates providing a variety of functions.
Default delegate API for use as trait by delegate subclasses.
Default implementation of
ExecutionContext for use with
AbstractRootDefault implementation of
ProxyInfo that can be parsed from a PMap,
used by HubConfiguration.A default implementation of
ScriptService.Common interface of reference, port and control descriptors.
Environment context interface passed in to
StackFrame.process(org.praxislive.script.Env) and
InlineCommand.process(org.praxislive.script.Env, org.praxislive.script.Namespace, java.util.List).An optional context available from the
Root lookup providing the
ability to query and listen for changes in root state or clock time.Listener called on clock time updates.
Possible states of a Root.
Listener called on state changes.
An implementation of
SupportedTypes that can be included in the
lookup of a container.Annotate a method as a function.
Annotation for use on CodeDelegate subclasses to create a class body
template file during compilation.
Builders for graph component elements.
Abstract base class of component and root element builders.
Component element builder.
Root element builder.
Elements of a graph tree.
A component element.
A root component element.
Model for graph and subgraph scripts, encompassing the element tree and
related information.
A builder for Hubs.
An interface for creating custom core root implementations.
Hub configuration for a networked hub.
Hub configuration builder.
Override the default ID for ports or controls.
Annotate a field or method representing an input, such as an
Input or
a method with single parameter.Builder utilities for creating
ComponentInfo and related classes.Builder for ControlInfo of action controls.
Abstract base class for ArgumentInfoBuilders.
Helper class for choosing an ArgumentInfoBuilder type.
ComponentInfoBuilder class
Abstract base class for ControlInfo builders.
Helper class for choosing a ControlInfoBuilder type.
Builder for ControlInfo for function controls.
Builder for ArgumentInfo of PNumber.
PortInfoBuilder
Helper class to choose a PortInfoBuilder type.
Builder for ControlInfo of property controls.
Builder for ControlInfo of read-only properties.
Builder for ArgumentInfo of PString.
Builder for ArgumentInfo of any Value type.
Annotate a field to be injected - an injected field will be automatically
created and persisted between code changes.
Simple subtype of
Command that can be executed and produce a result
immediately (without child stack frames or making calls).A default implementation of StackFrame for use by InlineCommand
implementations.
A field type providing a control input port.
Exception thrown when text syntax is invalid and cannot be parsed.
Main entry point for parsing command line arguments and launching a
Hub.Context for launching child processes.
Service for resolving library resources to one or more local paths for
compilation.
Context providing access to existing resolved libraries and files, the
Lookup for resource resolution, and a LogBuilder for reporting
information and errors.
Data type giving a resource and the additional, resolved local files that
were added for that resource.
Provider interface for creating instances of
LibraryResolver.Provider interface for pre-seeding the list of provided libraries with
those built into the current PraxisCORE system.
Linkable is a lightweight form of reactive stream for listening to changing
values from inputs, properties, animation, etc.
A double primitive specialisation of Linkable.
An int primitive specialisation of Linkable.
A general type-safe registry by which clients can access implementations of
various services (eg. implementations of a specific interface).
Interface to be implemented by all types that provide access to a Lookup.
Provide access to the main or first Thread where certain APIs need the
ability to run tasks on the thread that initially started the VM.
A TreeWriter implementation that builds the data in the format specified by
.
invalid reference
SerializableProtocolSimple implementation of
ComponentProtocol.META property, with linked
ComponentProtocol.META_MERGE control.A CoreRootFactory supporting a tree of networked roots.
A builder for NetworkCoreFactory.
Information about the launched network hub.
Annotate a PGraphics field as an additional offscreen buffer.
Annotate a PGraphics field as an additional offscreen buffer.
Pixel format of the buffer.
Name a method to call when a property field (see
@P) changes in
response to an external port or control call.Name a method to call when a property field (see
@P) has an error
in response to an external port or control call.A
Map with consistent order of entries.A
Set with consistent order of entries.Annotate a field representing an output, such as
Output.A field type providing a control output port.
Annotate a field as a property.
Package-URL (aka purl) is a "mostly universal" URL to describe a package.
A builder construct for Package-URL objects.
Superclass of Call.
Interface for an object that can route Calls to their required destination.
An ordered list of Values.
An abstract superclass for values that are backed solely by a PArray.
Exception thrown when a script cannot be parsed into a graph or project
model.
An error message, possibly wrapping a Java Exception.
Annotate a field to be persisted between code changes.
PGL code utility functions.
An ordered map of Strings to Values.
A PMap builder.
An abstract superclass for values that are backed solely by a PMap.
A PortDescriptor wraps a Port in a CodeContext.
Information on the type, direction and properties for a
Port.Port direction.
Elements of a project.
A file element wrapping a file to be included.
A line element wrapping a single line of script.
Model for project scripts.
Project model builder.
A field type for properties (see
@P).Provides keyframe animation support for Property.
A Protocol defines known controls and behaviours that a component can
provide.
A protocol type registration, allowing protocols to be discovered by
class or name.
Provide additional
Protocol.Type.Mark a field referencing an interface implementation to be wrapped by an
interface proxy.
Information about an available proxy process to connect to.
Information about process that should be executed when initializing a
proxy.
( begin auto-generated from PVector.xml )
A class to describe a two or three dimensional vector.
Mark a property field as read-only.
A generic object holder for safely passing references between different
iterations of code.
Event passed to
Ref.onChangeHandler when the Ref value changes.A functional type for initializing a Ref, used by Providers.
A field type for Ref input ports.
Providers initialize Ref instances so that the underlying value can be
used directly as the injected field type.
Annotation to be used on a
Ref field on a container, to allow Ref
fields of direct child components to subscribe and bind to the values of
the published Ref.Annotation to be used on a
Ref field to bind its values to the
values of the published Ref in the direct parent container.A ReferenceDescriptor is used for wrapping references carried across from one
iteration of code context to the next that do not correspond to controls or
ports.
Ports for sharing Ref values.
Ref input, linked to
implementation.
invalid reference
Ref.InOutput port linked to
Ref implementation.Root provides the companion part of the actor-model to Component within
PraxisCORE's forest-of-actors model.
An interface used by the RootHub to control the lifecycle of, and
communicate with, the Root.
A
Service for creating new root instances.RootHub implementations act as a container for Roots, providing a way for
Roots to communicate with each other and access other hub-wide services.
An interface that can be registered as a service provider for modules
wanting to provide Root instances to be installed as RootHub extensions -
usually for Roots providing additional Services.
An interface for RootHub extensions (see
RootHub.ExtensionProvider) to
advertise the services they provide.A stackframe implementation that supports parsing and running of Pcl scripts.
A builder for
ScriptStackFrame.Protocol to serialize all or part of a component tree.
An extension of
Protocol for various system services.Facility to query service addresses.
A context object that should be acquired from a
SharedCodeProperty
and added to the container's lookup.A property control for shared code classes.
A
Service for handling shared code updates and creating dependent
CodeContext.A dependent result with new code context linked to new shared code
classes.
A dependent task for recompiling a
CodeDelegate against the new
shared code classes.Result with shared classes, dependent code contexts, and log.
Task containing new shared code and dependents to be updated, for sending
to the SharedCodeService.
Instances of Signals provide the ability to register custom signal handlers,
for example to ignore SIGINT and similar in a child process.
A StackFrame used within the script executor pointing to the currently
executing command.
Possible states of a StackFrame.
Protocol for a component that can be started and stopped.
A basic Struct-like DataObject for grouping other DataObjects or primitive arrays.
Containers can expose an instance of this interface in their lookup to
facilitate child container support of the supported-types control.
Supported types result to be returned from
SupportedTypes.query().Various utility functions for parsing and writing values.
Mark a field or method as a trigger (action).
Service provider interface for creating terminal IO.
An optional context available from the
Root lookup, providing the
ability to query whether code is running on the Root thread, and to pass
tasks to invoke on the Root thread.This class represents the basic tokens of the Praxis script format.
Class to split a CharSequence into Tokens.
Mark a property field as transient.
Interface for writing the configuration and state of a Component, or tree of
components, into a data structure.
A field type for triggers (actions) - see
@T.Annotations for setting meta-data about fields.
Abstract base class of all types used in messaging inside PraxisCORE.
The type of a Value.
Exception thrown if a String is not a valid representation of the required
Value subclass.
ValueMappers translate values of type Value to another Java type.
Storage for a value, to be used with
Namespace.Video code utility functions.