Package org.apache.camel.spi

package org.apache.camel.spi

Service Provider Interfaces used by the Camel runtime which are plugin strategies.

Related Packages

Package	Description
org.apache.camel	The core Camel API.
org.apache.camel.spi.annotations	SPI annotations for plugins

Class	Description
AggregationRepository	Access to a repository to store aggregated exchanges to support pluggable implementations.
AnnotationBasedProcessorFactory	Factory to create Processor for annotation based EIPs.
AnnotationScanTypeConverters	A TypeConverter which is capable of annotation scanning for Converter classes and add these as type converters.
ApiMethod	Represents an API method as part of a parent API.
ApiParam	Used for annotating a UriParam parameter that its for use by API based endpoints.
ApiParams	Used to annotate a nested configuration parameter type (such as a nested Configuration object) which can then be used on a API based component, endpoint.
AsEndpointUri	Indicates that the Camel string/expression should be used as an endpoint uri.
AsPredicate	Indicates that the Camel language/expression should be used as predicate.
AsyncProcessorAwaitManager	A manager to handle async routing engine, when Exchanges are being handed over from one thread to another, while the callee thread is blocked waiting for the other threads to complete, before it can continue.
AsyncProcessorAwaitManager.AwaitThread	Information about the thread and exchange that are inflight.
AsyncProcessorAwaitManager.Statistics	Utilization statistics of this manager.
AuthorizationPolicy	A marker for defining the policy to be used for applying authorization to routes.
AutowiredLifecycleStrategy	Marker interface for LifecycleStrategy that are used for auto-wiring components, data formats and languages.
BacklogTracer	Backlog tracer that captures the last N messages during routing in a backlog.
BacklogTracerEventMessage	Represents a traced message by the BacklogTracer.
BeanIntrospection	Used for introspecting beans properties via Java reflection; such as extracting current property values, or updating one or more properties etc.
BeanIntrospection.ClassInfo	Structure of an introspected class.
BeanIntrospection.MethodInfo	Structure of an introspected method.
BeanProcessorFactory	Factory for creating a Processor that can invoke a method on a bean and supporting using Camel bean parameter bindings.
BeanProxyFactory	A factory for creating a Proxy for a bean.
BeanRepository	Represents a bean repository used to lookup components by name and type.
BootstrapCloseable	A marker interface for a service, or other kind of process that is only used during bootstrapping Camel.
Breakpoint	Breakpoint are used by the Debugger API.
Breakpoint.State	State of the breakpoint as either active or suspended.
BrowsableEndpoint	An optional interface an Endpoint may choose to implement which allows it to expose a way of browsing the exchanges available.
BulkTypeConverters	Bulk type converters that often comes out of the box with Apache Camel.
CamelBeanPostProcessor	Bean post processor.
CamelBeanPostProcessorInjector	Used for custom injection when doing CamelBeanPostProcessor bean post-processing.
CamelContextCustomizer	To apply custom configurations to CamelContext instances.
CamelContextNameStrategy	Strategy for assigning name to a CamelContext.
CamelContextTracker	A CamelContext creation and destruction tracker.
CamelContextTracker.Filter
CamelDependencyInjectionAnnotationFactory	A factory which performs the task from Camel dependency injection annotations on a field, property or method parameter of a specified type.
CamelEvent	This interface is implemented by all events.
CamelEvent.CamelContextEvent
CamelEvent.CamelContextInitializedEvent
CamelEvent.CamelContextInitializingEvent
CamelEvent.CamelContextReloadedEvent
CamelEvent.CamelContextReloadFailureEvent
CamelEvent.CamelContextReloadingEvent
CamelEvent.CamelContextResumedEvent
CamelEvent.CamelContextResumeFailureEvent
CamelEvent.CamelContextResumingEvent
CamelEvent.CamelContextRoutesStartedEvent
CamelEvent.CamelContextRoutesStartingEvent
CamelEvent.CamelContextRoutesStoppedEvent
CamelEvent.CamelContextRoutesStoppingEvent
CamelEvent.CamelContextStartedEvent
CamelEvent.CamelContextStartingEvent
CamelEvent.CamelContextStartupFailureEvent
CamelEvent.CamelContextStopFailureEvent
CamelEvent.CamelContextStoppedEvent
CamelEvent.CamelContextStoppingEvent
CamelEvent.CamelContextSuspendedEvent
CamelEvent.CamelContextSuspendingEvent
CamelEvent.ExchangeAsyncProcessingStartedEvent	Special event only in use for camel-tracing / camel-opentelemetry.
CamelEvent.ExchangeCompletedEvent
CamelEvent.ExchangeCreatedEvent
CamelEvent.ExchangeEvent
CamelEvent.ExchangeFailedEvent
CamelEvent.ExchangeFailureEvent
CamelEvent.ExchangeFailureHandledEvent
CamelEvent.ExchangeFailureHandlingEvent
CamelEvent.ExchangeRedeliveryEvent
CamelEvent.ExchangeSendingEvent
CamelEvent.ExchangeSentEvent
CamelEvent.FailureEvent	This interface is implemented by all events that contain an exception and is used to retrieve the exception in a universal way.
CamelEvent.RouteAddedEvent
CamelEvent.RouteEvent
CamelEvent.RouteReloadedEvent
CamelEvent.RouteRemovedEvent
CamelEvent.RouteStartedEvent
CamelEvent.RouteStartingEvent
CamelEvent.RouteStoppedEvent
CamelEvent.RouteStoppingEvent
CamelEvent.ServiceEvent
CamelEvent.ServiceStartupFailureEvent
CamelEvent.ServiceStopFailureEvent
CamelEvent.StepCompletedEvent
CamelEvent.StepEvent
CamelEvent.StepFailedEvent
CamelEvent.StepStartedEvent
CamelEvent.Type
CamelInternalProcessorAdvice<T>	An advice (before and after) to execute cross-cutting functionality in the Camel routing engine.
CamelLogger	A logger which logs to a slf4j Logger.
CircuitBreakerConstants
ClaimCheckRepository	Access to a repository of keys to implement the Claim Check pattern.
ClassResolver	A class resolver for loading classes in a loosly coupled manner to cater for different platforms such as standalone, web container, j2ee container and OSGi platforms.
CliConnector	Local CliConnector that allows Camel CLI to manage local running Camel integrations.
CliConnectorFactory	Factory for creating connector to CLI tooling.
CompilePostProcessor	Allows to plugin custom post processors that are processed after the DSL has loaded the source and compiled into a Java object.
ComponentCustomizer	To apply custom configurations to Component instances.
ComponentCustomizer.Builder<T extends Component>	A fluent builder to create a ComponentCustomizer instance.
ComponentCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
ComponentNameResolver	Discovers which components are available on the classpath.
ComponentResolver	Represents a resolver of components from a URI to be able to auto-load them using some discovery mechanism like org.apache.camel.impl.DefaultComponentResolver
Condition	A condition to define when a given Exchange matches when is being routed.
Configurer	An annotation used to mark classes to indicate code capable of configuring its options via a getter/setters that can be called via Camels PropertyConfigurer.
ConfigurerResolver	A pluggable strategy for resolving different configurers in a loosely coupled manner
ConfigurerStrategy	Strategy for configurers.
ConsumerCache	Cache containing created PollingConsumer.
ContentTypeAware	Represents an object that can have an associated content type.
ContextReloadStrategy	SPI strategy for reloading CamelContext.
Contract	A Contract which represents the input type and/or output type of the Endpoint or Processor.
DataFormat	Represents a data format used to marshal objects to and from streams such as Java Serialization or using JAXB2 to encode/decode objects using XML or using SOAP encoding.
DataFormatContentTypeHeader	Special accessor for a DataFormat
DataFormatCustomizer	To apply custom configurations to DataFormat instances.
DataFormatCustomizer.Builder<T extends DataFormat>	A fluent builder to create a DataFormatCustomizer instance.
DataFormatCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
DataFormatFactory	A factory to create DataFormat.
DataFormatName	The name of the DataFormat which allows to know which kind of data format the implementation is.
DataFormatResolver	Represents a resolver of data formats.
DataType	Represents the data type URN which is used for message data type contract.
DataTypeAware	Allows Message to store a DataType which represents the data type of the Message.
DataTypeTransformer	Annotation to configure a data type transformer with either specifying its name or from/to data types.
Debugger	A debugger which allows tooling to attach breakpoints which is being invoked when Exchanges is being routed.
DebuggerFactory	Factory for creating Debugger.
DeferServiceFactory	Factory to create services such as Producers and defer starting the created service, until CamelContext has been started.
DependencyStrategy	Strategy when 3rd party dependencies are detected during loading routes.
EndpointRegistry<K>	Registry to cache endpoints in memory.
EndpointStrategy	Endpoint strategy with callback invoked when an Endpoint is about to be registered to the endpoint registry in CamelContext.
EndpointUriFactory	Factory to create Endpoint URI string from a Map of parameters.
EndpointUtilizationStatistics	Various statistics about endpoint utilization, such as from EIP patterns that uses dynamic endpoints.
ErrorHandler	An interface used to represent an error handler
ErrorHandlerAware	An interface for Processor aware of its ErrorHandler which are wrapped via the Channel during route initialization, or specially used by RecipientList EIP annotation.
ErrorHandlerRedeliveryCustomizer	Customizer for ErrorHandler which supports redeliveries.
EventFactory	Factory to create events that are emitted when such an event occur.
EventNotifier	Notifier to send events.
ExceptionHandler	A Strategy pattern for handling exceptions; particularly in asynchronous processes such as consumers.
ExchangeFactory	Factory used by Consumer to create Camel Exchange holding the incoming message received by the consumer.
ExchangeFactoryManager	Manages ExchangeFactory.
ExchangeFormatter	A plugin used to turn an Exchange into a String representation usually to be used for logging or tracing purposes.
ExecutorServiceManager	Strategy to create thread pools.
ExpressionFactoryAware	When an instance is aware of ExpressionFactory.
ExpressionResultTypeAware	Represents an Expression or Predicate that supports a result type.
ExtendedPropertyConfigurerGetter	A marker interface to identify the object as being a configurer which can provide details about the options the configurer supports.
ExtendedRoutesBuilderLoader	An extended RoutesBuilderLoader that is capable of loading from multiple resources in one unit (such as compiling them together).
FactoryFinder	Finder to find factories from the resource classpath, usually META-INF/services/org/apache/camel/.
FactoryFinderResolver	Represents a resolver for FactoryFinder
GeneratedPropertyConfigurer	A auto generated PropertyConfigurer for fast configuration of Camel components & endpoints.
GroupAware	To allow objects to be injected with an group.
HasCamelContext	A simple marker interface for an object which holds a CamelContext.
HasGroup	A simple marker interface for an object which has belongs to a group Group which is useful for group related operation such as clustering, JMX style API
HasId	A simple marker interface for an object which has a unique ID which is useful for referring to objects in REST or JMX style APIs
HeaderFilterStrategy	Interface to allow plug-able implementation to filter header to and from Camel message.
HeaderFilterStrategy.Direction	The direction is either IN or OUT.
HeaderFilterStrategyAware	An interface to represent an object which can make use of injected HeaderFilterStrategy.
HeadersMapFactory	Factory to create the Map implementation to use for storing headers on Message.
HttpResponseAware	Represents an object which is aware of HTTP responses.
IdAware	To allow objects to be injected with an id, such as EIP Processors which has been defined from Camel routes.
IdempotentRepository	Access to a repository of Message IDs to implement the Idempotent Consumer pattern.
InflightRepository	A repository which tracks in flight Exchanges.
InflightRepository.InflightExchange	Information about the inflight exchange.
Injector	A pluggable strategy for creating and possibly dependency injecting objects which could be implemented using straight forward reflection or using Spring or CDI to perform dependency injection.
InterceptEndpointFactory	A factory to create Endpoint which are intercepted.
InterceptSendToEndpoint	This is an endpoint when sending to it, is intercepted and is routed in a detour, with the following flow: before, send to original endpoint (can be skipped), after (optional).
InterceptStrategy	The purpose of this interface is to allow an implementation to wrap processors in a route with interceptors.
InternalProcessor	Internal Processor that Camel routing engine used during routing for cross cutting functionality such as: Execute UnitOfWork Keeping track which route currently is being routed Execute RoutePolicy Gather JMX performance statics Tracing Debugging Message History Stream Caching Transformer ...
InternalProcessorFactory	A factory used internally by Camel to create Processor and other internal building blocks.
InvokeOnHeader	Marks a method as being invoked for a specific header value.
InvokeOnHeaderStrategy	Pluggable strategy for invoking InvokeOnHeader.
Language	Represents a language to be used for Expression or Predicate instances
LanguageCustomizer	To apply custom configurations to Language instances.
LanguageCustomizer.Builder<T extends Language>	A fluent builder to create a LanguageCustomizer instance.
LanguageCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
LanguageResolver	A pluggable strategy for resolving different languages in a loosely coupled manner
LifecycleStrategy	Strategy for lifecycle notifications.
LoadablePropertiesSource	A source for properties that can be loaded all at once during initialization, such as loading .properties files.
LocalBeanRepositoryAware	Allows a BeanRepository to temporary have a local repository take precedence, such as when creating route templates to give more flexibility.
LogListener	An event listener SPI for logging.
ManagementAgent	Camel JMX service agent
ManagementInterceptStrategy	A specialized InterceptStrategy which is used for JMX management for EIPs.
ManagementInterceptStrategy.InstrumentationProcessor<T>
ManagementMBeanAssembler	An assembler to assemble a RequiredModelMBean which can be used to register the object in JMX.
ManagementNameStrategy	Strategy for assigning the name part of the ObjectName for a managed CamelContext.
ManagementObjectNameStrategy	Strategy for computing ObjectName names for the various beans that Camel register for management.
ManagementObjectStrategy	Strategy for creating the managed object for the various beans Camel register for management.
ManagementStrategy	Strategy for management.
ManagementStrategyFactory	Service Factory for ManagementStrategy
MaskingFormatter	A plugin used to mask a log String, for example security information like password or passphrase.
MessageHistoryFactory	A factory to create MessageHistory instances.
Metadata	Meta data for EIPs, components, data formats and other Camel concepts
MockSendToEndpointStrategyFactory	Factory for intercepting sending to endpoint pattern and sending to mock component.
ModelineFactory	Factory for parsing camel-k modeline when running Camel standalone with DSLs.
ModelJAXBContextFactory	Factory to abstract the creation of the Model's jakarta.xml.bind.JAXBContext.
ModelReifierFactory	Factory that uses reifiers to build an entity from a given model.
ModelToXMLDumper	SPI for dumping model definitions into XML representation.
ModelToYAMLDumper	SPI for dumping model definitions into YAML representation.
NamespaceAware	Represents an object which is aware of the namespaces in which its used such as XPath and XQuery type expressions so that the current namespace context can be injected
NodeIdFactory	Factory to generate unique ids for model nodes.
NormalizedEndpointUri	An Uri which has been normalized.
NotifyBuilderMatcher	Allows to be used in combination with NotifyBuilder as external predicate implementations to compute if the exchange matches.
OnCamelContextEvent	Marker interface used to make it easy to discover CamelContext related event handlers from the registry.
OnCamelContextInitialized	Notification on an initialized a CamelContext.
OnCamelContextInitializing	Notification on initializing a CamelContext.
OnCamelContextStarted	Notification on a started CamelContext.
OnCamelContextStarting	Notification on starting a CamelContext.
OnCamelContextStopped	Notification on a stopped CamelContext.
OnCamelContextStopping	Notification on stopping a CamelContext.
OptimisticLockingAggregationRepository	A specialized AggregationRepository which also supports optimistic locking.
OptimisticLockingAggregationRepository.OptimisticLockingException	Exception used by an AggregationRepository to indicate that an optimistic update error has occurred and that the operation should be retried by the caller.
PackageScanClassResolver	A resolver that can find classes based on package scanning.
PackageScanFilter	Filter that can be used with the PackageScanClassResolver resolver.
PackageScanResourceResolver	A resolver that can find resources based on package scanning.
PeriodTaskResolver	Finder to find PeriodicTask tasks.
PeriodTaskScheduler	A shared scheduler to run small period tasks, such as updating internal statistics, or for custom components to have a background task.
PluginManager	A manager for internal plugins.
Policy	A strategy capable of applying interceptors to a processor.
PollingConsumerPollStrategy	Strategy for a PollingConsumer when polling an Endpoint.
PooledObjectFactory<T>	Factory for pooled objects or tasks.
PooledObjectFactory.Statistics	Utilization statistics of the this factory.
PredicateExceptionFactory	A factory that can be used to create a specific exception when a Predicate returning false, which can be used by camel-validator and other components.
PredicateFactoryAware	When an instance is aware of PredicateFactory.
ProcessorExchangeFactory	Factory used by Processor (EIPs) when they create copies of the processed Exchange.
ProcessorFactory	A factory to create Processor based on the definition.
ProducerCache	Cache containing created Producer.
ProducerCache.AsyncProducerCallback	Callback for sending a exchange message to a endpoint using an AsyncProcessor capable producer.
PropertiesComponent	Component for property placeholders and loading properties from sources (such as .properties file from classpath or file system)
PropertiesFunction	A function that is applied instead of looking up a property placeholder.
PropertiesReload	Listener for re-loading a Properties such as a Camel route.
PropertiesSource	A source for properties.
PropertiesSourceFactory	Factory for creating out of the box PropertiesSource.
PropertyConfigurer	A marker interface to identify the object as being configurable via a configurer class.
PropertyConfigurerAware	An interface to represent an object which is capable of configuring via PropertyConfigurer.
PropertyConfigurerGetter	A marker interface to identify the object as being a configurer which can provide details about the options the configurer supports.
ReactiveExecutor	SPI to plugin different reactive engines in the Camel routing engine.
RecoverableAggregationRepository	A specialized AggregationRepository which also supports recovery.
Registry	Represents a BeanRepository which may also be capable of binding beans to its repository.
ReifierStrategy	Strategy for reifiers.
ReloadStrategy	SPI strategy for reloading.
Resource	Describe a resource, such as a file or class path resource.
ResourceAware	An interface to represent an object which wishes to be injected with the Resource
ResourceLoader	SPI for loading resources.
ResourceReload	Listener for re-loading a Resource such as a Camel route.
ResourceReloadStrategy	SPI strategy for reloading Resource in an existing running CamelContext
ResourceResolver	SPI for loading resources.
RestApiConsumerFactory	Allows SPI to plugin a RestApiConsumerFactory that creates the Camel Consumer responsible for handling incoming HTTP GET requests from clients that request to access the REST API documentation.
RestApiProcessorFactory	Allows SPI to plugin a RestApiProcessorFactory that creates the Camel Processor responsible for servicing and generating the REST API documentation.
RestBindingJaxbDataFormatFactory	SPI for setting up XML data format (JAXB) for rest-dsl.
RestConfiguration	Configuration use by RestConsumerFactory and RestApiConsumerFactory for Camel components to support the Camel rest DSL.
RestConfiguration.RestBindingMode
RestConfiguration.RestHostNameResolver
RestConsumerFactory	Allows SPI to plugin a RestConsumerFactory that creates the Camel Consumer responsible for handling incoming HTTP requests from clients that request to access REST services which has been created using the rest-dsl.
RestProducerFactory	Allows SPI to plugin a RestProducerFactory that creates the Camel Producer responsible for performing HTTP requests to call a remote REST service.
RestRegistry	A registry of all REST services running within the CamelContext which have been defined and created using the Rest DSL.
RestRegistry.RestService	Details about the REST service
RestRegistryFactory	A factory for RestRegistry.
RouteController	Controller for managing the lifecycle of all the Route's.
RouteError	The last error that happened during changing the route lifecycle, i.e.
RouteError.Phase
RouteFactory	A factory to create Route
RouteIdAware	To allow objects to be injected with the route id
RoutePolicy	Policy for a Route which allows controlling the route at runtime.
RoutePolicyFactory	A factory to create RoutePolicy and assign to routes automatic.
RoutesBuilderLoader	SPI for loading RoutesBuilder from a Resource.
RoutesLoader	SPI for loading RoutesBuilder from a list of Resource.
RouteStartupOrder	Information about a route to be started where we want to control the order in which they are started by CamelContext.
RouteTemplateLoaderListener	Listener when route templates is loaded from a Resource.
RouteTemplateParameterSource	Source for parameters used when creating routes from route templates.
RuntimeEndpointRegistry	A registry which listen for runtime usage of Endpoint during routing in Camel.
RuntimeEndpointRegistry.Statistic	Statistics gathered about the endpoint.
ScheduledPollConsumerScheduler	A pluggable scheduler for org.apache.camel.support.ScheduledPollConsumer consumers.
ScriptingLanguage	Represents a Language which is a general purpose scripting languages such as groovy, joor and others.
SendDynamicAware	Used for components that can optimise the usage of org.apache.camel.processor.SendDynamicProcessor (toD) to reuse a static Endpoint and Producer that supports using headers to provide the dynamic parts.
SendDynamicAware.DynamicAwareEntry	An entry of detailed information from the recipient uri, which allows the SendDynamicAware implementation to prepare pre- and post- processor and the static uri to be used for the optimised dynamic to.
SharedInternalProcessor	A Shared (thread safe) internal Processor that Camel routing engine used during routing for cross cutting functionality such as: Execute UnitOfWork Keeping track which route currently is being routed Execute RoutePolicy Gather JMX performance statics Tracing Debugging Message History Stream Caching Transformer ...
ShutdownAware	Allows Consumer to fine grained control on shutdown which mostly have to cater for in-memory based components.
ShutdownPrepared	Allows a Service to prepare for shutdown.
ShutdownStrategy	Pluggable shutdown strategy executed during shutdown of Camel and the active routes.
SimpleExecutorService	Marker interface to signal that a ExecutorService is simple and tasks are either only submitted via ExecutorService.submit(Runnable) or executed via Executor.execute(Runnable) methods.
StartupStepRecorder	To record StartupStep during startup to allow to capture diagnostic information to help troubleshoot Camel applications via various tooling such as Java Flight Recorder.
StateRepository<K,V>	This StateRepository holds a set of key/value pairs for defining a particular state of a component.
StreamCachingStrategy	Strategy for using stream caching.
StreamCachingStrategy.SpoolRule	Rule for determine if stream caching should be spooled to disk or kept in-memory.
StreamCachingStrategy.SpoolUsedHeapMemoryLimit	Used for selecting if the memory limit is committed or maximum heap memory setting.
StreamCachingStrategy.Statistics	Utilization statistics of stream caching.
SupervisingRouteController	A supervising capable RouteController that delays the startup of the routes after the camel context startup and takes control of starting the routes in a safe manner.
Synchronization	Provides a hook for custom Processor or Component instances to respond to completed or failed processing of an Exchange rather like Spring's TransactionSynchronization
SynchronizationRouteAware	An extension to Synchronization which provides route awareness capabilities.
SynchronizationVetoable	A vetoable Synchronization.
ThreadPoolFactory	Creates ExecutorService and ScheduledExecutorService objects that work with a thread pool for a given ThreadPoolProfile and ThreadFactory.
ThreadPoolProfile	A profile which defines thread pool settings.
Tracer	SPI for tracing messages.
TransactedPolicy	A marker for defining the policy to be used for applying transaction to routes.
Transformer	Transformer performs message transformation according to the declared data type.
TransformerLoader	A pluggable strategy to load data types into a TransformerRegistry.
TransformerRegistry<K>	Registry to cache transformers in memory.
TransformerResolver<K>	Resolves data type transformers from given transformer key.
TypeConverterLoader	A pluggable strategy to load type converters into a TypeConverterRegistry from some kind of mechanism.
TypeConverterRegistry	Registry for type converters.
TypeConverterRegistry.Statistics	Utilization statistics of the registry.
UnitOfWork	An object representing the unit of work processing an Exchange which allows the use of Synchronization hooks.
UnitOfWorkFactory	Factory to create UnitOfWork.
UriEndpoint	Represents an annotated Camel Endpoint which can have its properties (and the properties on its consumer) injected from the Camel URI path and its query parameters
UriFactoryResolver	A pluggable strategy for resolving different URI factories in a loosely coupled manner.
UriParam	Represents an injection point of a Camel Uri parameter value on an Endpoint or Consumer, usually configured via a URI style query parameter in a URI
UriParams	Used to annotate a nested configuration parameter type (such as a nested Configuration object) which can then be used on a Component, Endpoint and/or Consumer and then be configured via Camel URI query arguments.
UriPath	Represents an injection point of a Camel Uri path value (the remaining part of a Camel URI without any query arguments)
UuidGenerator	Generator to generate UUID strings.
Validator	Validator performs message content validation according to the declared data type.
ValidatorRegistry<K>	Registry to cache validators in memory.
WrapAwareProcessor	An interface to represent an object which wraps a Processor.