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