001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.camel.impl.lw;
018
019import java.io.IOException;
020import java.util.Collection;
021import java.util.Date;
022import java.util.List;
023import java.util.Map;
024import java.util.Set;
025import java.util.concurrent.ScheduledExecutorService;
026import java.util.function.Function;
027
028import org.apache.camel.CamelContext;
029import org.apache.camel.CatalogCamelContext;
030import org.apache.camel.Component;
031import org.apache.camel.ConsumerTemplate;
032import org.apache.camel.Endpoint;
033import org.apache.camel.ErrorHandlerFactory;
034import org.apache.camel.Experimental;
035import org.apache.camel.Expression;
036import org.apache.camel.ExtendedCamelContext;
037import org.apache.camel.FluentProducerTemplate;
038import org.apache.camel.GlobalEndpointConfiguration;
039import org.apache.camel.NoSuchLanguageException;
040import org.apache.camel.Predicate;
041import org.apache.camel.Processor;
042import org.apache.camel.ProducerTemplate;
043import org.apache.camel.Route;
044import org.apache.camel.RouteConfigurationsBuilder;
045import org.apache.camel.RouteTemplateContext;
046import org.apache.camel.RoutesBuilder;
047import org.apache.camel.Service;
048import org.apache.camel.ServiceStatus;
049import org.apache.camel.ShutdownRoute;
050import org.apache.camel.ShutdownRunningTask;
051import org.apache.camel.StartupListener;
052import org.apache.camel.StartupSummaryLevel;
053import org.apache.camel.TypeConverter;
054import org.apache.camel.ValueHolder;
055import org.apache.camel.builder.AdviceWithRouteBuilder;
056import org.apache.camel.catalog.RuntimeCamelCatalog;
057import org.apache.camel.console.DevConsoleResolver;
058import org.apache.camel.health.HealthCheckResolver;
059import org.apache.camel.impl.DefaultCamelContext;
060import org.apache.camel.model.DataFormatDefinition;
061import org.apache.camel.model.FaultToleranceConfigurationDefinition;
062import org.apache.camel.model.ModelCamelContext;
063import org.apache.camel.model.ModelLifecycleStrategy;
064import org.apache.camel.model.ProcessorDefinition;
065import org.apache.camel.model.Resilience4jConfigurationDefinition;
066import org.apache.camel.model.RouteConfigurationDefinition;
067import org.apache.camel.model.RouteDefinition;
068import org.apache.camel.model.RouteTemplateDefinition;
069import org.apache.camel.model.TemplatedRouteDefinition;
070import org.apache.camel.model.cloud.ServiceCallConfigurationDefinition;
071import org.apache.camel.model.language.ExpressionDefinition;
072import org.apache.camel.model.rest.RestDefinition;
073import org.apache.camel.model.transformer.TransformerDefinition;
074import org.apache.camel.model.validator.ValidatorDefinition;
075import org.apache.camel.spi.AnnotationBasedProcessorFactory;
076import org.apache.camel.spi.AsyncProcessorAwaitManager;
077import org.apache.camel.spi.BeanIntrospection;
078import org.apache.camel.spi.BeanProcessorFactory;
079import org.apache.camel.spi.BeanProxyFactory;
080import org.apache.camel.spi.BeanRepository;
081import org.apache.camel.spi.BootstrapCloseable;
082import org.apache.camel.spi.CamelBeanPostProcessor;
083import org.apache.camel.spi.CamelContextNameStrategy;
084import org.apache.camel.spi.CamelDependencyInjectionAnnotationFactory;
085import org.apache.camel.spi.ClassResolver;
086import org.apache.camel.spi.CliConnectorFactory;
087import org.apache.camel.spi.ComponentNameResolver;
088import org.apache.camel.spi.ComponentResolver;
089import org.apache.camel.spi.ConfigurerResolver;
090import org.apache.camel.spi.DataFormat;
091import org.apache.camel.spi.DataFormatResolver;
092import org.apache.camel.spi.DataType;
093import org.apache.camel.spi.Debugger;
094import org.apache.camel.spi.DeferServiceFactory;
095import org.apache.camel.spi.EndpointRegistry;
096import org.apache.camel.spi.EndpointStrategy;
097import org.apache.camel.spi.EndpointUriFactory;
098import org.apache.camel.spi.ExchangeFactory;
099import org.apache.camel.spi.ExchangeFactoryManager;
100import org.apache.camel.spi.ExecutorServiceManager;
101import org.apache.camel.spi.FactoryFinder;
102import org.apache.camel.spi.FactoryFinderResolver;
103import org.apache.camel.spi.HeadersMapFactory;
104import org.apache.camel.spi.InflightRepository;
105import org.apache.camel.spi.Injector;
106import org.apache.camel.spi.InterceptEndpointFactory;
107import org.apache.camel.spi.InterceptStrategy;
108import org.apache.camel.spi.InternalProcessorFactory;
109import org.apache.camel.spi.Language;
110import org.apache.camel.spi.LanguageResolver;
111import org.apache.camel.spi.LifecycleStrategy;
112import org.apache.camel.spi.LogListener;
113import org.apache.camel.spi.ManagementMBeanAssembler;
114import org.apache.camel.spi.ManagementNameStrategy;
115import org.apache.camel.spi.ManagementStrategy;
116import org.apache.camel.spi.MessageHistoryFactory;
117import org.apache.camel.spi.ModelJAXBContextFactory;
118import org.apache.camel.spi.ModelReifierFactory;
119import org.apache.camel.spi.ModelToXMLDumper;
120import org.apache.camel.spi.ModelineFactory;
121import org.apache.camel.spi.NodeIdFactory;
122import org.apache.camel.spi.NormalizedEndpointUri;
123import org.apache.camel.spi.PackageScanClassResolver;
124import org.apache.camel.spi.PackageScanResourceResolver;
125import org.apache.camel.spi.PeriodTaskResolver;
126import org.apache.camel.spi.PeriodTaskScheduler;
127import org.apache.camel.spi.ProcessorExchangeFactory;
128import org.apache.camel.spi.ProcessorFactory;
129import org.apache.camel.spi.PropertiesComponent;
130import org.apache.camel.spi.ReactiveExecutor;
131import org.apache.camel.spi.Registry;
132import org.apache.camel.spi.ResourceLoader;
133import org.apache.camel.spi.RestBindingJaxbDataFormatFactory;
134import org.apache.camel.spi.RestConfiguration;
135import org.apache.camel.spi.RestRegistry;
136import org.apache.camel.spi.RouteController;
137import org.apache.camel.spi.RouteFactory;
138import org.apache.camel.spi.RoutePolicyFactory;
139import org.apache.camel.spi.RouteStartupOrder;
140import org.apache.camel.spi.RoutesLoader;
141import org.apache.camel.spi.RuntimeEndpointRegistry;
142import org.apache.camel.spi.ShutdownStrategy;
143import org.apache.camel.spi.StartupStepRecorder;
144import org.apache.camel.spi.StreamCachingStrategy;
145import org.apache.camel.spi.Tracer;
146import org.apache.camel.spi.Transformer;
147import org.apache.camel.spi.TransformerRegistry;
148import org.apache.camel.spi.TypeConverterRegistry;
149import org.apache.camel.spi.UnitOfWorkFactory;
150import org.apache.camel.spi.UriFactoryResolver;
151import org.apache.camel.spi.UuidGenerator;
152import org.apache.camel.spi.Validator;
153import org.apache.camel.spi.ValidatorRegistry;
154import org.apache.camel.spi.XMLRoutesDefinitionLoader;
155import org.apache.camel.support.DefaultRegistry;
156import org.apache.camel.support.jsse.SSLContextParameters;
157import org.apache.camel.vault.VaultConfiguration;
158
159@Experimental
160public class LightweightCamelContext implements ExtendedCamelContext, CatalogCamelContext, ModelCamelContext {
161
162    protected volatile CamelContext delegate;
163
164    protected LightweightCamelContext(CamelContext delegate) {
165        this.delegate = delegate;
166    }
167
168    /**
169     * Creates the {@link ModelCamelContext} using {@link org.apache.camel.support.DefaultRegistry} as registry.
170     * <p/>
171     * Use one of the other constructors to force use an explicit registry.
172     */
173    public LightweightCamelContext() {
174        DefaultCamelContext d = new DefaultCamelContext(false) {
175            @Override
176            public CamelContext getCamelContextReference() {
177                return LightweightCamelContext.this;
178            }
179        };
180        delegate = d;
181        d.build();
182    }
183
184    /**
185     * Creates the {@link CamelContext} using the given {@link BeanRepository} as first-choice repository, and the
186     * {@link org.apache.camel.support.SimpleRegistry} as fallback, via the {@link DefaultRegistry} implementation.
187     *
188     * @param repository the bean repository.
189     */
190    public LightweightCamelContext(BeanRepository repository) {
191        this(new DefaultRegistry(repository));
192    }
193
194    /**
195     * Creates the {@link ModelCamelContext} using the given registry
196     *
197     * @param registry the registry
198     */
199    public LightweightCamelContext(Registry registry) {
200        this();
201        setRegistry(registry);
202    }
203
204    public CamelContext getCamelContextReference() {
205        return this;
206    }
207
208    @Override
209    public byte getStatusPhase() {
210        return delegate.adapt(ExtendedCamelContext.class).getStatusPhase();
211    }
212
213    @Override
214    public void disposeModel() {
215        delegate.adapt(ExtendedCamelContext.class).disposeModel();
216    }
217
218    @Override
219    public boolean isStarted() {
220        return delegate.isStarted();
221    }
222
223    @Override
224    public boolean isStarting() {
225        return delegate.isStarting();
226    }
227
228    @Override
229    public boolean isStopped() {
230        return delegate.isStopped();
231    }
232
233    @Override
234    public boolean isStopping() {
235        return delegate.isStopping();
236    }
237
238    @Override
239    public boolean isSuspended() {
240        return delegate.isSuspended();
241    }
242
243    @Override
244    public boolean isRunAllowed() {
245        return delegate.isRunAllowed();
246    }
247
248    @Override
249    public boolean isSuspending() {
250        return delegate.isSuspending();
251    }
252
253    @Override
254    public void build() {
255        delegate.build();
256    }
257
258    @Override
259    public void suspend() {
260        delegate.suspend();
261    }
262
263    @Override
264    public void resume() {
265        delegate.resume();
266    }
267
268    @Override
269    public void shutdown() {
270        delegate.shutdown();
271    }
272
273    @Override
274    public void close() throws Exception {
275        delegate.close();
276    }
277
278    @Override
279    public <T extends CamelContext> T adapt(Class<T> type) {
280        T res = delegate.adapt(type);
281        if (res == delegate) {
282            return type.cast(this);
283        } else {
284            return res;
285        }
286    }
287
288    @Override
289    public <T> T getExtension(Class<T> type) {
290        return delegate.getExtension(type);
291    }
292
293    @Override
294    public <T> void setExtension(Class<T> type, T module) {
295        delegate.setExtension(type, module);
296    }
297
298    @Override
299    public void start() {
300        delegate.start();
301    }
302
303    @Override
304    public void stop() {
305        delegate.stop();
306    }
307
308    @Override
309    public boolean isVetoStarted() {
310        return delegate.isVetoStarted();
311    }
312
313    @Override
314    public String getName() {
315        return delegate.getName();
316    }
317
318    @Override
319    public CamelContextNameStrategy getNameStrategy() {
320        return delegate.getNameStrategy();
321    }
322
323    @Override
324    public void setNameStrategy(CamelContextNameStrategy nameStrategy) {
325        delegate.setNameStrategy(nameStrategy);
326    }
327
328    @Override
329    public String getDescription() {
330        return delegate.getDescription();
331    }
332
333    @Override
334    public void setDescription(String description) {
335        delegate.adapt(ExtendedCamelContext.class).setDescription(description);
336    }
337
338    @Override
339    public ManagementNameStrategy getManagementNameStrategy() {
340        return delegate.getManagementNameStrategy();
341    }
342
343    @Override
344    public void setManagementNameStrategy(ManagementNameStrategy nameStrategy) {
345        delegate.setManagementNameStrategy(nameStrategy);
346    }
347
348    @Override
349    public String getManagementName() {
350        return delegate.getManagementName();
351    }
352
353    @Override
354    public void setManagementName(String name) {
355        delegate.setManagementName(name);
356    }
357
358    @Override
359    public String getVersion() {
360        return delegate.getVersion();
361    }
362
363    @Override
364    public ServiceStatus getStatus() {
365        return delegate.getStatus();
366    }
367
368    @Override
369    public String getUptime() {
370        return delegate.getUptime();
371    }
372
373    @Override
374    public long getUptimeMillis() {
375        return delegate.getUptimeMillis();
376    }
377
378    @Override
379    public Date getStartDate() {
380        return delegate.getStartDate();
381    }
382
383    @Override
384    public void addBootstrap(BootstrapCloseable bootstrap) {
385        getExtendedCamelContext().addBootstrap(bootstrap);
386    }
387
388    @Override
389    public void addService(Object object) throws Exception {
390        delegate.addService(object);
391    }
392
393    @Override
394    public void addService(Object object, boolean stopOnShutdown) throws Exception {
395        delegate.addService(object, stopOnShutdown);
396    }
397
398    @Override
399    public void addService(Object object, boolean stopOnShutdown, boolean forceStart) throws Exception {
400        delegate.addService(object, stopOnShutdown, forceStart);
401    }
402
403    @Override
404    public void addPrototypeService(Object object) throws Exception {
405        delegate.addPrototypeService(object);
406    }
407
408    @Override
409    public boolean removeService(Object object) throws Exception {
410        return delegate.removeService(object);
411    }
412
413    @Override
414    public List<Service> getServices() {
415        return getExtendedCamelContext().getServices();
416    }
417
418    @Override
419    public boolean hasService(Object object) {
420        return delegate.hasService(object);
421    }
422
423    @Override
424    public <T> T hasService(Class<T> type) {
425        return delegate.hasService(type);
426    }
427
428    @Override
429    public <T> Set<T> hasServices(Class<T> type) {
430        return delegate.hasServices(type);
431    }
432
433    @Override
434    public void deferStartService(Object object, boolean stopOnShutdown) throws Exception {
435        delegate.deferStartService(object, stopOnShutdown);
436    }
437
438    @Override
439    public void addStartupListener(StartupListener listener) throws Exception {
440        delegate.addStartupListener(listener);
441    }
442
443    @Override
444    public void addComponent(String componentName, Component component) {
445        delegate.addComponent(componentName, component);
446    }
447
448    @Override
449    public Component hasComponent(String componentName) {
450        return delegate.hasComponent(componentName);
451    }
452
453    @Override
454    public Component getComponent(String componentName) {
455        return delegate.getComponent(componentName);
456    }
457
458    @Override
459    public Component getComponent(String name, boolean autoCreateComponents) {
460        return delegate.getComponent(name, autoCreateComponents);
461    }
462
463    @Override
464    public Component getComponent(String name, boolean autoCreateComponents, boolean autoStart) {
465        return delegate.getComponent(name, autoCreateComponents, autoStart);
466    }
467
468    @Override
469    public <T extends Component> T getComponent(String name, Class<T> componentType) {
470        return delegate.getComponent(name, componentType);
471    }
472
473    @Override
474    public Set<String> getComponentNames() {
475        return delegate.getComponentNames();
476    }
477
478    @Override
479    public Component removeComponent(String componentName) {
480        return delegate.removeComponent(componentName);
481    }
482
483    @Override
484    public EndpointRegistry<? extends ValueHolder<String>> getEndpointRegistry() {
485        return delegate.getEndpointRegistry();
486    }
487
488    @Override
489    public Endpoint getEndpoint(String uri) {
490        return delegate.getEndpoint(uri);
491    }
492
493    @Override
494    public Endpoint getEndpoint(String uri, Map<String, Object> parameters) {
495        return delegate.getEndpoint(uri, parameters);
496    }
497
498    @Override
499    public <T extends Endpoint> T getEndpoint(String name, Class<T> endpointType) {
500        return delegate.getEndpoint(name, endpointType);
501    }
502
503    @Override
504    public Collection<Endpoint> getEndpoints() {
505        return delegate.getEndpoints();
506    }
507
508    @Override
509    @Deprecated
510    public Map<String, Endpoint> getEndpointMap() {
511        return delegate.getEndpointMap();
512    }
513
514    @Override
515    public Endpoint hasEndpoint(String uri) {
516        return delegate.hasEndpoint(uri);
517    }
518
519    @Override
520    public Endpoint addEndpoint(String uri, Endpoint endpoint) throws Exception {
521        return delegate.addEndpoint(uri, endpoint);
522    }
523
524    @Override
525    public void removeEndpoint(Endpoint endpoint) throws Exception {
526        delegate.removeEndpoint(endpoint);
527    }
528
529    @Override
530    public Collection<Endpoint> removeEndpoints(String pattern) throws Exception {
531        return delegate.removeEndpoints(pattern);
532    }
533
534    @Override
535    public GlobalEndpointConfiguration getGlobalEndpointConfiguration() {
536        return delegate.getGlobalEndpointConfiguration();
537    }
538
539    @Override
540    public void setRouteController(RouteController routeController) {
541        delegate.setRouteController(routeController);
542    }
543
544    @Override
545    public RouteController getRouteController() {
546        return delegate.getRouteController();
547    }
548
549    @Override
550    public List<Route> getRoutes() {
551        return delegate.getRoutes();
552    }
553
554    @Override
555    public int getRoutesSize() {
556        return delegate.getRoutesSize();
557    }
558
559    @Override
560    public Route getRoute(String id) {
561        return delegate.getRoute(id);
562    }
563
564    @Override
565    public Processor getProcessor(String id) {
566        return delegate.getProcessor(id);
567    }
568
569    @Override
570    public <T extends Processor> T getProcessor(String id, Class<T> type) {
571        return delegate.getProcessor(id, type);
572    }
573
574    @Override
575    public void addRoutes(RoutesBuilder builder) throws Exception {
576        delegate.addRoutes(builder);
577    }
578
579    @Override
580    public void addTemplatedRoutes(RoutesBuilder builder) throws Exception {
581        delegate.addTemplatedRoutes(builder);
582    }
583
584    @Override
585    public void addRoutesConfigurations(RouteConfigurationsBuilder builder) throws Exception {
586        delegate.addRoutesConfigurations(builder);
587    }
588
589    @Override
590    public boolean removeRoute(String routeId) throws Exception {
591        return delegate.removeRoute(routeId);
592    }
593
594    @Override
595    public void addRoutePolicyFactory(RoutePolicyFactory routePolicyFactory) {
596        delegate.addRoutePolicyFactory(routePolicyFactory);
597    }
598
599    @Override
600    public List<RoutePolicyFactory> getRoutePolicyFactories() {
601        return delegate.getRoutePolicyFactories();
602    }
603
604    @Override
605    public void setRestConfiguration(RestConfiguration restConfiguration) {
606        delegate.setRestConfiguration(restConfiguration);
607    }
608
609    @Override
610    public RestConfiguration getRestConfiguration() {
611        return delegate.getRestConfiguration();
612    }
613
614    @Override
615    public void setVaultConfiguration(VaultConfiguration vaultConfiguration) {
616        delegate.setVaultConfiguration(vaultConfiguration);
617    }
618
619    @Override
620    public VaultConfiguration getVaultConfiguration() {
621        return delegate.getVaultConfiguration();
622    }
623
624    @Override
625    public RestRegistry getRestRegistry() {
626        return delegate.getRestRegistry();
627    }
628
629    @Override
630    public void setRestRegistry(RestRegistry restRegistry) {
631        delegate.setRestRegistry(restRegistry);
632    }
633
634    @Override
635    public TypeConverter getTypeConverter() {
636        return delegate.getTypeConverter();
637    }
638
639    @Override
640    public TypeConverterRegistry getTypeConverterRegistry() {
641        return delegate.getTypeConverterRegistry();
642    }
643
644    @Override
645    public void setTypeConverterRegistry(TypeConverterRegistry typeConverterRegistry) {
646        delegate.setTypeConverterRegistry(typeConverterRegistry);
647    }
648
649    @Override
650    public Registry getRegistry() {
651        return delegate.getRegistry();
652    }
653
654    @Override
655    public <T> T getRegistry(Class<T> type) {
656        return delegate.getRegistry(type);
657    }
658
659    @Override
660    public Injector getInjector() {
661        return delegate.getInjector();
662    }
663
664    @Override
665    public void setInjector(Injector injector) {
666        delegate.setInjector(injector);
667    }
668
669    @Override
670    public List<LifecycleStrategy> getLifecycleStrategies() {
671        return delegate.getLifecycleStrategies();
672    }
673
674    @Override
675    public void addLifecycleStrategy(LifecycleStrategy lifecycleStrategy) {
676        delegate.addLifecycleStrategy(lifecycleStrategy);
677    }
678
679    @Override
680    public Language resolveLanguage(String language) throws NoSuchLanguageException {
681        return delegate.resolveLanguage(language);
682    }
683
684    @Override
685    public String resolvePropertyPlaceholders(String text) {
686        return delegate.resolvePropertyPlaceholders(text);
687    }
688
689    @Override
690    public String resolvePropertyPlaceholders(String text, boolean keepUnresolvedOptional) {
691        return getExtendedCamelContext().resolvePropertyPlaceholders(text, keepUnresolvedOptional);
692    }
693
694    @Override
695    public PropertiesComponent getPropertiesComponent() {
696        return delegate.getPropertiesComponent();
697    }
698
699    @Override
700    public void setPropertiesComponent(PropertiesComponent propertiesComponent) {
701        delegate.setPropertiesComponent(propertiesComponent);
702    }
703
704    @Override
705    public Set<String> getLanguageNames() {
706        return delegate.getLanguageNames();
707    }
708
709    @Override
710    public ProducerTemplate createProducerTemplate() {
711        return delegate.createProducerTemplate();
712    }
713
714    @Override
715    public ProducerTemplate createProducerTemplate(int maximumCacheSize) {
716        return delegate.createProducerTemplate(maximumCacheSize);
717    }
718
719    @Override
720    public FluentProducerTemplate createFluentProducerTemplate() {
721        return delegate.createFluentProducerTemplate();
722    }
723
724    @Override
725    public FluentProducerTemplate createFluentProducerTemplate(int maximumCacheSize) {
726        return delegate.createFluentProducerTemplate(maximumCacheSize);
727    }
728
729    @Override
730    public ConsumerTemplate createConsumerTemplate() {
731        return delegate.createConsumerTemplate();
732    }
733
734    @Override
735    public ConsumerTemplate createConsumerTemplate(int maximumCacheSize) {
736        return delegate.createConsumerTemplate(maximumCacheSize);
737    }
738
739    @Override
740    public DataFormat resolveDataFormat(String name) {
741        return delegate.resolveDataFormat(name);
742    }
743
744    @Override
745    public DataFormat createDataFormat(String name) {
746        return delegate.createDataFormat(name);
747    }
748
749    @Override
750    public Set<String> getDataFormatNames() {
751        return delegate.getDataFormatNames();
752    }
753
754    @Override
755    public Transformer resolveTransformer(String model) {
756        return delegate.resolveTransformer(model);
757    }
758
759    @Override
760    public Transformer resolveTransformer(DataType from, DataType to) {
761        return delegate.resolveTransformer(from, to);
762    }
763
764    @Override
765    public TransformerRegistry getTransformerRegistry() {
766        return delegate.getTransformerRegistry();
767    }
768
769    @Override
770    public Validator resolveValidator(DataType type) {
771        return delegate.resolveValidator(type);
772    }
773
774    @Override
775    public ValidatorRegistry getValidatorRegistry() {
776        return delegate.getValidatorRegistry();
777    }
778
779    @Override
780    public void setGlobalOptions(Map<String, String> globalOptions) {
781        delegate.setGlobalOptions(globalOptions);
782    }
783
784    @Override
785    public Map<String, String> getGlobalOptions() {
786        return delegate.getGlobalOptions();
787    }
788
789    @Override
790    public String getGlobalOption(String key) {
791        return delegate.getGlobalOption(key);
792    }
793
794    @Override
795    public ClassResolver getClassResolver() {
796        return delegate.getClassResolver();
797    }
798
799    @Override
800    public void setClassResolver(ClassResolver resolver) {
801        delegate.setClassResolver(resolver);
802    }
803
804    @Override
805    public ManagementStrategy getManagementStrategy() {
806        return delegate.getManagementStrategy();
807    }
808
809    @Override
810    public void setManagementStrategy(ManagementStrategy strategy) {
811        delegate.setManagementStrategy(strategy);
812    }
813
814    @Override
815    public void disableJMX() throws IllegalStateException {
816        delegate.disableJMX();
817    }
818
819    @Override
820    public InflightRepository getInflightRepository() {
821        return delegate.getInflightRepository();
822    }
823
824    @Override
825    public void setInflightRepository(InflightRepository repository) {
826        delegate.setInflightRepository(repository);
827    }
828
829    @Override
830    public ClassLoader getApplicationContextClassLoader() {
831        return delegate.getApplicationContextClassLoader();
832    }
833
834    @Override
835    public void setApplicationContextClassLoader(ClassLoader classLoader) {
836        delegate.setApplicationContextClassLoader(classLoader);
837    }
838
839    @Override
840    public ShutdownStrategy getShutdownStrategy() {
841        return delegate.getShutdownStrategy();
842    }
843
844    @Override
845    public void setShutdownStrategy(ShutdownStrategy shutdownStrategy) {
846        delegate.setShutdownStrategy(shutdownStrategy);
847    }
848
849    @Override
850    public ExecutorServiceManager getExecutorServiceManager() {
851        return delegate.getExecutorServiceManager();
852    }
853
854    @Override
855    public void setExecutorServiceManager(ExecutorServiceManager executorServiceManager) {
856        delegate.setExecutorServiceManager(executorServiceManager);
857    }
858
859    @Override
860    public MessageHistoryFactory getMessageHistoryFactory() {
861        return delegate.getMessageHistoryFactory();
862    }
863
864    @Override
865    public void setMessageHistoryFactory(MessageHistoryFactory messageHistoryFactory) {
866        delegate.setMessageHistoryFactory(messageHistoryFactory);
867    }
868
869    @Override
870    public Debugger getDebugger() {
871        return delegate.getDebugger();
872    }
873
874    @Override
875    public void setDebugger(Debugger debugger) {
876        delegate.setDebugger(debugger);
877    }
878
879    @Override
880    public Tracer getTracer() {
881        return delegate.getTracer();
882    }
883
884    @Override
885    public void setTracer(Tracer tracer) {
886        delegate.setTracer(tracer);
887    }
888
889    @Override
890    public void setTracingStandby(boolean tracingStandby) {
891        delegate.setTracingStandby(tracingStandby);
892    }
893
894    @Override
895    public boolean isTracingStandby() {
896        return delegate.isTracingStandby();
897    }
898
899    @Override
900    public void setBacklogTracingStandby(boolean backlogTracingStandby) {
901        delegate.setBacklogTracingStandby(backlogTracingStandby);
902    }
903
904    @Override
905    public boolean isBacklogTracingStandby() {
906        return delegate.isBacklogTracingStandby();
907    }
908
909    @Override
910    public UuidGenerator getUuidGenerator() {
911        return delegate.getUuidGenerator();
912    }
913
914    @Override
915    public void setUuidGenerator(UuidGenerator uuidGenerator) {
916        delegate.setUuidGenerator(uuidGenerator);
917    }
918
919    @Override
920    public Boolean isLoadTypeConverters() {
921        return delegate.isLoadTypeConverters();
922    }
923
924    @Override
925    public void setLoadTypeConverters(Boolean loadTypeConverters) {
926        delegate.setLoadTypeConverters(loadTypeConverters);
927    }
928
929    @Override
930    public Boolean isTypeConverterStatisticsEnabled() {
931        return delegate.isTypeConverterStatisticsEnabled();
932    }
933
934    @Override
935    public void setTypeConverterStatisticsEnabled(Boolean typeConverterStatisticsEnabled) {
936        delegate.setTypeConverterStatisticsEnabled(typeConverterStatisticsEnabled);
937    }
938
939    @Override
940    public Boolean isLoadHealthChecks() {
941        return delegate.isLoadHealthChecks();
942    }
943
944    @Override
945    public void setLoadHealthChecks(Boolean loadHealthChecks) {
946        delegate.setLoadHealthChecks(loadHealthChecks);
947    }
948
949    @Override
950    public Boolean isSourceLocationEnabled() {
951        return delegate.isSourceLocationEnabled();
952    }
953
954    @Override
955    public void setSourceLocationEnabled(Boolean sourceLocationEnabled) {
956        delegate.setSourceLocationEnabled(sourceLocationEnabled);
957    }
958
959    @Override
960    public Boolean isModeline() {
961        return delegate.isModeline();
962    }
963
964    @Override
965    public void setModeline(Boolean modeline) {
966        delegate.setModeline(modeline);
967    }
968
969    @Override
970    public Boolean isDevConsole() {
971        return delegate.isDevConsole();
972    }
973
974    @Override
975    public void setDevConsole(Boolean loadDevConsoles) {
976        delegate.setDevConsole(loadDevConsoles);
977    }
978
979    @Override
980    public Boolean isDumpRoutes() {
981        return delegate.isDumpRoutes();
982    }
983
984    @Override
985    public void setDumpRoutes(Boolean dumpRoutes) {
986        delegate.setDumpRoutes(dumpRoutes);
987    }
988
989    @Override
990    public String getBasePackageScan() {
991        return getExtendedCamelContext().getBasePackageScan();
992    }
993
994    @Override
995    public void setBasePackageScan(String basePackageScan) {
996        getExtendedCamelContext().setBasePackageScan(basePackageScan);
997    }
998
999    @Override
1000    public Boolean isUseMDCLogging() {
1001        return delegate.isUseMDCLogging();
1002    }
1003
1004    @Override
1005    public void setUseMDCLogging(Boolean useMDCLogging) {
1006        delegate.setUseMDCLogging(useMDCLogging);
1007    }
1008
1009    @Override
1010    public String getMDCLoggingKeysPattern() {
1011        return delegate.getMDCLoggingKeysPattern();
1012    }
1013
1014    @Override
1015    public void setMDCLoggingKeysPattern(String pattern) {
1016        delegate.setMDCLoggingKeysPattern(pattern);
1017    }
1018
1019    @Override
1020    public Boolean isUseDataType() {
1021        return delegate.isUseDataType();
1022    }
1023
1024    @Override
1025    public void setUseDataType(Boolean useDataType) {
1026        delegate.setUseDataType(useDataType);
1027    }
1028
1029    @Override
1030    public Boolean isUseBreadcrumb() {
1031        return delegate.isUseBreadcrumb();
1032    }
1033
1034    @Override
1035    public void setUseBreadcrumb(Boolean useBreadcrumb) {
1036        delegate.setUseBreadcrumb(useBreadcrumb);
1037    }
1038
1039    @Override
1040    public StreamCachingStrategy getStreamCachingStrategy() {
1041        return delegate.getStreamCachingStrategy();
1042    }
1043
1044    @Override
1045    public void setStreamCachingStrategy(StreamCachingStrategy streamCachingStrategy) {
1046        delegate.setStreamCachingStrategy(streamCachingStrategy);
1047    }
1048
1049    @Override
1050    public RuntimeEndpointRegistry getRuntimeEndpointRegistry() {
1051        return delegate.getRuntimeEndpointRegistry();
1052    }
1053
1054    @Override
1055    public void setRuntimeEndpointRegistry(RuntimeEndpointRegistry runtimeEndpointRegistry) {
1056        delegate.setRuntimeEndpointRegistry(runtimeEndpointRegistry);
1057    }
1058
1059    @Override
1060    public void setSSLContextParameters(SSLContextParameters sslContextParameters) {
1061        delegate.setSSLContextParameters(sslContextParameters);
1062    }
1063
1064    @Override
1065    public SSLContextParameters getSSLContextParameters() {
1066        return delegate.getSSLContextParameters();
1067    }
1068
1069    @Override
1070    public void setStartupSummaryLevel(StartupSummaryLevel startupSummaryLevel) {
1071        delegate.setStartupSummaryLevel(startupSummaryLevel);
1072    }
1073
1074    @Override
1075    public StartupSummaryLevel getStartupSummaryLevel() {
1076        return delegate.getStartupSummaryLevel();
1077    }
1078
1079    @Override
1080    public void setStreamCaching(Boolean cache) {
1081        delegate.setStreamCaching(cache);
1082    }
1083
1084    @Override
1085    public Boolean isStreamCaching() {
1086        return delegate.isStreamCaching();
1087    }
1088
1089    @Override
1090    public void setTracing(Boolean tracing) {
1091        delegate.setTracing(tracing);
1092    }
1093
1094    @Override
1095    public Boolean isTracing() {
1096        return delegate.isTracing();
1097    }
1098
1099    @Override
1100    public String getTracingPattern() {
1101        return delegate.getTracingPattern();
1102    }
1103
1104    @Override
1105    public void setTracingPattern(String tracePattern) {
1106        delegate.setTracingPattern(tracePattern);
1107    }
1108
1109    @Override
1110    public String getTracingLoggingFormat() {
1111        return delegate.getTracingLoggingFormat();
1112    }
1113
1114    @Override
1115    public void setTracingLoggingFormat(String format) {
1116        delegate.setTracingLoggingFormat(format);
1117    }
1118
1119    @Override
1120    public void setBacklogTracing(Boolean backlogTrace) {
1121        delegate.setBacklogTracing(backlogTrace);
1122    }
1123
1124    @Override
1125    public Boolean isBacklogTracing() {
1126        return delegate.isBacklogTracing();
1127    }
1128
1129    @Override
1130    public void setDebugging(Boolean debugging) {
1131        delegate.setDebugging(debugging);
1132    }
1133
1134    @Override
1135    public Boolean isDebugging() {
1136        return delegate.isDebugging();
1137    }
1138
1139    @Override
1140    public void setMessageHistory(Boolean messageHistory) {
1141        delegate.setMessageHistory(messageHistory);
1142    }
1143
1144    @Override
1145    public Boolean isMessageHistory() {
1146        return delegate.isMessageHistory();
1147    }
1148
1149    @Override
1150    public void setLogMask(Boolean logMask) {
1151        delegate.setLogMask(logMask);
1152    }
1153
1154    @Override
1155    public Boolean isLogMask() {
1156        return delegate.isLogMask();
1157    }
1158
1159    @Override
1160    public void setLogExhaustedMessageBody(Boolean logExhaustedMessageBody) {
1161        delegate.setLogExhaustedMessageBody(logExhaustedMessageBody);
1162    }
1163
1164    @Override
1165    public Boolean isLogExhaustedMessageBody() {
1166        return delegate.isLogExhaustedMessageBody();
1167    }
1168
1169    @Override
1170    public void setDelayer(Long delay) {
1171        delegate.setDelayer(delay);
1172    }
1173
1174    @Override
1175    public Long getDelayer() {
1176        return delegate.getDelayer();
1177    }
1178
1179    @Override
1180    public void setAutoStartup(Boolean autoStartup) {
1181        delegate.setAutoStartup(autoStartup);
1182    }
1183
1184    @Override
1185    public Boolean isAutoStartup() {
1186        return delegate.isAutoStartup();
1187    }
1188
1189    @Override
1190    public void setShutdownRoute(ShutdownRoute shutdownRoute) {
1191        delegate.setShutdownRoute(shutdownRoute);
1192    }
1193
1194    @Override
1195    public ShutdownRoute getShutdownRoute() {
1196        return delegate.getShutdownRoute();
1197    }
1198
1199    @Override
1200    public void setShutdownRunningTask(ShutdownRunningTask shutdownRunningTask) {
1201        delegate.setShutdownRunningTask(shutdownRunningTask);
1202    }
1203
1204    @Override
1205    public ShutdownRunningTask getShutdownRunningTask() {
1206        return delegate.getShutdownRunningTask();
1207    }
1208
1209    @Override
1210    public void setAllowUseOriginalMessage(Boolean allowUseOriginalMessage) {
1211        delegate.setAllowUseOriginalMessage(allowUseOriginalMessage);
1212    }
1213
1214    @Override
1215    public Boolean isAllowUseOriginalMessage() {
1216        return delegate.isAllowUseOriginalMessage();
1217    }
1218
1219    @Override
1220    public Boolean isCaseInsensitiveHeaders() {
1221        return delegate.isCaseInsensitiveHeaders();
1222    }
1223
1224    @Override
1225    public void setCaseInsensitiveHeaders(Boolean caseInsensitiveHeaders) {
1226        delegate.setCaseInsensitiveHeaders(caseInsensitiveHeaders);
1227    }
1228
1229    @Override
1230    public Boolean isAutowiredEnabled() {
1231        return delegate.isAutowiredEnabled();
1232    }
1233
1234    @Override
1235    public void setAutowiredEnabled(Boolean autowiredEnabled) {
1236        delegate.setAutowiredEnabled(autowiredEnabled);
1237    }
1238
1239    @Override
1240    public void removeRouteTemplates(String pattern) throws Exception {
1241        delegate.removeRouteTemplates(pattern);
1242    }
1243
1244    //
1245    // ExtendedCamelContext
1246    //
1247
1248    protected ExtendedCamelContext getExtendedCamelContext() {
1249        return delegate.adapt(ExtendedCamelContext.class);
1250    }
1251
1252    @Override
1253    public void setName(String name) {
1254        getExtendedCamelContext().setName(name);
1255    }
1256
1257    @Override
1258    public void setRegistry(Registry registry) {
1259        getExtendedCamelContext().setRegistry(registry);
1260    }
1261
1262    @Override
1263    public void setupRoutes(boolean done) {
1264        getExtendedCamelContext().setupRoutes(done);
1265    }
1266
1267    @Override
1268    public boolean isSetupRoutes() {
1269        return getExtendedCamelContext().isSetupRoutes();
1270    }
1271
1272    @Override
1273    public void registerEndpointCallback(EndpointStrategy strategy) {
1274        getExtendedCamelContext().registerEndpointCallback(strategy);
1275    }
1276
1277    @Override
1278    public Endpoint getPrototypeEndpoint(String uri) {
1279        return getExtendedCamelContext().getPrototypeEndpoint(uri);
1280    }
1281
1282    @Override
1283    public Endpoint getPrototypeEndpoint(NormalizedEndpointUri uri) {
1284        return getExtendedCamelContext().getPrototypeEndpoint(uri);
1285    }
1286
1287    @Override
1288    public Endpoint hasEndpoint(NormalizedEndpointUri uri) {
1289        return getExtendedCamelContext().hasEndpoint(uri);
1290    }
1291
1292    @Override
1293    public Endpoint getEndpoint(NormalizedEndpointUri uri) {
1294        return getExtendedCamelContext().getEndpoint(uri);
1295    }
1296
1297    @Override
1298    public Endpoint getEndpoint(NormalizedEndpointUri uri, Map<String, Object> parameters) {
1299        return getExtendedCamelContext().getEndpoint(uri, parameters);
1300    }
1301
1302    @Override
1303    public NormalizedEndpointUri normalizeUri(String uri) {
1304        return getExtendedCamelContext().normalizeUri(uri);
1305    }
1306
1307    @Override
1308    public List<RouteStartupOrder> getRouteStartupOrder() {
1309        return getExtendedCamelContext().getRouteStartupOrder();
1310    }
1311
1312    @Override
1313    public CamelBeanPostProcessor getBeanPostProcessor() {
1314        return getExtendedCamelContext().getBeanPostProcessor();
1315    }
1316
1317    @Override
1318    public void setBeanPostProcessor(CamelBeanPostProcessor beanPostProcessor) {
1319        getExtendedCamelContext().setBeanPostProcessor(beanPostProcessor);
1320    }
1321
1322    @Override
1323    public CamelDependencyInjectionAnnotationFactory getDependencyInjectionAnnotationFactory() {
1324        return getExtendedCamelContext().getDependencyInjectionAnnotationFactory();
1325    }
1326
1327    @Override
1328    public void setDependencyInjectionAnnotationFactory(CamelDependencyInjectionAnnotationFactory factory) {
1329        getExtendedCamelContext().setDependencyInjectionAnnotationFactory(factory);
1330    }
1331
1332    @Override
1333    public ManagementMBeanAssembler getManagementMBeanAssembler() {
1334        return getExtendedCamelContext().getManagementMBeanAssembler();
1335    }
1336
1337    @Override
1338    public ErrorHandlerFactory getErrorHandlerFactory() {
1339        return getExtendedCamelContext().getErrorHandlerFactory();
1340    }
1341
1342    @Override
1343    public void setErrorHandlerFactory(ErrorHandlerFactory errorHandlerFactory) {
1344        getExtendedCamelContext().setErrorHandlerFactory(errorHandlerFactory);
1345    }
1346
1347    @Override
1348    public void setNodeIdFactory(NodeIdFactory factory) {
1349        getExtendedCamelContext().setNodeIdFactory(factory);
1350    }
1351
1352    @Override
1353    public NodeIdFactory getNodeIdFactory() {
1354        return getExtendedCamelContext().getNodeIdFactory();
1355    }
1356
1357    @Override
1358    public ComponentResolver getComponentResolver() {
1359        return getExtendedCamelContext().getComponentResolver();
1360    }
1361
1362    @Override
1363    public void setComponentResolver(ComponentResolver componentResolver) {
1364        getExtendedCamelContext().setComponentResolver(componentResolver);
1365    }
1366
1367    @Override
1368    public ComponentNameResolver getComponentNameResolver() {
1369        return getExtendedCamelContext().getComponentNameResolver();
1370    }
1371
1372    @Override
1373    public void setComponentNameResolver(ComponentNameResolver componentNameResolver) {
1374        getExtendedCamelContext().setComponentNameResolver(componentNameResolver);
1375    }
1376
1377    @Override
1378    public LanguageResolver getLanguageResolver() {
1379        return getExtendedCamelContext().getLanguageResolver();
1380    }
1381
1382    @Override
1383    public void setLanguageResolver(LanguageResolver languageResolver) {
1384        getExtendedCamelContext().setLanguageResolver(languageResolver);
1385    }
1386
1387    @Override
1388    public DataFormatResolver getDataFormatResolver() {
1389        return getExtendedCamelContext().getDataFormatResolver();
1390    }
1391
1392    @Override
1393    public void setDataFormatResolver(DataFormatResolver dataFormatResolver) {
1394        getExtendedCamelContext().setDataFormatResolver(dataFormatResolver);
1395    }
1396
1397    @Override
1398    public HealthCheckResolver getHealthCheckResolver() {
1399        return getExtendedCamelContext().getHealthCheckResolver();
1400    }
1401
1402    @Override
1403    public void setHealthCheckResolver(HealthCheckResolver healthCheckResolver) {
1404        getExtendedCamelContext().setHealthCheckResolver(healthCheckResolver);
1405    }
1406
1407    @Override
1408    public DevConsoleResolver getDevConsoleResolver() {
1409        return getExtendedCamelContext().getDevConsoleResolver();
1410    }
1411
1412    @Override
1413    public void setDevConsoleResolver(DevConsoleResolver devConsoleResolver) {
1414        getExtendedCamelContext().setDevConsoleResolver(devConsoleResolver);
1415    }
1416
1417    @Override
1418    public PackageScanClassResolver getPackageScanClassResolver() {
1419        return getExtendedCamelContext().getPackageScanClassResolver();
1420    }
1421
1422    @Override
1423    public void setPackageScanClassResolver(PackageScanClassResolver resolver) {
1424        getExtendedCamelContext().setPackageScanClassResolver(resolver);
1425    }
1426
1427    @Override
1428    public PackageScanResourceResolver getPackageScanResourceResolver() {
1429        return getExtendedCamelContext().getPackageScanResourceResolver();
1430    }
1431
1432    @Override
1433    public void setPackageScanResourceResolver(PackageScanResourceResolver resolver) {
1434        getExtendedCamelContext().setPackageScanResourceResolver(resolver);
1435    }
1436
1437    @Override
1438    public FactoryFinder getDefaultFactoryFinder() {
1439        return getExtendedCamelContext().getDefaultFactoryFinder();
1440    }
1441
1442    @Override
1443    public ConfigurerResolver getBootstrapConfigurerResolver() {
1444        return getExtendedCamelContext().getBootstrapConfigurerResolver();
1445    }
1446
1447    @Override
1448    public void setBootstrapConfigurerResolver(ConfigurerResolver configurerResolver) {
1449        getExtendedCamelContext().setBootstrapConfigurerResolver(configurerResolver);
1450    }
1451
1452    @Override
1453    public FactoryFinder getBootstrapFactoryFinder() {
1454        return getExtendedCamelContext().getBootstrapFactoryFinder();
1455    }
1456
1457    @Override
1458    public void setBootstrapFactoryFinder(FactoryFinder factoryFinder) {
1459        getExtendedCamelContext().setBootstrapFactoryFinder(factoryFinder);
1460    }
1461
1462    @Override
1463    public FactoryFinder getBootstrapFactoryFinder(String path) {
1464        return getExtendedCamelContext().getBootstrapFactoryFinder(path);
1465    }
1466
1467    @Override
1468    public FactoryFinder getFactoryFinder(String path) {
1469        return getExtendedCamelContext().getFactoryFinder(path);
1470    }
1471
1472    @Override
1473    public void setFactoryFinderResolver(FactoryFinderResolver resolver) {
1474        getExtendedCamelContext().setFactoryFinderResolver(resolver);
1475    }
1476
1477    @Override
1478    public FactoryFinderResolver getFactoryFinderResolver() {
1479        return getExtendedCamelContext().getFactoryFinderResolver();
1480    }
1481
1482    @Override
1483    public ProcessorFactory getProcessorFactory() {
1484        return getExtendedCamelContext().getProcessorFactory();
1485    }
1486
1487    @Override
1488    public void setProcessorFactory(ProcessorFactory processorFactory) {
1489        getExtendedCamelContext().setProcessorFactory(processorFactory);
1490    }
1491
1492    @Override
1493    public ModelineFactory getModelineFactory() {
1494        return getExtendedCamelContext().getModelineFactory();
1495    }
1496
1497    @Override
1498    public void setModelineFactory(ModelineFactory modelineFactory) {
1499        getExtendedCamelContext().setModelineFactory(modelineFactory);
1500    }
1501
1502    @Override
1503    public InternalProcessorFactory getInternalProcessorFactory() {
1504        return getExtendedCamelContext().getInternalProcessorFactory();
1505    }
1506
1507    @Override
1508    public void setInternalProcessorFactory(InternalProcessorFactory internalProcessorFactory) {
1509        getExtendedCamelContext().setInternalProcessorFactory(internalProcessorFactory);
1510    }
1511
1512    @Override
1513    public InterceptEndpointFactory getInterceptEndpointFactory() {
1514        return getExtendedCamelContext().getInterceptEndpointFactory();
1515    }
1516
1517    @Override
1518    public void setInterceptEndpointFactory(InterceptEndpointFactory interceptEndpointFactory) {
1519        getExtendedCamelContext().setInterceptEndpointFactory(interceptEndpointFactory);
1520    }
1521
1522    @Override
1523    public RouteFactory getRouteFactory() {
1524        return getExtendedCamelContext().getRouteFactory();
1525    }
1526
1527    @Override
1528    public void setRouteFactory(RouteFactory routeFactory) {
1529        getExtendedCamelContext().setRouteFactory(routeFactory);
1530    }
1531
1532    @Override
1533    public ModelJAXBContextFactory getModelJAXBContextFactory() {
1534        return getExtendedCamelContext().getModelJAXBContextFactory();
1535    }
1536
1537    @Override
1538    public void setModelJAXBContextFactory(ModelJAXBContextFactory modelJAXBContextFactory) {
1539        getExtendedCamelContext().setModelJAXBContextFactory(modelJAXBContextFactory);
1540    }
1541
1542    @Override
1543    public DeferServiceFactory getDeferServiceFactory() {
1544        return getExtendedCamelContext().getDeferServiceFactory();
1545    }
1546
1547    @Override
1548    public void setDeferServiceFactory(DeferServiceFactory deferServiceFactory) {
1549        getExtendedCamelContext().setDeferServiceFactory(deferServiceFactory);
1550    }
1551
1552    @Override
1553    public UnitOfWorkFactory getUnitOfWorkFactory() {
1554        return getExtendedCamelContext().getUnitOfWorkFactory();
1555    }
1556
1557    @Override
1558    public void setUnitOfWorkFactory(UnitOfWorkFactory unitOfWorkFactory) {
1559        getExtendedCamelContext().setUnitOfWorkFactory(unitOfWorkFactory);
1560    }
1561
1562    @Override
1563    public AnnotationBasedProcessorFactory getAnnotationBasedProcessorFactory() {
1564        return getExtendedCamelContext().getAnnotationBasedProcessorFactory();
1565    }
1566
1567    @Override
1568    public void setAnnotationBasedProcessorFactory(AnnotationBasedProcessorFactory annotationBasedProcessorFactory) {
1569        getExtendedCamelContext().setAnnotationBasedProcessorFactory(annotationBasedProcessorFactory);
1570    }
1571
1572    @Override
1573    public BeanProxyFactory getBeanProxyFactory() {
1574        return getExtendedCamelContext().getBeanProxyFactory();
1575    }
1576
1577    @Override
1578    public BeanProcessorFactory getBeanProcessorFactory() {
1579        return getExtendedCamelContext().getBeanProcessorFactory();
1580    }
1581
1582    @Override
1583    public ScheduledExecutorService getErrorHandlerExecutorService() {
1584        return getExtendedCamelContext().getErrorHandlerExecutorService();
1585    }
1586
1587    @Override
1588    public void addInterceptStrategy(InterceptStrategy interceptStrategy) {
1589        getExtendedCamelContext().addInterceptStrategy(interceptStrategy);
1590    }
1591
1592    @Override
1593    public List<InterceptStrategy> getInterceptStrategies() {
1594        return getExtendedCamelContext().getInterceptStrategies();
1595    }
1596
1597    @Override
1598    public void setupManagement(Map<String, Object> options) {
1599        getExtendedCamelContext().setupManagement(options);
1600    }
1601
1602    @Override
1603    public Set<LogListener> getLogListeners() {
1604        return getExtendedCamelContext().getLogListeners();
1605    }
1606
1607    @Override
1608    public void addLogListener(LogListener listener) {
1609        getExtendedCamelContext().addLogListener(listener);
1610    }
1611
1612    @Override
1613    public AsyncProcessorAwaitManager getAsyncProcessorAwaitManager() {
1614        return getExtendedCamelContext().getAsyncProcessorAwaitManager();
1615    }
1616
1617    @Override
1618    public void setAsyncProcessorAwaitManager(AsyncProcessorAwaitManager manager) {
1619        getExtendedCamelContext().setAsyncProcessorAwaitManager(manager);
1620    }
1621
1622    @Override
1623    public BeanIntrospection getBeanIntrospection() {
1624        return getExtendedCamelContext().getBeanIntrospection();
1625    }
1626
1627    @Override
1628    public void setBeanIntrospection(BeanIntrospection beanIntrospection) {
1629        getExtendedCamelContext().setBeanIntrospection(beanIntrospection);
1630    }
1631
1632    @Override
1633    public HeadersMapFactory getHeadersMapFactory() {
1634        return getExtendedCamelContext().getHeadersMapFactory();
1635    }
1636
1637    @Override
1638    public void setHeadersMapFactory(HeadersMapFactory factory) {
1639        getExtendedCamelContext().setHeadersMapFactory(factory);
1640    }
1641
1642    @Override
1643    public ExchangeFactory getExchangeFactory() {
1644        return getExtendedCamelContext().getExchangeFactory();
1645    }
1646
1647    @Override
1648    public void setExchangeFactory(ExchangeFactory exchangeFactory) {
1649        getExtendedCamelContext().setExchangeFactory(exchangeFactory);
1650    }
1651
1652    @Override
1653    public ExchangeFactoryManager getExchangeFactoryManager() {
1654        return getExtendedCamelContext().getExchangeFactoryManager();
1655    }
1656
1657    @Override
1658    public void setExchangeFactoryManager(ExchangeFactoryManager exchangeFactoryManager) {
1659        getExtendedCamelContext().setExchangeFactoryManager(exchangeFactoryManager);
1660    }
1661
1662    @Override
1663    public ProcessorExchangeFactory getProcessorExchangeFactory() {
1664        return getExtendedCamelContext().getProcessorExchangeFactory();
1665    }
1666
1667    @Override
1668    public void setProcessorExchangeFactory(ProcessorExchangeFactory processorExchangeFactory) {
1669        getExtendedCamelContext().setProcessorExchangeFactory(processorExchangeFactory);
1670    }
1671
1672    @Override
1673    public ReactiveExecutor getReactiveExecutor() {
1674        return getExtendedCamelContext().getReactiveExecutor();
1675    }
1676
1677    @Override
1678    public void setReactiveExecutor(ReactiveExecutor reactiveExecutor) {
1679        getExtendedCamelContext().setReactiveExecutor(reactiveExecutor);
1680    }
1681
1682    @Override
1683    public boolean isEventNotificationApplicable() {
1684        return getExtendedCamelContext().isEventNotificationApplicable();
1685    }
1686
1687    @Override
1688    public void setEventNotificationApplicable(boolean eventNotificationApplicable) {
1689        getExtendedCamelContext().setEventNotificationApplicable(eventNotificationApplicable);
1690    }
1691
1692    @Override
1693    public void setXMLRoutesDefinitionLoader(XMLRoutesDefinitionLoader xmlRoutesDefinitionLoader) {
1694        getExtendedCamelContext().setXMLRoutesDefinitionLoader(xmlRoutesDefinitionLoader);
1695    }
1696
1697    @Override
1698    public XMLRoutesDefinitionLoader getXMLRoutesDefinitionLoader() {
1699        return getExtendedCamelContext().getXMLRoutesDefinitionLoader();
1700    }
1701
1702    @Override
1703    public void setRoutesLoader(RoutesLoader routesLoader) {
1704        getExtendedCamelContext().setRoutesLoader(routesLoader);
1705    }
1706
1707    @Override
1708    public RoutesLoader getRoutesLoader() {
1709        return getExtendedCamelContext().getRoutesLoader();
1710    }
1711
1712    @Override
1713    public ResourceLoader getResourceLoader() {
1714        return getExtendedCamelContext().getResourceLoader();
1715    }
1716
1717    @Override
1718    public void setResourceLoader(ResourceLoader resourceLoader) {
1719        getExtendedCamelContext().setResourceLoader(resourceLoader);
1720    }
1721
1722    @Override
1723    public void setModelToXMLDumper(ModelToXMLDumper modelToXMLDumper) {
1724        getExtendedCamelContext().setModelToXMLDumper(modelToXMLDumper);
1725    }
1726
1727    @Override
1728    public ModelToXMLDumper getModelToXMLDumper() {
1729        return getExtendedCamelContext().getModelToXMLDumper();
1730    }
1731
1732    @Override
1733    public void setRestBindingJaxbDataFormatFactory(RestBindingJaxbDataFormatFactory restBindingJaxbDataFormatFactory) {
1734        getExtendedCamelContext().setRestBindingJaxbDataFormatFactory(restBindingJaxbDataFormatFactory);
1735    }
1736
1737    @Override
1738    public RestBindingJaxbDataFormatFactory getRestBindingJaxbDataFormatFactory() {
1739        return getExtendedCamelContext().getRestBindingJaxbDataFormatFactory();
1740    }
1741
1742    @Override
1743    public RuntimeCamelCatalog getRuntimeCamelCatalog() {
1744        return getExtendedCamelContext().getRuntimeCamelCatalog();
1745    }
1746
1747    @Override
1748    public void setRuntimeCamelCatalog(RuntimeCamelCatalog runtimeCamelCatalog) {
1749        getExtendedCamelContext().setRuntimeCamelCatalog(runtimeCamelCatalog);
1750    }
1751
1752    @Override
1753    public ConfigurerResolver getConfigurerResolver() {
1754        return getExtendedCamelContext().getConfigurerResolver();
1755    }
1756
1757    @Override
1758    public void setConfigurerResolver(ConfigurerResolver configurerResolver) {
1759        getExtendedCamelContext().setConfigurerResolver(configurerResolver);
1760    }
1761
1762    @Override
1763    public UriFactoryResolver getUriFactoryResolver() {
1764        return getExtendedCamelContext().getUriFactoryResolver();
1765    }
1766
1767    @Override
1768    public void setUriFactoryResolver(UriFactoryResolver uriFactoryResolver) {
1769        getExtendedCamelContext().setUriFactoryResolver(uriFactoryResolver);
1770    }
1771
1772    @Override
1773    public RouteController getInternalRouteController() {
1774        return getExtendedCamelContext().getInternalRouteController();
1775    }
1776
1777    @Override
1778    public EndpointUriFactory getEndpointUriFactory(String scheme) {
1779        return getExtendedCamelContext().getEndpointUriFactory(scheme);
1780    }
1781
1782    @Override
1783    public void addRoute(Route route) {
1784        getExtendedCamelContext().addRoute(route);
1785    }
1786
1787    @Override
1788    public void removeRoute(Route route) {
1789        getExtendedCamelContext().removeRoute(route);
1790    }
1791
1792    @Override
1793    public Processor createErrorHandler(Route route, Processor processor) throws Exception {
1794        return getExtendedCamelContext().createErrorHandler(route, processor);
1795    }
1796
1797    @Override
1798    public void setLightweight(boolean lightweight) {
1799        getExtendedCamelContext().setLightweight(lightweight);
1800    }
1801
1802    @Override
1803    public boolean isLightweight() {
1804        return getExtendedCamelContext().isLightweight();
1805    }
1806
1807    @Override
1808    public StartupStepRecorder getStartupStepRecorder() {
1809        return getExtendedCamelContext().getStartupStepRecorder();
1810    }
1811
1812    @Override
1813    public void setStartupStepRecorder(StartupStepRecorder startupStepRecorder) {
1814        getExtendedCamelContext().setStartupStepRecorder(startupStepRecorder);
1815    }
1816
1817    @Override
1818    public CliConnectorFactory getCliConnectorFactory() {
1819        return getExtendedCamelContext().getCliConnectorFactory();
1820    }
1821
1822    @Override
1823    public void setCliConnectorFactory(CliConnectorFactory cliConnectorFactory) {
1824        getExtendedCamelContext().setCliConnectorFactory(cliConnectorFactory);
1825    }
1826
1827    @Override
1828    public String getTestExcludeRoutes() {
1829        return getExtendedCamelContext().getTestExcludeRoutes();
1830    }
1831
1832    //
1833    // CatalogCamelContext
1834    //
1835
1836    protected CatalogCamelContext getCatalogCamelContext() {
1837        return delegate.adapt(CatalogCamelContext.class);
1838    }
1839
1840    @Override
1841    public String getComponentParameterJsonSchema(String componentName) throws IOException {
1842        return getCatalogCamelContext().getComponentParameterJsonSchema(componentName);
1843    }
1844
1845    @Override
1846    public String getDataFormatParameterJsonSchema(String dataFormatName) throws IOException {
1847        return getCatalogCamelContext().getDataFormatParameterJsonSchema(dataFormatName);
1848    }
1849
1850    @Override
1851    public String getLanguageParameterJsonSchema(String languageName) throws IOException {
1852        return getCatalogCamelContext().getLanguageParameterJsonSchema(languageName);
1853    }
1854
1855    @Override
1856    public String getEipParameterJsonSchema(String eipName) throws IOException {
1857        return getCatalogCamelContext().getEipParameterJsonSchema(eipName);
1858    }
1859
1860    //
1861    // ModelCamelContext
1862    //
1863
1864    protected ModelCamelContext getModelCamelContext() {
1865        return delegate.adapt(ModelCamelContext.class);
1866    }
1867
1868    @Override
1869    public void addModelLifecycleStrategy(ModelLifecycleStrategy modelLifecycleStrategy) {
1870        getModelCamelContext().addModelLifecycleStrategy(modelLifecycleStrategy);
1871    }
1872
1873    @Override
1874    public List<ModelLifecycleStrategy> getModelLifecycleStrategies() {
1875        return getModelCamelContext().getModelLifecycleStrategies();
1876    }
1877
1878    @Override
1879    public void addRouteConfiguration(RouteConfigurationDefinition routesConfiguration) {
1880        getModelCamelContext().addRouteConfiguration(routesConfiguration);
1881    }
1882
1883    @Override
1884    public void addRouteConfigurations(List<RouteConfigurationDefinition> routesConfigurations) {
1885        getModelCamelContext().addRouteConfigurations(routesConfigurations);
1886    }
1887
1888    @Override
1889    public List<RouteConfigurationDefinition> getRouteConfigurationDefinitions() {
1890        return getModelCamelContext().getRouteConfigurationDefinitions();
1891    }
1892
1893    @Override
1894    public void removeRouteConfiguration(RouteConfigurationDefinition routeConfigurationDefinition) throws Exception {
1895        getModelCamelContext().removeRouteConfiguration(routeConfigurationDefinition);
1896    }
1897
1898    @Override
1899    public RouteConfigurationDefinition getRouteConfigurationDefinition(String id) {
1900        return getModelCamelContext().getRouteConfigurationDefinition(id);
1901    }
1902
1903    @Override
1904    public List<RouteDefinition> getRouteDefinitions() {
1905        return getModelCamelContext().getRouteDefinitions();
1906    }
1907
1908    @Override
1909    public RouteDefinition getRouteDefinition(String id) {
1910        return getModelCamelContext().getRouteDefinition(id);
1911    }
1912
1913    @Override
1914    public void addRouteDefinitions(Collection<RouteDefinition> routeDefinitions) throws Exception {
1915        getModelCamelContext().addRouteDefinitions(routeDefinitions);
1916    }
1917
1918    @Override
1919    public void addRouteDefinition(RouteDefinition routeDefinition) throws Exception {
1920        getModelCamelContext().addRouteDefinition(routeDefinition);
1921    }
1922
1923    @Override
1924    public void removeRouteDefinitions(Collection<RouteDefinition> routeDefinitions) throws Exception {
1925        getModelCamelContext().removeRouteDefinitions(routeDefinitions);
1926    }
1927
1928    @Override
1929    public void removeRouteDefinition(RouteDefinition routeDefinition) throws Exception {
1930        getModelCamelContext().removeRouteDefinition(routeDefinition);
1931    }
1932
1933    @Override
1934    public List<RouteTemplateDefinition> getRouteTemplateDefinitions() {
1935        return getModelCamelContext().getRouteTemplateDefinitions();
1936    }
1937
1938    @Override
1939    public RouteTemplateDefinition getRouteTemplateDefinition(String id) {
1940        return getModelCamelContext().getRouteTemplateDefinition(id);
1941    }
1942
1943    @Override
1944    public void addRouteTemplateDefinitions(Collection<RouteTemplateDefinition> routeTemplateDefinitions) throws Exception {
1945        getModelCamelContext().addRouteTemplateDefinitions(routeTemplateDefinitions);
1946    }
1947
1948    @Override
1949    public void addRouteTemplateDefinition(RouteTemplateDefinition routeTemplateDefinition) throws Exception {
1950        getModelCamelContext().addRouteTemplateDefinition(routeTemplateDefinition);
1951    }
1952
1953    @Override
1954    public void removeRouteTemplateDefinitions(Collection<RouteTemplateDefinition> routeTemplateDefinitions) throws Exception {
1955        getModelCamelContext().removeRouteTemplateDefinitions(routeTemplateDefinitions);
1956    }
1957
1958    @Override
1959    public void removeRouteTemplateDefinition(RouteTemplateDefinition routeTemplateDefinition) throws Exception {
1960        getModelCamelContext().removeRouteTemplateDefinition(routeTemplateDefinition);
1961    }
1962
1963    @Override
1964    public void addRouteTemplateDefinitionConverter(String templateIdPattern, RouteTemplateDefinition.Converter converter) {
1965        getModelCamelContext().addRouteTemplateDefinitionConverter(templateIdPattern, converter);
1966    }
1967
1968    @Override
1969    public String addRouteFromTemplate(String routeId, String routeTemplateId, Map<String, Object> parameters)
1970            throws Exception {
1971        return getModelCamelContext().addRouteFromTemplate(routeId, routeTemplateId, parameters);
1972    }
1973
1974    @Override
1975    public String addRouteFromTemplate(String routeId, String routeTemplateId, String prefixId, Map<String, Object> parameters)
1976            throws Exception {
1977        return getModelCamelContext().addRouteFromTemplate(routeId, routeTemplateId, prefixId, parameters);
1978    }
1979
1980    @Override
1981    public String addRouteFromTemplate(String routeId, String routeTemplateId, RouteTemplateContext routeTemplateContext)
1982            throws Exception {
1983        return getModelCamelContext().addRouteFromTemplate(routeId, routeTemplateId, routeTemplateContext);
1984    }
1985
1986    @Override
1987    public String addRouteFromTemplate(
1988            String routeId, String routeTemplateId, String prefixId, RouteTemplateContext routeTemplateContext)
1989            throws Exception {
1990        return getModelCamelContext().addRouteFromTemplate(routeId, routeTemplateId, prefixId, routeTemplateContext);
1991    }
1992
1993    @Override
1994    public void addRouteFromTemplatedRoute(TemplatedRouteDefinition templatedRouteDefinition)
1995            throws Exception {
1996        getModelCamelContext().addRouteFromTemplatedRoute(templatedRouteDefinition);
1997    }
1998
1999    @Override
2000    public void removeRouteTemplateDefinitions(String pattern) throws Exception {
2001        getModelCamelContext().removeRouteTemplateDefinitions(pattern);
2002    }
2003
2004    @Override
2005    public List<RestDefinition> getRestDefinitions() {
2006        return getModelCamelContext().getRestDefinitions();
2007    }
2008
2009    @Override
2010    public void addRestDefinitions(Collection<RestDefinition> restDefinitions, boolean addToRoutes) throws Exception {
2011        getModelCamelContext().addRestDefinitions(restDefinitions, addToRoutes);
2012    }
2013
2014    @Override
2015    public void setDataFormats(Map<String, DataFormatDefinition> dataFormats) {
2016        getModelCamelContext().setDataFormats(dataFormats);
2017    }
2018
2019    @Override
2020    public Map<String, DataFormatDefinition> getDataFormats() {
2021        return getModelCamelContext().getDataFormats();
2022    }
2023
2024    @Override
2025    public DataFormatDefinition resolveDataFormatDefinition(String name) {
2026        return getModelCamelContext().resolveDataFormatDefinition(name);
2027    }
2028
2029    @Override
2030    public ProcessorDefinition<?> getProcessorDefinition(String id) {
2031        return getModelCamelContext().getProcessorDefinition(id);
2032    }
2033
2034    @Override
2035    public <T extends ProcessorDefinition<T>> T getProcessorDefinition(String id, Class<T> type) {
2036        return getModelCamelContext().getProcessorDefinition(id, type);
2037    }
2038
2039    @Override
2040    public void setValidators(List<ValidatorDefinition> validators) {
2041        getModelCamelContext().setValidators(validators);
2042    }
2043
2044    @Override
2045    public Resilience4jConfigurationDefinition getResilience4jConfiguration(String id) {
2046        return getModelCamelContext().getResilience4jConfiguration(id);
2047    }
2048
2049    @Override
2050    public void setResilience4jConfiguration(Resilience4jConfigurationDefinition configuration) {
2051        getModelCamelContext().setResilience4jConfiguration(configuration);
2052    }
2053
2054    @Override
2055    public void setResilience4jConfigurations(List<Resilience4jConfigurationDefinition> configurations) {
2056        getModelCamelContext().setResilience4jConfigurations(configurations);
2057    }
2058
2059    @Override
2060    public void addResilience4jConfiguration(String id, Resilience4jConfigurationDefinition configuration) {
2061        getModelCamelContext().addResilience4jConfiguration(id, configuration);
2062    }
2063
2064    @Override
2065    public FaultToleranceConfigurationDefinition getFaultToleranceConfiguration(String id) {
2066        return getModelCamelContext().getFaultToleranceConfiguration(id);
2067    }
2068
2069    @Override
2070    public void setFaultToleranceConfiguration(FaultToleranceConfigurationDefinition configuration) {
2071        getModelCamelContext().setFaultToleranceConfiguration(configuration);
2072    }
2073
2074    @Override
2075    public void setFaultToleranceConfigurations(List<FaultToleranceConfigurationDefinition> configurations) {
2076        getModelCamelContext().setFaultToleranceConfigurations(configurations);
2077    }
2078
2079    @Override
2080    public void addFaultToleranceConfiguration(String id, FaultToleranceConfigurationDefinition configuration) {
2081        getModelCamelContext().addFaultToleranceConfiguration(id, configuration);
2082    }
2083
2084    @Override
2085    public List<ValidatorDefinition> getValidators() {
2086        return getModelCamelContext().getValidators();
2087    }
2088
2089    @Override
2090    public void setTransformers(List<TransformerDefinition> transformers) {
2091        getModelCamelContext().setTransformers(transformers);
2092    }
2093
2094    @Override
2095    public List<TransformerDefinition> getTransformers() {
2096        return getModelCamelContext().getTransformers();
2097    }
2098
2099    @Override
2100    public ServiceCallConfigurationDefinition getServiceCallConfiguration(String serviceName) {
2101        return getModelCamelContext().getServiceCallConfiguration(serviceName);
2102    }
2103
2104    @Override
2105    public void setServiceCallConfiguration(ServiceCallConfigurationDefinition configuration) {
2106        getModelCamelContext().setServiceCallConfiguration(configuration);
2107    }
2108
2109    @Override
2110    public void setServiceCallConfigurations(List<ServiceCallConfigurationDefinition> configurations) {
2111        getModelCamelContext().setServiceCallConfigurations(configurations);
2112    }
2113
2114    @Override
2115    public void addServiceCallConfiguration(String serviceName, ServiceCallConfigurationDefinition configuration) {
2116        getModelCamelContext().addServiceCallConfiguration(serviceName, configuration);
2117    }
2118
2119    @Override
2120    public void startRouteDefinitions() throws Exception {
2121        getModelCamelContext().startRouteDefinitions();
2122    }
2123
2124    @Override
2125    public void startRouteDefinitions(List<RouteDefinition> routeDefinitions) throws Exception {
2126        getModelCamelContext().startRouteDefinitions(routeDefinitions);
2127    }
2128
2129    @Override
2130    public void setRouteFilterPattern(String include, String exclude) {
2131        getModelCamelContext().setRouteFilterPattern(include, exclude);
2132    }
2133
2134    @Override
2135    public void setRouteFilter(Function<RouteDefinition, Boolean> filter) {
2136        getModelCamelContext().setRouteFilter(filter);
2137    }
2138
2139    @Override
2140    public Function<RouteDefinition, Boolean> getRouteFilter() {
2141        return getModelCamelContext().getRouteFilter();
2142    }
2143
2144    @Override
2145    public ModelReifierFactory getModelReifierFactory() {
2146        return getModelCamelContext().getModelReifierFactory();
2147    }
2148
2149    @Override
2150    public PeriodTaskScheduler getPeriodTaskScheduler() {
2151        return getExtendedCamelContext().getPeriodTaskScheduler();
2152    }
2153
2154    @Override
2155    public void setPeriodTaskScheduler(PeriodTaskScheduler periodTaskScheduler) {
2156        getExtendedCamelContext().setPeriodTaskScheduler(periodTaskScheduler);
2157
2158    }
2159
2160    @Override
2161    public PeriodTaskResolver getPeriodTaskResolver() {
2162        return getExtendedCamelContext().getPeriodTaskResolver();
2163    }
2164
2165    @Override
2166    public void setPeriodTaskResolver(PeriodTaskResolver periodTaskResolver) {
2167        getExtendedCamelContext().setPeriodTaskResolver(periodTaskResolver);
2168    }
2169
2170    @Override
2171    public void setModelReifierFactory(ModelReifierFactory modelReifierFactory) {
2172        getModelCamelContext().setModelReifierFactory(modelReifierFactory);
2173    }
2174
2175    @Override
2176    public Expression createExpression(ExpressionDefinition definition) {
2177        return getModelCamelContext().createExpression(definition);
2178    }
2179
2180    @Override
2181    public Predicate createPredicate(ExpressionDefinition definition) {
2182        return getModelCamelContext().createPredicate(definition);
2183    }
2184
2185    @Override
2186    public RouteDefinition adviceWith(RouteDefinition definition, AdviceWithRouteBuilder builder) throws Exception {
2187        return getModelCamelContext().adviceWith(definition, builder);
2188    }
2189
2190    @Override
2191    public void registerValidator(ValidatorDefinition validator) {
2192        getModelCamelContext().registerValidator(validator);
2193    }
2194
2195    @Override
2196    public void registerTransformer(TransformerDefinition transformer) {
2197        getModelCamelContext().registerTransformer(transformer);
2198    }
2199
2200    //
2201    // Immutable
2202    //
2203
2204    public void init() {
2205        if (delegate instanceof LightweightRuntimeCamelContext) {
2206            return;
2207        }
2208        delegate.init();
2209        for (Route route : delegate.getRoutes()) {
2210            route.clearRouteModel();
2211        }
2212        delegate = new LightweightRuntimeCamelContext(this, delegate);
2213    }
2214
2215    public void startImmutable() {
2216        delegate.start();
2217    }
2218
2219}