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