All Classes and Interfaces

Class
Description
Provides the ability to label the Flow.
Abstract ManagedObjectSource allowing to asynchronously source the ManagedObject.
Provide AbstractAsyncManagedObjectSource.Labeller functionality along with qualifying type of dependency.
Provides the ability to label the required ExecutionStrategy.
Provides the ability to label the required dependency or Flow.
Abstract Change.
Abstract operations TestCase.
Abstract JUnit CosmosDb functionality.
Abstract SupplierSource for CosmosDatabase / CosmosAsyncDatabase.
Abstract FunctionState that delegates functionality to a delegate FunctionState.
Abstract JUnit DynamoDb connect functionality.
Configuration of DynamoDb.
Abstract JUnit DynamoDb functionality.
Abstract functionality for overriding the System.getenv(String) values in tests.
Change to environment.
Abstract ExecutiveSource.
TeamSource based on the Executors cached thread pool.
Factory to create the ExecutorService.
Team based on the ExecutorService.
Abstract functionality for modifying System for tests.
Context Runnable.
Convenience OfficeFloorSpringBootExtensionServiceFactory that handles extra Spring Boots that may not be on the class path.
Abstract JUnit connect Firestore functionality.
Configuration of Firestore.
Abstract JUnit Firestore functionality.
ClassDependencyManufacturer for providing Flow invocations.
Abstract FunctionBuilder.
ManagedFunctionSource for a Class having the Method instances as the ManagedFunction instances.
Abstract FunctionState.
Abstract Google HttpFunction JUnit functionality.
Provides the ability to label the Flow.
Abstract HttpClient to HttpServer.
Abstract HttpResource.
Abstract HttpSecurable implementation to be configured as HttpSecurableBuilder.
AbstractHttpSecuritySource<A,AC extends Serializable,C,O extends Enum<O>,F extends Enum<F>>
Provide AbstractHttpSecuritySource.Labeller functionality along with qualifying type of dependency.
Provides the ability to label the required dependency or Flow.
Abstract TestCase for testing a HttpServerImplementation.
Test fixture for asynchronous servicing.
Test fixture for servicing requests with a ByteBuffer.
Test fixture for servicing requests with raw bytes.
AbstractManagedObjectSource to cancel connections.
Test fixture for servicing requests that wait for connection cancellation.
Test fixture for servicing requests that closes a file channel after writing.
Compares results of OfficeFloor servicing against Raw servicing.
Test fixture for servicing requests with encoded URLs.
Test fixture for servicing requests that fail.
Test fixture for servicing requests with a file.
Test fixture for verifying full HTTP request and response functionality.
Result of a pipeline execution.
Servicer that is slow causing significant back pressure.
Test fixture for servicing requests with qualified connections.
Test fixture for servicing requests.
Marker ManagedObject for identifying Team.
Marker ManagedObject for identifying Team.
Marker managed object for threaded servicing.
Test fixture for servicing requests on a different thread.
Flow interface.
SocketServicerFactory and RequestServicerFactory to use the HttpRequestParser to produce ServerHttpConnection instances for servicing.
Convenient AbstractJdbcManagedObjectSource.Connectivity implementation to wrap a Connection.
Connectivity.
Abstract tests for an JDBC vendor implementation.
Test fixture section for checking connection decoration.
Test fixture section for checking connectivity.
Flow interface.
Test fixture section for inserting rows.
Marker for new thread.
Parameter holding the selected name value.
Test fixture section for selecting rows.
Flow interface.
Abstract functionality for the JPA testing.
Mock section for deleting entity.
Mock section for inserting entity.
Marker for new thread.
Mock section for reading entity.
Holder for the result.
Input parameter carrying the row identifier for the select stress test.
Parameter holding the selected entity for the select stress test.
Test fixture section for stress insert.
Flow interface.
Test fixture section for stress select.
Flow interface.
Mock section for updating entity.
Abstract JUnit Logger functionality.
Context for defining the specification.
Abstract ManagedObjectSource that allows to synchronously source the ManagedObject.
Abstract Google HttpFunction JUnit functionality serviced by MockHttpServer.
Abstract mock HttpSecuritySource.
Abstract JUnit mock JWT access tokens for the JwtHttpSecuritySource.
Provides top level functionality for all model elements.
Abstract Netty HTTP server.
Abstract JUnit functionality for running Objectify with local Datastore.
Loads the entity.
Loads the entity.
Indicates timeout on obtaining entity.
Abstract TestCase for construction testing of an Office.
Abstract JUnit functionality for OfficeFloor.
Context for defining the specification.
Abstract OfficeSource.
Context for defining the specification.
Abstract tests for polyglot object via ManagedObjectSource.
Logic for testing objects.
Abstract tests for a polyglot Procedure via a SectionSource.
Handles the return of collection types.
Handles various flow outputs from the procedure.
Handles the return of object types.
Passes a parameter to the procedure.
Returns parameter types from the procedure.
Handles the return of primitive types.
Builds the Procedure.
Passes variables through to the procedure.
Returns variable types from the procedure.
Abstract JUnit PostgreSql functionality.
Configuration of the PostgreSql database.
Abstract property meta-data.
ProcedureSourceServiceFactory providing abstract support for Scripts.
Abstract SectionSource.
Context for defining the specification.
Abstract ManagedFunction to send HttpFile.
Dependency keys.
Flow keys.
Provide abstract test functionality for testing with HttpServlet.
Filter to fix the HttpHeader instances.
Context for configuring the Server.
Abstract functionality for setting up using Google HttpFunction.
Abstract source error.
Starts SAM for the integration testing.
Abstract SupplierSource.
Context for defining the specification.
Abstract functionality for overriding the System.getProperty(String) values in tests.
Abstract TeamSource.
Abstract XmlMapping to aid in type specific mapping.
Abstract Undertow HTTP server.
Abstract value loader.
Abstract XmlMapping to aid in writing an attribute/value.
Abstract WebTemplate.
Function interface to remove the ConfigurationItem.
Function interface to write the InputStream for the ConfigurationItem.
Abstract XmlMapping to aid in mapping.
Decorates the accepted Socket connections.
Negotiates the acceptable handler for the HttpRequest.
Builds the AcceptNegotiator.
AcceptNegotiatorBuilder implementation.
AcceptNegotiator implementation.
Accept handler.
Listens for change in access control (or Escalation in failing to authenticate).
ManagedObjectSource for the access control object.
Dependency keys.
Access token.
Indicates failure in creating an Access token.
Loads ActionHook to Request and Response.
Actively executing AsynchronousFlow.
Context for the ActivityLoader.
Loads the Activity configuration.
ActivityLoader implementation.
SectionSource to load the ActivityModel.
Adapted Exception to enable details of the cause to be provided to the CompilerIssues for an issue.
Utility class that adapts objects for the delegate objects.
Administration configuration.
ManagedObject that may be administered by an OfficeAdministration.
Administration<E,F extends Enum<F>,G extends Enum<G>>
Provides administration of the ManagedObject instances.
Architect for configuring administration.
AdministrationBuilder<F extends Enum<F>,G extends Enum<G>>
Enables building an Administration.
AdministrationBuilderImpl<E,F extends Enum<F>,G extends Enum<G>>
Implementation of the AdministrationBuilder.
Configuration for the OfficeAdministration.
Configuration of the Administration.
AdministrationContext<E,F extends Enum<F>,G extends Enum<G>>
Context in which the Administration executes.
Describes a Escalation from the Administration.
Type definition of a possible EscalationFlow by the Administration.
ClassDependencyFactory to obtain the extensions.
AdministrationFactory<E,F extends Enum<F>,G extends Enum<G>>
Factory for the creation of an Administration.
Describes a Flow required by the Administration.
Type definition of a Flow instigated by a Administration.
AdministrationFlowType implementation.
Configuration of linking Governance to Administration.
Describes a Governance used by the Administration.
Type definition of a Governance used by Administration.
AdministrationLoader implementation.
Utility class for testing the AdministrationSource.
AdministrationMetaData<E,F extends Enum<F>,G extends Enum<G>>
Meta-data of the Administration.
AdministrationMetaDataImpl<E,F extends Enum<F>,G extends Enum<G>>
Implementation of the AdministrationMetaData.
AdministrationNode implementation.
AdministrationSource<E,F extends Enum<F>,G extends Enum<G>>
Source to obtain a particular type of Administration.
Context for initialising a AdministrationSource.
Meta-data of the AdministrationSource.
Individual property of the AdministrationSourceSpecification.
Service to plug-in an AdministrationSource Class alias by including the extension AdministrationSource jar on the class path.
Specification of a AdministrationSource.
AdministrationType<E,F extends Enum<F>,G extends Enum<G>>
Type definition of an Administration.
AdministrationTypeBuilder<F extends Enum<F>,G extends Enum<G>>
Builder of the AdministrationType to validate the loaded AdministrationType from the AdministrationSource.
AdministrationTypeImpl<E,F extends Enum<F>,G extends Enum<G>>
AdministrationType implementation.
Context for a SpringSupplierExtension after loading ConfigurableApplicationContext.
Aggregates multiple Change instances into a single Change.
AmazonDynamoDB connect functionality.
Factory for AmazonDynamoDB connection.
Identifies types that may be annotated.
Utility functionality for annotations.
HttpSecurity enable access to all roles.
ManagedObjectSource for the ConfigurableApplicationContext.
OfficeFloorSource to create a single empty Office.
Factory for creation of WAR aware ClassLoader.
Arguments matcher.
Assertions extended with additional features.
Latch on an Asset to only allow the ThreadState instances proceed when Asset is ready.
Implementation of the AssetLatch.
AssetManager to manage Asset instances.
Hires an AssetManager.
AssetManagerHirer implementation.
AssetManager implementation.
Reference to an AssetManager.
AssetManagerReference implementation.
Registry of the AssetManager instances.
Context to be notified about asynchronous operations by the AsynchronousManagedObject.
Provides an unmanaged asynchronous flow outside the ManagedFunction.
Allows ThreadState safe logic to run on the completion of the AsynchronousFlow.
Escalation indicating the AsynchronousFlow timed out.
Factory for asynchronous KeyPair.
Contract to provide control over asynchronous processing by the ManagedObject.
Asynchronous operation.
Writes an XML attribute with value sourced from object.
Contains the XmlMapping instances for attributes of a particular element.
Augmented FunctionObject.
AuthenticateContext<AC extends Serializable,O extends Enum<O>,F extends Enum<F>>
Context for authentication.
Request for logging out.
Context for authentication.
ManagedObjectSource for the custom authentication.
Dependency keys.
Flow keys.
ManagedObjectSource for the authentication object.
Dependency keys.
Escalation indicating authentication is required.
Administration source for authorization.
RestMethodDecorator applying YAML-configured SpEL authorization before endpoint execution.
Auto-wire.
Direction of AutoWire.
AutoWireLink<S extends Node,T extends Node>
Auto-wiring of a source Node to target Node.
AutoWirer<N extends Node>
Auto wirer.
AutoWirer implementation.
Visitor for AutoWirer of the Office.
StateManager that enables obtaining ManagedObject objects by their qualifications and types.
AutoWireStateManager implementation.
Visitor for the AutoWireStateManager of each Office.
Available type (via ManagedObject) that may source.
AvailableType implementation.
Provides details to avoid execution with a particular Team.
Local environment for AWS.
Optional interface for Executive to implement to indicate it supports background scheduling of Runnable instances.
Opportunity for background scheduling.
TeamSource that causes back pressure to be applied.
Bad request HttpException.
Buffer to capture the output data as a Base64 string.
HttpSecuritySource for Basic HTTP security.
Decoded credentials.
Dependency keys.
OpenApiSecurityExtension for basic authentication.
WebTemplateWriter to write a bean.
Context for a SpringSupplierExtension before loading ConfigurableApplicationContext.
Representative of blocks of code to be executed.
Configuration of the ManagedObjectSource to be bound for the input ManagedObject.
ManagedObject bound into the Office.
Fix for compatibility issue between JDK8 and JDK9.
ServerOutputStream that writes to StreamBuffer instances from a StreamBufferPool.
byte array ByteSequence.
Factory to create ByteBuffer.
Sequence of byte values.
Common cache interface.
ChallengeContext<O extends Enum<O>,F extends Enum<F>>
Context for triggering a challenge.
Challenge momento to reinstate the ServerHttpConnection and HttpRequestState.
A change to be applied/reverted.
List of Change instances.
Context to check on the Asset.
Factory for Cipher.
Administration that delegates to Method instances of an Object to do administration.
AdministrationSource that delegates to Object.
Enables Class compatibility between Java versions by reflection (so can compile in different Java versions).
Argument compatibility.
Indicates failure from Method.
Interrogates the Class for a Constructor.
Class dependencies.
Context for the ClassDependencies.
Context for the ClassDependencies.
Manages Class dependencies.
Creates the dependency for the ClassManagedObject.
Injector of dependencies into an object.
Manufactures the ClassDependencyFactory.
Allows specifying annotation.
Allows further configuration of the Class dependency.
Allows further configuration of the Class dependency.
Builds and adds the item.
Allows specifying the qualifier.
ExtensionFactory that return the object of the ClassManagedObject.
Factory to create the Flow instances.
Context for the ClassFlowRegistry.
Factory for FlowInterface interface.
Invokes the Flow.
Meta-data of a Method on a FlowInterface.
Registry of Flow.
GovernanceSource that uses a Class to reflectively provide the functionality for Governance.
Interrogator of the Class members to determine if requires injection.
Class injections.
Index for Class item.
ManagedFunctionSource for a Class having the Method instances as the ManagedFunction instances.
CoordinatingManagedObject to dependency inject the Object instance and make it available for use.
ManagedObjectSource that manages an Object via reflection.
QualifierNameFactory providing the fully qualified Class name.
Creates an object from Class.
Manufactures a ClassObjectFactory from Class.
Node on the class path that may be retrieved as a HttpResource.
Locates a HttpFile from a ClassLoader.
ResourceSystemFactory to create a ResourceSystem from the class path.
Allows enhancing the Class path scanning with custom scanning.
Context for the ClassPathScanner.
Flow context for Class section.
Manufactures the Flow for ClassSectionSource.
Manufactures the Flow for ClassSectionSource.
Class loader for SectionSource.
Context for the ClassSectionLoader.
Object context for Class section.
Manufactures the Object for ClassSectionSource.
Utility to determine if Parameter.
Manufactures the Flow for ClassSectionSource.
ManagedFunctionSource implementation to provide the ManagedFunction instances for the ClassSectionSource.
SubSection with meta-data for ClassSectionLoader.
Type qualifier for SectionManagedObject.
Loads Class via ClassManagedObjectSource for stand alone use.
Escalation occurring on cleanup of a ManagedObject.
Exception wrapping the CleanupEscalation instances.
Clock to obtain time.
Factory to create a Clock.
ClockFactory implementation.
Handles closing the ServerOutputStream.
Open OfficeFloor Mojo.
Captures a free variable for closure state of a Function.
Collection types.
Implementation of XmlMapping to iterate over a Collection object in context.
Handling of retrieving keys when the JwtAuthority is hosted in the same server as the JwtHttpSecuritySource.
LinkedListSet that compares LinkedListSetEntry instances before adding as LinkedListSetEntry may hold content that should not be re-added to the LinkedListSet.
Context for loading a type.
CompileContext implementation.
CompilerIssue Error to enable propagating to OfficeFloor.
Compile Exception.
Context for compiling the Office.
Extension for the Office.
Provides easier compiling of OfficeFloor for testing.
Provides context for the CompileOfficeFloorExtension.
Extension for the CompileOfficeFloor.
Compile issue to be used as cause of another issue.
Notified of issues in compilation of the OfficeFloor.
Runnable to undertake compiling with particular state.
Context for the CompileSectionExtension.
Extends the OfficeSection.
Provides compiler state to an object.
Runnable to undertake compiling with particular state.
Utility methods to aid in compiling.
Closure to obtain Var value.
Context for the CompileWebExtension.
CompileWebContext implementation.
Extension to compile the web application into the Office.
Enables compiling MockWoofServer for testing.
Extension to compile WoOF into the Office.
ManagedFunctionFactory for completing authentication with application specific credentials.
Dependency keys.
FlowCallback that checks on completion and propagates failures.
Explorer of execution tree once other exploration is complete.
Builds the composed ManagedFunction instances.
Compose configuration.
Context for the ComposeArchitect.
CORS configuration for composition.
Employs compose architecture.
Implementation of ComposeArchitect.
Handles linking composition.
Listens for compositions from a directory.
Source to build composition.
Composition configuration.
Context of the ConfigurationItem instances.
Function interface to obtain the InputStream for the ConfigurationItem.
Indicates a failure in obtaining configuration.
Item of configuration within a ConfigurationContext.
Obtains a Conflict preventing a Change from being applied.
Conflict implementation.
Decorator on all created Connection instances.
Dependency keys.
Interface to aid manipulation of connections/associations.
Factory for the creation of a ConnectionPoolDataSource.
Means to obtain the Connection being wrapped.
Retrieves the data for the ConstantCacheManagedObjectSource.
Cache ManagedObjectSource that loads a constant data set.
Flow keys.
Construction testing of an Office TestSupport.
Utility class to aid in construction of the OfficeFloor.
Delegate Connector to provide to CoyoteAdapter to service via Container.
Context aware ManagedObject.
Provides the ability for the ManagedObject to obtain references to the Objects of other ManagedObject instances.
ManagedObjectSource for the CosmosAsyncDatabase.
SupplierSource for CosmosAsyncDatabase.
Provides means to work with entities for Cosmos.
Decorates the CosmosClientBuilder.
ServiceFactory for the CosmosClientBuilder.
ManagedObjectSource for the CosmosDatabase.
CosmosDatabase connect functionality.
Extension for CosmosDb.
Factory for CosmosDatabase or CosmosAsyncDatabase.
CosmosDb TestRule.
SupplierSource for CosmosDatabase.
Utility function for Cosmos DB.
Operation that can be retried.
Instance of running CosmosDb Emulator.
Configuration of CosmosDb.
Provides means to construct the failure.
Provides means to work with entities for Cosmos.
Annotates an entity to specify details of the entity.
Locates CosmosDatabase entity types for registering.
Indicates unable to determine the identifier for a Cosmos entity.
Annotates an entity's field/accessor as the partition key.
Indicates unable to extract PartitionKey for a Cosmos entity.
Allows use of self signed certificate for connecting to Cosmos.
Reference to a test CosmosDatabase.
Core information linked to logical CPUs.
FunctionalInterface for custom CpuLayout execution.
Logical CPU on a Core.
Operation to obtain details of creating a new HttpSession within the HttpSessionStore.
Entry within the CredentialStore.
Store containing the credentials.
Utility functions for working with a CredentialStore.
Provide utility functionality for database testing.
Validates the database.
Cleans up the DataSource creation attempt.
Creates the DataSource.
Factory for the creation of a DataSource.
Transforms the DataSource.
Context for the DataSourceTransformer.
Means to obtain the DataSource being wrapped.
Clock for the Date HttpHeaderValue.
Default CompilerIssue.
Default Executive.
Dependency keys.
Default handling of JWT challenges.
Default OfficeFloor EscalationHandler that prints issue to System.err.
Annotates a Field, Method or Constructor for dependency injection.
Dependency InjectionResolver.
Provides the mappings of the dependencies of a ManagedObject to the ManagedObject providing necessary functionality.
DependencyMappingBuilder implementation.
Node of the object fulfilling a dependency.
Type definition for a dependent object.
DependentObjectType implementation.
Deployed Office within the OfficeFloor.
Input into a DeployedOffice.
Output from a DeployedOffice.
XmlUnmarshaller that delegates to XML specific XmlUnmarshaller instances.
HttpSecuritySource for Digest HTTP security.
Dependency keys.
Allows mocking DigestHttpSecuritySource.SecurityState for testing.
Enables different ComposeSource implementations per directory items.
Context for the DirectoryItemComposer.
Change to simplify removing ConnectionModel instances.
Annotates the Method to disregard the Governance.
Operation to connect to started Docker container instance.
Instance of running Docker.
Docker network.
Map that provides a double key to obtain the entry.
Loader to load value onto target object.
Extension for connecting to local DynamoDb.
Connect to local AmazonDynamoDB TestRule.
Extension for DynamoDb.
ManagedObjectSource for the DynamoDBMapper.
AmazonDynamoDB TestRule.
SupplierSource for DynamoDBMapper.
Locates DynamoDBMapper entity types for registering.
Contains the XmlMapping instance for a particular element and the AttributeXmlMappings for the attributes of the element.
Annotates the Method to enforce the Governance.
HttpRequest entity utilities.
Extension for specifying environment ( System.getenv() ) for tests.
TestRule for specifying environment ( System.getenv() ) for tests.
Internal failures within the OfficeFrame extend Escalation.
Architect for configuring global escalation handling via composition.
Handler for the completion of Escalation handling.
Configuration for the EscalationFlow.
Implementation of the EscalationConfiguration.
Employs the EscalationArchitect.
Explorer of an escalation trees.
Context for the EscalationExplorer.
Flow to handle an Escalation from a ManagedFunction.
EscalationFlowFactory implementation.
Implementation of EscalationFlow.
Handles an Escalation from an Office.
Key identifying the Exception for the EscalationFlow.
EscalationNode implementation.
Procedure to undertake in resolving exceptional circumstances to normal processing.
Implementation of the EscalationProcedure.
Execution.
Explorer of an execution tree.
Context for the ExecutionExplorer.
Explorer of execution tree from ManagedObject.
Context for the ExecutionObjectExplorer.
Strategy of execution.
ExecutionStrategyNode implementation.
Type definition of an ExecutionStrategy.
ExecutionStrategyType implementation.
Executive.
Builder of Executive.
Implements the ExecutiveBuilder.
Configuration of an Executive.
Context for the Executive.
ExecutiveContext implementation.
Loads the ExecutiveType from the ExecutiveSource.
ExecutiveLoader implementation.
ExecutiveNode implementation.
Office context for the Executive.
Source to obtain the Executive.
Context for the ExecutiveSource.
ExecutiveSourceContext implementation.
Individual property of the ExecutiveSourceSpecification.
ExecutiveSourceProperty implementation.
Specification of a ExecutiveSource.
Loads ExecutiveSource for stand-alone use.
Context for Executive to start managing the OfficeFloor.
Type definition of an Executive.
ExecutiveType implementation.
TeamSource utilising a cached ExecutorService.
TeamSource utilising a fixed ExecutorService.
Creates a specific extension for the ManagedObject.
OfficeExtensionService to setup an external server.
OfficeFloorExtensionService to setup an external server.
Enables running an external server.
Logic to run within context.
External service input to OfficeFloor.
Factory to create an ExternalServiceInput to OfficeFloor.
CompilerIssues that fails on an issue.
CompilerIssues that invokes TestCase.fail() for issues raised.
Factory for creation of dependency from Field.
Field meta-data.
Cache of files.
Factory for the creation of a new FileCache.
Context for the FileCacheService.
Invokes on completion of writing the FileChannel content.
ResourceSystem for files.
ResourceSystemFactory backed by files.
ModelContext that creates the ModelFile instances within a file system relative to a root directory.
Flow keys.
Services ServerHttpConnection via Filter.
Firestore connect functionality.
Extension for Firestore.
Firestore TestRule.
Extension for Firestore.
Factory for Firestore connection.
ManagedObjectSource for Firestore.
Firestore TestRule.
RuntimeException for Firestore timing out to start up.
SupplierSource for Firestore.
XML unmarshaller to load a flat object.
Handler to load XML values onto target object.
Meta-data for a FlatXmlUnmarshaller.
Represents a sub-graph of the ManagedFunctionContainer graph making up the ThreadState.
Annotates a Method parameter to indicate it is a FlowInterface parameter.
FlowBuilder<F extends Enum<F>>
Callback for completion of a Flow.
ClassDependencyManufacturerContext implementation for flows.
Handler for the completion of the Flow.
Configuration for a Flow.
FlowConfiguration implementation.
Implementation of the Flow.
Annotates an interface to have each of its methods be a Flow that may be invoked by the ManagedFunction class method.
ClassDependencyManufacturer for providing a dependency FlowInterface.
Meta-data of a Flow.
FlowMetaDataFactory implementation.
Implementation of the FlowMetaData.
FlowCallback that propagates failures and only handles success.
Flux subscription.
Configures the Flyway.
Extension to enable Flyway clean.
TestRule to enable Flyway clean.
Dependency keys.
Flyway migrate ManagedObjectSource.
Flow keys.
Migrate dependency keys.
OfficeExtensionService to undertake Flyway migration.
Tagging interface for Flyway migration start up ordering.
Provides formatting of the XML output to a delegate XmlOutput.
Form based HttpSecuritySource.
Dependency keys.
Flow keys.
Newly created HttpSession requiring a session Id.
Allows specifying to load test dependency from a particular Office (rather than default Office).
ManagedFunction authentication context.
Builds a FunctionState provides linking to other FunctionState instances.
Context for the ClassSectionLoader.
Function configuration.
Configuration of a ManagedFunctionLogic.
Decoration of ManagedFunction.
Context for the Flow instances from the ManagedFunctionLogic.
FunctionFlowNode implementation.
Encapsulates simple logic for a FunctionState.
ManagedFunction logout context.
Executes the FunctionState instances.
FunctionLoop implementation.
Interface to manage a particular ManagedFunction.
FunctionManager implementation.
Provides means for the ManagedFunctionSource to provide the ManagedFunction type definitions.
FunctionNamespaceNode implementation.
Type definition of a ManagedFunctionSource.
FunctionNamespaceType implementation.
Object required by the SectionFunction.
FunctionObjectNode implementation.
Node within the graph of FunctionState instances to execute.
Context for executing a FunctionState.
Generates the OfficeFloor model.
Google Function HttpResponseWriter.
Google Function HttpServerImplementation.
Google HttpFunction OfficeExtensionService.
Extension for Google HttpFunction.
JUnit 4 rule for Google HTTP function testing.
Annotates the Method to govern the ManagedObject.
Governance<E,F extends Enum<F>>
Provides Governance over the ManagedObject instances.
Activity undertaken for Governance.
Architect for configuring governance.
Builds the Governance.
GovernanceBuilder implementation.
Configuration for the OfficeGovernance.
Configuration for the Governance.
Container managing the Governance.
GovernanceContainer implementation.
Context for Governance.
Type definition of a possible EscalationFlow by the GovernanceActivity.
GovernanceEscalationType implementation.
Factory for the creation of the Governance.
Describes a Flow required by the Governance.
Type definition of a Flow possibly instigated by a GovernanceActivity.
GovernanceFlowType implementation.
Loads the GovernanceSource.
GovernanceLoader implementation.
Utility class for testing the GovernanceSource.
Manager over a particular Governance.
Meta-data of the Governance.
GovernanceMetaData implementation.
Implementation of the GovernanceNode.
Source to obtain the Governance.
Context for initialising a GovernanceSource.
Meta-data of the GovernanceSource.
Individual property of the GovernanceSourceSpecification.
GovernanceSourceProperty implementation.
Service to plug-in an GovernanceSource Class alias by including the extension GovernanceSource jar on the class path.
Specification of a GovernanceSource.
GovernanceType<E,F extends Enum<F>>
Type definition of a Governance.
Builder of the GovernanceType to validate the loaded GovernanceType from the GovernanceSource.
GovernanceType implementation.
Configuration for OfficeGovernance composition.
ManagedObject that may be governed by an OfficeGovernance.
ScriptExceptionTranslator for the GraalVM.
Generates all the models.
Provides generic meta-data for generating a Model.
GUI Test.
Enables reseting the H2 database for testing.
Dependency keys.
Wraps the DataSource with HikariDataSource for pooling.
Annotation on a ManagedFunction Method to control access.
HTTP access configuration.
Adapting interface to provide standard access control by the HttpSecuritySource.
Factory for the creation of the HttpAccessControl.
HttpAccessControl implementation.
Dependency keys.
ManagedObjectSource to cache creation of an Object within the HttpApplicationState.
ManagedObject to retrieve the object from the HttpApplicationState.
State for the web application instance.
Annotated on the class of the parameter to indicate it should be bound to the application state.
HTTP argument.
ManagedObjectSource for a HTTP argument.
Dependency keys.
Parses arguments from the ServerHttpConnection.
Dependency interface allowing the application to check if the HTTP client is authenticated.
Factory for the creation of the HttpAuthentication.
HttpAuthentication implementation.
Dependency keys.
Wraps the HttpRequest to obtain the HTTP authentication scheme information.
HTTP challenge.
Context for the HttpChallenge.
HttpChallengeFunction<O extends Enum<O>,F extends Enum<F>>
ManagedFunctionFactory to challenge the client.
Extension for a HttpClient to HttpServer.
TestRule for a HttpClient to HttpServer.
Utility class aiding in testing HTTP functionality.
Annotation to indicate the value is loaded from content of HttpRequest.
Parameter within the HTTP content.
Annotation to indicate the value is loaded from a HttpCookie parameter.
Portable interface for HttpSecuritySource credentials.
HttpCredentials implementation.
HTTP Directory.
HttpDirectory implementation.
Context for the HttpEscalationHandler.
Enables sending an appropriate response for an Escalation.
Provides ability to send an Escalation response.
Context for the HttpEscalationResponder.
HTTP Exception.
Enables flagging that the HttpResponse is externally sent.
Dependency keys.
HTTP file.
Abstract HttpFile implementation.
Provides HttpSecurity Flow decision.
Flow keys.
HttpFunction HttpRequest.
HttpFunction HttpResponse.
Section to execute the HttpFunction.
Keys for dependencies.
ManagedFunction to handle the redirect.
Dependency keys.
HTTP header.
Means to provide common HttpHeader names in already encoded HTTP bytes for faster writing.
Annotation to indicate the value is loaded from a HttpHeader parameter.
Provides formatting of values for HttpHeader values.
HTTP input.
Explorer of an execution tree for a HttpInput.
Context for the HttpInputExplorer.
Overrides the default linking of the HttpInput to its service OfficeSectionInput.
Context for the HttpInputInterceptor.
Provides path details for the HttpInput.
HttpInputPath implementation.
Segment of the HttpInputPath.
HTTP method.
HttpMethod Enum for common HTTP methods.
Annotation on the Class of the parameter (or the parameter itself) to indicate it is parsed out of the HttpRequest via an HttpObjectParser.
HttpObject annotation.
ManagedObjectSource to provide an Object from the HttpObjectParser instances.
Obtains the default HttpObjectParserFactory.
Dependency keys.
Parses an object from the ServerHttpConnection.
Factory for the creation of HttpObjectParser instances.
Provides ability to send an Object response.
Context for the HttpObjectResponder.
Factory for the creation of HttpObjectResponder instances.
Context for the HttpOfficeSecurer.
HTTP parameter.
HTTP parameter annotation.
Builder for an HTTP parameter.
Annotated on the class of the parameter to indicate it should be a HttpRequestObjectManagedObjectSource that will load the HttpRequest parameters onto the object.
HttpParameters annotation.
Path for a HttpResource.
Creates the HTTP path.
Factory to create the HTTP path.
Segment of the path.
Annotation to indicate the value is loaded from a path parameter.
HttpPathParameter annotation.
Annotation to indicate the value is loaded from a query parameter.
HttpQueryParameter annotation.
ManagedFunction to send a redirect.
Dependency keys.
HTTP request from the ServerHttpConnection.
Cookie on the HttpRequest.
HttpRequestCookie instances for the HttpRequest.
HttpHeader instances for the HttpRequest.
ManagedObjectSource to cache creation of an Object within the HttpRequestState.
Dependency keys.
HttpRequest parser.
Meta-data for the HttpRequestParser.
State for the HttpRequest.
Annotated on the class of the parameter to indicate it should be a HttpRequestObjectManagedObjectSource.
Dependency keys.
Tokenises the HttpRequest for the path, parameters, fragment.
HTTP resource.
Builds the HttpResource for WebArchitect.
Cache of the HttpResource instances.
Builds the external HttpResource instances.
Store of HttpResource instances.
HttpResourceStore implementation.
Responder for an Object or Escalation.
Obtains the default HttpObjectResponderFactory.
Annotates an ObjectResponse parameter to provide additional HTTP response configuration.
QualifierNameFactory to obtain qualified name for HttpResponse.
Cookie to send in the HttpResponse.
HttpResponseCookie instances for the HttpResponse.
HttpHeader instances for the HttpResponse.
Writes the HttpResponse.
Dependency keys.
SectionSource to handle HTTP routing.
Obtains the interception details.
Redirect.
Route input information.
Securable HTTP item.
Interface for HttpSecurer to correspond with the HttpSecurable.
Configures HttpSecurity around configuration for the OfficeArchitect and SectionDesigner.
HttpSecurity<A,AC extends Serializable,C,O extends Enum<O>,F extends Enum<F>>
HTTP security.
Generic context for HttpSecurity actions.
Generic context for integrating HttpSecurity actions into the application.
Builds the HttpSecurityBuilder instances for the WebArchitect.
HTTP security builder.
yml configuration for a HttpSecurity.
HTTP security configuration.
HttpSecurityConfiguration<A,AC extends Serializable,C,O extends Enum<O>,F extends Enum<F>>
Configuration for HttpSecuritySectionSource.
Context for the HttpSecurity.
Describes an object which the HttpSecuritySource is dependent upon.
Implementation of the HttpSecurityDependencyMetaData.
Type definition of a dependency required by the HttpSecuritySource.
Context that the HttpSecurity is to execute within.
Explorer of the execution tree from the HttpSecurity.
Context for the HttpSecurityExplorer.
Describes a Flow required by the HttpSecuritySource.
HttpSecurityFlowMetaData implementation.
Type definition of a Flow instigated by the HttpSecuritySource.
HttpSecurityLoader implementation.
Utility class for testing the HttpSecuritySource.
HttpSecuritySectionSource<A,AC extends Serializable,C,O extends Enum<O>,F extends Enum<F>>
HttpSecuritySource<A,AC extends Serializable,C,O extends Enum<O>,F extends Enum<F>>
Source for obtaining HttpSecurity.
Configuration for a HttpSecuritySource within a HttpSecurityConfiguration.
Context for the HttpSecuritySource.
HttpSecuritySourceMetaData<A,AC extends Serializable,C,D extends Enum<D>,F extends Enum<F>>
Meta-data of the HttpSecuritySource.
Individual property of the HttpSecuritySourceSpecification.
Specification of a HttpSecuritySource.
OfficeFloorCompilerRunnable to obtain the specification for the HttpSecuritySource.
HttpSecuritySource configured ManagedObject to provide supporting dependencies to the HttpAuthentication and HttpAccessControl for using the HttpSecuritySource.
Type definition of the HttpSecuritySupportingManagedObject dependency.
Type definition of the HttpSecuritySupportingManagedObject.
HttpSecurityType<A,AC extends Serializable,C,O extends Enum<O>,F extends Enum<F>>
Type definition of a HttpSecuritySource.
Builder for the HttpSecurityType to validate the loaded HttpSecurityType from the HttpSecuritySource.
HttpSecurityTypeImpl<A,AC extends Serializable,C,O extends Enum<O>,F extends Enum<F>>
HTTP Server.
HttpServer implementation.
Context for the HttpServerImplementation.
Location of the HTTP server.
HttpServerLocation implementation.
ByteSequence for the HttpServletRequest entity.
HttpServlet HttpResponseWriter.
HttpServerImplementation to validate tests.
Provides context to load the HttpServletHttpServerImplementation.
OfficeExtensionService for the HTTP Servlet.
Bridge from HttpServlet to OfficeFloor.
ManagedObjectSource for the HttpServletRequest.
Dependency keys.
ManagedObjectSource for the HttpServletResponse.
Dependency keys.
HTTP session.
Administration interface for the HttpSession.
Generates the HttpSession Id.
ManagedObject to cache creation of an Object within the HttpSession.
Dependency keys for the HttpSessionObjectManagedObject.
ManagedObjectSource to cache creation of an Object within the HttpSession.
Annotated on the class of the parameter to indicate it should be a HttpSessionObjectManagedObjectSource.
Provides a store (or cache) of HttpSession instances.
HTTP status.
HTTP URL continuation.
Location of the HttpParameter.
HTTP version.
HttpVersion Enum for common HTTP methods.
Mock Entity to allow different Entity implementations for each implementing vendor.
In<T>
Provides input to retrieve variable value.
Enum indicating the: ManagedObject instances Flow instances will be specified by an index rather than an Enum.
Annotates a Method for initialising the object after dependencies injected.
Dependency keys.
Type definition of a Supplier that requires completing.
InitialSupplierType implementation.
Context for injection.
Factory for the InjectContext.
Field to have dependency injected.
Registry of injections.
ManagedObject passed in externally.
Configuration of a ManagedObject input into a ProcessState.
Node representing an instance use of an Input ManagedObject.
InputManagedObjectNode implementation.
InputStream adapter.
ManagedFunction to trigger the interception before routing.
Exposes internal objects from the SupplierSource.
Indicates the HttpSession is currently invalidated and can not be used.
Operation to obtain details of invalidating a HttpSession within the HttpSessionStore.
Indicates an incorrect configuration.
Indicates parameter type to ManagedFunction is invalid.
Services an invoked ProcessState from the ManagedObjectSourceStandAlone.
Capture of CompilerIssue.
Receives the issue.
ItemModel<M extends Model>
Interface to aid manipulation of items.
Facet that is checked to see if the current version of Java supports.
Context for the JavaFacet.
Java Object.
JavaScript function ProcedureSourceServiceFactory.
ExceptionMapper for the Procedure.
Error entity for JAX-RS failure.
Configuration to register Jersey as a filter.
Keys for dependencies.
Job executed by a Team.
Queue of Job instances.
Dependency type.
Wraps the EntityManager.
Factory creating the EntityManager wrapper.
FunctionalInterface to create the EntityManagerFactory.
Provides ability to skip via ExtensionContext.
Provides JUnit agnostic assertions.
Parses out the JWKS Key from the content.
Context for the JwksKeyParser.
ServiceFactory to plug in various JwksKeyParser implementations.
Creates the JWKS key JsonNode from the Key.
Context for the JwksKeyWriter.
ServiceFactory to plug in various JwksKeyWriter implementations.
JWKS publish SectionSource.
Retrieves the JWKS content.
JWT key to encode access token.
Collects JwtAccessKey instances for JWT validation.
Authority for JWT.
Common attributes for authority key.
Flow keys.
Time window to determine appropriate token.
JWT repository.
Critical section logic for the cluster.
Context for retrieving keys.
Context for saving keys.
ManagedObjectSource to provide the JWT claims.
Dependency keys.
Extra JWT functions to HttpAccessControl.
Flow keys.
JWT claims.
JWT header.
Allows overriding the creation of JwtValidateKey instances.
OpenApiSecurityExtension for basic authentication.
JWT refresh key.
Collects JwtRefreshKey instances for generating refresh tokens.
Collects the roles for the JWT claims.
JWT validate key.
Collects JwtValidateKey instances for JWT validation.
StatelessValueLoaderFactory to load a keyed object.
StatelessValueLoaderFactory to load keyed string parameter.
Team implementation of many Thread instances that follow the leader follower pattern.
Handling details for the LeafWebRouteNode.
Leaf WebRouteNode that services the HttpRequest.
Linked List maintaining a unique set of LinkedListSetEntry.
Entry for a LinkedListSet.
Item copied out of a LinkedListSet.
Translates the entry to a FunctionState.
Configuration linking in a ManagedObjectSource.
Configuration linking a Team.
LinkedTeamConfiguration implementation.
LinkFlowNode that can be linked to another LinkFlowNode.
LinkObjectNode that can be linked to another LinkObjectNode.
LinkOfficeNode that can be linked to another LinkOfficeNode.
LinkPoolNode that can be linked to another LinkPoolNode.
LinkStartAfterNode that can be linked to another LinkStartAfterNode.
LinkStartBeforeNode that can be linked to another LinkStartBeforeNode.
LinkStartupAfterNode that can be linked to another LinkStartupAfterNode.
LinkStartupBeforeNode that can be linked to another LinkStartupBeforeNode.
LinkTeamNode that can be linked to another LinkTeamNode.
Utility class to work with links.
WebTemplateWriter to write the link.
Extracts the values of a List.
Matches a list item.
List meta-data.
Utility methods for loader test utilities.
ManagedFunctionFactory to load the object of a ManagedObject.
Dependency keys for the LoadManagedObjectFunctionFactory.
Interface for parameter to receive the loaded object of the ManagedObject.
Indicates a service was not able to be loaded.
Propagates a failure loading a type.
Asserts Logger messages.
Extension to assert Logger events.
TestRule to capture and assert Logger.
Utility functionality for Logger.
Resets the Logger state.
LogoutContext<O extends Enum<O>,F extends Enum<F>>
Context for logging out.
Request for logging out.
Test support for logging.
Test capture interface.
Managed execution.
Factory for the ManagedExecution.
ManagedExecutionFactory implementation.
ManagedFunction<O extends Enum<O>,F extends Enum<F>>
Managed function.
Meta-data for the Administration of the ManagedFunction.
Augments the ManagedFunction instances within the Office.
Context for the ManagedFunctionAugmentor.
ManagedFunctionBuilder<O extends Enum<O>,F extends Enum<F>>
Builder of the ManagedFunction.
Implementation of the ManagedFunctionBuilder.
Configuration of a ManagedFunction.
Container of ManagedFunctionLogic.
ManagedFunctionContext<O extends Enum<O>,F extends Enum<F>>
Context in which the ManagedFunction is done.
Escalation from managing a ManagedFunction.
Type definition of a possible EscalationFlow by the ManagedFunction.
Provides means for the ManagedFunctionSource to provide a type definition of a possible EscalationFlow by the ManagedFunction.
ManagedFunctionFactory<O extends Enum<O>,F extends Enum<F>>
Creates the ManagedFunction to be executed.
Type definition of a Flow possibly instigated by a ManagedFunction.
Provides means for the ManagedFunctionSource to provide a type definition of a possible Flow instigated by the ManagedFunction.
ManagedFunctionFlowType implementation.
Configuration of a Governance for the ManagedFunction.
Interest in a ManagedFunctionContainer.
Provides reference details to invoke a ManagedFunction.
ManagedFunctionLoader implementation.
Utility class for testing a ManagedFunctionSource.
Locates a ManagedFunctionMetaData within the Office.
ManagedFunctionLocator implementation.
Managed FunctionLogic.
Context for the execution of a ManagedFunction.
ManagedFunctionLogicImpl<O extends Enum<O>,F extends Enum<F>>
ManagedFunction implementation of a Job.
Meta-data for a ManagedFunctionLogic to be executed within a ManagedFunctionContainer.
ManagedFunctionMetaData<O extends Enum<O>,F extends Enum<F>>
Meta-data for the ManagedFunction.
Meta-data of a ManagedFunction.
ManagedFunctionNode implementation.
Configuration for a dependent Object of a ManagedFunction.
Type definition of a dependent Object required by the ManagedFunction.
Provides means for the ManagedFunctionSource to provide a type definition of a dependency Object required by the ManagedFunction.
ProcedureSource that enables full ability to build the ManagedFunction.
Reference to a ManagedFunction.
ManagedFunctionReference implementation.
Registry of the ManagedFunctionNode instances.
SectionSource implementation that wraps a ManagedFunctionSource to expose it as a section.
Context for loading a FunctionNamespaceType.
Service to plug-in an ManagedFunctionSource Class alias by including the extension ManagedFunctionSource jar on the class path.
Provides the specification of the ManagedFunctionSource.
ManagedFunctionType<M extends Enum<M>,F extends Enum<F>>
Type definition of a ManagedFunction.
Provides means for the ManagedFunctionSource to provide a type definition of the ManagedFunction.
ManagedFunctionTypeImpl<M extends Enum<M>,F extends Enum<F>>
ManagedFunctionType implementation.
Visits each ManagedFunctionNode.
Core interface of a Managed Object.
Annotates a Field for the ClassSectionSource for configuration of a SectionManagedObject.
Meta-data for the Administration of a ManagedObject.
Factory for the creation of ManagedObjectAdministrationMetaData.
Architect to build ManagedObject instances.
Builder of a ManagedObject.
Implements the ManagedObjectBuilder.
Manages the clean up of ManagedObject instances.
ManagedObjectCleanup implementation.
Configuration for a managed object.
Configuration of a ProcessState or ThreadState bound ManagedObject.
Container managing a ManagedObject.
Container of a ManagedObject.
Context for the ManagedObject.
Dependency of a ManagedObject.
Configuration of ManagedObject dependency to another ManagedObject.
Describes an object which the ManagedObject for the ManagedObjectSource is dependent upon.
Implementation of the ManagedObjectDependencyMetaData.
Type definition of a dependency required by the ManagedObject.
Employs ManagedObjectArchitect instances.
ComposeSource for managed objects.
Escalation from managing a ManagedObject.
Context that the ManagedObject is to execute within.
Factory for the creation of the ManagedObjectExecuteManager.
Configuration of an ExecutionStrategy utilised by a ManagedObjectSource.
Describes an ExecutionStrategy required by the ManagedObjectSource.
Type definition of a ExecutionStrategy required by the ManagedObject.
Convenience class to wrap the ManagedObjectServiceContext as an Executor.
Extracts the extension interface from the ManagedObject within the ManagedObjectContainer.
Meta-data to extract the extension from the ManagedObject.
Meta-data regarding an extension interface implemented by the ManagedObject.
Extension of ManagedObjectNode.
Configuration of a Flow instigated by a ManagedObjectSource.
Describes a Flow required by the ManagedObjectSource.
ManagedObjectFlowNode implementation.
Type definition of a Flow instigated by the ManagedObjectSource or one of its ManagedFunction instances.
ManagedObjectFlowType implementation.
Builds the ManagedFunction necessary for the ManagedObjectSource.
Dependency available to ManagedFunction instances added via ManagedObjectSourceContext.
Configuration of ManagedObjectFunctionDependency to another ManagedObject.
Type definition of a dependency required by a ManagedFunction added by ManagedObjectSource.
Enhances the ManagedFunction provided by a ManagedObjectSource.
Configuration of Governance of the ManagedObject.
Meta-data for the Governance of a ManagedObject.
Index of the ManagedObject, providing both the scope it lives within and the index of it within that scope.
ManagedObjectIndex implementation.
ManagedObjectLoader implementation.
Utility class for testing the ManagedObjectSource.
Meta-data of a ManagedObject.
Meta-data of the ManagedObject.
Node representing an instance use of a ManagedObject.
ManagedObjectNode implementation.
Escalation indicating that an operation by the ManagedObject was timed out.
Pool of ManagedObject instances.
Builder for the ManagedObjectPool.
Implements the ManagedObjectPoolBuilder.
Configuration for the ManagedObjectPool.
Context for the ManagedObjectPool.
ManagedObjectPoolContext implementation.
Factory for the creation a ManagedObjectPool.
ManagedObjectPoolLoader implementation.
Node representing instance use of a ManagedObjectPool.
ManagedObjectPoolNode implementation.
Context for the ManagedObjectPoolSource.
ManagedObjectPoolSource implementation.
Meta-data regarding the ManagedObjectPool.
Individual property of the ManagedObjectPoolSourceSpecification.
Service to plug-in an ManagedObjectPoolSource Class alias by including the extension ManagedObjectPoolSource jar on the class path.
Specification of a ManagedObjectPoolSource.
Type definition of a ManagedObjectPool.
ManagedObjectPoolType implementation.
Check that the ManagedObject is ready.
ManagedObjectReadyCheck implementation.
Registry of the ManagedObjectNode within a particular context (for example SectionNode).
Scopes for a ManagedObject.
Allows the ManagedObjectSource to service by invoking ProcessState.
Service context for the ManagedObjectSource.
Indicates if ready to start ManagedObjectService instances.
ManagedObjectSource<O extends Enum<O>,F extends Enum<F>>
Source to obtain a particular type of ManagedObject.
Augments the ManagedObjectSource instances within the OfficeFloor.
Configuration for the OfficeManagedObject.
Configuration of a ManagedObjectSource.
Context for a ManagedObjectSource.
Implementation of the ManagedObjectSourceContext.
Flow to be configured from the ManagedObjectSource (invoked via ManagedObjectExecuteContext).
Instance of a ManagedObjectSource and items to support it.
Meta-data of the ManagedObjectSource.
Node representing a ManagedObjectSource.
ManagedObjectSourceNode implementation.
Individual property of the ManagedObjectSourceSpecification.
Implementation of the ManagedObjectSourceProperty.
Service to plug-in an ManagedObjectSource Class alias by including the extension ManagedObjectSource jar on the class path.
Specification of a ManagedObjectSource.
Loads ManagedObjectSource for stand-alone use.
Startup completion for a ManagedObjectSource.
Start up ProcessState registered via a ManagedObjectExecuteContext.
Runnable wrapping the invocation of the ManagedObjectStartupProcess.
Team required by the ManagedObjectSource.
ResponsibleTeamNode implementation.
Type definition of a Team required by the ManagedObject.
ManagedObjectTeamType implementation.
Type definition of a ManagedObject.
Builder for the ManagedObjectType to validate the loaded ManagedObjectType from the ManagedObjectSource.
ManagedObjectType implementation.
User interested in using the ManagedObject.
Implementation of a ManagedObjectUser to source an object from a ManagedObjectSource.
Builds details of a ManagedObjectSource being managed by an Office.
ManagingOfficeBuilder implementation.
Configuration of the ManagedObjectSource being managed by an Office.
ManagingOfficeNode implementation.
HttpRequest implementation.
Materialising HttpRequestCookies.
Materialising HttpRequestHeaders.
Run Firestore for maven.
OfficeExtensionService to run Google Function.
OfficeFloorExtension to run Google Function.
Factory to create the MBean.
Registers the MBean.
ConfigurationContext that stores content in memory only (not persisting it).
HttpSessionStore that contains state of the HttpSession within memory.
Annotates ManagedFunction with the Method implementing it.
ManagedFunction to invoke a Method.
Builder to wrap execution of a Method with a ManagedFunction.
Utility class for testing MethodManagedFunctionBuilder.
Handles Flow.
Result of running the ManagedFunction.
Factory to create the Object instance to invoke the Method on.
Manufactures the MethodObjectFactory.
Context for the MethodReturnManufacturer.
Annotates the ManagedFunction object with the details of the parameter for the MethodAnnotation.
Manufactures the MethodReturnTranslator.
Context for the MethodReturnManufacturer.
Translate the return value of the MethodFunction.
Context for the MethodReturnTranslator.
Mock access control.
Mock authentication.
Mock HttpSecuritySource to use for testing with challenges.
Mock credentials.
Provides mocking of a CredentialStore in a similar way MockChallengeHttpSecuritySource works.
Mock HttpSecuritySource that challenges with a HTML form.
Flow keys.
Extension for Google HttpFunction execution.
TestRule for Google HttpFunction execution.
Mock AuthenticateContext for testing HttpSecuritySource instances.
MockHttpChallengeContext<O extends Enum<O>,F extends Enum<F>>
Mock ChallengeContext for testing HttpSecuritySource instances.
MockHttpLogoutContext<O extends Enum<O>,F extends Enum<F>>
Mock LogoutContext for testing HttpSecuritySource instances.
Mock HttpParameters object.
Mock RatifyContext for testing HttpSecuritySource instances.
Builder for a mock HttpRequest.
Callback with the MockHttpResponse for the MockHttpRequestBuilder.
Builder for a mock HttpResponse.
HTTP request details for the MockHttpResponse.
MockHttpResponse implementation.
MockServerHttpConnection implementation.
Extension to mock JWT access tokens for the JwtHttpSecuritySource.
TestRule to mock JWT access tokens for the JwtHttpSecuritySource.
Mock implementation of the ManagedObjectSource for testing.
Mock test support.
Test logic interface.
Mock Var.
Mock web application.
MockHttpResponse with additional assertions.
MockHttpServer loading the WoOF application.
Annotates service methods for the ClassSectionSource.
Enables configuring the MockWoofServer.
Enables wrapping the compile and open.
Extension for running the MockWoofServer.
TestRule for running the MockWoofServer.
Contract for top level functionality for all model elements.
Bridge to Spring for the ModelAndView.
Context for generating a Model.
File within the generated Model.
Generates the Model.
Meta-data for the generation of a Model.
Repository to the Model instances.
ModelRepository implementation.
Checks whether a Package is accessible.
JavaFacet to determine if Jigsaw Modules available.
Key to Momento added by RestMethodDecorator.
MomentoKey implementation.
Clock for monitoring the Office.
MonitorClock implementation.
Mono subscription.
Annotates a method with the name of the next in the Flow.
Indicates there were no Accept handlers configured for AcceptNegotiator.
Change that does nothing.
Node within the compilation tree.
Context for a Node.
Common utility functions for Node implementations.
Enum specifying no enumerations.
Enables flagging a public method of a Class to not be ManagedFunction for the ClassManagedFunctionSource.
Non materialised HttpHeader.
Non materialized HttpHeader instances.
Marker on a property method of a bean to indicate that its return value should be rendered unescaped to the HTTP template response.
Not existing HttpResource.
Not found HttpException.
ManagedFunction for not handling routing.
Dependency keys.
Flags that the ParsedTemplate should not be rendered after the method completes.
ClassDependencyFactory for dependency object.
ClassDependencyManufacturer for providing a dependency Object.
Context for the ClassSectionLoader.
Decoration of ManagedObject.
Type definition of a dependent object of an OfficeSectionFunction.
ObjectDependencyType implementation.
Locates Objectify Entity types for registering.
Extension for running Objectify with local Datastore.
Rule for running Objectify with local Datastore.
SupplierSource to provide Objectify.
Creates the ObjectifyFactory.
ThreadSynchroniserFactory that auto-registers itself with the OfficeArchitect.
Responsible for instantiating the object instances.
Interface for polyglot object.
Loader to load objects onto the target object.
Loads objects onto a target object.
Decorates the ObjectMapper for the JacksonHttpObjectParserFactory.
Decorates the ObjectMapper for the JacksonHttpObjectResponderFactory.
StatelessValueLoaderFactory to load an object parameter.
Registry providing the dependent Object instances for a CoordinatingManagedObject instance.
Implementation of the ObjectRegistry.
Dependency injected interface to send the Object response.
Annotation providing details of ObjectResponse.
ClassDependencyManufacturerServiceFactory to provide enriched annotations for the ObjectResponse.
Dependency keys.
TestDependencyService providing an Object instance.
Indicates timed out waiting on the object.
Object types.
User of an object.
ObjectUser implementation.
Writes an object into XML.
XmlMapping that loads object onto target object.
Office within the OfficeFloor.
Architect to structure the Office.
Type definition of an input into the Office that may be used for a ManagedObjectFlow added to the OfficeFloor.
Bindings to the Office.
OfficeBindings implementation.
Builder of an Office.
Implements the OfficeBuilder.
OfficeChanges implementation.
Configuration of an Office.
Tags a node as a office dependency sink.
Tags a node as a office dependency source.
Enables enhancing the Office.
Context for the OfficeEnhancer.
OfficeEnhancerContext implementation.
Context for the OfficeExtensionService.
Enables plug-in extension of the Office.
OfficeFloor where ManagedFunction instances are executed within Office instances.
OfficeFloor ApplicationEventListener.
Builder of an OfficeFloor.
Implementation of OfficeFloorBuilder.
Indicates failure to build a OfficeFloor.
OfficeFloorChanges implementation.
Class path scanner to aid discovering resources.
OfficeFloor compiler to compile the OfficeFloor into the OfficeFrame to be built.
Factory to create the OfficeFloorCompiler.
Adapts the implementing OfficeFloorCompiler to be used when the OfficeFloorCompiler reference may be from a different ClassLoader.
Service to enable configuring the OfficeFloorCompiler.
OfficeFloorCompiler implementation.
Runnable using ClassLoader of the OfficeFloorCompiler.
OfficeFloor ComponentProvider.
Configuration for an OfficeFloor.
OfficeFloor default SslContextSource.
Dependencies available from OfficeFloor.
Tags a node as a OfficeFloor dependency sink.
Tags a node as a OfficeFloor dependency source.
Deploys the OfficeFloor.
Docker wrapper for running third party services (typically for testing).
Factory to create the build directory.
OfficeFloor AbstractEndpoint.
Extension for running OfficeFloor around tests.
Enables plug-in extension of the OfficeFloor.
Provides safe FileAttribute support.
OfficeFloor HttpFilter.
Tags a node as an OfficeFloor Flow sink.
Tags a node as an OfficeFloor Flow source.
HandlerInterceptor to bridge OfficeFloor REST handling.
OfficeFloor ActiveDescriptor.
OfficeFloor HttpFunction.
Factory to create the compiled and open OfficeFloor.
Main runner for OfficeFloorHttpFunction.
Reference to the OfficeFloor HttpFunction implementation.
Implementation of OfficeFloor.
OfficeFloor InstanceManager.
This enables OfficeFloor to provide ManagedObject instances to HK2.
OfficeFloorIntoHk2Bridge implementation.
Notified of issues in construction of the OfficeFloor.
Listing of the asset types within the OfficeFloor that may have issues in construction.
IssueTarget implementation that adapts to the OfficeFloorIssues.
Java compiler to avoid Proxy implementations.
Class Field.
Class name.
Writes the Constructor for the wrapping implementation.
Runnable to use with the specified OfficeFloorJavaCompiler implementation.
Java source.
Provides means to including source.
Writes each Method required by implementing interfaces.
Operation undertaken without the Java compiler being available.
OfficeFloorJavaCompiler implementation.
JUnit functionality for OfficeFloor.
OfficeFloor JustInTimeInjectionResolver.
Listens to the open/close of the OfficeFloor.
Loads the OfficeFloor from the OfficeFloorSource.
OfficeFloorLoader implementation.
Provides main method to compile and run OfficeFloor.
Type definition of a configurable Property of the ManagedObjectSource.
Type definition of a ManagedObjectSource available to be configured in the OfficeFloor.
Proxy interface for the OfficeFloor MBean.
Register to register the possible MBeans.
Meta-data for the OfficeFloor.
OfficeFloorMetaData implementation.
OfficeFloorModel OfficeFloorSource.
OfficeFloorNode implementation.
Auto-configuration for OfficeFloor OpenAPI integration.
Optional OpenAPI configuration loaded only when springdoc is on the classpath.
OfficeFloor Processor.
Type definition for a Property of the OfficeFloor.
OfficeFloor ProtocolHandler.
OfficeFloorRepository implementation.
Tags a node as a OfficeFloor responsibility source.
Auto-configuration for OfficeFloor REST integration.
REST endpoint for handling by OfficeFloor.
REST method for handling by OfficeFloor.
Configuration properties for OfficeFloor REST integration.
Handles starting OfficeFloor.
TestRule for running OfficeFloor around tests.
Runs the OfficeFloor.
Handles the APIGatewayProxyRequestEvent.
OfficeFloor ServerHttpRequest.
OfficeFloor ServerHttpResponse.
OfficeFloor SocketWrapperBase.
Sources the OfficeFloor.
Context for the OfficeFloorSource.
OfficeFloorSourceContext implementation.
Provides the specification of the OfficeFloor to be deployed by the particular OfficeFloorSource.
Extension for OfficeFloor Spring Boot support.
Supplies OfficeFloorManagedObjectSource instances within the OfficeFloor.
Team within the OfficeFloor.
Type definition of a Property that may be configured on the TeamSource.
Type definition of a TeamSource available to be configured in the OfficeFloor.
Type definition of an OfficeFloor.
OfficeFloorType implementation.
Indicates the adapting type is incompatible.
Utility functions for working with Vertx within OfficeFloor.
Wrapper Exception for Throwable from Vertx.
Vertx Handler to service with OfficeFloor.
Enables OfficeFloor to run a WAR application.
WebMvcConfigurer for OfficeFloor REST Spring Boot integration.
Tags a node as an office Flow sink.
Tags a node as an office Flow source.
Office Frame to create the OfficeFloor.
Default implementation of the OfficeFrame.
TestCase providing additional helper functions.
Marks a GUI test.
Multi-threaded test logic interface.
Marks a stress test.
Test capture interface.
Test logic interface.
Marks a test that uses Docker.
Marks a test that uses Google Cloud.
Predicate to check for is true.
Type definition of the OfficeSectionFunction.
OfficeFunctionType implementation.
Governance within the Office.
Office implementation.
Input to the Office.
Implementation of the OfficeInputNode.
Type definition of an OfficeInput into the Office.
OfficeInputType implementation.
Loads the OfficeType from the OfficeSource.
OfficeLoader implementation.
Utility class for testing an OfficeSource.
Type definition of a ManagedObject required by the OfficeType.
OfficeManagedObjectType implementation.
Manages AssetManager instances within an Office.
Hires a new OfficeManager.
OfficeManagerHirer implementation.
Implementation of the OfficeManager.
TestSupport to provide the OfficeManager.
Meta-data for the Office.
OfficeMetaData implementation.
OfficeModel OfficeSource.
Office node.
OfficeNode implementation.
Object required by the Office that is to be provided by the OfficeFloor.
OfficeObjectNode implementation.
Output from the OfficeOutput.
Implementation of the OfficeOutputNode.
Type definition of an OfficeOutput from the Office.
OfficeOutputType implementation.
OfficeRepository implementation.
Tags a node as a office responsibility source.
Input into the OfficeSection.
Type definition of the OfficeSectionInput.
ManagedObject contained within an OfficeSubSection.
Type definition of an Office SectionManagedObjectSource.
Type definition for a Team of a ManagedObject within an OfficeSection.
Type definition for an Office SectionManagedObject.
Object required by the OfficeSection.
Type definition of the OfficeSectionObject.
Output from the OfficeSection.
Type definition of the OfficeSectionOutput.
OfficeSectionOutputType implementation.
Enables transforming the OfficeSection.
Context for the OfficeSectionTransformer.
Type definition of a section of the OfficeSection.
OfficeSectionType implementation.
Sources the OfficeType.
Context for the OfficeSource.
OfficeSourceContext implementation.
Property of the OfficeSourceSpecification.
OfficeSourceProperty implementation.
Service to plug-in an OfficeSource Class alias by including the extension OfficeSource jar on the class path.
Provides the specification of the OfficeType to be loaded by the particular OfficeSource.
Start-up trigger for a ManagedFunction within the Office.
OfficeStartNode implementation.
Startup task for an Office.
OfficeStartupFunction implementation.
Type definition of a section of the OfficeSubSection.
Supplies OfficeManagedObjectSource instances within the Office.
Team required by the Office.
OfficeTeamNode implementation.
Factory for the creation of an OfficeTeam.
Type definition of a Team required by the OfficeType.
OfficeTeamType implementation.
Type definition of an Office.
OfficeType implementation.
Visitor to the Office.
Team having only one Thread.
Architect for creating Open API.
Employer for the OpenApiArchitect.
Builds the Operation.
Context for the OpenApiOperationBuilder.
Extension to configure the Operation.
Configures the Open API servicing.
Extension to load SecurityScheme based on HttpSecurity.
WoofExtensionService to configure OpenAPI specification.
Open OfficeFloor Mojo.
Provides ThreadLocal access to the ManagedObject object instances.
Receives the OptionalThreadLocal.
Provides output to set a variable.
Node to provide override Property.
Annotates a Method parameter to indicate it is a ManagedFunction parameter.
Annotates a Method parameter to indicate it is a ManagedFunction parameter.
Captures a parameter value.
Parameter type.
WebRouteNode for a path parameter.
Meta-data for the PartitionKey.
TeamSource for the PassiveTeamSource.PassiveTeam.
Contents of the password file.
Password file implementation of CredentialStore.
Decorator on all created PooledConnection instances.
PostgreSql DataSourceFactory.
Extension to run PostgreSql.
TestRule to run PostgreSql.
Primitive types.
Annotation to be applied to private sources so they are ignored from being dynamically "discovered" for use in configuration.
Procedure.
Builds the Procedure instances.
DispatcherServlet for the SpringWebMvcProcedureSource.
Type definition of a possible EscalationFlow by the Procedure.
ProcedureEscalationType implementation.
Type definition of a Flow possibly instigated by a Procedure.
ProcedureFlowType implementation.
Procedure implementation.
Context for listing the Procedure instances.
ProcedureLoader implementation.
Utility to test the ProcedureLoader.
ManagedFunctionSource for first-class procedure.
Context for the ProcedureSource.
Type definition of a dependent Object required by the Procedure.
ProcedureObjectType implementation.
Individual property of the Procedure.
ProcedureProperty implementation.
Source providing a Procedure.
Builds the specification for the Procedure.
Type definition of a Procedure.
Builder of expected ProcedureType.
ProcedureType implementation.
Type definition of Var required by the Procedure.
ProcedureVariableType implementation.
ServerHttpConnection implementation available for ExternalServiceInput.
ProcessState aware writing ServerWriter.
Indicates the ProcessState was cancelled.
Identifier for ProcessState.
Manages the ProcessState.
Meta-data for the ProcessState.
ProcessMetaData implementation.
Profiler of the ProcessState.
ProcessProfiler implementation.
ProcessState safe operation.
State of a process within the Office.
Implementation of the ProcessState.
Profiled execution of a ManagedFunction.
Profiled ProcessState.
Profiled ThreadState.
Profiler that receives profile information from OfficeFrame on each ProcessState completion.
Provides promise like functionality for FunctionState instances.
Utility methods for working with Property instances.
Property.
Flags to inject a Property value.
Item that is configurable with Property instances.
Property implementation.
Key for matching property names.
Factory for a PropertyKey.
Listing of Property instances.
Implementation of the PropertyList.
SourceProperties initialised from a PropertyList.
Utility class for testing a PropertyList.
Meta-data for the property.
Node identifying an Property.
Property annotation.
ValueRetriever implementation.
WebTemplateWriter to write a bean property.
Enables wrapping of a XmlWriter to let it be referenced.
Enables qualifying dependencies by textual name.
Enables qualifying dependencies by Annotation instances.
Determines the Qualifier name from the Qualifier attributes.
TypeQualifierInterrogator for Spring's Qualifier.
ManagedObjectSource for R2DBC Connection.
Obtains a Connection.
HTTP ratify context.
Raw meta-data for the bound Administration.
Factory to create the RawAdministrationMetaData.
Raw meta-data for a bound ManagedObject.
Factory for the creation of RawBoundManagedObjectMetaData.
Raw Executive meta-data.
Factory for the construction of the RawExecutiveMetaData.
Raw meta-data for a Governance.
Factory for the creation of the RawGovernanceMetaData.
Raw meta-data for a ManagedFunction.
Factory to construct RawManagedFunctionMetaData.
RawManagedObjectMetaData<O extends Enum<O>,F extends Enum<F>>
Factory for the creation of RawManagedObjectMetaData.
Raw OfficeFloorMetaData implementation.
Factory for creating RawOfficeFloorMetaData.
RawOfficeMetaData implementation.
Factory for creating the RawOfficeMetaData.
Raw Team meta-data.
Factory for the construction of RawTeamMetaData.
Utility methods for WoOF working with Spring Reactive.
ReactorMethodReturnManufacturerServiceFactory<R extends org.reactivestreams.Publisher<? super T>,T>
Parameter to the recycle ManagedFunction.
Registry of XmlMapping instances by id.
Registry of ReferenceXmlMapping instances.
Enables referencing another XmlWriter to write the XML of the object obtained from the source object.
Reflective flow to be used as a parameter.
Reflective GovernanceBuilder.
Refresh token.
Indicates failure in creating an Refresh token.
Registered ManagedObject with the Governance.
Action containing the details of a delete.
Handles requests.
Services requests.
Factory to create the RequestServicer.
Required dependency.
Enables the OfficeFloorSource to specify any required Property instances necessary for loading the OfficeFloor.
Source for resources.
Underlying system to the HttpResourceStore.
Context for the ResourceSystem.
Service for the creation of a ResourceSystem.
ServiceFactory interface for providing a ResourceSystemFactory.
Transforms resource instances.
Context for the ResourceTransformer.
Factory to create the ResourceTransformer.
Provides means to write header content before the response StreamBuffer instances.
Writes the response.
Team responsible for the ManagedFunction.
ResponsibleTeamNode implementation.
Builds servicing of REST requests.
Obtains the configuration item.
Employs the REST architecture.
Composed REST endpoint.
RestArchitect implementation.
Configured REST endpoint.
REST endpoint configuration.
RestEndpoint implementation.
REST supported HttpMethod.
Decorates the RestMethod.
Context for the RestMethod.
RestMethod implementation.
Context for the REST path.
RestPathContext implementation.
Operation to obtain details of retrieving a HttpSession from the HttpSessionStore.
HttpException from attempting to retrieve a value.
AbstractAdministrationSource to enforce roles-allowed security.
ValueRetriever implementation.
XmlMapping that puts the root object into context.
Mojo to run Google Function.
Runs SAM for the manual testing.
Wraps the set up of the ManagedObjectService to block invocations until available.
Safely invokes service on the ManagedObjectServiceContext.
ByteSequence for the AWS SAM entity.
Provides access to MockWoofServer static methods.
Translate ScriptException to possible more appropriate Throwable.
Provides means for script to invoke Flow.
Meta-data for a ScriptEngine function.
Decorates the ScriptEngine.
Meta-data for a ScriptEngine function.
SectionChanges implementation.
Tags a node as a section dependency sink.
Tags a node as a section dependency source.
Designer to design the SectionNode.
Tags a node as a section Flow sink.
Tags a node as a section Flow source.
Input to an SectionNode.
Type definition of an input for a SectionType.
SectionInputType implementation.
Annotates an interface to be a SectionSource.
SectionLoader implementation.
Utility class for testing a SectionSource.
Dependency for a section ManagedObject.
Flow from a section ManagedObject.
SectionSource for a SectionModel.
Name of SubSection.
Node within the hierarchy of OfficeSection instances.
SectionNode implementation.
Object required by the SectionNode.
SectionObjectNode implementation.
Type definition of an Object dependency required by the SectionType.
SectionObjectType implementation.
Output of a SectionNode.
SectionOutputNode implementation.
Type definition of an output for a SectionType.
SectionOutputType implementation.
SectionRepository implementation.
Sources the SectionType.
Context for loading a SectionType.
SectionSourceContext implementation.
SectionSourceProperty implementation.
Service to plug-in an SectionSource Class alias by including the extension SectionSource jar on the class path.
Provides the specification of the SectionType to be loaded by the particular SectionSource.
Type definition of a section of the Office.
Facade builder for the SectionType.
SectionType implementation.
RestMethodDecorator to handle HTTPS.
Spring Security SpringExceptionHandler.
Dependency keys.
HTTP connection to be handled by the OfficeFloor.
Provides non-blocking InputStream for servicing.
OutputStream with additional methods to write cached ByteBuffer instances.
Decorates the ServerSocket.
Server Writer.
Context for the ServiceFactory.
Generic factory to be loaded by the ServiceLoader.
Dependencies.
Manager of Servlet instances for ServletServicer.
SectionSource servicing ServerHttpConnection via Servlet.
Services ServerHttpConnection via Servlet.
Extension to ServletSupplierSource.
SupplierSource to provide Servlet functionality.
WoofExtensionService to provide a Servlet container.
OfficeExtensionService to setup an testing of Google HttpFunction.
OfficeFloorExtensionService to setup testing a Google HttpFunction.
StatelessValueLoaderFactory to load a string parameter.
Provides a singleton object.
Extension to skip test under particular conditions.
Condition for skipping.
JUnit 4 skip logic.
TestRule to skip test under particular conditions.
Condition for skipping.
Functionality for skipping tests.
Manages the Socket interaction.
Runnable to run on the Socket Thread.
Services the Socket.
Factory to create a SocketServicer.
Generic context for a source.
SourceContext implementation.
Provides means to raise CompilerIssue.
Adapts the SourceIssues to IssueTarget.
Escalation indicating that the ManagedObjectSource was timed out in providing a ManagedObject.
Properties for the source.
SourceProperties implementation.
Annotates a Method of the FlowInterface to indicate to spawn a ThreadState.
ManagedObjectSource for a Spring argument.
Dependency keys.
Provides Spring argument annotation types.
Spring Bean decorator context.
Spring bean ManagedObjectSource.
ManagedObjectSource for a Spring Bean.
AbstractSupplierSource for Spring beans.
OfficeFloorSpringBootExtension for Spring Boot Data.
Provides means to load services from other Spring boot starters (other than Spring MVC).
AbstractOfficeFloorSource for Spring Boot.
AbstractOfficeSource for Spring Boot.
Spring Data ThreadSynchroniser.
Spring Data transaction Governance.
Spring Data transaction Governance.
Spring Data transaction GovernanceSource.
Spring Data transaction GovernanceSource.
Spring dependency on OfficeFloor.
Handler for exceptions from DispatcherServlet.
Determines if a Spring argument.
OfficeExtensionService for Spring Security.
OfficeExtensionServiceFactory for Spring Security.
Extension to SpringSupplierSource.
Factory for the creation of the Spring dependencies.
Provides the loading of Spring.
TypeQualifierInterrogator for Spring annotations.
Spring Web Flux Controller Procedure.
Dependency keys.
Registry to map SpringWebFluxProcedureSource to its Controller HttpHandler.
Web Flux Controller ProcedureSource.
Spring Web MVC Controller Procedure.
Dependency keys.
Registry to map SpringWebMvcProcedureSource to its Controller HandlerExecutionChain.
Web MVC Controller ProcedureSource.
Source for SSLContext instances.
ManagedFunction and ManagedFunctionFactory for triggering authentication with application specific credentials.
Dependency keys.
Mojo to start Google Function.
Starts SAM for the integration testing.
Loads a value onto the Object graph.
Factory to create the StatelessValueLoader.
Manages state (multiple ManagedObject instances used externally).
StateManager implementation.
Identifies a state point.
StatePoint implementation.
Context for a particular poll of state.
StatePoller<S,F extends Enum<F>>
Provides polling within a ManagedObjectSource to keep particular state up to date.
Builder for the StatePoller.
Initialiser for polling state.
Custom poller.
StaticManagedFunction<O extends Enum<O>,F extends Enum<F>>
Annotation identify the Method as static.
Loader to load a static value onto target object.
WebRouteNode for static characters.
WebTemplateWriter to write static content.
Provides static mapping.
XmlMapping that loads a static value to the target object.
CompilerIssues to write issues to System.err.
Team that executes the Job by the TestCase.
Mojo to stop Google Function.
Stops SAM for the integration testing.
Operation to obtain details of storing the HttpSession within the HttpSessionStore.
Indicates the HttpSession is currently being stored and can not be altered until storage is complete.
Buffer that is part of a stream.
FileChannel content buffer.
ByteSequence reading from StreamBuffer instances.
Provides interface to wrap buffer pooling implementations.
Provides scanning of StreamBuffer instances.
Scan target.
Utility functionality for a StreamBuffer.
Stress Test.
LinkedListSet that provides strict adherence to ensuring correctness.
Extracts a String value from the input object.
Matcher that provides stub functionality.
Input into a SubSection.
Object for a SubSection.
Output for a SubSection.
Node for the supplied ManagedObject.
Type definition of a potentially supplied ManagedObject.
Architect to configure OfficeSupplier instances.
Invoke on completion of compiling.
Configuration from the SupplierCompileContext.
Compile context for the SupplierSource.
Completion context for the SupplierSource.
Configuration for an OfficeSupplier.
Employs the supplier architecture.
SupplierLoader implementation.
Utility class for testing a SupplierSource.
Supplier Node.
SupplierNode implementation.
Supplies ManagedObjectSource instances.
Context for the SupplierSource.
SupplierSourceContext implementation.
SupplierSourceProperty implementation.
Service to plug-in an SupplierSource Class alias by including the extension SupplierSource jar on the class path.
Provides the specification of the Supplier to be loaded by the particular SupplierSource.
Provides ThreadLocal access to the ManagedObject object instances for the SuppliedManagedObjectSource.
SupplierThreadLocalNode implementation.
Type definition of a SupplierThreadLocal.
SupplierThreadLocalType implementation.
SupplierThreadLocal implementation.
Type definition of a Supplier.
Builder for the InitialSupplierType.
InitialSupplierType implementation.
FunctionState to synchronise the ProcessState with the current ThreadState.
Factory for synchronous Key.
Extension for specifying system properties ( System.getProperty(String) ) for tests.
TestRule for specifying System properties.
Team of workers to execute the assigned Job instances.
Augments the Team instances within the OfficeFloor.
Context for the TeamAugmentor.
Builder of a Team.
Implements the TeamBuilder.
Configuration for an OfficeFloorTeam.
Configuration of a Team.
Deployer to configure OfficeFloorTeam instances.
Executor that is backed by a Team.
Loads the TeamType from the TeamSource.
TeamLoader implementation.
Provides management of a particular Team.
TeamManagement implementation.
TeamNode implementation.
Indicates the Team is overloaded.
Oversight for a Team.
Source to obtain Team instances.
Context for the TeamSource.
Wrapper of TeamSourceContext to enable customising the Team.
Provides a wrapper around the Runnable from the Executive for a Thread.
Individual property of the TeamSourceSpecification.
TeamSourceProperty implementation.
Service to plug-in an TeamSource Class alias by including the extension TeamSource jar on the class path.
Specification of a TeamSource.
Loads a TeamSource for stand-alone use.
Type definition of a Team.
TeamType implementation.
Visits each TeamNode.
Temporary directory FileCacheService.
Provides means to manage temporary FileChannel content.
Service providing additional test dependencies.
Context for the TestDependencyService.
TestManagedObject<O extends Enum<O>,F extends Enum<F>>
Test ManagedObject that simplifies the TestManagedObject.
Annotation to be applied to test/mock sources so they are ignored from being dynamically "discovered" for use in configuration.
Test support object.
Extension for TestSupport.
Listener on the completion of a Thread.
Factory for the creation of the ThreadCompletionListener.
Provides additional means to obtain the ManagedObject from ThreadLocal.
TestSupport for multiple Thread tests.
Multi-threaded execution.
Multi-threaded test logic interface.
Predicate to check for is true.
Manufactures ThreadFactory.
Context for the ThreadLocalAwareTeam Team.
ThreadLocalAwareContext implementation.
Executes Job instances to enable access to the invoking ProcessState Thread ThreadLocal instances.
ThreadLocalAwareExecutor implementation.
Enables a Team to execute the Job with the Thread invoking the ProcessState.
Provides configuration for the OptionalThreadLocal.
OptionalThreadLocal implementation.
OptionalThreadLocal implementation.
StreamBufferPool of ByteBuffer instances that utilises ThreadLocal caches for performance.
Meta-data for the ThreadState.
ThreadMetaData implementation.
Profiler of the ThreadState.
ThreadProfiler implementation.
Thread safe capture of a free variable for closure state of a Function.
ThreadState safe operation.
State of a thread within the ProcessState.
Context for executing a ThreadState.
Implementation of the ThreadState.
Synchronises the ThreadLocal instances on Thread to Thread interaction between Team instances.
Factory for the ThreadSynchroniser.
ManagedObjectSource providing an application-scoped TemplateEngine.
OfficeExtensionService that auto-registers the ThymeleafManagedObjectSource so that a TemplateEngine is available for auto-wiring into ThymeleafProcedureSource render functions.
ProcedureSource that renders a Thymeleaf template.
HttpServlet to handle FilterChain.
Operation to run.
ServletContextListener for application setup.
SectionDesigner to intercept configuration to provide access to the SectionSource configured items.
Enables transforming a SectionSource.
Translates the HttpPath to WebServicer.
Dependency keys.
Contract to translate an object value to an string value for XML.
Contract to translate the XML string value to specific typed object.
Registry of Translator instances by type they translate.
Registry of the
Implementation of XmlMarshaller that is capable of marshalling a tree object graph.
Factory for the creation of a TreeXmlMarshaller.
Implementation of XmlUnmarshaller that is capable of unmarshalling a tree structure of objects from XML.
Handler to load XML values onto target object.
Factory for the creation of a TreeXmlUnmarshaller.
Map that provides a triple key to obtain the entry.
Locates an archive within the tutorials.
InvocationHandler to enable type compatibility between interface loaded in one ClassLoader and implementation in another.
Encapsulates ClassLoader handling to load the various OfficeFloor types.
Provides type qualification for a ManagedObject.
Configuration for a type qualification of a OfficeFloorTeam.
TypeQualification implementation.
Interrogates for the type qualifier.
Context for the TypeQualifierInterrogator.
Context for the TypeQualifierInterrogator.
Implementation of XmlMapping to map an object based on its specific sub-type implementation.
Indicates a Class was not available from the SourceContext.
Indicates an unknown ManagedFunction was requested.
Indicates an unknown ManagedObject was requested.
Indicates an unknown Office was requested.
Indicates a property was not configured within the SourceProperties.
Indicates a resource was not available from the SourceContext.
Indicates a service was not available from the SourceContext.
Utility methods to help in US-ASCII testing.
Test that uses AWS and related local services such as SAM.
Test that uses docker.
Test that uses GCloud.
Identifies an input value from variable.
ConnectionDecorator to validate the Connection instances.
ConnectionDecoratorServiceFactory to validate all created Connection and PooledConnection instances are closed on closing OfficeFloor.
Indicates if the PooledConnection is closed.
Indicates failure in obtaining the JwtValidateKey instances.
PooledConnectionDecorator to validate the PooledConnection instances.
Loads a value onto the Object graph.
Loads string values onto a target object.
Factory for the creation of a ValueLoader.
ValueLoaderFactory implementation.
ValueLoader implementation.
Sources the ValueLoaderFactory for a Class type.
Name of a value.
Retrieves a value from an object graph.
Sources the ValueRetriever.
Writes a XML value with value sourced from object.
XmlMapping that loads a value to the target object.
Represents a variable.
Annotation for Var.
ClassDependencyFactory for a Var appropriately wrapped.
Context logic.
Variables.
Configures the Pool.
Context for the VertxSqlPoolConfigurer.
ManagedObjectSource for Vertx Pool.
Renders a view (typically Thyme Leaf).
Dependency keys.
Loads the ClassLoader for WAR.
Web configuration extensions for the OfficeArchitect.
WebArchitect implementation.
Factory to create custom WebClient WebClient.Builder.
ManagedObjectSource for a WebClient.
Provides WebArchitect and server configuration for testing web applications.
SectionSource servicing ServerHttpConnection via Web Flux.
Configuration to embed OfficeFloor.
OfficeFloor ReactiveWebServerFactory.
WoofExtensionService to service via Web Flux.
ServiceFactory to provide a single Method Class for intercepting all HttpRequest instances before they are serviced by WoOF.
SectionSource servicing ServerHttpConnection via Web MVC.
Configuration to embed OfficeFloor managed Tomcat.
OfficeFloor ServletWebServerFactory.
WoofExtensionService to provide a Servlet container.
Handles the web route.
WebRouteHandler implementation.
Node in the WebRouter route tree.
Indicates possible matching of WebRouteNode.
Routes ServerHttpConnection instances to their respective handling ManagedFunction.
Builds the WebRouter.
Servicer for web route.
Result of matching.
Web template.
Architect to create web templates.
WebTemplateArchitect implementation.
ManagedFunction to iterate over an array to render content.
WebTemplateSectionSource.WebTemplateArrayIteratorManagedFunctionSource dependency keys.
WebTemplateSectionSource.WebTemplateArrayIteratorManagedFunctionSource flow keys.
Extension for the WebTemplate.
Context for the WebTemplateExtension.
Factory for the creation of a WebTemplate.
ManagedFunction to write the ParsedTemplateSection.
Initial ManagedFunction to ensure appropriate conditions for rendering the ParsedTemplate.
Keys for the WebTemplateInitialFunction flows.
Keys for the WebTemplateInitialFunction dependencies.
Annotation identifying a HttpInput link for the WebTemplate.
Loads the type for the WebTemplate.
WebTemplateLoader implementation.
Utility class for testing the WebTemplate.
Type definition of an output for a WebTemplateType.
Annotation identifying a redirect to the WebTemplate.
SectionSource for the HTTP template.
No-logic placeholder class for ClassSectionSource.
Section WebTemplateWriter struct.
ManagedFunctionSource for the HTTP template.
Type definition of a WebTemplate.
WebTemplateType implementation.
Interface to write the template content to ServerWriter.
Web Thread affinity Executive.
Web based ExecutiveSource providing Thread affinity.
Web.
Provides main method for running Web on OfficeFloor (WoOF) application.
Context for the WoofLoader.
Service that enables extending functionality over and above the WoofLoader by direct configuration.
Loads the WoOF configuration to the WebArchitect.
WoofLoader implementation.
Settings for the WoofLoader.
Configuration for the WoofLoader.
Configurer for an Office.
Runs within a context.
Loads the WoofObjectsModel and configures the SupplierSource.
Context for the WoofObjectsLoader.
WoofObjectsLoader implementation.
Loads the WoofResourcesModel configuration.
Context for the WoofResourcesLoader.
WoofResourcesLoader implementation.
Loads the WoofTeamsModel configuration.
Context for the WoofResourcesLoader.
WoofTeamsLoader implementation.
Context for the WoofResourcesLoader.
Context for WoofTemplateExtensionSource creating a Change.
Configuration for a WoofTemplateExtension.
Flags that the WebTemplateExtension is unknown or unable to be obtained.
Loads the extension from the WoofTemplateExtensionSource.
Loads the specification.
Utility functions for testing a WoofTemplateExtensionSource implementation.
Source that allows extending behaviour of a WebTemplate.
Individual property of the WoofTemplateExtensionSource.
Specification of the WoofTemplateExtensionSource.
TeamSource for the WorkerPerJobTeamSource.WorkerPerJobTeam.
Writable HTTP Cookie.
Writable HttpHeader.
Implementation of XmlOutput to write to a Writer.
Context for XML marhalling of source object.
Context for XML unmarshalling to target object.
ConfigurationContext obtaining ConfigurationItem instances from a single XML File.
Mapping of object to XML.
Provides an mapping of the XML element/attribute to a load method of a target object.
Mapping of XML element/attribute to either a value/new object on a target object.
Contains the meta-data of the XML mappings.
Meta-data of the XmlContext.
Type of the XmlMappingMetaData.
Type of the XmlMappingMetaData.
Contract to marshall XML from an object.
Provides utility methods to write XML.
Indicates failure to marshall/unmarshall XML.
Contract to output the text of the XML.
Instance of XmlContext for a particular concrete class.
State of the XML unmarshalling.
Contract to unmarshall XML onto an object.
Writes the XML for an object.