Base class for active element activators registry.

An active element is an element which is able to perform an action in a predefined context. This is a fundamental block of execution plan for any engine.

Base engine that processes a request

This provides information regarding the runtime exception that has happened during either execution plan creation or logic execution.

Base execution context for each engine request

This is a abstract base class for executors that require tracing information to be captured.

A default base class for engine executors. It does provide the version basic functions for different executors.

Helper class to read values from an ActiveElement Sometimes value provided in the parameter of a model element has to be considered as a reference and sometimes it is the value itself. This class helps to resolve this situation.

EventArgs for an active element call back to the client

Base class collection

Converts a value to another type using TypeConverter or Parse method whenever possible

This registers and holds to necessary factories that are required for model activation process

This is the factory that creates IElementActivatorRegistry for each ActiveElement

Provides utilities for the logic model

Manages the exception logging based on the set configuration

Provides information related to the context at runtime

Default implementation of execution context provider.

ActiveElementEngine is pausing execition

Execution plan for model of a logic

Configuration information for an engine's executor

Base exception class for all FlexRule runtime exceptions

Formats a message based on a variable container

Base class for runtime types

Provides some methods to serialize or deserialize an object to and from binary format

A factory to create different outputs

Result of executing a logic (e.g. validation, procedure, flow, decision...) that contains notifications, variable container, logs and return result.

This is base class to register types

If a type can not be created or loaded this exception would happen

This base class has implemented the execution behavior in a recursive way. It can be used as a fundamental ready to use base class of engines executors.

Creates a value of a specific type by determining the value type.

Default implementation of IVariableContainer

Extension methods for IVariableContainer

Value of a container change event arguments

Accessing a variable in the container may raise this exception if the variable does not exits

Boolean result that carries more information

To transform a model ([!:IElementModel]) to an ActiveElement this interface will give engine access to populated registry for activation process.

Cleanup will be called after execution is finished by engine

Each ActiveElement if it is an executable item IElementExecutableItem , behaviour setting will be managed by this interface during execution.

An engine that executes active elements inside a context with this interface

It provides an access to execution related information for read and write data related to processing each individual request to the engine.

Executor module of an active element engine

Provides lifecycle definition to ActiveElements

Gives access to an array

Gives access to a generic array

Interface to child manager for a collection

Navigator manager that allows to navigate on nodes

Provides mechanisms when an ActiveElement can communicate back to the host. e.g. application is running the engine.

This is a session interface that allows ActiveElements share information with other during execution.

Each model element of an active element needs to provide an activator to be registered in an activator registry which exposes the following interface through IActiveElementExecutionContext

Each element wants to control the execution process needs to implement this interface

Encapsulate all executable instances of models

Execution plan of a model

That is designed for internal use

Internal interface to the variable context

Iterable list that has item

Iterable of generic list that has item

Iterator of a list

Iterator of a generic list

This manages lifecycle of ActiveElements.

Manages all the nested containers inside a IVariableContainer

Interface to user output

Defines the root hierarchy of ActiveElements that they are participating in execution of a logic. The root usually need to prepare context or reset existing context

Rule engine encapsulates all the plumbing and execution plan management of a rule.

This provides access to any type registry

Provides information about the position of an element in the source

Registers a type to be addressed by a TypeId as an identifier

Retrieves the type id manager

An interface to a variable container. Defines mechanism to manipulate and register types and variables in evaluation context.

Workflow executable model allows resuming logic from a specific point in the model

The behaviour of element during execution process

Different editions of product