Uses of Interface org.apache.camel.CamelContext (Camel

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Uses of Interface
org.apache.camel.CamelContext

Packages that use CamelContext
org.apache.camel	The core Camel API.
org.apache.camel.builder	The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers.
org.apache.camel.builder.xml	Support for XPath based Expressions and Predicates as well as an XSLT processor
org.apache.camel.component.bean	The Bean Component which will look up the bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO
org.apache.camel.component.file	The File Component for working with file systems.
org.apache.camel.component.file.strategy	Strategies for the File Component.
org.apache.camel.component.mock	The Mock Component which is used for testing of routing and mediation rules.
org.apache.camel.component.properties	The Properties Component for lookup of property placeholders for endpoint URI.
org.apache.camel.component.validator	The Validator Component for validating XML against some schema
org.apache.camel.impl	Default implementation classes for Camel Core
org.apache.camel.impl.osgi	Camel OSGi Activator.
org.apache.camel.main	Application level classes that can be used to instantiate camel.
org.apache.camel.management	Camel management
org.apache.camel.management.event	Camel management events
org.apache.camel.management.mbean	Camel management JMX MBeans
org.apache.camel.model	The JAXB POJOs for the XML Configuration of the routing rules.
org.apache.camel.model.dataformat	The JAXB POJOs for the Data Formats used to marshal and unmarshal objects to and from streams inside components
org.apache.camel.model.language	The JAXB POJOs for the Expression and Predicate plugins for the XML Configuration.
org.apache.camel.processor	A collection of Processor implementations which are used to implement the Enterprise Integration Patterns
org.apache.camel.processor.aggregate	Helper classes for the Aggregator pattern.
org.apache.camel.processor.interceptor	Helper classes for interceptors.
org.apache.camel.processor.loadbalancer	Various load balancer processors
org.apache.camel.spi	Service Provider Interfaces used internally by the Camel runtime which are plugin strategies.
org.apache.camel.support	Base classes that help to implement the camel API and are expected to be extended by the user
org.apache.camel.util	Utility classes used by the core of Camel.
org.apache.camel.util.jsse	A collection of utility classes for configuring a JSSE SSLContext and other JSSE classes.
org.apache.camel.view	Helper class to help with the Visualisation of Routes

Uses of CamelContext in org.apache.camel

Methods in org.apache.camel that return CamelContext
`CamelContext`	`CamelContextAware.getCamelContext()` Get the `CamelContext`
`CamelContext`	`ProducerTemplate.getCamelContext()` Get the `CamelContext`
`CamelContext`	`Endpoint.getCamelContext()` Returns the context which created the endpoint
`CamelContext`	`ConsumerTemplate.getCamelContext()` Get the `CamelContext`
`CamelContext`	`Exchange.getContext()` Returns the container so that a processor can resolve endpoints from URIs
`CamelContext`	`VetoCamelContextStartException.getContext()`

Methods in org.apache.camel with parameters of type CamelContext
`void`	`RoutesBuilder.addRoutesToCamelContext(CamelContext context)` Adds the routes from this Route Builder to the CamelContext.
`void`	`StartupListener.onCamelContextStarted(CamelContext context, boolean alreadyStarted)` Callback invoked when the `CamelContext` has just been started.
`void`	`CamelContextAware.setCamelContext(CamelContext camelContext)` Injects the `CamelContext`
`void`	`Endpoint.setCamelContext(CamelContext context)` Sets the camel context.

Constructors in org.apache.camel with parameters of type CamelContext
`VetoCamelContextStartException(String message, CamelContext context)`
`VetoCamelContextStartException(String message, CamelContext context, boolean rethrowException)`
`VetoCamelContextStartException(String message, Throwable cause, CamelContext context)`
`VetoCamelContextStartException(String message, Throwable cause, CamelContext context, boolean rethrowException)`

Uses of CamelContext in org.apache.camel.builder

Methods in org.apache.camel.builder with parameters of type CamelContext
`void`	`RouteBuilder.addRoutesToCamelContext(CamelContext context)`
`static ExchangeBuilder`	`ExchangeBuilder.anExchange(CamelContext context)` Create the exchange by setting the camel context
`protected void`	`ExpressionClauseSupport.configureExpression(CamelContext camelContext, Expression expression)`
`protected Expression`	`ExpressionClauseSupport.createExpression(CamelContext camelContext)`
`protected ScheduledExecutorService`	`DefaultErrorHandlerBuilder.getExecutorService(CamelContext camelContext)`
`Predicate`	`DefaultErrorHandlerBuilder.getRetryWhilePolicy(CamelContext context)`
`void`	`BuilderSupport.setContext(CamelContext context)` Deprecated.

Constructors in org.apache.camel.builder with parameters of type CamelContext
`BuilderSupport(CamelContext context)`
`ExchangeBuilder(CamelContext context)`
`NotifyBuilder(CamelContext context)` Creates a new builder.
`ProxyBuilder(CamelContext camelContext)`
`RouteBuilder(CamelContext context)`
`ThreadPoolBuilder(CamelContext context)`

Uses of CamelContext in org.apache.camel.builder.xml

Methods in org.apache.camel.builder.xml with parameters of type CamelContext

String XPathBuilder.evaluate(CamelContext context, Object body)
Evaluates the given xpath using the provided body as a String return type.





<T> T

XPathBuilder.evaluate(CamelContext context,
                 Object body,
                 Class<T> type)

Evaluates the given xpath using the provided body.

boolean XPathBuilder.matches(CamelContext context, Object body)
Matches the given xpath using the provided body.

Uses of CamelContext in org.apache.camel.component.bean

Methods in org.apache.camel.component.bean that return CamelContext
`CamelContext`	`BeanInfo.getCamelContext()`
`CamelContext`	`RegistryBean.getContext()`

Methods in org.apache.camel.component.bean with parameters of type CamelContext
`Expression`	`BeanAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)`
`Expression`	`XPathAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)`
`Expression`	`AnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)`
`Expression`	`DefaultAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)`
`static ParameterMappingStrategy`	`BeanInfo.createParameterMappingStrategy(CamelContext camelContext)`
`protected static ExecutorService`	`AbstractCamelInvocationHandler.getExecutorService(CamelContext context)`
`protected static Class<?>`	`AbstractCamelInvocationHandler.getGenericType(CamelContext context, Type type)`

Constructors in org.apache.camel.component.bean with parameters of type CamelContext
`BeanInfo(CamelContext camelContext, Class<?> type)`
`BeanInfo(CamelContext camelContext, Class<?> type, Method explicitMethod, ParameterMappingStrategy strategy)`
`BeanInfo(CamelContext camelContext, Class<?> type, ParameterMappingStrategy strategy)`
`BeanInfo(CamelContext camelContext, Method explicitMethod)`
`BeanProcessor(Object pojo, CamelContext camelContext)`
`BeanProcessor(Object pojo, CamelContext camelContext, ParameterMappingStrategy parameterMappingStrategy)`
`ConstantBeanHolder(Object bean, CamelContext context)`
`ConstantBeanHolder(Object bean, CamelContext context, ParameterMappingStrategy parameterMappingStrategy)`
`ConstantTypeBeanHolder(Class<?> type, CamelContext context)`
`ConstantTypeBeanHolder(Class<?> type, CamelContext context, ParameterMappingStrategy parameterMappingStrategy)`
`MethodInfo(CamelContext camelContext, Class<?> type, Method method, List<ParameterInfo> parameters, List<ParameterInfo> bodyParameters, boolean hasCustomAnnotation, boolean hasHandlerAnnotation)`
`MethodInfoCache(CamelContext camelContext)`
`MethodInfoCache(CamelContext camelContext, int classCacheSize, int methodCacheSize)`
`MethodInfoCache(CamelContext camelContext, Map<Class<?>,BeanInfo> classCache, Map<Method,MethodInfo> methodCache)`
`RegistryBean(CamelContext context, String name)`
`RegistryBean(Registry registry, CamelContext context, String name)`

Uses of CamelContext in org.apache.camel.component.file

Methods in org.apache.camel.component.file with parameters of type CamelContext
`static Comparator<Exchange>`	`GenericFileDefaultSorter.sortByFileLanguage(CamelContext context, String expression, boolean reverse)` Returns a new sory by file language expression
`static Comparator<Exchange>`	`GenericFileDefaultSorter.sortByFileLanguage(CamelContext context, String expression, boolean reverse, boolean ignoreCase)` Returns a new sory by file language expression
`static Comparator<Exchange>`	`GenericFileDefaultSorter.sortByFileLanguage(CamelContext context, String expression, boolean reverse, boolean ignoreCase, Comparator<Exchange> nested)` Returns a new sort by file language expression

Constructors in org.apache.camel.component.file with parameters of type CamelContext
`FileComponent(CamelContext context)`
`GenericFileComponent(CamelContext context)`

Uses of CamelContext in org.apache.camel.component.file.strategy

Methods in org.apache.camel.component.file.strategy with parameters of type CamelContext

static GenericFileProcessStrategy<File> FileProcessStrategyFactory.createGenericFileProcessStrategy(CamelContext context, Map<String,Object> params)

static



<T> GenericFileProcessStrategy<T>

GenericFileProcessStrategyFactory.createGenericFileProcessStrategy(CamelContext context,
                                                                 Map<String,Object> params)

Uses of CamelContext in org.apache.camel.component.mock

Methods in org.apache.camel.component.mock with parameters of type CamelContext
`static void`	`MockEndpoint.assertIsSatisfied(CamelContext context)` Asserts that all the expectations on any `MockEndpoint` instances registered in the given context are valid
`static void`	`MockEndpoint.assertIsSatisfied(CamelContext context, long timeout, TimeUnit unit)` Asserts that all the expectations on any `MockEndpoint` instances registered in the given context are valid
`static void`	`MockEndpoint.resetMocks(CamelContext context)` Reset all mock endpoints
`static MockEndpoint`	`MockEndpoint.resolve(CamelContext context, String uri)` A helper method to resolve the mock endpoint of the given URI on the given context
`static void`	`MockEndpoint.setAssertPeriod(CamelContext context, long period)` Sets the assert period on all the expectations on any `MockEndpoint` instances registered in the given context.

Uses of CamelContext in org.apache.camel.component.properties

Methods in org.apache.camel.component.properties with parameters of type CamelContext
`protected Properties`	`DefaultPropertiesResolver.loadPropertiesFromClasspath(CamelContext context, boolean ignoreMissingLocation, String path)`
`protected Properties`	`DefaultPropertiesResolver.loadPropertiesFromFilePath(CamelContext context, boolean ignoreMissingLocation, String path)`
`protected Properties`	`DefaultPropertiesResolver.loadPropertiesFromRegistry(CamelContext context, boolean ignoreMissingLocation, String path)`
`Properties`	`PropertiesResolver.resolveProperties(CamelContext context, boolean ignoreMissingLocation, String... uri)` Resolve properties from the given uri
`Properties`	`DefaultPropertiesResolver.resolveProperties(CamelContext context, boolean ignoreMissingLocation, String... uri)`

Uses of CamelContext in org.apache.camel.component.validator

Constructors in org.apache.camel.component.validator with parameters of type CamelContext
`DefaultLSResourceResolver(CamelContext camelContext, String resourceUri)`

Uses of CamelContext in org.apache.camel.impl

Classes in org.apache.camel.impl that implement CamelContext
`class`	`DefaultCamelContext` Represents the context used to configure routes and the policies to use.

Fields in org.apache.camel.impl declared as CamelContext
`protected CamelContext`	`DefaultCamelBeanPostProcessor.camelContext`
`protected CamelContext`	`DefaultExchange.context`

Methods in org.apache.camel.impl that return CamelContext
`CamelContext`	`UriEndpointConfiguration.getCamelContext()`
`CamelContext`	`DefaultDebugger.getCamelContext()`
`CamelContext`	`UriComponentConfiguration.getCamelContext()`
`CamelContext`	`DefaultShutdownStrategy.getCamelContext()`
`CamelContext`	`DefaultRouteContext.getCamelContext()`
`CamelContext`	`DefaultEndpoint.getCamelContext()`
`CamelContext`	`DefaultStreamCachingStrategy.getCamelContext()`
`CamelContext`	`RouteService.getCamelContext()`
`CamelContext`	`CamelPostProcessorHelper.getCamelContext()`
`CamelContext`	`DefaultScheduledPollConsumerScheduler.getCamelContext()`
`CamelContext`	`DefaultConsumerTemplate.getCamelContext()`
`CamelContext`	`ProducerCache.getCamelContext()`
`CamelContext`	`DefaultProducerTemplate.getCamelContext()`
`CamelContext`	`ConsumerCache.getCamelContext()`
`protected CamelContext`	`DefaultEndpointConfiguration.getCamelContext()`
`CamelContext`	`DefaultComponent.getCamelContext()`
`CamelContext`	`InterceptSendToEndpoint.getCamelContext()`
`CamelContext`	`ThrottlingInflightRoutePolicy.getCamelContext()`
`CamelContext`	`DefaultExchange.getContext()`
`CamelContext`	`DefaultConsumerTemplate.getContext()` Deprecated. use `DefaultConsumerTemplate.getCamelContext()`
`CamelContext`	`DefaultProducerTemplate.getContext()` Deprecated. use `DefaultProducerTemplate.getCamelContext()`
`CamelContext`	`DefaultCamelBeanPostProcessor.getOrLookupCamelContext()` Strategy to get the `CamelContext` to use.

Methods in org.apache.camel.impl with parameters of type CamelContext

static EndpointConfiguration ConfigurationHelper.createConfiguration(String uri, CamelContext context)

protected boolean DefaultShutdownStrategy.doShutdown(CamelContext context, List<RouteStartupOrder> routes, long timeout, TimeUnit timeUnit, boolean suspendOnly, boolean abortAfterTimeout, boolean forceShutdown)

protected Class<?> DefaultLanguageResolver.findLanguage(String name, CamelContext context)

protected Class<?> DefaultLanguageResolver.findLanguageResolver(String name, CamelContext context)

static DefaultProducerTemplate DefaultProducerTemplate.newInstance(CamelContext camelContext, String defaultEndpointUri)

protected Language DefaultLanguageResolver.noSpecificLanguageFound(String name, CamelContext context)

static void ConfigurationHelper.populateFromURI(CamelContext camelContext, EndpointConfiguration config, ConfigurationHelper.ParameterSetter setter)

Component DefaultComponentResolver.resolveComponent(String name, CamelContext context)

DataFormat DefaultDataFormatResolver.resolveDataFormat(String name, CamelContext context)

Language DefaultLanguageResolver.resolveLanguage(String name, CamelContext context)





<T> void

ConfigurationHelper.ParameterSetter.set(CamelContext camelContext,
       EndpointConfiguration config,
       String name,
       T value)

Sets the parameter on the configuration.





<T> void

ConfigurationHelper.FieldParameterSetter.set(CamelContext camelContext,
       EndpointConfiguration config,
       String name,
       T value)

void DefaultDebugger.setCamelContext(CamelContext camelContext)

void DefaultShutdownStrategy.setCamelContext(CamelContext camelContext)

void DefaultEndpoint.setCamelContext(CamelContext camelContext)

void DefaultStreamCachingStrategy.setCamelContext(CamelContext camelContext)

void CamelPostProcessorHelper.setCamelContext(CamelContext camelContext)

void DefaultScheduledPollConsumerScheduler.setCamelContext(CamelContext camelContext)

void DefaultComponent.setCamelContext(CamelContext context)

void InterceptSendToEndpoint.setCamelContext(CamelContext context)

void ThrottlingInflightRoutePolicy.setCamelContext(CamelContext camelContext)

static



<T> void

ConfigurationHelper.setConfigurationField(CamelContext camelContext,
                                           EndpointConfiguration config,
                                           String name,
                                           T value)

void DefaultShutdownStrategy.shutdown(CamelContext context, List<RouteStartupOrder> routes)

void DefaultShutdownStrategy.shutdown(CamelContext context, List<RouteStartupOrder> routes, long timeout, TimeUnit timeUnit)

boolean DefaultShutdownStrategy.shutdown(CamelContext context, RouteStartupOrder route, long timeout, TimeUnit timeUnit, boolean abortAfterTimeout)

void DefaultShutdownStrategy.shutdownForced(CamelContext context, List<RouteStartupOrder> routes)

void DefaultShutdownStrategy.suspend(CamelContext context, List<RouteStartupOrder> routes)

void DefaultShutdownStrategy.suspend(CamelContext context, List<RouteStartupOrder> routes, long timeout, TimeUnit timeUnit)

Constructors in org.apache.camel.impl with parameters of type CamelContext
`CamelPostProcessorHelper(CamelContext camelContext)`
`ConsumerCache(Object source, CamelContext camelContext)`
`ConsumerCache(Object source, CamelContext camelContext, int cacheSize)`
`ConsumerCache(Object source, CamelContext camelContext, Map<String,PollingConsumer> cache)`
`DefaultCamelBeanPostProcessor(CamelContext camelContext)`
`DefaultComponent(CamelContext context)`
`DefaultConsumerTemplate(CamelContext camelContext)`
`DefaultDebugger(CamelContext camelContext)`
`DefaultEndpoint(String endpointUri, CamelContext camelContext)` Deprecated.
`DefaultEndpointConfiguration(CamelContext camelContext)`
`DefaultEndpointConfiguration(CamelContext camelContext, String uri)`
`DefaultExchange(CamelContext context)`
`DefaultExchange(CamelContext context, ExchangePattern pattern)`
`DefaultExecutorServiceManager(CamelContext camelContext)`
`DefaultExecutorServiceStrategy(CamelContext camelContext)` Deprecated.
`DefaultInjector(CamelContext context)`
`DefaultManagementNameStrategy(CamelContext camelContext)`
`DefaultManagementNameStrategy(CamelContext camelContext, String defaultPattern, String nextPattern)`
`DefaultPollingEndpoint(String endpointUri, CamelContext context)` Deprecated.
`DefaultProducerTemplate(CamelContext camelContext)`
`DefaultProducerTemplate(CamelContext camelContext, Endpoint defaultEndpoint)`
`DefaultProducerTemplate(CamelContext camelContext, ExecutorService executor)`
`DefaultRouteContext(CamelContext camelContext)` Only used for lazy construction from inside ExpressionType
`DefaultRouteContext(CamelContext camelContext, RouteDefinition route, FromDefinition from, Collection<Route> routes)`
`DefaultShutdownStrategy(CamelContext camelContext)`
`EndpointRegistry(CamelContext context)`
`EndpointRegistry(CamelContext context, Map<org.apache.camel.impl.EndpointKey,Endpoint> endpoints)`
`HeaderFilterStrategyComponent(CamelContext context)`
`LoggingExceptionHandler(CamelContext camelContext, CamelLogger logger)`
`LoggingExceptionHandler(CamelContext camelContext, Class<?> ownerType)`
`LoggingExceptionHandler(CamelContext camelContext, Class<?> ownerType, LoggingLevel level)`
`ProcessorEndpoint(String endpointUri, CamelContext context, Processor processor)`
`ProducerCache(Object source, CamelContext camelContext)`
`ProducerCache(Object source, CamelContext camelContext, int cacheSize)`
`ProducerCache(Object source, CamelContext camelContext, Map<String,Producer> cache)`
`ProducerCache(Object source, CamelContext camelContext, ServicePool<Endpoint,Producer> producerServicePool, Map<String,Producer> cache)`
`PropertyPlaceholderDelegateRegistry(CamelContext context, Registry delegate)`
`ScheduledPollEndpoint(String endpointUri, CamelContext context)` Deprecated.
`UriEndpointComponent(CamelContext context, Class<? extends Endpoint> endpointClass)`
`UriEndpointConfiguration(CamelContext camelContext, Endpoint endpoint, String uriText)`

Uses of CamelContext in org.apache.camel.impl.osgi

Methods in org.apache.camel.impl.osgi with parameters of type CamelContext
`protected T`	`Activator.BaseResolver.createInstance(String name, String path, CamelContext context)`
`Component`	`Activator.BundleComponentResolver.resolveComponent(String name, CamelContext context)`
`DataFormat`	`Activator.BundleDataFormatResolver.resolveDataFormat(String name, CamelContext context)`
`DataFormatDefinition`	`Activator.BundleDataFormatResolver.resolveDataFormatDefinition(String name, CamelContext context)`
`Language`	`Activator.BundleLanguageResolver.resolveLanguage(String name, CamelContext context)`
`Language`	`Activator.BundleMetaLanguageResolver.resolveLanguage(String name, CamelContext context)`

Uses of CamelContext in org.apache.camel.main

Fields in org.apache.camel.main with type parameters of type CamelContext
`protected List<CamelContext>`	`MainSupport.camelContexts`

Methods in org.apache.camel.main that return CamelContext
`protected CamelContext`	`Main.createContext()`

Methods in org.apache.camel.main that return types with arguments of type CamelContext
`protected Map<String,CamelContext>`	`Main.getCamelContextMap()`
`protected abstract Map<String,CamelContext>`	`MainSupport.getCamelContextMap()`
`List<CamelContext>`	`MainSupport.getCamelContexts()`

Methods in org.apache.camel.main with parameters of type CamelContext
`protected void`	`MainSupport.generateDot(String name, CamelContext camelContext, int size)`
`protected void`	`MainSupport.loadRouteBuilders(CamelContext camelContext)`
`protected void`	`MainSupport.postProcessCamelContext(CamelContext camelContext)`

Uses of CamelContext in org.apache.camel.management

Fields in org.apache.camel.management declared as CamelContext
`protected CamelContext`	`DefaultManagementMBeanAssembler.camelContext`
`protected CamelContext`	`DefaultManagementNamingStrategy.camelContext`

Methods in org.apache.camel.management that return CamelContext
`CamelContext`	`PublishEventNotifier.getCamelContext()`
`CamelContext`	`DefaultManagementLifecycleStrategy.getCamelContext()`
`CamelContext`	`DefaultManagementStrategy.getCamelContext()`
`CamelContext`	`DefaultManagementNamingStrategy.getCamelContext()`
`CamelContext`	`DefaultManagementAgent.getCamelContext()`

Methods in org.apache.camel.management with parameters of type CamelContext
`ManagementStrategy`	`ManagementStrategyFactory.create(CamelContext context, boolean disableJMX)`
`protected String`	`DefaultManagementNamingStrategy.getContextId(CamelContext context)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForCamelContext(CamelContext context)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForComponent(CamelContext context, Component component, String name)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForConsumer(CamelContext context, Consumer consumer)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForEndpoint(CamelContext context, Endpoint endpoint)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForErrorHandler(CamelContext context, RouteContext routeContext, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForEventNotifier(CamelContext context, EventNotifier eventNotifier)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition, Route route)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForProducer(CamelContext context, Producer producer)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForRoute(CamelContext context, Route route)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForService(CamelContext context, Service service)`
`Object`	`DefaultManagementObjectStrategy.getManagedObjectForThreadPool(CamelContext context, ThreadPoolExecutor threadPool, String id, String sourceId, String routeId, String threadPoolProfileId)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForCamelContext(CamelContext context)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForConsumer(CamelContext context, Consumer consumer)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForEventNotifier(CamelContext context, EventNotifier eventNotifier)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForProcessor(CamelContext context, Processor processor, NamedNode definition)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForProducer(CamelContext context, Producer producer)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForService(CamelContext context, Service service)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForThreadPool(CamelContext context, ThreadPoolExecutor threadPool, String id, String sourceId)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForTracer(CamelContext context, InterceptStrategy tracer)`
`void`	`DefaultManagementLifecycleStrategy.onContextStart(CamelContext context)`
`void`	`DefaultManagementLifecycleStrategy.onContextStop(CamelContext context)`
`void`	`DefaultManagementLifecycleStrategy.onServiceAdd(CamelContext context, Service service, Route route)`
`void`	`DefaultManagementLifecycleStrategy.onServiceRemove(CamelContext context, Service service, Route route)`
`void`	`DefaultManagementLifecycleStrategy.onThreadPoolAdd(CamelContext camelContext, ThreadPoolExecutor threadPool, String id, String sourceId, String routeId, String threadPoolProfileId)`
`void`	`DefaultManagementLifecycleStrategy.onThreadPoolRemove(CamelContext camelContext, ThreadPoolExecutor threadPool)`
`void`	`PublishEventNotifier.setCamelContext(CamelContext camelContext)`
`void`	`DefaultManagementLifecycleStrategy.setCamelContext(CamelContext camelContext)`
`void`	`DefaultManagementStrategy.setCamelContext(CamelContext camelContext)`
`void`	`DefaultManagementNamingStrategy.setCamelContext(CamelContext camelContext)`
`void`	`DefaultManagementAgent.setCamelContext(CamelContext camelContext)`
`Processor`	`InstrumentationInterceptStrategy.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)`

Constructors in org.apache.camel.management with parameters of type CamelContext
`DefaultManagementAgent(CamelContext camelContext)`
`DefaultManagementLifecycleStrategy(CamelContext camelContext)`
`DefaultManagementMBeanAssembler(CamelContext camelContext)`
`DefaultManagementStrategy(CamelContext camelContext)`
`ManagedManagementStrategy(CamelContext camelContext, ManagementAgent managementAgent)`
`MBeanInfoAssembler(CamelContext camelContext)`

Uses of CamelContext in org.apache.camel.management.event

Methods in org.apache.camel.management.event that return CamelContext
`CamelContext`	`CamelContextStoppingEvent.getContext()`
`CamelContext`	`ServiceStopFailureEvent.getContext()`
`CamelContext`	`CamelContextResumingEvent.getContext()`
`CamelContext`	`CamelContextStoppedEvent.getContext()`
`CamelContext`	`CamelContextStartedEvent.getContext()`
`CamelContext`	`CamelContextStopFailureEvent.getContext()`
`CamelContext`	`CamelContextStartupFailureEvent.getContext()`
`CamelContext`	`CamelContextSuspendingEvent.getContext()`
`CamelContext`	`CamelContextSuspendedEvent.getContext()`
`CamelContext`	`CamelContextResumedEvent.getContext()`
`CamelContext`	`CamelContextResumeFailureEvent.getContext()`
`CamelContext`	`CamelContextStartingEvent.getContext()`
`CamelContext`	`ServiceStartupFailureEvent.getContext()`

Methods in org.apache.camel.management.event with parameters of type CamelContext
`EventObject`	`DefaultEventFactory.createCamelContextResumedEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextResumeFailureEvent(CamelContext context, Throwable cause)`
`EventObject`	`DefaultEventFactory.createCamelContextResumingEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextStartedEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextStartingEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextStartupFailureEvent(CamelContext context, Throwable cause)`
`EventObject`	`DefaultEventFactory.createCamelContextStopFailureEvent(CamelContext context, Throwable cause)`
`EventObject`	`DefaultEventFactory.createCamelContextStoppedEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextStoppingEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextSuspendedEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextSuspendingEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createServiceStartupFailureEvent(CamelContext context, Object service, Throwable cause)`
`EventObject`	`DefaultEventFactory.createServiceStopFailureEvent(CamelContext context, Object service, Throwable cause)`

Constructors in org.apache.camel.management.event with parameters of type CamelContext
`CamelContextResumedEvent(CamelContext source)`
`CamelContextResumeFailureEvent(CamelContext context, Throwable cause)`
`CamelContextResumingEvent(CamelContext source)`
`CamelContextStartedEvent(CamelContext source)`
`CamelContextStartingEvent(CamelContext source)`
`CamelContextStartupFailureEvent(CamelContext context, Throwable cause)`
`CamelContextStopFailureEvent(CamelContext context, Throwable cause)`
`CamelContextStoppedEvent(CamelContext source)`
`CamelContextStoppingEvent(CamelContext source)`
`CamelContextSuspendedEvent(CamelContext source)`
`CamelContextSuspendingEvent(CamelContext source)`
`ServiceStartupFailureEvent(CamelContext context, Object service, Throwable cause)`
`ServiceStopFailureEvent(CamelContext context, Object service, Throwable cause)`

Uses of CamelContext in org.apache.camel.management.mbean

Methods in org.apache.camel.management.mbean that return CamelContext
`CamelContext`	`ManagedStreamCachingStrategy.getCamelContext()`
`CamelContext`	`ManagedEventNotifier.getContext()`
`CamelContext`	`ManagedBacklogDebugger.getContext()`
`CamelContext`	`ManagedThreadPool.getContext()`
`CamelContext`	`ManagedRoute.getContext()`
`CamelContext`	`ManagedProcessor.getContext()`
`CamelContext`	`ManagedService.getContext()`
`CamelContext`	`ManagedTracer.getContext()`
`CamelContext`	`ManagedCamelContext.getContext()`
`CamelContext`	`ManagedBacklogTracer.getContext()`

Constructors in org.apache.camel.management.mbean with parameters of type CamelContext
`ManagedBacklogDebugger(CamelContext camelContext, BacklogDebugger backlogDebugger)`
`ManagedBacklogTracer(CamelContext camelContext, BacklogTracer backlogTracer)`
`ManagedBeanProcessor(CamelContext context, BeanProcessor processor, ProcessorDefinition<?> definition)`
`ManagedConsumer(CamelContext context, Consumer consumer)`
`ManagedConsumerCache(CamelContext context, ConsumerCache consumerCache)`
`ManagedDelayer(CamelContext context, Delayer delayer, ProcessorDefinition<?> definition)`
`ManagedEndpointRegistry(CamelContext context, EndpointRegistry endpointRegistry)`
`ManagedEventNotifier(CamelContext context, EventNotifier eventNotifier)`
`ManagedIdempotentConsumer(CamelContext context, IdempotentConsumer idempotentConsumer, ProcessorDefinition<?> definition)`
`ManagedProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition)`
`ManagedProducer(CamelContext context, Producer producer)`
`ManagedProducerCache(CamelContext context, ProducerCache producerCache)`
`ManagedScheduledPollConsumer(CamelContext context, ScheduledPollConsumer consumer)`
`ManagedSendProcessor(CamelContext context, SendProcessor processor, ProcessorDefinition<?> definition)`
`ManagedService(CamelContext context, Service service)`
`ManagedStreamCachingStrategy(CamelContext camelContext, StreamCachingStrategy streamCachingStrategy)`
`ManagedThreadPool(CamelContext camelContext, ThreadPoolExecutor threadPool, String id, String sourceId, String routeId, String threadPoolProfileId)`
`ManagedThrottler(CamelContext context, Throttler throttler, ProcessorDefinition<?> definition)`
`ManagedThrottlingInflightRoutePolicy(CamelContext context, ThrottlingInflightRoutePolicy policy)`
`ManagedThroughputLogger(CamelContext context, ThroughputLogger logger, ProcessorDefinition<?> definition)`
`ManagedTracer(CamelContext camelContext, Tracer tracer)`
`ManagedTypeConverterRegistry(CamelContext context, TypeConverterRegistry registry)`

Uses of CamelContext in org.apache.camel.model

Subinterfaces of CamelContext in org.apache.camel.model
`interface`	`ModelCamelContext` Model level interface for the `CamelContext`

Methods in org.apache.camel.model with parameters of type CamelContext
`protected RouteContext`	`RouteDefinition.addRoutes(CamelContext camelContext, Collection<Route> routes, FromDefinition fromType)`
`RouteDefinition`	`RouteDefinition.adviceWith(CamelContext camelContext, RouteBuilder builder)` Deprecated.
`protected void`	`DataFormatDefinition.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)` Allows derived classes to customize the data format
`protected List<Class<? extends Throwable>>`	`CatchDefinition.createExceptionClasses(CamelContext context)`
`RedeliveryPolicy`	`RedeliveryPolicyDefinition.createRedeliveryPolicy(CamelContext context, RedeliveryPolicy parentPolicy)`
`RedeliveryPolicy`	`OnExceptionDefinition.createRedeliveryPolicy(CamelContext context, RedeliveryPolicy parentPolicy)` Allows an exception handler to create a new redelivery policy for this exception type
`RouteBuilder`	`RouteBuilderDefinition.createRouteBuilder(CamelContext camelContext)`
`RoutesBuilder`	`RouteBuilderDefinition.createRoutes(CamelContext camelContext)`
`static void`	`RouteDefinitionHelper.forceAssignIds(CamelContext context, List<RouteDefinition> routes)` Force assigning ids to the routes
`static void`	`RouteDefinitionHelper.forceAssignIds(CamelContext context, ProcessorDefinition processor)` Force assigning ids to the give node and all its children (recursively).
`ServiceStatus`	`RouteDefinition.getStatus(CamelContext camelContext)` Returns the status of the route if it has been registered with a `CamelContext`
`boolean`	`RedeliveryPolicyDefinition.isAsyncDelayedRedelivery(CamelContext context)`
`boolean`	`OnExceptionDefinition.isAsyncDelayedRedelivery(CamelContext context)`
`boolean`	`RouteDefinition.isAutoStartup(CamelContext camelContext)`
`boolean`	`RouteDefinition.isContextScopedErrorHandler(CamelContext context)`
`boolean`	`RouteDefinition.isStartable(CamelContext camelContext)`
`boolean`	`RouteDefinition.isStoppable(CamelContext camelContext)`
`List<RouteDefinition>`	`RouteContextRefDefinition.lookupRoutes(CamelContext camelContext)`
`static List<RouteDefinition>`	`RouteContextRefDefinitionHelper.lookupRoutes(CamelContext camelContext, String ref)` Lookup the routes from the `RouteContextRefDefinition`.
`Endpoint`	`RouteDefinition.resolveEndpoint(CamelContext camelContext, String uri)`
`protected void`	`DataFormatDefinition.setProperty(CamelContext camelContext, Object bean, String name, Object value)` Sets a named property on the data format instance using introspection

Uses of CamelContext in org.apache.camel.model.dataformat

Methods in org.apache.camel.model.dataformat with parameters of type CamelContext
`protected void`	`BeanioDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`Base64DataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`JsonDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`TidyMarkupDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`ProtobufDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`AvroDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`CryptoDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`HL7DataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`PGPDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`XStreamDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`XmlJsonDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`BindyDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`CastorDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`XmlRpcDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`XMLSecurityDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`CsvDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`SoapJaxbDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`ZipFileDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`JibxDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`
`protected void`	`JaxbDataFormat.configureDataFormat(DataFormat dataFormat, CamelContext camelContext)`

Uses of CamelContext in org.apache.camel.model.language

Methods in org.apache.camel.model.language with parameters of type CamelContext
`protected void`	`JXPathExpression.configureExpression(CamelContext camelContext, Expression expression)`
`protected void`	`NamespaceAwareExpression.configureExpression(CamelContext camelContext, Expression expression)`
`protected void`	`XPathExpression.configureExpression(CamelContext camelContext, Expression expression)`
`protected void`	`XQueryExpression.configureExpression(CamelContext camelContext, Expression expression)`
`protected void`	`JsonPathExpression.configureExpression(CamelContext camelContext, Expression expression)`
`protected void`	`ExpressionDefinition.configureExpression(CamelContext camelContext, Expression expression)`
`protected void`	`JXPathExpression.configurePredicate(CamelContext camelContext, Predicate predicate)`
`protected void`	`NamespaceAwareExpression.configurePredicate(CamelContext camelContext, Predicate predicate)`
`protected void`	`XPathExpression.configurePredicate(CamelContext camelContext, Predicate predicate)`
`protected void`	`XQueryExpression.configurePredicate(CamelContext camelContext, Predicate predicate)`
`protected void`	`JsonPathExpression.configurePredicate(CamelContext camelContext, Predicate predicate)`
`protected void`	`ExpressionDefinition.configurePredicate(CamelContext camelContext, Predicate predicate)`
`Expression`	`SimpleExpression.createExpression(CamelContext camelContext)`
`Expression`	`TokenizerExpression.createExpression(CamelContext camelContext)`
`Expression`	`XPathExpression.createExpression(CamelContext camelContext)`
`Expression`	`XQueryExpression.createExpression(CamelContext camelContext)`
`Expression`	`MethodCallExpression.createExpression(CamelContext camelContext)`
`Expression`	`JsonPathExpression.createExpression(CamelContext camelContext)`
`Expression`	`ExpressionDefinition.createExpression(CamelContext camelContext)`
`Predicate`	`SimpleExpression.createPredicate(CamelContext camelContext)`
`Predicate`	`TokenizerExpression.createPredicate(CamelContext camelContext)`
`Predicate`	`XPathExpression.createPredicate(CamelContext camelContext)`
`Predicate`	`MethodCallExpression.createPredicate(CamelContext camelContext)`
`Predicate`	`ExpressionDefinition.createPredicate(CamelContext camelContext)`
`protected void`	`MethodCallExpression.validateHasMethod(CamelContext context, Object bean, Class<?> type, String method)` Validates the given bean has the method.

Uses of CamelContext in org.apache.camel.processor

Fields in org.apache.camel.processor declared as CamelContext
`protected CamelContext`	`RedeliveryErrorHandler.camelContext`
`protected CamelContext`	`SendProcessor.camelContext`
`protected CamelContext`	`RoutingSlip.camelContext`

Methods in org.apache.camel.processor that return CamelContext
`CamelContext`	`UnmarshalProcessor.getCamelContext()`
`CamelContext`	`OnCompletionProcessor.getCamelContext()`
`CamelContext`	`MarshalProcessor.getCamelContext()`
`CamelContext`	`MulticastProcessor.getCamelContext()`

Methods in org.apache.camel.processor with parameters of type CamelContext
`static Processor`	`Pipeline.newInstance(CamelContext camelContext, List<Processor> processors)`
`void`	`UnmarshalProcessor.setCamelContext(CamelContext camelContext)`
`void`	`MarshalProcessor.setCamelContext(CamelContext camelContext)`

Constructors in org.apache.camel.processor with parameters of type CamelContext
`BatchProcessor(CamelContext camelContext, Processor processor, Collection<Exchange> collection, Expression expression)` Deprecated.
`DeadLetterChannel(CamelContext camelContext, Processor output, CamelLogger logger, Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy, ExceptionPolicyStrategy exceptionPolicyStrategy, Processor deadLetter, String deadLetterUri, boolean useOriginalBodyPolicy, Predicate retryWhile, ScheduledExecutorService executorService)` Creates the dead letter channel.
`DefaultErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger, Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy, ExceptionPolicyStrategy exceptionPolicyStrategy, Predicate retryWhile, ScheduledExecutorService executorService)` Creates the default error handler.
`Delayer(CamelContext camelContext, Processor processor, Expression delay, ScheduledExecutorService executorService, boolean shutdownExecutorService)`
`DelayProcessorSupport(CamelContext camelContext, Processor processor)`
`DelayProcessorSupport(CamelContext camelContext, Processor processor, ScheduledExecutorService executorService, boolean shutdownExecutorService)`
`DynamicRouter(CamelContext camelContext)`
`DynamicRouter(CamelContext camelContext, Expression expression, String uriDelimiter)`
`LoggingErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger, RedeliveryPolicy redeliveryPolicy, ExceptionPolicyStrategy exceptionPolicyStrategy)` Creates the logging error handler.
`MulticastProcessor(CamelContext camelContext, Collection<Processor> processors)`
`MulticastProcessor(CamelContext camelContext, Collection<Processor> processors, AggregationStrategy aggregationStrategy)`
`MulticastProcessor(CamelContext camelContext, Collection<Processor> processors, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean shutdownExecutorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean shareUnitOfWork)`
`OnCompletionProcessor(CamelContext camelContext, Processor processor, ExecutorService executorService, boolean shutdownExecutorService, boolean onCompleteOnly, boolean onFailureOnly, Predicate onWhen, boolean useOriginalBody)`
`Pipeline(CamelContext camelContext, Collection<Processor> processors)`
`RecipientList(CamelContext camelContext)`
`RecipientList(CamelContext camelContext, Expression expression)`
`RecipientList(CamelContext camelContext, Expression expression, String delimiter)`
`RecipientList(CamelContext camelContext, String delimiter)`
`RecipientListProcessor(CamelContext camelContext, ProducerCache producerCache, Iterator<Object> iter)`
`RecipientListProcessor(CamelContext camelContext, ProducerCache producerCache, Iterator<Object> iter, AggregationStrategy aggregationStrategy)`
`RecipientListProcessor(CamelContext camelContext, ProducerCache producerCache, Iterator<Object> iter, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean shutdownExecutorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean shareUnitOfWork)`
`RedeliveryErrorHandler(CamelContext camelContext, Processor output, CamelLogger logger, Processor redeliveryProcessor, RedeliveryPolicy redeliveryPolicy, Processor deadLetter, String deadLetterUri, boolean useOriginalMessagePolicy, Predicate retryWhile, ScheduledExecutorService executorService)`
`Resequencer(CamelContext camelContext, Processor processor, Expression expression)`
`Resequencer(CamelContext camelContext, Processor processor, Expression expression, boolean allowDuplicates, boolean reverse)`
`Resequencer(CamelContext camelContext, Processor processor, Set<Exchange> collection, Expression expression)`
`RoutingSlip(CamelContext camelContext)`
`RoutingSlip(CamelContext camelContext, Expression expression, String uriDelimiter)`
`Splitter(CamelContext camelContext, Expression expression, Processor destination, AggregationStrategy aggregationStrategy)`
`Splitter(CamelContext camelContext, Expression expression, Processor destination, AggregationStrategy aggregationStrategy, boolean parallelProcessing, ExecutorService executorService, boolean shutdownExecutorService, boolean streaming, boolean stopOnException, long timeout, Processor onPrepare, boolean useSubUnitOfWork)`
`StreamResequencer(CamelContext camelContext, Processor processor, SequenceElementComparator<Exchange> comparator)` Creates a new `StreamResequencer` instance.
`ThreadsProcessor(CamelContext camelContext, ExecutorService executorService, boolean shutdownExecutorService)`
`Throttler(CamelContext camelContext, Processor processor, Expression maxRequestsPerPeriodExpression, long timePeriodMillis, ScheduledExecutorService executorService, boolean shutdownExecutorService)`
`ThroughputLogger(CamelLogger log, CamelContext camelContext, Long groupInterval, Long groupDelay, Boolean groupActiveOnly)`

Uses of CamelContext in org.apache.camel.processor.aggregate

Methods in org.apache.camel.processor.aggregate that return CamelContext
`CamelContext`	`AggregationStrategyBeanAdapter.getCamelContext()`

Methods in org.apache.camel.processor.aggregate with parameters of type CamelContext
`Exchange`	`MemoryAggregationRepository.add(CamelContext camelContext, String key, Exchange exchange)`
`Exchange`	`MemoryAggregationRepository.add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)`
`void`	`MemoryAggregationRepository.confirm(CamelContext camelContext, String exchangeId)`
`protected void`	`AggregateProcessor.doAggregationRepositoryAdd(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)`
`Exchange`	`MemoryAggregationRepository.get(CamelContext camelContext, String key)`
`void`	`MemoryAggregationRepository.remove(CamelContext camelContext, String key, Exchange exchange)`
`void`	`AggregationStrategyBeanAdapter.setCamelContext(CamelContext camelContext)`

Constructors in org.apache.camel.processor.aggregate with parameters of type CamelContext
`AggregateProcessor(CamelContext camelContext, Processor processor, Expression correlationExpression, AggregationStrategy aggregationStrategy, ExecutorService executorService, boolean shutdownExecutorService)`
`AggregationStrategyBeanInfo(CamelContext camelContext, Class<?> type, Method method)`
`AggregationStrategyMethodInfo(CamelContext camelContext, Class<?> type, Method method, List<ParameterInfo> oldParameters, List<ParameterInfo> newParameters)`

Uses of CamelContext in org.apache.camel.processor.interceptor

Methods in org.apache.camel.processor.interceptor with parameters of type CamelContext
`static BacklogTracer`	`BacklogTracer.createTracer(CamelContext context)` Creates a new backlog tracer.
`static Tracer`	`Tracer.createTracer(CamelContext context)` Creates a new tracer.
`static BacklogDebugger`	`BacklogDebugger.getBacklogDebugger(CamelContext context)` A helper method to return the BacklogDebugger instance if one is enabled
`static BacklogTracer`	`BacklogTracer.getBacklogTracer(CamelContext context)` A helper method to return the BacklogTracer instance if one is enabled
`static Delayer`	`Delayer.getDelayer(CamelContext context)` Deprecated. A helper method to return the Delayer instance for a given `CamelContext` if one is enabled
`static HandleFault`	`HandleFault.getHandleFault(CamelContext context)` A helper method to return the HandleFault instance for a given `CamelContext` if one is enabled
`static StreamCaching`	`StreamCaching.getStreamCaching(CamelContext context)` Deprecated. A helper method to return the StreamCaching instance for a given `CamelContext` if one is enabled
`static Tracer`	`Tracer.getTracer(CamelContext context)` A helper method to return the Tracer instance if one is enabled
`Processor`	`Delayer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)` Deprecated.
`Processor`	`HandleFault.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)`
`Processor`	`StreamCaching.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)` Deprecated.
`Processor`	`BacklogDebugger.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)` Deprecated.
`Processor`	`Debug.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)`
`Processor`	`BacklogTracer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)` Deprecated.
`Processor`	`Tracer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)`

Constructors in org.apache.camel.processor.interceptor with parameters of type CamelContext
`BacklogDebugger(CamelContext camelContext)`
`BacklogTracer(CamelContext camelContext)`
`DelayInterceptor(CamelContext camelContext, ProcessorDefinition<?> node, Processor target, Delayer delayer)` Deprecated.

Uses of CamelContext in org.apache.camel.processor.loadbalancer

Methods in org.apache.camel.processor.loadbalancer that return CamelContext
`CamelContext`	`FailOverLoadBalancer.getCamelContext()`

Methods in org.apache.camel.processor.loadbalancer with parameters of type CamelContext
`void`	`FailOverLoadBalancer.setCamelContext(CamelContext camelContext)`

Uses of CamelContext in org.apache.camel.spi

Methods in org.apache.camel.spi that return CamelContext
`CamelContext`	`RouteContext.getCamelContext()` Gets the camel context

Methods in org.apache.camel.spi with parameters of type CamelContext
`Exchange`	`AggregationRepository.add(CamelContext camelContext, String key, Exchange exchange)` Add the given `Exchange` under the correlation key.
`Exchange`	`OptimisticLockingAggregationRepository.add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)` Add the given `Exchange` under the correlation key.
`void`	`AggregationRepository.confirm(CamelContext camelContext, String exchangeId)` Confirms the completion of the `Exchange`.
`EventObject`	`EventFactory.createCamelContextResumedEvent(CamelContext context)` Creates an `EventObject` for Camel has been resumed successfully.
`EventObject`	`EventFactory.createCamelContextResumeFailureEvent(CamelContext context, Throwable cause)` Creates an `EventObject` for Camel failing to resume
`EventObject`	`EventFactory.createCamelContextResumingEvent(CamelContext context)` Creates an `EventObject` for Camel is resuming.
`EventObject`	`EventFactory.createCamelContextStartedEvent(CamelContext context)` Creates an `EventObject` for Camel has been started successfully.
`EventObject`	`EventFactory.createCamelContextStartingEvent(CamelContext context)` Creates an `EventObject` for Camel is starting.
`EventObject`	`EventFactory.createCamelContextStartupFailureEvent(CamelContext context, Throwable cause)` Creates an `EventObject` for Camel failing to start
`EventObject`	`EventFactory.createCamelContextStopFailureEvent(CamelContext context, Throwable cause)` Creates an `EventObject` for Camel failing to stop cleanly
`EventObject`	`EventFactory.createCamelContextStoppedEvent(CamelContext context)` Creates an `EventObject` for Camel has been stopped successfully.
`EventObject`	`EventFactory.createCamelContextStoppingEvent(CamelContext context)` Creates an `EventObject` for Camel is stopping.
`EventObject`	`EventFactory.createCamelContextSuspendedEvent(CamelContext context)` Creates an `EventObject` for Camel has been suspended successfully.
`EventObject`	`EventFactory.createCamelContextSuspendingEvent(CamelContext context)` Creates an `EventObject` for Camel is suspending.
`EventObject`	`EventFactory.createServiceStartupFailureEvent(CamelContext context, Object service, Throwable cause)` Creates an `EventObject` for a Service failed to start cleanly
`EventObject`	`EventFactory.createServiceStopFailureEvent(CamelContext context, Object service, Throwable cause)` Creates an `EventObject` for a Service failed to stop cleanly
`Exchange`	`AggregationRepository.get(CamelContext camelContext, String key)` Gets the given exchange with the correlation key This method is always invoked for any incoming exchange in the aggregator.
`Object`	`ManagementObjectStrategy.getManagedObjectForCamelContext(CamelContext context)`
`Object`	`ManagementObjectStrategy.getManagedObjectForComponent(CamelContext context, Component component, String name)`
`Object`	`ManagementObjectStrategy.getManagedObjectForConsumer(CamelContext context, Consumer consumer)`
`Object`	`ManagementObjectStrategy.getManagedObjectForEndpoint(CamelContext context, Endpoint endpoint)`
`Object`	`ManagementObjectStrategy.getManagedObjectForErrorHandler(CamelContext context, RouteContext routeContext, Processor errorHandler, ErrorHandlerFactory errorHandlerBuilder)`
`Object`	`ManagementObjectStrategy.getManagedObjectForEventNotifier(CamelContext context, EventNotifier eventNotifier)`
`Object`	`ManagementObjectStrategy.getManagedObjectForProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition, Route route)`
`Object`	`ManagementObjectStrategy.getManagedObjectForProducer(CamelContext context, Producer producer)`
`Object`	`ManagementObjectStrategy.getManagedObjectForRoute(CamelContext context, Route route)`
`Object`	`ManagementObjectStrategy.getManagedObjectForService(CamelContext context, Service service)`
`Object`	`ManagementObjectStrategy.getManagedObjectForThreadPool(CamelContext context, ThreadPoolExecutor threadPool, String id, String sourceId, String routeId, String threadPoolProfileId)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForCamelContext(CamelContext context)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForConsumer(CamelContext context, Consumer consumer)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForEventNotifier(CamelContext context, EventNotifier eventNotifier)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForProcessor(CamelContext context, Processor processor, NamedNode definition)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForProducer(CamelContext context, Producer producer)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForService(CamelContext context, Service service)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForThreadPool(CamelContext context, ThreadPoolExecutor threadPool, String id, String sourceId)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForTracer(CamelContext context, InterceptStrategy tracer)`
`void`	`Container.manage(CamelContext camelContext)` Called by Camel when a `CamelContext` has been created.
`static void`	`Container.Instance.manage(CamelContext camelContext)` Called by Camel when a `CamelContext` has been created.
`void`	`LifecycleStrategy.onContextStart(CamelContext context)` Notification on starting a `CamelContext`.
`void`	`LifecycleStrategy.onContextStop(CamelContext context)` Notification on stopping a `CamelContext`.
`void`	`LifecycleStrategy.onServiceAdd(CamelContext context, Service service, Route route)` Notification on adding a `Service`.
`void`	`LifecycleStrategy.onServiceRemove(CamelContext context, Service service, Route route)` Notification on removing a `Service`.
`void`	`LifecycleStrategy.onThreadPoolAdd(CamelContext camelContext, ThreadPoolExecutor threadPool, String id, String sourceId, String routeId, String threadPoolProfileId)` Notification on adding a thread pool.
`void`	`LifecycleStrategy.onThreadPoolRemove(CamelContext camelContext, ThreadPoolExecutor threadPool)` Notification on removing a thread pool.
`Exchange`	`RecoverableAggregationRepository.recover(CamelContext camelContext, String exchangeId)` Recovers the exchange with the given exchange id
`void`	`OptimisticLockingAggregationRepository.remove(CamelContext camelContext, String key, Exchange exchange)` Removes the given Exchange when both the supplied key and Exchange are present in the repository.
`void`	`AggregationRepository.remove(CamelContext camelContext, String key, Exchange exchange)` Removes the exchange with the given correlation key, which should happen when an `Exchange` is completed Important: This method is not invoked if only one exchange was completed, and therefore the exchange does not need to be added to a repository, as its completed immediately.
`Component`	`ComponentResolver.resolveComponent(String name, CamelContext context)` Attempts to resolve the component for the given URI
`DataFormat`	`DataFormatResolver.resolveDataFormat(String name, CamelContext context)` Resolves the given data format given its name.
`Language`	`LanguageResolver.resolveLanguage(String name, CamelContext context)` Resolves the given language.
`Set<String>`	`RecoverableAggregationRepository.scan(CamelContext camelContext)` Scans the repository for `Exchange`s to be recovered
`void`	`ShutdownStrategy.shutdown(CamelContext context, List<RouteStartupOrder> routes)` Shutdown the routes
`void`	`ShutdownStrategy.shutdown(CamelContext context, List<RouteStartupOrder> routes, long timeout, TimeUnit timeUnit)` Shutdown the routes using a specified timeout instead of the default timeout values
`boolean`	`ShutdownStrategy.shutdown(CamelContext context, RouteStartupOrder route, long timeout, TimeUnit timeUnit, boolean abortAfterTimeout)` Shutdown the route using a specified timeout instead of the default timeout values and supports abortAfterTimeout mode
`void`	`ShutdownStrategy.shutdownForced(CamelContext context, List<RouteStartupOrder> routes)` Shutdown the routes, forcing shutdown being more aggressive, if timeout occurred.
`void`	`ShutdownStrategy.suspend(CamelContext context, List<RouteStartupOrder> routes)` Suspends the routes
`void`	`ShutdownStrategy.suspend(CamelContext context, List<RouteStartupOrder> routes, long timeout, TimeUnit timeUnit)` Suspends the routes using a specified timeout instead of the default timeout values
`Processor`	`InterceptStrategy.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)` This method is invoked by `ProcessorDefinition.wrapProcessor(RouteContext, Processor)` to give the implementor an opportunity to wrap the target processor in a route.

Uses of CamelContext in org.apache.camel.support

Methods in org.apache.camel.support that return CamelContext
`CamelContext`	`TimerListenerManager.getCamelContext()`
`CamelContext`	`LanguageSupport.getCamelContext()`

Methods in org.apache.camel.support with parameters of type CamelContext
`void`	`LifecycleStrategySupport.onContextStart(CamelContext context)`
`void`	`LifecycleStrategySupport.onContextStop(CamelContext context)`
`void`	`LifecycleStrategySupport.onServiceAdd(CamelContext context, Service service, Route route)`
`void`	`LifecycleStrategySupport.onServiceRemove(CamelContext context, Service service, Route route)`
`void`	`LifecycleStrategySupport.onThreadPoolAdd(CamelContext camelContext, ThreadPoolExecutor threadPool, String id, String sourceId, String routeId, String threadPoolProfileId)`
`void`	`LifecycleStrategySupport.onThreadPoolRemove(CamelContext camelContext, ThreadPoolExecutor threadPool)`
`void`	`TimerListenerManager.setCamelContext(CamelContext camelContext)`
`void`	`LanguageSupport.setCamelContext(CamelContext camelContext)`

Uses of CamelContext in org.apache.camel.util

Methods in org.apache.camel.util with parameters of type CamelContext

static



<T> T

CamelContextHelper.convertTo(CamelContext context,
                   Class<T> type,
                   Object value)

Converts the given value to the requested type

static Exchange ExchangeHelper.copyExchangeAndSetCamelContext(Exchange exchange, CamelContext context)
Copies the exchange but the copy will be tied to the given context

static Exchange ExchangeHelper.copyExchangeAndSetCamelContext(Exchange exchange, CamelContext context, boolean handover)
Copies the exchange but the copy will be tied to the given context

static



<T> T

ExchangeHelper.extractFutureBody(CamelContext context,
                                   Future<Object> future,
                                   Class<T> type)

Extracts the body from the given future, that represents a handle to an asynchronous exchange.

static



<T> T

ExchangeHelper.extractFutureBody(CamelContext context,
                                   Future<Object> future,
                                   long timeout,
                                   TimeUnit unit,
                                   Class<T> type)

Extracts the body from the given future, that represents a handle to an asynchronous exchange.

static SortedMap<String,Properties> CamelContextHelper.findComponents(CamelContext camelContext)
Finds all possible Components on the classpath, already registered in CamelContext, and from the Registry.

static SortedMap<String,Properties> CamelContextHelper.findComponents(CamelContext camelContext, Enumeration<URL> componentDescriptionIter)

static Properties ObjectHelper.getCamelPropertiesWithPrefix(String prefix, CamelContext camelContext)
A helper method to access a camel context properties with a prefix

static Endpoint CamelContextHelper.getEndpointInjection(CamelContext camelContext, String uri, String ref, String injectionPointName, boolean mandatory)
Evaluates the @EndpointInject annotation using the given context

static Endpoint CamelContextHelper.getMandatoryEndpoint(CamelContext camelContext, String uri)
Returns the mandatory endpoint for the given URI or the NoSuchEndpointException is thrown

static



<T extends Endpoint> 


T

CamelContextHelper.getMandatoryEndpoint(CamelContext camelContext,
                                         String uri,
                                         Class<T> type)

Returns the mandatory endpoint for the given URI and type or the NoSuchEndpointException is thrown

static int CamelContextHelper.getMaximumCachePoolSize(CamelContext camelContext)
Gets the maximum cache pool size.

static int CamelContextHelper.getMaximumEndpointCacheSize(CamelContext camelContext)
Gets the maximum endpoint cache size.

static int CamelContextHelper.getRouteStartupOrder(CamelContext camelContext, String routeId)
Gets the route startup order for the given route id

static boolean PlatformHelper.isOsgiContext(CamelContext camelContext)
Determine whether Camel is OSGi-aware.

static Object CamelContextHelper.lookup(CamelContext context, String name)
Look up the given named bean in the Registry on the CamelContext

static



<T> T

CamelContextHelper.lookup(CamelContext context,
             String name,
             Class<T> beanType)

Look up the given named bean of the given type in the Registry on the CamelContext

static



<T> T

CamelContextHelper.mandatoryConvertTo(CamelContext context,
                                     Class<T> type,
                                     Object value)

Converts the given value to the specified type throwing an IllegalArgumentException if the value could not be converted to a non null value

static Object CamelContextHelper.mandatoryLookup(CamelContext context, String name)
Look up the given named bean in the Registry on the CamelContext or throws NoSuchBeanException if not found.

static



<T> T

CamelContextHelper.mandatoryLookup(CamelContext context,
                               String name,
                               Class<T> beanType)

Look up the given named bean of the given type in the Registry on the CamelContext or throws NoSuchBeanException if not found.

static boolean EndpointHelper.matchEndpoint(CamelContext context, String uri, String pattern)
Matches the endpoint with the given pattern.

static



<T> T

CamelContextHelper.newInstance(CamelContext context,
                       Class<T> beanType)

Creates a new instance of the given type using the Injector on the given CamelContext

static void EventHelper.notifyCamelContextResumed(CamelContext context)

static void EventHelper.notifyCamelContextResumeFailed(CamelContext context, Throwable cause)

static void EventHelper.notifyCamelContextResuming(CamelContext context)

static void EventHelper.notifyCamelContextStarted(CamelContext context)

static void EventHelper.notifyCamelContextStarting(CamelContext context)

static void EventHelper.notifyCamelContextStartupFailed(CamelContext context, Throwable cause)

static void EventHelper.notifyCamelContextStopFailed(CamelContext context, Throwable cause)

static void EventHelper.notifyCamelContextStopped(CamelContext context)

static void EventHelper.notifyCamelContextStopping(CamelContext context)

static void EventHelper.notifyCamelContextSuspended(CamelContext context)

static void EventHelper.notifyCamelContextSuspending(CamelContext context)

static void EventHelper.notifyExchangeCreated(CamelContext context, Exchange exchange)

static void EventHelper.notifyExchangeDone(CamelContext context, Exchange exchange)

static void EventHelper.notifyExchangeFailed(CamelContext context, Exchange exchange)

static void EventHelper.notifyExchangeFailureHandled(CamelContext context, Exchange exchange, Processor failureHandler, boolean deadLetterChannel)

static void EventHelper.notifyExchangeRedelivery(CamelContext context, Exchange exchange, int attempt)

static void EventHelper.notifyExchangeSending(CamelContext context, Exchange exchange, Endpoint endpoint)

static void EventHelper.notifyExchangeSent(CamelContext context, Exchange exchange, Endpoint endpoint, long timeTaken)

static void EventHelper.notifyRouteStarted(CamelContext context, Route route)

static void EventHelper.notifyRouteStopped(CamelContext context, Route route)

static void EventHelper.notifyServiceStartupFailure(CamelContext context, Object service, Throwable cause)

static void EventHelper.notifyServiceStopFailure(CamelContext context, Object service, Throwable cause)

static Boolean CamelContextHelper.parseBoolean(CamelContext camelContext, String text)
Parses the given text and converts it to an Boolean and handling property placeholders as well

static Double CamelContextHelper.parseDouble(CamelContext camelContext, String text)
Parses the given text and converts it to a Double and handling property placeholders as well

static Integer CamelContextHelper.parseInteger(CamelContext camelContext, String text)
Parses the given text and converts it to an Integer and handling property placeholders as well

static Long CamelContextHelper.parseLong(CamelContext camelContext, String text)
Parses the given text and converts it to an Long and handling property placeholders as well

static String CamelContextHelper.parseText(CamelContext camelContext, String text)
Parses the given text and handling property placeholders as well

static



<T> List<T>

EndpointHelper.resolveReferenceListParameter(CamelContext context,
                                                           String value,
                                                           Class<T> elementType)

Resolves a reference list parameter by making lookups in the registry.

static



<T> T

EndpointHelper.resolveReferenceParameter(CamelContext context,
                                                   String value,
                                                   Class<T> type)

Resolves a reference parameter by making a lookup in the registry.

static



<T> T

EndpointHelper.resolveReferenceParameter(CamelContext context,
                                                   String value,
                                                   Class<T> type,
                                                   boolean mandatory)

Resolves a reference parameter by making a lookup in the registry.

static void EndpointHelper.setProperties(CamelContext context, Object bean, Map<String,Object> parameters)
Sets the regular properties on the given bean

static boolean IntrospectionSupport.setProperty(CamelContext context, TypeConverter typeConverter, Object target, String name, Object value, String refName, boolean allowBuilderPattern)
This method supports two modes to set a property: 1.

static void

EndpointHelper.setReferenceProperties(CamelContext context,
                                             Object bean,
                                             Map<String,Object> parameters)

Sets the reference properties on the given bean

This is convention over configuration, setting all reference parameters (using EndpointHelper.isReferenceParameter(String) by looking it up in registry and setting it on the bean if possible.

Constructors in org.apache.camel.util with parameters of type CamelContext
`GroupIterator(CamelContext camelContext, Iterator<?> it, String token, int group)` Creates a new group iterator

Uses of CamelContext in org.apache.camel.util.jsse

Methods in org.apache.camel.util.jsse that return CamelContext
`CamelContext`	`JsseParameters.getCamelContext()`

Methods in org.apache.camel.util.jsse with parameters of type CamelContext
`void`	`JsseParameters.setCamelContext(CamelContext context)` Sets the optional `CamelContext` used for integration with core capabilities such as Camel Property Placeholders and `ClassResolver`.

Uses of CamelContext in org.apache.camel.view

Methods in org.apache.camel.view with parameters of type CamelContext
`void`	`GraphGeneratorSupport.drawRoutes(CamelContext context)`
`String`	`GraphGeneratorSupport.getRoutesText(CamelContext context)`