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 JAXB POJOs for the XML Configuration of the routing rules.
org.apache.camel.builder	The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers.
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.browse	The Browse Component which is a simple in memory component which maintains a list of all message exchanges which can be useful for debugging, tooling or visualistion.
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.impl	Default implementation classes for Camel Core
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.processor.interceptor	Helper classes for interceptors.
org.apache.camel.spi	Service Provider Interfaces used internally by the Camel runtime which are plugin strategies.
org.apache.camel.util	Utility classes used by the core of Camel and useful for Camel component developers
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`	`Endpoint.getCamelContext()` Returns the context which created the endpoint
`CamelContext`	`Component.getCamelContext()` Returns the context
`CamelContext`	`CamelContextAware.getCamelContext()` Get the `CamelContext`
`CamelContext`	`Exchange.getContext()` Returns the container so that a processor can resolve endpoints from URIs

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`	`Endpoint.setCamelContext(CamelContext context)` Sets the camel context.
`void`	`Component.setCamelContext(CamelContext context)` The `CamelContext` is injected into the component when it is added to it
`void`	`CamelContextAware.setCamelContext(CamelContext camelContext)` Injects the `CamelContext`

Uses of CamelContext in org.apache.camel.builder

Methods in org.apache.camel.builder that return CamelContext
`protected CamelContext`	`RouteBuilder.createContainer()` Factory method
`CamelContext`	`RouteBuilder.getContext()`
`CamelContext`	`BuilderSupport.getContext()`

Methods in org.apache.camel.builder with parameters of type CamelContext
`void`	`RouteBuilder.addRoutesToCamelContext(CamelContext context)`
`RoutesDefinition`	`RouteBuilder.configureRoutes(CamelContext context)` Configures the routes
`protected static ErrorHandlerBuilder`	`ErrorHandlerBuilderRef.lookupErrorHandlerBuilder(CamelContext camelContext)`
`void`	`BuilderSupport.setContext(CamelContext context)`

Constructors in org.apache.camel.builder with parameters of type CamelContext
`BuilderSupport(CamelContext context)`
`RouteBuilder(CamelContext context)`

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`	`XPathAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)`
`Expression`	`DefaultAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)`
`Expression`	`BeanAnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)`
`Expression`	`AnnotationExpressionFactory.createExpression(CamelContext camelContext, Annotation annotation, LanguageAnnotation languageAnnotation, Class<?> expressionReturnType)`
`static ParameterMappingStrategy`	`BeanInfo.createParameterMappingStrategy(CamelContext camelContext)`

Constructors in org.apache.camel.component.bean with parameters of type CamelContext
`BeanInfo(CamelContext camelContext, Class<?> type)`
`BeanInfo(CamelContext camelContext, Class<?> type, ParameterMappingStrategy strategy)`
`BeanProcessor(Object pojo, CamelContext camelContext)`
`BeanProcessor(Object pojo, CamelContext camelContext, ParameterMappingStrategy parameterMappingStrategy)`
`ConstantBeanHolder(Object bean, CamelContext context)`
`ConstantBeanHolder(Object bean, 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)`

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

Constructors in org.apache.camel.component.browse with parameters of type CamelContext
`BrowseEndpoint(String uri, CamelContext camelContext)`

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

Methods in org.apache.camel.component.file that return CamelContext
`CamelContext`	`AntPathMatcherGenericFileFilter.getCamelContext()`

Methods in org.apache.camel.component.file with parameters of type CamelContext
`void`	`AntPathMatcherGenericFileFilter.setCamelContext(CamelContext 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
`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 MockEndpoint`	`MockEndpoint.resolve(CamelContext context, String uri)` A helper method to resolve the mock endpoint of the given URI on the given context

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`	`DefaultExchange.context`

Methods in org.apache.camel.impl that return CamelContext
`CamelContext`	`RouteService.getCamelContext()`
`CamelContext`	`InterceptSendToEndpoint.getCamelContext()`
`CamelContext`	`DefaultRouteContext.getCamelContext()`
`CamelContext`	`DefaultEndpoint.getCamelContext()`
`CamelContext`	`DefaultConsumerTemplate.getCamelContext()`
`CamelContext`	`DefaultComponent.getCamelContext()`
`CamelContext`	`CamelPostProcessorHelper.getCamelContext()`
`CamelContext`	`DefaultProducerTemplate.getContext()`
`CamelContext`	`DefaultExchange.getContext()`

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

Methods in org.apache.camel.impl with parameters of type CamelContext
`protected Class<?>`	`DefaultLanguageResolver.findLanguage(String name, CamelContext context)`
`protected Class<?>`	`DefaultLanguageResolver.findLanguageResolver(String name, CamelContext context)`
`protected void`	`MainSupport.generateDot(String name, CamelContext camelContext, int size)`
`static DefaultProducerTemplate`	`DefaultProducerTemplate.newInstance(CamelContext camelContext, String defaultEndpointUri)`
`protected Language`	`DefaultLanguageResolver.noSpecificLanguageFound(String name, CamelContext context)`
`protected void`	`MainSupport.postProcesCamelContext(CamelContext camelContext)`
`Component`	`DefaultComponentResolver.resolveComponent(String name, CamelContext context)`
`DataFormat`	`DefaultDataFormatResolver.resolveDataFormat(String name, CamelContext context)`
`DataFormatDefinition`	`DefaultDataFormatResolver.resolveDataFormatDefinition(String name, CamelContext context)`
`Language`	`DefaultLanguageResolver.resolveLanguage(String name, CamelContext context)`
`void`	`InterceptSendToEndpoint.setCamelContext(CamelContext context)`
`void`	`DefaultEndpoint.setCamelContext(CamelContext camelContext)`
`void`	`DefaultComponent.setCamelContext(CamelContext context)`
`void`	`CamelPostProcessorHelper.setCamelContext(CamelContext camelContext)`

Constructors in org.apache.camel.impl with parameters of type CamelContext
`CamelPostProcessorHelper(CamelContext camelContext)`
`DefaultComponent(CamelContext context)`
`DefaultConsumerTemplate(CamelContext context)`
`DefaultEndpoint(String endpointUri, CamelContext camelContext)`
`DefaultExchange(CamelContext context)`
`DefaultExchange(CamelContext context, ExchangePattern pattern)`
`DefaultPollingEndpoint(String endpointUri, CamelContext context)`
`DefaultProducerTemplate(CamelContext context)`
`DefaultProducerTemplate(CamelContext context, Endpoint defaultEndpoint)`
`DefaultProducerTemplate(CamelContext context, ExecutorService executor)`
`DefaultRouteContext(CamelContext camelContext)` Only used for lazy construction from inside ExpressionType
`DefaultRouteContext(CamelContext camelContext, RouteDefinition route, FromDefinition from, Collection<Route> routes)`
`HeaderFilterStrategyComponent(CamelContext context)`
`ProcessorEndpoint(String endpointUri, CamelContext context, Processor processor)`
`ProducerCache(CamelContext context)`
`ProducerCache(CamelContext context, ServicePool<Endpoint,Producer> producerServicePool)`
`ProducerCache(CamelContext context, ServicePool<Endpoint,Producer> producerServicePool, Map<String,Producer> cache)`
`ScheduledPollEndpoint(String endpointUri, CamelContext context)`

Uses of CamelContext in org.apache.camel.management

Methods in org.apache.camel.management with parameters of type CamelContext
`EventObject`	`DefaultEventFactory.createCamelContextStartedEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextStartingEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextStartupFailureEvent(CamelContext context, Exception cause)`
`EventObject`	`DefaultEventFactory.createCamelContextStopFailureEvent(CamelContext context, Exception cause)`
`EventObject`	`DefaultEventFactory.createCamelContextStoppedEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createCamelContextStoppingEvent(CamelContext context)`
`EventObject`	`DefaultEventFactory.createServiceStartupFailureEvent(CamelContext context, Object service, Exception cause)`
`EventObject`	`DefaultEventFactory.createServiceStopFailureEvent(CamelContext context, Object service, Exception cause)`
`protected String`	`DefaultManagementNamingStrategy.getContextId(CamelContext context)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForCamelContext(CamelContext context)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForConsumer(CamelContext context, Consumer consumer)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForProducer(CamelContext context, Producer producer)`
`ObjectName`	`DefaultManagementNamingStrategy.getObjectNameForService(CamelContext context, Service service)`
`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)`
`Processor`	`InstrumentationInterceptStrategy.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition definition, Processor target, Processor nextTarget)`

Constructors in org.apache.camel.management with parameters of type CamelContext
`DefaultManagementLifecycleStrategy(CamelContext context)`

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

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

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

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

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

Constructors in org.apache.camel.management.mbean with parameters of type CamelContext
`ManagedCamelContext(CamelContext context)`
`ManagedConsumer(CamelContext context, Consumer consumer)`
`ManagedDelayer(CamelContext context, Delayer delayer, ProcessorDefinition<?> definition)`
`ManagedProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition)`
`ManagedProducer(CamelContext context, Producer producer)`
`ManagedRoute(CamelContext context, Route route)`
`ManagedScheduledPollConsumer(CamelContext context, ScheduledPollConsumer consumer)`
`ManagedSendProcessor(CamelContext context, SendProcessor processor, ProcessorDefinition<?> definition)`
`ManagedService(CamelContext context, Service service)`
`ManagedThrottler(CamelContext context, Throttler throttler, ProcessorDefinition<?> definition)`
`ManagedThrottlingInflightRoutePolicy(CamelContext context, ThrottlingInflightRoutePolicy policy)`
`ManagedTracer(CamelContext camelContext, Tracer tracer)`

Uses of CamelContext in org.apache.camel.model

Methods in org.apache.camel.model that return CamelContext
`CamelContext`	`RoutesDefinition.getCamelContext()`
`CamelContext`	`RouteDefinition.getCamelContext()`

Methods in org.apache.camel.model with parameters of type CamelContext
`List<RouteContext>`	`RouteDefinition.addRoutes(CamelContext context, Collection<Route> routes)`
`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)`
`void`	`RoutesDefinition.setCamelContext(CamelContext camelContext)`
`void`	`RouteDefinition.setCamelContext(CamelContext camelContext)`

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

Methods in org.apache.camel.processor.interceptor with parameters of type CamelContext
`static Tracer`	`Tracer.createTracer(CamelContext context)` Creates a new tracer.
`static Delayer`	`Delayer.getDelayer(CamelContext context)` 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)` 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`	`Tracer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)`
`Processor`	`StreamCaching.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)`
`Processor`	`HandleFault.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)`
`Processor`	`Delayer.wrapProcessorInInterceptors(CamelContext context, ProcessorDefinition<?> definition, Processor target, Processor nextTarget)`

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
`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, Exception cause)` Creates an `EventObject` for Camel failing to start
`EventObject`	`EventFactory.createCamelContextStopFailureEvent(CamelContext context, Exception 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.createServiceStartupFailureEvent(CamelContext context, Object service, Exception cause)` Creates an `EventObject` for a Service failed to start cleanly
`EventObject`	`EventFactory.createServiceStopFailureEvent(CamelContext context, Object service, Exception cause)` Creates an `EventObject` for a Service failed to stop cleanly
`ObjectName`	`ManagementNamingStrategy.getObjectNameForCamelContext(CamelContext context)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForConsumer(CamelContext context, Consumer consumer)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForProcessor(CamelContext context, Processor processor, ProcessorDefinition<?> definition)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForProducer(CamelContext context, Producer producer)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForService(CamelContext context, Service service)`
`ObjectName`	`ManagementNamingStrategy.getObjectNameForTracer(CamelContext context, InterceptStrategy tracer)`
`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`.
`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.
`DataFormatDefinition`	`DataFormatResolver.resolveDataFormatDefinition(String name, CamelContext context)` Resolves the given data format definition given its name.
`Language`	`LanguageResolver.resolveLanguage(String name, CamelContext context)` Resolves the given language.
`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.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



<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 Endpoint CamelContextHelper.getEndpointInjection(CamelContext camelContext, String uri, String name, 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 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 IllegalArgumentException 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 IllegalArgumentException if not found.

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.notifyCamelContextStarted(CamelContext context)

static void EventHelper.notifyCamelContextStarting(CamelContext context)

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

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

static void EventHelper.notifyCamelContextStopped(CamelContext context)

static void EventHelper.notifyCamelContextStopping(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.notifyRouteStarted(CamelContext context, Route route)

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

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

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

static



<T> T

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

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 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.

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)`