You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by lb...@apache.org on 2021/02/26 10:08:49 UTC
[camel] 01/09: CAMEL-12545: create a yaml based route loader
This is an automated email from the ASF dual-hosted git repository.
lburgazzoli pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 547ecc32db3fe7921e94426d04cb400fb3836493
Author: Luca Burgazzoli <lb...@gmail.com>
AuthorDate: Wed Feb 24 12:04:05 2021 +0100
CAMEL-12545: create a yaml based route loader
---
bom/camel-bom/pom.xml | 15 +
camel-dependencies/pom.xml | 3 +
catalog/camel-catalog/pom.xml | 1 +
.../org/apache/camel/catalog/docs/yaml-dsl.adoc | 216 +
.../apache/camel/spi/annotations/RoutesLoader.java | 4 +-
.../annotations/{RoutesLoader.java => YamlIn.java} | 12 +-
.../{RoutesLoader.java => YamlOut.java} | 12 +-
.../{RoutesLoader.java => YamlProperty.java} | 19 +-
.../{RoutesLoader.java => YamlType.java} | 17 +-
.../org/apache/camel/util/CollectionHelper.java | 1 +
docs/components/modules/others/pages/yaml-dsl.adoc | 218 +
dsl/camel-yaml-dsl/camel-yaml-dsl-common/pom.xml | 138 +
.../services/org/apache/camel/other.properties | 7 +
.../src/generated/resources/yaml-dsl-common.json | 14 +
.../yaml/common/YamlDeserializationContext.java | 231 +
.../dsl/yaml/common/YamlDeserializerBase.java | 112 +
.../dsl/yaml/common/YamlDeserializerResolver.java | 28 +-
.../dsl/yaml/common/YamlDeserializerSupport.java | 334 +
.../apache/camel/dsl/yaml/common/YamlSupport.java | 232 +
.../exception/UnknownNodeConstructorException.java | 22 +-
.../common/exception/UnknownNodeTypeException.java | 22 +-
.../common/exception/UnknownPropertyException.java | 24 +-
.../exception/UnsupportedFieldException.java | 23 +-
.../exception/UnsupportedNodeTypeException.java | 24 +-
.../exception/YamlDeserializationException.java | 26 +-
.../dsl/yaml/common/ConstructorResolverTest.groovy | 149 +
.../src/test/resources/log4j2-test.properties | 31 +
.../camel-yaml-dsl-deserializers/pom.xml | 139 +
.../EndpointConsumerDeserializersResolver.java | 244 +
.../EndpointProducerDeserializersResolver.java | 348 +
.../deserializers/ExpressionDeserializers.java | 175 +
.../dsl/yaml/deserializers/ModelDeserializers.java | 16620 +++++++++++++++++++
.../deserializers/ModelDeserializersResolver.java | 435 +
.../dsl/yaml/deserializers/BeansDeserializer.java | 107 +
.../dsl/yaml/deserializers/CustomResolver.java | 69 +
.../yaml/deserializers/EndpointDeserializers.java | 54 +
.../ErrorHandlerBuilderDeserializer.java | 59 +
.../deserializers/FromDefinitionDeserializer.java | 98 +
.../ProcessorDefinitionDefinitionDeserializer.java | 44 +
.../deserializers/RouteDefinitionDeserializer.java | 85 +
.../RouteFromDefinitionDeserializer.java | 107 +
.../SagaActionUriDefinitionDeserializer.java | 96 +
.../SagaOptionDefinitionDeserializer.java | 72 +
.../deserializers/TryDefinitionDeserializer.java | 61 +
.../model/OutputAwareFromDefinition.java | 60 +
.../camel/dsl/yaml/deserializers/SplitTest.groovy | 96 +
.../src/test/resources/log4j2-test.properties | 31 +
.../camel-yaml-dsl-maven-plugin/pom.xml | 174 +
.../dsl/yaml/GenerateYamlDeserializersMojo.java | 910 +
.../maven/dsl/yaml/GenerateYamlSchemaMojo.java | 266 +
.../maven/dsl/yaml/GenerateYamlSupportMojo.java | 575 +
.../maven/dsl/yaml/support/IndexerSupport.java | 131 +
.../maven/dsl/yaml/support/ToolingSupport.java | 57 +
.../maven/dsl/yaml/support/TypeSpecHolder.java | 27 +-
dsl/camel-yaml-dsl/camel-yaml-dsl/pom.xml | 223 +
.../services/org/apache/camel/other.properties | 7 +
.../services/org/apache/camel/routes-loader/yaml | 2 +
.../src/generated/resources/camel-yaml-dsl.json | 6733 ++++++++
.../src/generated/resources/yaml-dsl.json | 14 +
.../camel-yaml-dsl/src/main/docs/yaml-dsl.adoc | 216 +
.../camel/dsl/yaml/YamlRoutesBuilderLoader.java | 135 +
.../org/apache/camel/dsl/yaml/AggregateTest.groovy | 57 +
.../org/apache/camel/dsl/yaml/BeanTest.groovy | 49 +
.../org/apache/camel/dsl/yaml/BeansTest.groovy | 90 +
.../org/apache/camel/dsl/yaml/ChoiceTest.groovy | 68 +
.../camel/dsl/yaml/CircuitBreakerTest.groovy | 90 +
.../apache/camel/dsl/yaml/ClaimCheckTest.groovy | 44 +
.../apache/camel/dsl/yaml/ConvertBodyTest.groovy | 56 +
.../org/apache/camel/dsl/yaml/DelayTest.groovy | 61 +
.../apache/camel/dsl/yaml/DynamicRouterTest.groovy | 57 +
.../org/apache/camel/dsl/yaml/EndpointsTest.groovy | 114 +
.../org/apache/camel/dsl/yaml/EnrichTest.groovy | 57 +
.../apache/camel/dsl/yaml/ErrorHandlerTest.groovy | 59 +
.../org/apache/camel/dsl/yaml/FilterTest.groovy | 100 +
.../camel/dsl/yaml/IdempotentConsumerTest.groovy | 60 +
.../apache/camel/dsl/yaml/LoadBalanceTest.groovy | 57 +
.../org/apache/camel/dsl/yaml/LogTest.groovy | 45 +
.../org/apache/camel/dsl/yaml/LoopTest.groovy | 59 +
.../org/apache/camel/dsl/yaml/MarshalTest.groovy | 78 +
.../org/apache/camel/dsl/yaml/MulticastTest.groovy | 53 +
.../apache/camel/dsl/yaml/OnExceptionTest.groovy | 60 +
.../org/apache/camel/dsl/yaml/PipelineTest.groovy | 34 +-
.../apache/camel/dsl/yaml/PollEnrichTest.groovy | 61 +
.../org/apache/camel/dsl/yaml/ProcessTest.groovy | 33 +-
.../apache/camel/dsl/yaml/RecipientListTest.groovy | 64 +
.../apache/camel/dsl/yaml/RemoveHeaderTest.groovy | 71 +
.../camel/dsl/yaml/RemovePropertyTest.groovy | 71 +
.../apache/camel/dsl/yaml/ResequenceTest.groovy | 76 +
.../org/apache/camel/dsl/yaml/RestTest.groovy | 101 +
.../org/apache/camel/dsl/yaml/RollbackTest.groovy | 35 +-
.../org/apache/camel/dsl/yaml/RoutesTest.groovy | 96 +
.../apache/camel/dsl/yaml/RoutingSlipTest.groovy | 61 +
.../org/apache/camel/dsl/yaml/SagaTest.groovy | 128 +
.../org/apache/camel/dsl/yaml/SampleTest.groovy | 33 +-
.../org/apache/camel/dsl/yaml/ScriptTest.groovy | 57 +
.../apache/camel/dsl/yaml/ServiceCallTest.groovy | 59 +
.../org/apache/camel/dsl/yaml/SetBodyTest.groovy | 57 +
.../camel/dsl/yaml/SetExchangePatternTest.groovy | 33 +-
.../org/apache/camel/dsl/yaml/SetHeaderTest.groovy | 61 +
.../apache/camel/dsl/yaml/SetPropertyTest.groovy | 61 +
.../org/apache/camel/dsl/yaml/SortTest.groovy | 33 +-
.../org/apache/camel/dsl/yaml/SplitTest.groovy | 59 +
.../org/apache/camel/dsl/yaml/StepsTest.groovy | 52 +
.../org/apache/camel/dsl/yaml/StopTest.groovy | 31 +-
.../org/apache/camel/dsl/yaml/ThreadsTest.groovy | 33 +-
.../org/apache/camel/dsl/yaml/ThrottleTest.groovy | 60 +
.../camel/dsl/yaml/ThrowExceptionTest.groovy | 35 +-
.../apache/camel/dsl/yaml/TransactedTest.groovy | 33 +-
.../org/apache/camel/dsl/yaml/TryTest.groovy | 177 +
.../org/apache/camel/dsl/yaml/UnmarshalTest.groovy | 78 +
.../org/apache/camel/dsl/yaml/ValidateTest.groovy | 57 +
.../org/apache/camel/dsl/yaml/WireTapTest.groovy | 61 +
.../yaml/support/MockRestConsumerFactory.groovy | 36 +-
.../camel/dsl/yaml/support/YamlTestSupport.groovy | 132 +
.../camel/dsl/yaml/support/model/MyBean.groovy | 22 +-
.../dsl/yaml/support/model/MyException.groovy | 22 +-
.../yaml/support/model/MyFailingProcessor.groovy | 24 +-
.../camel/dsl/yaml/support/model/MyFooBar.groovy | 21 +-
.../yaml/support/model/MyUppercaseProcessor.groovy | 24 +-
.../src/test/resources/log4j2-test.properties | 31 +
dsl/camel-yaml-dsl/pom.xml | 43 +
dsl/pom.xml | 170 +
parent/pom.xml | 18 +
pom.xml | 3 +-
.../apache/camel/spi/annotations/RoutesLoader.java | 4 +-
.../org/apache/camel/spi/annotations/YamlIn.java | 12 +-
.../org/apache/camel/spi/annotations/YamlOut.java | 12 +-
.../apache/camel/spi/annotations/YamlProperty.java | 19 +-
.../org/apache/camel/spi/annotations/YamlType.java | 17 +-
129 files changed, 33783 insertions(+), 447 deletions(-)
diff --git a/bom/camel-bom/pom.xml b/bom/camel-bom/pom.xml
index c547ea6..536bbff 100644
--- a/bom/camel-bom/pom.xml
+++ b/bom/camel-bom/pom.xml
@@ -2035,6 +2035,21 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-yaml-dsl</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-yaml-dsl-common</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-yaml-dsl-deserializers</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-yammer</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/camel-dependencies/pom.xml b/camel-dependencies/pom.xml
index 5d235b1..c75c0b0 100644
--- a/camel-dependencies/pom.xml
+++ b/camel-dependencies/pom.xml
@@ -223,6 +223,7 @@
<geronimo-ws-metadata-spec-version>1.1.3</geronimo-ws-metadata-spec-version>
<glassfish-javax-json>1.0.4</glassfish-javax-json>
<glassfish-jaxb-runtime-version>2.3.3</glassfish-jaxb-runtime-version>
+ <gmavenplus-plugin-version>1.12.0</gmavenplus-plugin-version>
<gmetric4j-version>1.0.10</gmetric4j-version>
<google-api-client-version>1.22.0</google-api-client-version>
<google-api-services-calendar-version>v3-rev291-1.22.0</google-api-services-calendar-version>
@@ -355,6 +356,7 @@
<json-accessors-smart-version>1.2</json-accessors-smart-version>
<json-api>1.0</json-api>
<json-path-version>2.4.0</json-path-version>
+ <json-schema-validator-version>2.2.14</json-schema-validator-version>
<json-simple-version>1.1.1</json-simple-version>
<json-smart-version>2.3</json-smart-version>
<jsonassert-version>1.5.0</jsonassert-version>
@@ -519,6 +521,7 @@
<sourcecheckExcludesComma></sourcecheckExcludesComma>
<spark-version>2.4.6</spark-version>
<splunk-version>1.6.5.0_1</splunk-version>
+ <spock-version>2.0-M4-groovy-3.0</spock-version>
<spring-batch-version>4.3.1</spring-batch-version>
<spring-data-redis-version>2.4.3</spring-data-redis-version>
<spring-integration-version>5.4.3</spring-integration-version>
diff --git a/catalog/camel-catalog/pom.xml b/catalog/camel-catalog/pom.xml
index 29d6b46..6f3e0cd 100644
--- a/catalog/camel-catalog/pom.xml
+++ b/catalog/camel-catalog/pom.xml
@@ -62,6 +62,7 @@
<artifactId>camel-allcomponents</artifactId>
<version>${project.version}</version>
<type>pom</type>
+ <scope>provided</scope>
<exclusions>
<exclusion>
<groupId>org.apache.camel</groupId>
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/yaml-dsl.adoc b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/yaml-dsl.adoc
new file mode 100644
index 0000000..080603d
--- /dev/null
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/yaml-dsl.adoc
@@ -0,0 +1,216 @@
+[[yaml-dsl-other]]
+= Yaml Dsl Component
+:docTitle: Yaml Dsl
+:artifactId: camel-yaml-dsl
+:description: Camel DSL with YAML
+:since: 3.9
+:supportLevel: Preview
+include::{cq-version}@camel-quarkus:ROOT:partial$reference/others/yaml-dsl.adoc[opts=optional]
+//Manually maintained attributes
+:group: DSL
+
+*Since Camel {since}*
+
+== Defining a route
+
+A route is collection of elements defined as follows:
+
+[source,yaml]
+----
+- from: #<1>
+ uri: "direct:start"
+ steps: #<2>
+ - filter:
+ expression:
+ simple: "${in.header.continue} == true"
+ steps: #<2>
+ - to:
+ uri: "log:filtered"
+ - to:
+ uri: "log:original"
+----
+<1> route entry point, by default `from` and `rest` are supported
+<2> processing steps
+
+[NOTE]
+====
+Each step is represented by a YAML map that has a single entry where the field name is the EIP name
+====
+
+As general rule each step provide all the parameters the related definition declares but there are some minor differences/enhancements:
+
+- *Output Aware Steps*
++
+Some steps such as `filter` and `split` have their own pipeline when an exchange matches the filter expression or for the items generated by the split expression, such pipeline can be defined by the `steps` field:
++
+[source,yaml]
+----
+filter:
+ expression:
+ simple: "${in.header.continue} == true"
+ steps:
+ - to:
+ uri: "log:filtered"
+----
++
+
+- *Expression Aware Steps*
++
+Some EIP such as `filter` and `split` supports the definition of an expression through the `expression` field:
++
+[source,yaml]
+.Explicit Expression field
+----
+filter:
+ expression:
+ simple: "${in.header.continue} == true"
+----
++
+To make the DSL less verbose, the `expression` field can be omitted:
++
+[source,yaml]
+.Implicit Expression field
+----
+filter:
+ simple: "${in.header.continue} == true"
+----
++
+In general expression can be defined inline like in the examples above but in case you need provide more information, you can 'unroll' the expression definition and configure any single parameter the expression defines.
++
+[source,yaml]
+.Full Expression definition
+----
+filter:
+ tokenize:
+ token: "<"
+ end-token: ">"
+----
+
+- *Data Format Aware Steps*
++
+Some EIP such as `set-body` and `marshal` supports the definition of data formats through the `data-format` field:
++
+[source,yaml]
+.Explicit Data Format field
+----
+set-body:
+ data-format:
+ json:
+ library: Gson
+----
++
+To make the DSL less verbose, the `data-format` field can be omitted:
++
+[source,yaml]
+.Implicit Data Format field
+----
+set-body:
+ json:
+ library: Gson
+----
++
+[NOTE]
+====
+In case you want to use the data-format's default settings, you need to place an empty block as data format parameters, like `json: {}`
+====
+
+== Defining endpoints
+
+To define an endpoint with the YAML dsl you have three options:
+
+. Using a classic Camel URI:
++
+[source,yaml]
+----
+- from:
+ uri: "timer:tick?period=1s"
+ steps:
+ - to:
+ uri: "telegram:bots?authorizationToken=XXX"
+----
+. Using URI and parameters:
++
+[source,yaml]
+----
+- from:
+ uri: "timer://tick"
+ parameters:
+ period: "1s"
+ steps:
+ - to:
+ uri: "telegram:bots"
+ parameters:
+ authorizationToken: "XXX"
+----
+. Using the YAML implementation of the xref:latest@manual::Endpoint-dsl.adoc[Endpoint DSL]:
++
+[source,yaml]
+----
+- from:
+ timer:
+ name: "tick"
+ period: "1s"
+ steps:
+ - telegram:
+ type: "bots"
+ authorizationToken: "XXX"
+----
+
+[WARNING]
+====
+Support for the Endpoint DSL with YAML is experimental and subject to changes.
+====
+[NOTE]
+====
+Support for Endpoint DSL auto completion https://github.com/apache/camel-k-runtime/issues/485[is not yet available].
+====
+
+== Defining beans
+
+In addition to the general support for creating beans provided by xref:latest@components:others:main.adoc#_specifying_custom_beans[Camel Main], the YAML DSL provide a convenient syntax to define and configure them:
+
+[source,yaml]
+----
+- beans:
+ - name: beanFromMap # <1>
+ type: com.acme.MyBean # <2>
+ properties: # <3>
+ foo: bar
+----
+<1> the name of the bean which will be used to bound the instance to the Camel Registry
+<2> the full qualified class name of the bean
+<3> the properties of the bean to be set
+
+The properties of the bean can be defined using either a map or properties style as shown in the example below:
+
+[source,yaml]
+----
+- beans:
+ # map style
+ - name: beanFromMap
+ type: com.acme.MyBean
+ properties:
+ field1: 'f1'
+ field2: 'f2'
+ nested:
+ field1: 'nf1'
+ field2: 'nf2'
+ # properties style
+ - name: beanFromProps
+ type: com.acme.MyBean
+ properties:
+ field1: 'f1_p'
+ field2: 'f2_p'
+ nested.field1: 'nf1_p'
+ nested.field2: 'nf2_p'
+----
+
+[NOTE]
+====
+The `beans` elements can only be used as root element
+====
+
+== Examples
+
+You can find a set of examples using `camel-yaml-dsl` in https://github.com/apache/camel-examples[Camel Examples]
+which demonstrate creating Camel Routes with YAML.
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
index 646bcf6..72be70e 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
@@ -22,12 +22,10 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-import org.apache.camel.spi.RoutesBuilderLoader;
-
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
+@ServiceFactory("routes-loader")
public @interface RoutesLoader {
String value();
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlIn.java
similarity index 81%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlIn.java
index 646bcf6..7e204d6 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlIn.java
@@ -16,20 +16,12 @@
*/
package org.apache.camel.spi.annotations;
-import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-import org.apache.camel.spi.RoutesBuilderLoader;
-
+@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
-
- String value();
-
+public @interface YamlIn {
}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlOut.java
similarity index 81%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlOut.java
index 646bcf6..e9565c1 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlOut.java
@@ -16,20 +16,12 @@
*/
package org.apache.camel.spi.annotations;
-import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-import org.apache.camel.spi.RoutesBuilderLoader;
-
+@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
-
- String value();
-
+public @interface YamlOut {
}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlProperty.java
similarity index 80%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlProperty.java
index 646bcf6..484fc71 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlProperty.java
@@ -16,20 +16,23 @@
*/
package org.apache.camel.spi.annotations;
-import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-import org.apache.camel.spi.RoutesBuilderLoader;
-
+@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
+public @interface YamlProperty {
+ String name();
+
+ String type();
+
+ String format() default "";
+
+ String description() default "";
- String value();
+ boolean required() default false;
+ String[] values() default {};
}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlType.java
similarity index 81%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlType.java
index 646bcf6..2887a22 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/YamlType.java
@@ -16,20 +16,21 @@
*/
package org.apache.camel.spi.annotations;
-import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-import org.apache.camel.spi.RoutesBuilderLoader;
-
+@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
+public @interface YamlType {
+ Class<?>[] types() default {};
+
+ String[] nodes() default {};
+
+ int order() default 0;
- String value();
+ boolean inline() default false;
+ YamlProperty[] properties() default {};
}
diff --git a/core/camel-util/src/main/java/org/apache/camel/util/CollectionHelper.java b/core/camel-util/src/main/java/org/apache/camel/util/CollectionHelper.java
index 89dc186..7e80b6c 100644
--- a/core/camel-util/src/main/java/org/apache/camel/util/CollectionHelper.java
+++ b/core/camel-util/src/main/java/org/apache/camel/util/CollectionHelper.java
@@ -99,6 +99,7 @@ public final class CollectionHelper {
}
}
+ @SafeVarargs
public static <T> Set<T> createSetContaining(T... contents) {
return new HashSet<>(Arrays.asList(contents));
}
diff --git a/docs/components/modules/others/pages/yaml-dsl.adoc b/docs/components/modules/others/pages/yaml-dsl.adoc
new file mode 100644
index 0000000..029daf8
--- /dev/null
+++ b/docs/components/modules/others/pages/yaml-dsl.adoc
@@ -0,0 +1,218 @@
+[[yaml-dsl-other]]
+= Yaml Dsl Component
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: dsl/camel-yaml-dsl/camel-yaml-dsl/src/main/docs/yaml-dsl.adoc
+:docTitle: Yaml Dsl
+:artifactId: camel-yaml-dsl
+:description: Camel DSL with YAML
+:since: 3.9
+:supportLevel: Preview
+include::{cq-version}@camel-quarkus:ROOT:partial$reference/others/yaml-dsl.adoc[opts=optional]
+//Manually maintained attributes
+:group: DSL
+
+*Since Camel {since}*
+
+== Defining a route
+
+A route is collection of elements defined as follows:
+
+[source,yaml]
+----
+- from: #<1>
+ uri: "direct:start"
+ steps: #<2>
+ - filter:
+ expression:
+ simple: "${in.header.continue} == true"
+ steps: #<2>
+ - to:
+ uri: "log:filtered"
+ - to:
+ uri: "log:original"
+----
+<1> route entry point, by default `from` and `rest` are supported
+<2> processing steps
+
+[NOTE]
+====
+Each step is represented by a YAML map that has a single entry where the field name is the EIP name
+====
+
+As general rule each step provide all the parameters the related definition declares but there are some minor differences/enhancements:
+
+- *Output Aware Steps*
++
+Some steps such as `filter` and `split` have their own pipeline when an exchange matches the filter expression or for the items generated by the split expression, such pipeline can be defined by the `steps` field:
++
+[source,yaml]
+----
+filter:
+ expression:
+ simple: "${in.header.continue} == true"
+ steps:
+ - to:
+ uri: "log:filtered"
+----
++
+
+- *Expression Aware Steps*
++
+Some EIP such as `filter` and `split` supports the definition of an expression through the `expression` field:
++
+[source,yaml]
+.Explicit Expression field
+----
+filter:
+ expression:
+ simple: "${in.header.continue} == true"
+----
++
+To make the DSL less verbose, the `expression` field can be omitted:
++
+[source,yaml]
+.Implicit Expression field
+----
+filter:
+ simple: "${in.header.continue} == true"
+----
++
+In general expression can be defined inline like in the examples above but in case you need provide more information, you can 'unroll' the expression definition and configure any single parameter the expression defines.
++
+[source,yaml]
+.Full Expression definition
+----
+filter:
+ tokenize:
+ token: "<"
+ end-token: ">"
+----
+
+- *Data Format Aware Steps*
++
+Some EIP such as `set-body` and `marshal` supports the definition of data formats through the `data-format` field:
++
+[source,yaml]
+.Explicit Data Format field
+----
+set-body:
+ data-format:
+ json:
+ library: Gson
+----
++
+To make the DSL less verbose, the `data-format` field can be omitted:
++
+[source,yaml]
+.Implicit Data Format field
+----
+set-body:
+ json:
+ library: Gson
+----
++
+[NOTE]
+====
+In case you want to use the data-format's default settings, you need to place an empty block as data format parameters, like `json: {}`
+====
+
+== Defining endpoints
+
+To define an endpoint with the YAML dsl you have three options:
+
+. Using a classic Camel URI:
++
+[source,yaml]
+----
+- from:
+ uri: "timer:tick?period=1s"
+ steps:
+ - to:
+ uri: "telegram:bots?authorizationToken=XXX"
+----
+. Using URI and parameters:
++
+[source,yaml]
+----
+- from:
+ uri: "timer://tick"
+ parameters:
+ period: "1s"
+ steps:
+ - to:
+ uri: "telegram:bots"
+ parameters:
+ authorizationToken: "XXX"
+----
+. Using the YAML implementation of the xref:latest@manual::Endpoint-dsl.adoc[Endpoint DSL]:
++
+[source,yaml]
+----
+- from:
+ timer:
+ name: "tick"
+ period: "1s"
+ steps:
+ - telegram:
+ type: "bots"
+ authorizationToken: "XXX"
+----
+
+[WARNING]
+====
+Support for the Endpoint DSL with YAML is experimental and subject to changes.
+====
+[NOTE]
+====
+Support for Endpoint DSL auto completion https://github.com/apache/camel-k-runtime/issues/485[is not yet available].
+====
+
+== Defining beans
+
+In addition to the general support for creating beans provided by xref:latest@components:others:main.adoc#_specifying_custom_beans[Camel Main], the YAML DSL provide a convenient syntax to define and configure them:
+
+[source,yaml]
+----
+- beans:
+ - name: beanFromMap # <1>
+ type: com.acme.MyBean # <2>
+ properties: # <3>
+ foo: bar
+----
+<1> the name of the bean which will be used to bound the instance to the Camel Registry
+<2> the full qualified class name of the bean
+<3> the properties of the bean to be set
+
+The properties of the bean can be defined using either a map or properties style as shown in the example below:
+
+[source,yaml]
+----
+- beans:
+ # map style
+ - name: beanFromMap
+ type: com.acme.MyBean
+ properties:
+ field1: 'f1'
+ field2: 'f2'
+ nested:
+ field1: 'nf1'
+ field2: 'nf2'
+ # properties style
+ - name: beanFromProps
+ type: com.acme.MyBean
+ properties:
+ field1: 'f1_p'
+ field2: 'f2_p'
+ nested.field1: 'nf1_p'
+ nested.field2: 'nf2_p'
+----
+
+[NOTE]
+====
+The `beans` elements can only be used as root element
+====
+
+== Examples
+
+You can find a set of examples using `camel-yaml-dsl` in https://github.com/apache/camel-examples[Camel Examples]
+which demonstrate creating Camel Routes with YAML.
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/pom.xml b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/pom.xml
new file mode 100644
index 0000000..46947e6
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/pom.xml
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-yaml-dsl-parent</artifactId>
+ <version>3.9.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>camel-yaml-dsl-common</artifactId>
+ <packaging>jar</packaging>
+ <name>Camel :: YAML DSL :: Common</name>
+ <description>Camel DSL with YAML Common</description>
+
+ <properties>
+ <firstVersion>3.9.0</firstVersion>
+ <sourcecheckExcludes>
+ **/*.groovy
+ </sourcecheckExcludes>
+ <sourcecheckExcludesComma>
+ ${sourcecheckExcludes},
+ </sourcecheckExcludesComma>
+ </properties>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-core-engine</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>org.snakeyaml</groupId>
+ <artifactId>snakeyaml-engine</artifactId>
+ <version>${snakeyaml-engine-version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.spockframework</groupId>
+ <artifactId>spock-core</artifactId>
+ <version>${spock-version}</version>
+ <scope>test</scope>
+ <exclusions>
+ <exclusion>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>*</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>junit</groupId>
+ <artifactId>*</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy</artifactId>
+ <version>${groovy-version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-test</artifactId>
+ <version>${groovy-version}</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-slf4j-impl</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-jcl</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.codehaus.gmavenplus</groupId>
+ <artifactId>gmavenplus-plugin</artifactId>
+ <version>${gmavenplus-plugin-version}</version>
+ <executions>
+ <execution>
+ <goals>
+ <goal>addTestSources</goal>
+ <goal>compileTests</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <invokeDynamic>true</invokeDynamic>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
\ No newline at end of file
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/generated/resources/META-INF/services/org/apache/camel/other.properties b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/generated/resources/META-INF/services/org/apache/camel/other.properties
new file mode 100644
index 0000000..0fbee6d
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/generated/resources/META-INF/services/org/apache/camel/other.properties
@@ -0,0 +1,7 @@
+# Generated by camel build tools - do NOT edit this file!
+name=yaml-dsl-common
+groupId=org.apache.camel
+artifactId=camel-yaml-dsl-common
+version=3.9.0-SNAPSHOT
+projectName=Camel :: YAML DSL :: Common
+projectDescription=Camel DSL with YAML Common
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/generated/resources/yaml-dsl-common.json b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/generated/resources/yaml-dsl-common.json
new file mode 100644
index 0000000..6904738
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/generated/resources/yaml-dsl-common.json
@@ -0,0 +1,14 @@
+{
+ "other": {
+ "kind": "other",
+ "name": "yaml-dsl-common",
+ "title": "Yaml Dsl Common",
+ "description": "Camel DSL with YAML Common",
+ "deprecated": false,
+ "firstVersion": "3.9.0",
+ "supportLevel": "Preview",
+ "groupId": "org.apache.camel",
+ "artifactId": "camel-yaml-dsl-common",
+ "version": "3.9.0-SNAPSHOT"
+ }
+}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializationContext.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializationContext.java
new file mode 100644
index 0000000..769d779
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializationContext.java
@@ -0,0 +1,231 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.yaml.common;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.Function;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.CamelContextAware;
+import org.apache.camel.ExtendedCamelContext;
+import org.apache.camel.Ordered;
+import org.apache.camel.Service;
+import org.apache.camel.dsl.yaml.common.exception.UnknownNodeTypeException;
+import org.apache.camel.dsl.yaml.common.exception.YamlDeserializationException;
+import org.apache.camel.util.ObjectHelper;
+import org.snakeyaml.engine.v2.api.ConstructNode;
+import org.snakeyaml.engine.v2.api.LoadSettings;
+import org.snakeyaml.engine.v2.constructor.StandardConstructor;
+import org.snakeyaml.engine.v2.nodes.MappingNode;
+import org.snakeyaml.engine.v2.nodes.Node;
+import org.snakeyaml.engine.v2.nodes.NodeType;
+import org.snakeyaml.engine.v2.nodes.ScalarNode;
+
+public class YamlDeserializationContext extends StandardConstructor implements CamelContextAware, Service {
+ private final Set<YamlDeserializerResolver> resolvers;
+ private final Map<String, ConstructNode> constructors;
+
+ private ExtendedCamelContext camelContext;
+
+ public YamlDeserializationContext(LoadSettings settings) {
+ super(settings);
+
+ this.resolvers = new TreeSet<>(Comparator.comparing(Ordered::getOrder));
+ this.constructors = new HashMap<>();
+ }
+
+ public void addResolver(YamlDeserializerResolver resolver) {
+ this.resolvers.add(resolver);
+ }
+
+ public void addResolvers(YamlDeserializerResolver... resolvers) {
+ addResolvers(Arrays.asList(resolvers));
+ }
+
+ public void addResolvers(Collection<YamlDeserializerResolver> resolvers) {
+ this.resolvers.addAll(resolvers);
+ }
+
+ @Override
+ public CamelContext getCamelContext() {
+ return camelContext;
+ }
+
+ @Override
+ public void setCamelContext(CamelContext camelContext) {
+ this.camelContext = camelContext.adapt(ExtendedCamelContext.class);
+ }
+
+ @Override
+ protected Optional<ConstructNode> findConstructorFor(Node node) {
+ ConstructNode ctor = resolve(node);
+ if (ctor != null) {
+ return Optional.of(ctor);
+ }
+
+ return super.findConstructorFor(node);
+ }
+
+ @Override
+ public void start() {
+ ObjectHelper.notNull(camelContext, "camel context");
+
+ this.resolvers.addAll(getCamelContext().getRegistry().findByType(YamlDeserializerResolver.class));
+ }
+
+ @Override
+ public void stop() {
+ this.constructors.clear();
+ }
+
+ // *********************************
+ //
+ // Construct
+ //
+ // *********************************
+
+ public Object construct(String key, Node val) {
+ return mandatoryResolve(key).construct(val);
+ }
+
+ public <T> T construct(String key, Node val, Class<T> type) {
+ Object result = construct(key, val);
+ if (result == null) {
+ return null;
+ }
+
+ return type.cast(result);
+ }
+
+ public Object construct(Node key, Node val) {
+ return mandatoryResolve(key).construct(val);
+ }
+
+ public <T> T construct(Node key, Node val, Class<T> type) {
+ Object result = construct(key, val);
+ if (result == null) {
+ return null;
+ }
+
+ return type.cast(result);
+ }
+
+ // *********************************
+ //
+ // Resolve
+ //
+ // *********************************
+
+ public ConstructNode resolve(Class<?> type) {
+ final ConstructNode answer = resolve(type.getName());
+
+ return CamelContextAware.trySetCamelContext(
+ new ConstructNode() {
+ @Override
+ public Object construct(Node node) {
+ Node n = YamlSupport.setProperty(
+ node,
+ YamlDeserializationContext.class.getName(),
+ YamlDeserializationContext.this);
+
+ return answer.construct(n);
+ }
+ },
+ camelContext);
+ }
+
+ public ConstructNode mandatoryResolve(Node node) {
+ ConstructNode constructor = resolve(node);
+ if (constructor == null) {
+ throw new YamlDeserializationException("Unable to find constructor for node: " + node);
+ }
+
+ return constructor;
+ }
+
+ public ConstructNode resolve(Node node) {
+ if (node.getNodeType() != NodeType.MAPPING) {
+ return null;
+ }
+
+ MappingNode mn = (MappingNode) node;
+ if (mn.getValue().size() != 1) {
+ return null;
+ }
+
+ Node key = mn.getValue().get(0).getKeyNode();
+ if (key.getNodeType() != NodeType.SCALAR) {
+ return null;
+ }
+
+ final String id = ((ScalarNode) key).getValue();
+ final ConstructNode answer = resolve(id);
+
+ return CamelContextAware.trySetCamelContext(
+ new ConstructNode() {
+ @Override
+ public Object construct(Node node) {
+ Node n = YamlSupport.setProperty(
+ node,
+ YamlDeserializationContext.class.getName(),
+ YamlDeserializationContext.this);
+
+ return answer.construct(
+ ((MappingNode) n).getValue().get(0).getValueNode());
+ }
+ },
+ camelContext);
+ }
+
+ public ConstructNode mandatoryResolve(String id) {
+ ConstructNode constructor = resolve(id);
+ if (constructor == null) {
+ throw new YamlDeserializationException("Unable to find constructor for id: " + id);
+ }
+
+ return constructor;
+ }
+
+ public ConstructNode resolve(String id) {
+ return constructors.computeIfAbsent(id, new Function<String, ConstructNode>() {
+ @Override
+ public ConstructNode apply(String s) {
+ ConstructNode answer = null;
+
+ for (YamlDeserializerResolver resolver : resolvers) {
+ answer = resolver.resolve(id);
+ if (answer != null) {
+ break;
+ }
+ }
+
+ if (answer == null) {
+ throw new UnknownNodeTypeException(id);
+ }
+
+ return answer;
+ }
+ });
+ }
+}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerBase.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerBase.java
new file mode 100644
index 0000000..128ed36
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerBase.java
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.yaml.common;
+
+import java.util.Locale;
+
+import org.apache.camel.util.StringHelper;
+import org.snakeyaml.engine.v2.api.ConstructNode;
+import org.snakeyaml.engine.v2.nodes.MappingNode;
+import org.snakeyaml.engine.v2.nodes.Node;
+import org.snakeyaml.engine.v2.nodes.NodeTuple;
+import org.snakeyaml.engine.v2.nodes.NodeType;
+import org.snakeyaml.engine.v2.nodes.ScalarNode;
+
+public abstract class YamlDeserializerBase<T> extends YamlDeserializerSupport implements ConstructNode {
+ private final Class<T> type;
+
+ public YamlDeserializerBase(Class<T> type) {
+ this.type = type;
+ }
+
+ public Class<T> getType() {
+ return type;
+ }
+
+ @Override
+ public Object construct(Node node) {
+ final T target;
+
+ if (node.getNodeType() == NodeType.SCALAR) {
+ ScalarNode mn = (ScalarNode) node;
+ target = newInstance(mn.getValue());
+ } else if (node.getNodeType() == NodeType.MAPPING) {
+ MappingNode mn = (MappingNode) node;
+ target = newInstance();
+
+ setProperties(target, mn);
+ } else {
+ throw new IllegalArgumentException("Unsupported node type: " + node);
+ }
+
+ return target;
+ }
+
+ /**
+ * Creates a Java instance of the expected type.
+ *
+ * @return the instance.
+ */
+ protected abstract T newInstance();
+
+ /**
+ * Creates a Java instance of the expected type from a string.
+ *
+ * @return the instance.
+ */
+ protected T newInstance(String value) {
+ throw new IllegalArgumentException("Unsupported " + value);
+ }
+
+ /**
+ * Set a property to the given target.
+ *
+ * @param target the target object
+ * @param propertyKey the normalized property key
+ * @param propertyName the name of the property as defined in the YAML
+ * @param value the value of the property as {@link Node}
+ */
+ protected boolean setProperty(T target, String propertyKey, String propertyName, Node value) {
+ return false;
+ }
+
+ /**
+ * Set properties from a YAML node to the given target.
+ *
+ * @param node the node
+ * @param target the target object
+ */
+ protected void setProperties(T target, MappingNode node) {
+ org.apache.camel.dsl.yaml.common.YamlDeserializationContext dc = getDeserializationContext(node);
+
+ for (NodeTuple tuple : node.getValue()) {
+ final ScalarNode key = (ScalarNode) tuple.getKeyNode();
+ final String propertyName = StringHelper.camelCaseToDash(key.getValue()).toLowerCase(Locale.US);
+ final Node val = tuple.getValueNode();
+
+ setDeserializationContext(val, dc);
+
+ if (!setProperty(target, propertyName, key.getValue(), val)) {
+ handleUnknownProperty(target, propertyName, key.getValue(), val);
+ }
+ }
+ }
+
+ protected void handleUnknownProperty(T target, String propertyKey, String propertyName, Node value) {
+ throw new IllegalArgumentException("Unsupported field: " + propertyName + " on " + target.getClass().getName());
+ }
+}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerResolver.java
similarity index 61%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerResolver.java
index 646bcf6..666b5f3 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerResolver.java
@@ -14,22 +14,24 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.spi.annotations;
+package org.apache.camel.dsl.yaml.common;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import org.apache.camel.Ordered;
+import org.snakeyaml.engine.v2.api.ConstructNode;
-import org.apache.camel.spi.RoutesBuilderLoader;
+public interface YamlDeserializerResolver extends Ordered {
+ int ORDER_DEFAULT = 0;
+ int ORDER_HIGHEST = Ordered.HIGHEST;
+ int ORDER_LOWEST = Ordered.LOWEST;
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
+ ConstructNode resolve(String id);
- String value();
+ default ConstructNode resolve(Class<?> type) {
+ return resolve(type.getName());
+ }
+ @Override
+ default int getOrder() {
+ return ORDER_DEFAULT;
+ }
}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerSupport.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerSupport.java
new file mode 100644
index 0000000..56430ba
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlDeserializerSupport.java
@@ -0,0 +1,334 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.yaml.common;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException;
+import org.apache.camel.dsl.yaml.common.exception.UnsupportedNodeTypeException;
+import org.apache.camel.dsl.yaml.common.exception.YamlDeserializationException;
+import org.apache.camel.util.CollectionHelper;
+import org.apache.camel.util.StringHelper;
+import org.snakeyaml.engine.v2.api.ConstructNode;
+import org.snakeyaml.engine.v2.nodes.MappingNode;
+import org.snakeyaml.engine.v2.nodes.Node;
+import org.snakeyaml.engine.v2.nodes.NodeTuple;
+import org.snakeyaml.engine.v2.nodes.NodeType;
+import org.snakeyaml.engine.v2.nodes.ScalarNode;
+import org.snakeyaml.engine.v2.nodes.SequenceNode;
+
+public class YamlDeserializerSupport {
+ protected YamlDeserializerSupport() {
+ }
+
+ public static Class<?> asClass(String val) throws YamlDeserializationException {
+ try {
+ return Class.forName(val);
+ } catch (ClassNotFoundException e) {
+ throw new YamlDeserializationException("Unable to load class " + val, e);
+ }
+ }
+
+ public static Class<?>[] asClassArray(String val) throws YamlDeserializationException {
+ String[] values = val.split(" ");
+ Class<?>[] cls = new Class<?>[values.length];
+ for (int i = 0; i < values.length; i++) {
+ cls[i] = asClass(values[i]);
+ }
+ return cls;
+ }
+
+ public static byte[] asByteArray(String val) {
+ return Base64.getDecoder().decode(val);
+ }
+
+ public static List<String> asStringList(String val) {
+ return Arrays.asList(val.split(" "));
+ }
+
+ public static Set<String> asStringSet(String val) {
+ return CollectionHelper.createSetContaining(val.split(" "));
+ }
+
+ public static byte[] asByteArray(Node node) {
+ return asByteArray(asText(node));
+ }
+
+ public static Class<?> asClass(Node node) {
+ return asClass(asText(node));
+ }
+
+ public static List<String> asStringList(Node node) {
+ List<String> answer;
+
+ if (node.getNodeType() == NodeType.SCALAR) {
+ answer = asStringList(asText(node));
+ } else if (node.getNodeType() == NodeType.SEQUENCE) {
+ answer = new ArrayList<>();
+ for (Node item : asSequenceNode(node).getValue()) {
+ answer.add(asText(item));
+ }
+ } else {
+ throw new UnsupportedNodeTypeException(node);
+ }
+
+ return answer;
+ }
+
+ public static Set<String> asStringSet(Node node) {
+ return asStringSet(asText(node));
+ }
+
+ public static Class<?>[] asClassArray(Node node) throws YamlDeserializationException {
+ return asClassArray(asText(node));
+ }
+
+ public static String asText(Node node) throws YamlDeserializationException {
+ if (node.getNodeType() != NodeType.SCALAR) {
+ throw new IllegalArgumentException("Node is not SCALAR");
+ }
+
+ return ((ScalarNode) node).getValue();
+ }
+
+ public static Map<String, Object> asMap(Node node) {
+ final MappingNode mn = asMappingNode(node);
+ final Map<String, Object> answer = new HashMap<>();
+
+ for (NodeTuple tuple : mn.getValue()) {
+ final String key = asText(tuple.getKeyNode());
+ final Node val = tuple.getValueNode();
+
+ switch (val.getNodeType()) {
+ case SCALAR:
+ answer.put(StringHelper.dashToCamelCase(key), asText(val));
+ break;
+ case MAPPING:
+ answer.put(StringHelper.dashToCamelCase(key), asMap(val));
+ break;
+ default:
+ throw new UnsupportedNodeTypeException(node);
+ }
+ }
+
+ return answer;
+ }
+
+ public static Map<String, Object> asScalarMap(Node node) {
+ final MappingNode mn = asMappingNode(node);
+ final Map<String, Object> answer = new HashMap<>();
+
+ for (NodeTuple tuple : mn.getValue()) {
+ final String key = asText(tuple.getKeyNode());
+ final Node val = tuple.getValueNode();
+
+ switch (val.getNodeType()) {
+ case SCALAR:
+ answer.put(StringHelper.dashToCamelCase(key), asText(val));
+ break;
+ default:
+ throw new UnsupportedNodeTypeException(node);
+ }
+ }
+
+ return answer;
+ }
+
+ public static boolean asBoolean(Node node) throws YamlDeserializationException {
+ return Boolean.parseBoolean(asText(node));
+ }
+
+ public static int asInt(Node node) throws YamlDeserializationException {
+ return Integer.parseInt(asText(node));
+ }
+
+ public static long asLong(Node node) throws YamlDeserializationException {
+ return Long.parseLong(asText(node));
+ }
+
+ public static double asDouble(Node node) throws YamlDeserializationException {
+ return Double.parseDouble(asText(node));
+ }
+
+ public static MappingNode asMappingNode(Node node) throws YamlDeserializationException {
+ if (node == null) {
+ return null;
+ }
+
+ if (node.getNodeType() != NodeType.MAPPING) {
+ throw new IllegalArgumentException("Node is not MAPPING");
+ }
+
+ return (MappingNode) node;
+ }
+
+ public static SequenceNode asSequenceNode(Node node) throws YamlDeserializationException {
+ if (node == null) {
+ return null;
+ }
+
+ if (node.getNodeType() != NodeType.SEQUENCE) {
+ throw new IllegalArgumentException("Node is not MAPPING");
+ }
+
+ return (SequenceNode) node;
+ }
+
+ public static Node getNamedNode(MappingNode node, String name) throws YamlDeserializationException {
+ if (node == null) {
+ return null;
+ }
+
+ for (NodeTuple tuple : node.getValue()) {
+ if (name.equals(asText(tuple.getKeyNode()))) {
+ return tuple.getValueNode();
+ }
+ }
+
+ return null;
+ }
+
+ public static <T> List<T> asNestedList(Node node, Class<T> type) throws YamlDeserializationException {
+ List<T> answer = new ArrayList<>();
+ asNestedCollection(node, type, answer);
+
+ return answer;
+ }
+
+ public static <T> List<T> asFlatList(Node node, Class<T> type) throws YamlDeserializationException {
+ List<T> answer = new ArrayList<>();
+ asFlatCollection(node, type, answer);
+
+ return answer;
+ }
+
+ public static <T> Set<T> asNestedSet(Node node, Class<T> type) throws YamlDeserializationException {
+ Set<T> answer = new HashSet<>();
+ asNestedCollection(node, type, answer);
+
+ return answer;
+ }
+
+ public static <T> Set<T> asFlatSet(Node node, Class<T> type) throws YamlDeserializationException {
+ Set<T> answer = new HashSet<>();
+ asFlatCollection(node, type, answer);
+
+ return answer;
+ }
+
+ public static <T> void asNestedCollection(Node node, Class<T> type, Collection<T> collection)
+ throws YamlDeserializationException {
+ asCollection(node, type, collection, false);
+ }
+
+ public static <T> void asFlatCollection(Node node, Class<T> type, Collection<T> collection)
+ throws YamlDeserializationException {
+ asCollection(node, type, collection, true);
+ }
+
+ private static <T> void asCollection(Node node, Class<T> type, Collection<T> collection, boolean flat)
+ throws YamlDeserializationException {
+ if (node.getNodeType() != NodeType.SEQUENCE) {
+ throw new UnsupportedOperationException("Unable to parse no array node");
+ }
+
+ YamlDeserializationContext dc = getDeserializationContext(node);
+ if (dc == null) {
+ throw new IllegalArgumentException("Unable to find YamlConstructor");
+ }
+
+ for (Node element : asSequenceNode(node).getValue()) {
+ final Node val = setDeserializationContext(element, dc);
+ final T instance;
+
+ if (flat) {
+ instance = asType(val, type);
+ } else {
+ ConstructNode cn = dc.mandatoryResolve(val);
+ instance = type.cast(cn.construct(val));
+ }
+
+ collection.add(instance);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <T> T asType(Node node, Class<T> type) throws YamlDeserializationException {
+ YamlDeserializationContext resolver
+ = (YamlDeserializationContext) node.getProperty(YamlDeserializationContext.class.getName());
+ if (resolver == null) {
+ throw new IllegalArgumentException("Unable to find YamlConstructor");
+ }
+ ConstructNode construct = resolver.resolve(type);
+ if (construct == null) {
+ throw new IllegalArgumentException("Unable to determine constructor for type: " + type.getName());
+ }
+
+ return (T) construct.construct(node);
+ }
+
+ public static String asEndpoint(Node node) {
+ return asEndpoint(
+ asMappingNode(node));
+ }
+
+ public static String asEndpoint(MappingNode node) {
+ final YamlDeserializationContext dc = getDeserializationContext(node);
+ final CamelContext cc = dc.getCamelContext();
+
+ String uri = null;
+ Map<String, Object> properties = null;
+
+ for (NodeTuple tuple : node.getValue()) {
+ final String key = YamlDeserializerSupport.asText(tuple.getKeyNode());
+ final Node val = tuple.getValueNode();
+
+ setDeserializationContext(val, dc);
+
+ switch (key) {
+ case "uri":
+ uri = YamlDeserializerSupport.asText(val);
+ break;
+ case "properties":
+ properties = YamlDeserializerSupport.asScalarMap(tuple.getValueNode());
+ break;
+ default:
+ throw new UnsupportedFieldException(node, key);
+ }
+ }
+
+ return YamlSupport.createEndpointUri(cc, uri, properties);
+ }
+
+ public static YamlDeserializationContext getDeserializationContext(Node node) {
+ return (YamlDeserializationContext) node.getProperty(YamlDeserializationContext.class.getName());
+ }
+
+ public static Node setDeserializationContext(Node node, YamlDeserializationContext context) {
+ node.setProperty(YamlDeserializationContext.class.getName(), context);
+ return node;
+ }
+}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlSupport.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlSupport.java
new file mode 100644
index 0000000..054158d
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/YamlSupport.java
@@ -0,0 +1,232 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.yaml.common;
+
+import java.net.URISyntaxException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.function.Function;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.Component;
+import org.apache.camel.ExtendedCamelContext;
+import org.apache.camel.PropertyBindingException;
+import org.apache.camel.dsl.yaml.common.exception.UnsupportedNodeTypeException;
+import org.apache.camel.spi.CamelContextCustomizer;
+import org.apache.camel.spi.EndpointUriFactory;
+import org.apache.camel.spi.PropertyConfigurer;
+import org.apache.camel.support.PropertyBindingSupport;
+import org.apache.camel.support.service.ServiceHelper;
+import org.apache.camel.util.ObjectHelper;
+import org.apache.camel.util.StringHelper;
+import org.apache.camel.util.URISupport;
+import org.snakeyaml.engine.v2.api.ConstructNode;
+import org.snakeyaml.engine.v2.nodes.MappingNode;
+import org.snakeyaml.engine.v2.nodes.Node;
+import org.snakeyaml.engine.v2.nodes.NodeTuple;
+import org.snakeyaml.engine.v2.nodes.NodeType;
+import org.snakeyaml.engine.v2.nodes.SequenceNode;
+
+public final class YamlSupport {
+ private YamlSupport() {
+ }
+
+ public static void setPropertiesOnTarget(CamelContext context, Object target, Map<String, Object> properties) {
+ ObjectHelper.notNull(context, "context");
+ ObjectHelper.notNull(target, "target");
+ ObjectHelper.notNull(properties, "properties");
+
+ if (target instanceof CamelContext) {
+ throw new UnsupportedOperationException("Configuring the Camel Context si not supported");
+ }
+
+ PropertyConfigurer configurer = null;
+ if (target instanceof Component) {
+ // the component needs to be initialized to have the configurer ready
+ ServiceHelper.initService(target);
+ configurer = ((Component) target).getComponentPropertyConfigurer();
+ }
+
+ if (configurer == null) {
+ // see if there is a configurer for it
+ configurer = context.adapt(ExtendedCamelContext.class)
+ .getConfigurerResolver()
+ .resolvePropertyConfigurer(target.getClass().getSimpleName(), context);
+ }
+
+ try {
+ PropertyBindingSupport.build()
+ .withMandatory(true)
+ .withRemoveParameters(false)
+ .withConfigurer(configurer)
+ .withIgnoreCase(true)
+ .withFlattenProperties(true)
+ .bind(context, target, properties);
+ } catch (PropertyBindingException e) {
+ String key = e.getOptionKey();
+ if (key == null) {
+ String prefix = e.getOptionPrefix();
+ if (prefix != null && !prefix.endsWith(".")) {
+ prefix = "." + prefix;
+ }
+
+ key = prefix != null
+ ? prefix + "." + e.getPropertyName()
+ : e.getPropertyName();
+ }
+
+ // enrich the error with more precise details with option prefix and key
+ throw new PropertyBindingException(
+ e.getTarget(),
+ e.getPropertyName(),
+ e.getValue(),
+ null,
+ key,
+ e.getCause());
+ }
+ }
+
+ public static CamelContextCustomizer customizer(Collection<CamelContextCustomizer> customizers) {
+ return new CamelContextCustomizer() {
+ @Override
+ public void configure(CamelContext camelContext) {
+ for (CamelContextCustomizer customizer : customizers) {
+ customizer.configure(camelContext);
+ }
+ }
+ };
+ }
+
+ public static String createEndpointUri(CamelContext context, String uri, Map<String, Object> parameters) {
+ String answer = uri;
+
+ if (parameters == null || parameters.isEmpty()) {
+ //
+ // nothing to do here, there are no parameters so we can return the
+ // uri as it is.
+ //
+ return answer;
+ }
+ if (uri.indexOf('?') != -1) {
+ //
+ // we support URIs defined as scheme only or scheme and path params,
+ // query params are not supported so a definition like:
+ //
+ // - from:
+ // uri: "foo:bar?option1=value1"
+ // parameters:
+ // option2: value2
+ //
+ // is not supported and leads to the an IllegalArgumentException being
+ // thrown.
+ //
+ throw new IllegalArgumentException("Uri should not contains query params (uri: " + uri + ")");
+ }
+
+ final String scheme = uri.contains(":") ? StringHelper.before(uri, ":") : uri;
+ final EndpointUriFactory factory = context.adapt(ExtendedCamelContext.class).getEndpointUriFactory(scheme);
+
+ try {
+ if (factory != null && factory.isEnabled(scheme)) {
+ if (scheme.equals(uri)) {
+ //
+ // if the uri is expressed as simple scheme, then we can use the
+ // discovered EndpointUriFactory to build the uri
+ //
+ answer = factory.buildUri(scheme, parameters, false);
+ } else {
+ //
+ // otherwise we have to compose it but we can still leverage the
+ // discovered EndpointUriFactory to properly handle secrets
+ //
+ Map<String, Object> options = new TreeMap<>(parameters);
+
+ for (String secretParameter : factory.secretPropertyNames()) {
+ Object val = options.get(secretParameter);
+ if (val instanceof String) {
+ String newVal = (String) val;
+ if (!newVal.startsWith("#") && !newVal.startsWith("RAW(")) {
+ options.put(secretParameter, "RAW(" + val + ")");
+ }
+ }
+ }
+
+ answer += "?" + URISupport.createQueryString(options, false);
+ }
+ } else {
+ answer += "?" + URISupport.createQueryString(parameters, false);
+ }
+ } catch (URISyntaxException e) {
+ throw new IllegalArgumentException(e);
+ }
+
+ return answer;
+ }
+
+ public static Node setProperty(Node node, String key, Object value) {
+ node.setProperty(key, value);
+
+ if (node instanceof MappingNode) {
+ for (NodeTuple item : ((MappingNode) node).getValue()) {
+ item.getValueNode().setProperty(key, value);
+ }
+ } else if (node instanceof SequenceNode) {
+ for (Node item : ((SequenceNode) node).getValue()) {
+ item.setProperty(key, value);
+ }
+ }
+
+ return node;
+ }
+
+ private static String creteEndpointUri(String scheme, Node node) {
+ switch (node.getNodeType()) {
+ case SCALAR:
+ return scheme + ':' + YamlDeserializerSupport.asText(node);
+ case MAPPING:
+ final YamlDeserializationContext dc = YamlDeserializerSupport.getDeserializationContext(node);
+ final MappingNode bn = YamlDeserializerSupport.asMappingNode(node);
+ final Map<String, Object> parameters = new HashMap<>();
+
+ for (NodeTuple tuple : bn.getValue()) {
+ final String key = YamlDeserializerSupport.asText(tuple.getKeyNode());
+ final Node val = tuple.getValueNode();
+
+ if (val.getNodeType() == NodeType.SCALAR) {
+ parameters.put(StringHelper.dashToCamelCase(key), YamlDeserializerSupport.asText(val));
+ } else {
+ throw new UnsupportedNodeTypeException(node);
+ }
+ }
+
+ return YamlSupport.createEndpointUri(dc.getCamelContext(), scheme, parameters);
+ default:
+ throw new UnsupportedNodeTypeException(node);
+ }
+ }
+
+ public static <T> T creteEndpoint(String scheme, Node node, Function<String, T> constructor) {
+ return constructor.apply(
+ creteEndpointUri(scheme, node));
+ }
+
+ public static ConstructNode creteEndpointConstructor(String scheme, Function<String, Object> constructor) {
+ return node -> creteEndpoint(scheme, node, constructor);
+ }
+}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownNodeConstructorException.java
similarity index 62%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownNodeConstructorException.java
index 646bcf6..c47dbdd 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownNodeConstructorException.java
@@ -14,22 +14,10 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.spi.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.apache.camel.spi.RoutesBuilderLoader;
-
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
-
- String value();
+package org.apache.camel.dsl.yaml.common.exception;
+public class UnknownNodeConstructorException extends IllegalArgumentException {
+ public UnknownNodeConstructorException(Class<?> nodeType) {
+ super("Unknown constructor for node with type: " + nodeType.getName());
+ }
}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownNodeTypeException.java
similarity index 62%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownNodeTypeException.java
index 646bcf6..01f0ffb 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownNodeTypeException.java
@@ -14,22 +14,10 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.spi.annotations;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.apache.camel.spi.RoutesBuilderLoader;
-
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
-
- String value();
+package org.apache.camel.dsl.yaml.common.exception;
+public class UnknownNodeTypeException extends IllegalArgumentException {
+ public UnknownNodeTypeException(String nodeId) {
+ super("Unknown type for node with id: " + nodeId);
+ }
}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownPropertyException.java
similarity index 62%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownPropertyException.java
index 646bcf6..b47d3fa 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnknownPropertyException.java
@@ -14,22 +14,14 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.spi.annotations;
+package org.apache.camel.dsl.yaml.common.exception;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import org.apache.camel.spi.RoutesBuilderLoader;
-
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
-
- String value();
+public class UnknownPropertyException extends YamlDeserializationException {
+ public UnknownPropertyException(String property) {
+ super("Unsupported property: " + property);
+ }
+ public UnknownPropertyException(String property, Throwable rootCause) {
+ super("Unsupported property: " + property, rootCause);
+ }
}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnsupportedFieldException.java
similarity index 63%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnsupportedFieldException.java
index 646bcf6..4bf4396 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnsupportedFieldException.java
@@ -14,22 +14,17 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.spi.annotations;
+package org.apache.camel.dsl.yaml.common.exception;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import org.snakeyaml.engine.v2.nodes.Node;
-import org.apache.camel.spi.RoutesBuilderLoader;
+public class UnsupportedFieldException extends IllegalArgumentException {
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
-
- String value();
+ public UnsupportedFieldException(Node node, String field) {
+ super("Unsupported field (" + field + ") for node: " + node);
+ }
+ public UnsupportedFieldException(String field, String message) {
+ super("Unsupported field (" + field + "): " + message);
+ }
}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnsupportedNodeTypeException.java
similarity index 62%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnsupportedNodeTypeException.java
index 646bcf6..278f18f 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/UnsupportedNodeTypeException.java
@@ -14,22 +14,16 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.spi.annotations;
+package org.apache.camel.dsl.yaml.common.exception;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import org.snakeyaml.engine.v2.nodes.Node;
-import org.apache.camel.spi.RoutesBuilderLoader;
-
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
-
- String value();
+public class UnsupportedNodeTypeException extends IllegalArgumentException {
+ public UnsupportedNodeTypeException(int nodeType) {
+ super("Unsupported type (" + nodeType + ")");
+ }
+ public UnsupportedNodeTypeException(Node node) {
+ super("Unsupported type (" + node.getNodeType() + ") for node: " + node);
+ }
}
diff --git a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/YamlDeserializationException.java
similarity index 62%
copy from core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
copy to dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/YamlDeserializationException.java
index 646bcf6..b3253c1 100644
--- a/core/camel-api/src/generated/java/org/apache/camel/spi/annotations/RoutesLoader.java
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/main/java/org/apache/camel/dsl/yaml/common/exception/YamlDeserializationException.java
@@ -14,22 +14,18 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.spi.annotations;
+package org.apache.camel.dsl.yaml.common.exception;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+public class YamlDeserializationException extends IllegalStateException {
+ public YamlDeserializationException(String message) {
+ super(message);
+ }
-import org.apache.camel.spi.RoutesBuilderLoader;
-
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Target({ ElementType.TYPE })
-@ServiceFactory(RoutesBuilderLoader.FACTORY_GROUP)
-public @interface RoutesLoader {
-
- String value();
+ public YamlDeserializationException(Throwable rootCause) {
+ super(rootCause);
+ }
+ public YamlDeserializationException(String message, Throwable rootCause) {
+ super(message, rootCause);
+ }
}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/test/groovy/org/apache/camel/dsl/yaml/common/ConstructorResolverTest.groovy b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/test/groovy/org/apache/camel/dsl/yaml/common/ConstructorResolverTest.groovy
new file mode 100644
index 0000000..a02b427
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/test/groovy/org/apache/camel/dsl/yaml/common/ConstructorResolverTest.groovy
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.dsl.yaml.common
+
+import groovy.transform.ToString
+import org.apache.camel.impl.DefaultCamelContext
+import org.apache.camel.spi.annotations.YamlType
+import org.snakeyaml.engine.v2.api.ConstructNode
+import org.snakeyaml.engine.v2.api.Load
+import org.snakeyaml.engine.v2.api.LoadSettings
+import org.snakeyaml.engine.v2.nodes.Node
+import org.snakeyaml.engine.v2.nodes.ScalarNode
+import spock.lang.Specification
+
+class ConstructorResolverTest extends Specification {
+
+ def "test"() {
+ given:
+ def settings = LoadSettings.builder().build()
+ when:
+ def ctr = new YamlDeserializationContext(settings)
+ ctr.setCamelContext(new DefaultCamelContext());
+ ctr.addResolver(new LocalResolver())
+
+ def load = new Load(settings, ctr)
+
+ def result = load.loadFromString('''
+ - my-node:
+ message: node
+ nested:
+ message: nested
+ '''.stripLeading())
+ then:
+ with(result, List) {
+ size() == 1
+
+ with(get(0), MyNode) {
+ message == 'node'
+ nested != null
+ nested.message == 'nested'
+ }
+ }
+
+ }
+
+
+ static class LocalResolver implements YamlDeserializerResolver {
+ @Override
+ ConstructNode resolve(String id) {
+ switch (id) {
+ case 'my-node':
+ case 'org.apache.camel.dsl.yaml.common.ConstructorResolverTest$MyNode':
+ return new MyNodeConstructor();
+ case 'nested':
+ case 'org.apache.camel.dsl.yaml.common.ConstructorResolverTest$MyNested':
+ return new MyNestedConstructor();
+ }
+ return null;
+ }
+ }
+
+ @ToString
+ static class MyNode {
+ String message
+ MyNested nested;
+ }
+
+ @ToString
+ static class MyNested {
+ String message
+ }
+
+ @YamlType(types = MyNode.class, nodes = [ "my-node" ])
+ static class MyNodeConstructor extends YamlDeserializerBase<MyNode> {
+ MyNodeConstructor() {
+ super(MyNode.class)
+ }
+
+ @Override
+ protected MyNode newInstance() {
+ return new MyNode()
+ }
+
+ @Override
+ protected MyNode newInstance(String value) {
+ return new MyNode(message: value)
+ }
+
+ @Override
+ protected boolean setProperty(MyNode target, String propertyKey, String propertyName, Node value) throws Exception {
+ switch (propertyKey) {
+ case 'message':
+ target.message = ((ScalarNode)value).value
+ break
+ case 'nested':
+ target.nested = asType(value, MyNested.class)
+ break
+ default:
+ return false;
+ }
+
+ return true
+ }
+ }
+
+ @YamlType(types = MyNested.class)
+ static class MyNestedConstructor extends YamlDeserializerBase<MyNested> {
+ MyNestedConstructor() {
+ super(MyNested.class)
+ }
+
+ @Override
+ protected MyNested newInstance() {
+ return new MyNested()
+ }
+
+ @Override
+ protected MyNested newInstance(String value) {
+ return new MyNested(message: value)
+ }
+
+ @Override
+ protected boolean setProperty(MyNested target, String propertyKey, String propertyName, Node value) throws Exception {
+ switch (propertyKey) {
+ case 'message':
+ target.message = ((ScalarNode)value).value
+ break
+ default:
+ return false;
+ }
+
+ return true
+ }
+ }
+}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/test/resources/log4j2-test.properties b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/test/resources/log4j2-test.properties
new file mode 100644
index 0000000..e8bc1bf
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-common/src/test/resources/log4j2-test.properties
@@ -0,0 +1,31 @@
+## ---------------------------------------------------------------------------
+## Licensed to the Apache Software Foundation (ASF) under one or more
+## contributor license agreements. See the NOTICE file distributed with
+## this work for additional information regarding copyright ownership.
+## The ASF licenses this file to You under the Apache License, Version 2.0
+## (the "License"); you may not use this file except in compliance with
+## the License. You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+## ---------------------------------------------------------------------------
+
+appender.file.type = File
+appender.file.name = file
+appender.file.fileName = target/camel-yaml-dsl-common-test.log
+appender.file.layout.type = PatternLayout
+appender.file.layout.pattern = %d [%-15.15t] %-5p %-30.30c{1} - %m%n
+
+appender.out.type = Console
+appender.out.name = out
+appender.out.layout.type = PatternLayout
+appender.out.layout.pattern = [%30.30t] %-30.30c{1} %-5p %m%n
+
+rootLogger.level = INFO
+rootLogger.appenderRef.file.ref = file
+#rootLogger.appenderRef.out.ref = out
\ No newline at end of file
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/pom.xml b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/pom.xml
new file mode 100644
index 0000000..6f55e32
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/pom.xml
@@ -0,0 +1,139 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-yaml-dsl-parent</artifactId>
+ <version>3.9.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>camel-yaml-dsl-deserializers</artifactId>
+ <packaging>jar</packaging>
+ <name>Camel :: YAML DSL :: Deserializers </name>
+ <description>Camel DSL with YAML Deserializers</description>
+
+ <properties>
+ <firstVersion>3.9.0</firstVersion>
+ <sourcecheckExcludes>
+ **/*.groovy
+ </sourcecheckExcludes>
+ <sourcecheckExcludesComma>
+ ${sourcecheckExcludes},
+ </sourcecheckExcludesComma>
+ </properties>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-yaml-dsl-common</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.junit.jupiter</groupId>
+ <artifactId>junit-jupiter</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.spockframework</groupId>
+ <artifactId>spock-core</artifactId>
+ <version>${spock-version}</version>
+ <scope>test</scope>
+ <exclusions>
+ <exclusion>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>*</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>junit</groupId>
+ <artifactId>*</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy</artifactId>
+ <version>${groovy-version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-test</artifactId>
+ <version>${groovy-version}</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-slf4j-impl</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-jcl</artifactId>
+ <scope>test</scope>
+ </dependency>
+
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-yaml-dsl-maven-plugin</artifactId>
+ <version>3.9.0-SNAPSHOT</version>
+ <executions>
+ <execution>
+ <phase>generate-sources</phase>
+ <goals>
+ <goal>generate-yaml-deserializers</goal>
+ </goals>
+ <configuration>
+ <packageName>org.apache.camel.dsl.yaml.deserializers</packageName>
+ <bannedDefinitions>
+ <bannedDefinition>org.apache.camel.model.FromDefinition</bannedDefinition>
+ <bannedDefinition>org.apache.camel.model.language.ExpressionDefinition</bannedDefinition>
+ <bannedDefinition>org.apache.camel.model.ExpressionSubElementDefinition</bannedDefinition>
+ <bannedDefinition>org.apache.camel.model.PropertyDefinitions</bannedDefinition>
+ </bannedDefinitions>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+
+</project>
\ No newline at end of file
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/EndpointConsumerDeserializersResolver.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/EndpointConsumerDeserializersResolver.java
new file mode 100644
index 0000000..2039f99
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/EndpointConsumerDeserializersResolver.java
@@ -0,0 +1,244 @@
+package org.apache.camel.dsl.yaml.deserializers;
+
+import java.lang.Override;
+import java.lang.String;
+import org.apache.camel.dsl.yaml.common.YamlDeserializerResolver;
+import org.snakeyaml.engine.v2.api.ConstructNode;
+
+public final class EndpointConsumerDeserializersResolver implements YamlDeserializerResolver {
+ @Override
+ public int getOrder() {
+ return YamlDeserializerResolver.ORDER_LOWEST;
+ }
+
+ public static ConstructNode resolveEndpointConstructor(String id) {
+ switch(id) {
+ case "activemq":
+ case "ahc-ws":
+ case "ahc-wss":
+ case "amqp":
+ case "apns":
+ case "as2":
+ case "asterisk":
+ case "atmos":
+ case "atmosphere-websocket":
+ case "atom":
+ case "atomix-map":
+ case "atomix-messaging":
+ case "atomix-queue":
+ case "atomix-set":
+ case "atomix-value":
+ case "avro":
+ case "aws-ddbstream":
+ case "aws-s3":
+ case "aws-swf":
+ case "aws2-ddbstream":
+ case "aws2-kinesis":
+ case "aws2-s3":
+ case "aws2-sqs":
+ case "azure-blob":
+ case "azure-eventhubs":
+ case "azure-queue":
+ case "azure-storage-blob":
+ case "azure-storage-datalake":
+ case "azure-storage-queue":
+ case "beanstalk":
+ case "box":
+ case "browse":
+ case "cmis":
+ case "coap":
+ case "coap+tcp":
+ case "coaps":
+ case "coaps+tcp":
+ case "cometd":
+ case "cometds":
+ case "consul":
+ case "corda":
+ case "couchbase":
+ case "couchdb":
+ case "cql":
+ case "cron":
+ case "cxf":
+ case "cxfrs":
+ case "dataset":
+ case "debezium-mongodb":
+ case "debezium-mysql":
+ case "debezium-postgres":
+ case "debezium-sqlserver":
+ case "direct":
+ case "direct-vm":
+ case "disruptor":
+ case "disruptor-vm":
+ case "docker":
+ case "dropbox":
+ case "ehcache":
+ case "elsql":
+ case "etcd-stats":
+ case "etcd-watch":
+ case "facebook":
+ case "fhir":
+ case "file":
+ case "file-watch":
+ case "flatpack":
+ case "ftp":
+ case "ftps":
+ case "git":
+ case "github":
+ case "google-calendar":
+ case "google-calendar-stream":
+ case "google-drive":
+ case "google-mail":
+ case "google-mail-stream":
+ case "google-pubsub":
+ case "google-sheets":
+ case "google-sheets-stream":
+ case "google-storage":
+ case "gora":
+ case "grpc":
+ case "guava-eventbus":
+ case "hazelcast-instance":
+ case "hazelcast-list":
+ case "hazelcast-map":
+ case "hazelcast-multimap":
+ case "hazelcast-queue":
+ case "hazelcast-replicatedmap":
+ case "hazelcast-seda":
+ case "hazelcast-set":
+ case "hazelcast-topic":
+ case "hbase":
+ case "hdfs":
+ case "iec60870-client":
+ case "iec60870-server":
+ case "ignite-cache":
+ case "ignite-events":
+ case "ignite-messaging":
+ case "imap":
+ case "imaps":
+ case "infinispan":
+ case "infinispan-embedded":
+ case "irc":
+ case "ironmq":
+ case "jbpm":
+ case "jcache":
+ case "jclouds":
+ case "jcr":
+ case "jetty":
+ case "jgroups":
+ case "jgroups-raft":
+ case "jira":
+ case "jms":
+ case "jmx":
+ case "jooq":
+ case "jpa":
+ case "jt400":
+ case "kafka":
+ case "kamelet":
+ case "kubernetes-custom-resources":
+ case "kubernetes-deployments":
+ case "kubernetes-hpa":
+ case "kubernetes-job":
+ case "kubernetes-namespaces":
+ case "kubernetes-nodes":
+ case "kubernetes-pods":
+ case "kubernetes-replication-controllers":
+ case "kubernetes-services":
+ case "lumberjack":
+ case "master":
+ case "milo-client":
+ case "milo-server":
+ case "mina":
+ case "minio":
+ case "mllp":
+ case "mongodb":
+ case "mongodb-gridfs":
+ case "mybatis":
+ case "nats":
+ case "netty":
+ case "netty-http":
+ case "nitrite":
+ case "nsq":
+ case "oaipmh":
+ case "olingo2":
+ case "olingo4":
+ case "optaplanner":
+ case "paho":
+ case "paho-mqtt5":
+ case "pg-replication-slot":
+ case "pgevent":
+ case "platform-http":
+ case "pop3":
+ case "pop3s":
+ case "pubnub":
+ case "pulsar":
+ case "quartz":
+ case "quickfix":
+ case "rabbitmq":
+ case "reactive-streams":
+ case "ref":
+ case "rest":
+ case "rest-api":
+ case "resteasy":
+ case "robotframework":
+ case "rss":
+ case "salesforce":
+ case "scheduler":
+ case "seda":
+ case "service":
+ case "servlet":
+ case "sftp":
+ case "sip":
+ case "sips":
+ case "sjms":
+ case "sjms2":
+ case "slack":
+ case "smpp":
+ case "smpps":
+ case "smtp":
+ case "smtps":
+ case "snmp":
+ case "soroush":
+ case "splunk":
+ case "spring-event":
+ case "spring-integration":
+ case "spring-rabbitmq":
+ case "spring-redis":
+ case "spring-ws":
+ case "sql":
+ case "ssh":
+ case "stomp":
+ case "stream":
+ case "stub":
+ case "telegram":
+ case "thrift":
+ case "timer":
+ case "twilio":
+ case "twitter-directmessage":
+ case "twitter-search":
+ case "twitter-timeline":
+ case "undertow":
+ case "vertx":
+ case "vertx-kafka":
+ case "vertx-websocket":
+ case "vm":
+ case "weather":
+ case "web3j":
+ case "webhook":
+ case "websocket":
+ case "websocket-jsr356":
+ case "wordpress":
+ case "xmpp":
+ case "xquery":
+ case "yammer":
+ case "zendesk":
+ case "zookeeper":
+ case "zookeeper-master":
+ return org.apache.camel.dsl.yaml.common.YamlSupport.creteEndpointConstructor(id, org.apache.camel.model.FromDefinition::new);
+ }
+ return null;
+ }
+
+ @Override
+ public ConstructNode resolve(String id) {
+ return resolveEndpointConstructor(id);
+ }
+}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/EndpointProducerDeserializersResolver.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/EndpointProducerDeserializersResolver.java
new file mode 100644
index 0000000..6e88e76
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/EndpointProducerDeserializersResolver.java
@@ -0,0 +1,348 @@
+package org.apache.camel.dsl.yaml.deserializers;
+
+import java.lang.Override;
+import java.lang.String;
+import org.apache.camel.dsl.yaml.common.YamlDeserializerResolver;
+import org.snakeyaml.engine.v2.api.ConstructNode;
+
+public final class EndpointProducerDeserializersResolver implements YamlDeserializerResolver {
+ @Override
+ public int getOrder() {
+ return YamlDeserializerResolver.ORDER_LOWEST;
+ }
+
+ public static ConstructNode resolveEndpointConstructor(String id) {
+ switch(id) {
+ case "activemq":
+ case "ahc":
+ case "ahc-ws":
+ case "ahc-wss":
+ case "amqp":
+ case "apns":
+ case "arangodb":
+ case "as2":
+ case "asterisk":
+ case "atlasmap":
+ case "atmos":
+ case "atmosphere-websocket":
+ case "atomix-map":
+ case "atomix-messaging":
+ case "atomix-multimap":
+ case "atomix-queue":
+ case "atomix-set":
+ case "atomix-value":
+ case "avro":
+ case "aws-cw":
+ case "aws-ddb":
+ case "aws-s3":
+ case "aws-swf":
+ case "aws2-athena":
+ case "aws2-cw":
+ case "aws2-ddb":
+ case "aws2-ec2":
+ case "aws2-ecs":
+ case "aws2-eks":
+ case "aws2-eventbridge":
+ case "aws2-iam":
+ case "aws2-kinesis":
+ case "aws2-kinesis-firehose":
+ case "aws2-kms":
+ case "aws2-lambda":
+ case "aws2-mq":
+ case "aws2-msk":
+ case "aws2-s3":
+ case "aws2-ses":
+ case "aws2-sns":
+ case "aws2-sqs":
+ case "aws2-sts":
+ case "aws2-translate":
+ case "azure-blob":
+ case "azure-eventhubs":
+ case "azure-queue":
+ case "azure-storage-blob":
+ case "azure-storage-datalake":
+ case "azure-storage-queue":
+ case "bean":
+ case "bean-validator":
+ case "beanstalk":
+ case "bonita":
+ case "box":
+ case "braintree":
+ case "browse":
+ case "caffeine-cache":
+ case "caffeine-loadcache":
+ case "chatscript":
+ case "chunk":
+ case "class":
+ case "cm-sms":
+ case "cmis":
+ case "coap":
+ case "coap+tcp":
+ case "coaps":
+ case "coaps+tcp":
+ case "cometd":
+ case "cometds":
+ case "consul":
+ case "controlbus":
+ case "corda":
+ case "couchbase":
+ case "couchdb":
+ case "cql":
+ case "crypto":
+ case "crypto-cms":
+ case "cxf":
+ case "cxfrs":
+ case "dataformat":
+ case "dataset":
+ case "dataset-test":
+ case "digitalocean":
+ case "direct":
+ case "direct-vm":
+ case "disruptor":
+ case "disruptor-vm":
+ case "djl":
+ case "dns":
+ case "docker":
+ case "dozer":
+ case "drill":
+ case "dropbox":
+ case "ehcache":
+ case "elasticsearch-rest":
+ case "elsql":
+ case "etcd-keys":
+ case "etcd-stats":
+ case "exec":
+ case "facebook":
+ case "fhir":
+ case "file":
+ case "flatpack":
+ case "flink":
+ case "fop":
+ case "freemarker":
+ case "ftp":
+ case "ftps":
+ case "ganglia":
+ case "geocoder":
+ case "git":
+ case "github":
+ case "google-bigquery":
+ case "google-bigquery-sql":
+ case "google-calendar":
+ case "google-drive":
+ case "google-mail":
+ case "google-pubsub":
+ case "google-sheets":
+ case "google-storage":
+ case "gora":
+ case "grape":
+ case "graphql":
+ case "grpc":
+ case "guava-eventbus":
+ case "hazelcast-atomicvalue":
+ case "hazelcast-list":
+ case "hazelcast-map":
+ case "hazelcast-multimap":
+ case "hazelcast-queue":
+ case "hazelcast-replicatedmap":
+ case "hazelcast-ringbuffer":
+ case "hazelcast-seda":
+ case "hazelcast-set":
+ case "hazelcast-topic":
+ case "hbase":
+ case "hdfs":
+ case "http":
+ case "https":
+ case "hwcloud-smn":
+ case "iec60870-client":
+ case "iec60870-server":
+ case "ignite-cache":
+ case "ignite-compute":
+ case "ignite-idgen":
+ case "ignite-messaging":
+ case "ignite-queue":
+ case "ignite-set":
+ case "imap":
+ case "imaps":
+ case "infinispan":
+ case "infinispan-embedded":
+ case "influxdb":
+ case "iota":
+ case "ipfs":
+ case "irc":
+ case "ironmq":
+ case "jbpm":
+ case "jcache":
+ case "jclouds":
+ case "jcr":
+ case "jdbc":
+ case "jgroups":
+ case "jgroups-raft":
+ case "jing":
+ case "jira":
+ case "jms":
+ case "jolt":
+ case "jooq":
+ case "jpa":
+ case "jslt":
+ case "json-validator":
+ case "jsonata":
+ case "jt400":
+ case "kafka":
+ case "kamelet":
+ case "kubernetes-config-maps":
+ case "kubernetes-custom-resources":
+ case "kubernetes-deployments":
+ case "kubernetes-hpa":
+ case "kubernetes-job":
+ case "kubernetes-namespaces":
+ case "kubernetes-nodes":
+ case "kubernetes-persistent-volumes":
+ case "kubernetes-persistent-volumes-claims":
+ case "kubernetes-pods":
+ case "kubernetes-replication-controllers":
+ case "kubernetes-resources-quota":
+ case "kubernetes-secrets":
+ case "kubernetes-service-accounts":
+ case "kubernetes-services":
+ case "kudu":
+ case "language":
+ case "ldap":
+ case "ldif":
+ case "log":
+ case "lpr":
+ case "lucene":
+ case "metrics":
+ case "micrometer":
+ case "microprofile-metrics":
+ case "milo-client":
+ case "milo-server":
+ case "mina":
+ case "minio":
+ case "mllp":
+ case "mock":
+ case "mongodb":
+ case "mongodb-gridfs":
+ case "msv":
+ case "mustache":
+ case "mvel":
+ case "mybatis":
+ case "mybatis-bean":
+ case "nagios":
+ case "nats":
+ case "netty":
+ case "netty-http":
+ case "nitrite":
+ case "nsq":
+ case "oaipmh":
+ case "olingo2":
+ case "olingo4":
+ case "openshift-build-configs":
+ case "openshift-builds":
+ case "openstack-cinder":
+ case "openstack-glance":
+ case "openstack-keystone":
+ case "openstack-neutron":
+ case "openstack-nova":
+ case "openstack-swift":
+ case "optaplanner":
+ case "paho":
+ case "paho-mqtt5":
+ case "pdf":
+ case "pgevent":
+ case "pop3":
+ case "pop3s":
+ case "pubnub":
+ case "pulsar":
+ case "quickfix":
+ case "rabbitmq":
+ case "reactive-streams":
+ case "ref":
+ case "rest":
+ case "rest-openapi":
+ case "rest-swagger":
+ case "resteasy":
+ case "robotframework":
+ case "saga":
+ case "salesforce":
+ case "sap-netweaver":
+ case "schematron":
+ case "scp":
+ case "seda":
+ case "servicenow":
+ case "sftp":
+ case "sip":
+ case "sips":
+ case "sjms":
+ case "sjms2":
+ case "slack":
+ case "smpp":
+ case "smpps":
+ case "smtp":
+ case "smtps":
+ case "snmp":
+ case "solr":
+ case "solrCloud":
+ case "solrs":
+ case "soroush":
+ case "spark":
+ case "splunk":
+ case "splunk-hec":
+ case "spring-batch":
+ case "spring-event":
+ case "spring-integration":
+ case "spring-ldap":
+ case "spring-rabbitmq":
+ case "spring-redis":
+ case "spring-ws":
+ case "sql":
+ case "sql-stored":
+ case "ssh":
+ case "stax":
+ case "stitch":
+ case "stomp":
+ case "stream":
+ case "string-template":
+ case "stub":
+ case "telegram":
+ case "thrift":
+ case "tika":
+ case "twilio":
+ case "twitter-directmessage":
+ case "twitter-search":
+ case "twitter-timeline":
+ case "undertow":
+ case "validator":
+ case "velocity":
+ case "vertx":
+ case "vertx-http":
+ case "vertx-kafka":
+ case "vertx-websocket":
+ case "vm":
+ case "weather":
+ case "web3j":
+ case "websocket":
+ case "websocket-jsr356":
+ case "weka":
+ case "wordpress":
+ case "workday":
+ case "xchange":
+ case "xj":
+ case "xmlsecurity-sign":
+ case "xmlsecurity-verify":
+ case "xmpp":
+ case "xquery":
+ case "xslt":
+ case "xslt-saxon":
+ case "yammer":
+ case "zendesk":
+ case "zookeeper":
+ return org.apache.camel.dsl.yaml.common.YamlSupport.creteEndpointConstructor(id, org.apache.camel.model.ToDefinition::new);
+ }
+ return null;
+ }
+
+ @Override
+ public ConstructNode resolve(String id) {
+ return resolveEndpointConstructor(id);
+ }
+}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ExpressionDeserializers.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ExpressionDeserializers.java
new file mode 100644
index 0000000..1e32016
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ExpressionDeserializers.java
@@ -0,0 +1,175 @@
+package org.apache.camel.dsl.yaml.deserializers;
+
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.String;
+import org.apache.camel.dsl.yaml.common.YamlDeserializationContext;
+import org.apache.camel.dsl.yaml.common.YamlDeserializerSupport;
+import org.apache.camel.model.language.ExpressionDefinition;
+import org.apache.camel.spi.annotations.YamlProperty;
+import org.apache.camel.spi.annotations.YamlType;
+import org.snakeyaml.engine.v2.api.ConstructNode;
+import org.snakeyaml.engine.v2.nodes.MappingNode;
+import org.snakeyaml.engine.v2.nodes.Node;
+import org.snakeyaml.engine.v2.nodes.NodeTuple;
+
+public final class ExpressionDeserializers extends YamlDeserializerSupport {
+ private ExpressionDeserializers() {
+ }
+
+ public static ExpressionDefinition constructExpressionType(Node node) {
+ MappingNode mn = asMappingNode(node);
+ if (mn.getValue().size() != 1) {
+ return null;
+ }
+ NodeTuple nt = mn.getValue().get(0);
+ YamlDeserializationContext dc = getDeserializationContext(node);
+ String key = asText(nt.getKeyNode());
+ Node val = setDeserializationContext(nt.getValueNode(), dc);
+ return constructExpressionType(key, val);
+ }
+
+ public static ExpressionDefinition constructExpressionType(String id, Node node) {
+ switch(id) {
+ case "constant": {
+ return asType(node, org.apache.camel.model.language.ConstantExpression.class);
+ }
+ case "csimple": {
+ return asType(node, org.apache.camel.model.language.CSimpleExpression.class);
+ }
+ case "datasonnet": {
+ return asType(node, org.apache.camel.model.language.DatasonnetExpression.class);
+ }
+ case "exchangeProperty": {
+ return asType(node, org.apache.camel.model.language.ExchangePropertyExpression.class);
+ }
+ case "exchange-property": {
+ return asType(node, org.apache.camel.model.language.ExchangePropertyExpression.class);
+ }
+ case "groovy": {
+ return asType(node, org.apache.camel.model.language.GroovyExpression.class);
+ }
+ case "header": {
+ return asType(node, org.apache.camel.model.language.HeaderExpression.class);
+ }
+ case "hl7terser": {
+ return asType(node, org.apache.camel.model.language.Hl7TerserExpression.class);
+ }
+ case "joor": {
+ return asType(node, org.apache.camel.model.language.JoorExpression.class);
+ }
+ case "jsonpath": {
+ return asType(node, org.apache.camel.model.language.JsonPathExpression.class);
+ }
+ case "language": {
+ return asType(node, org.apache.camel.model.language.LanguageExpression.class);
+ }
+ case "method": {
+ return asType(node, org.apache.camel.model.language.MethodCallExpression.class);
+ }
+ case "mvel": {
+ return asType(node, org.apache.camel.model.language.MvelExpression.class);
+ }
+ case "ognl": {
+ return asType(node, org.apache.camel.model.language.OgnlExpression.class);
+ }
+ case "ref": {
+ return asType(node, org.apache.camel.model.language.RefExpression.class);
+ }
+ case "simple": {
+ return asType(node, org.apache.camel.model.language.SimpleExpression.class);
+ }
+ case "spel": {
+ return asType(node, org.apache.camel.model.language.SpELExpression.class);
+ }
+ case "tokenize": {
+ return asType(node, org.apache.camel.model.language.TokenizerExpression.class);
+ }
+ case "xpath": {
+ return asType(node, org.apache.camel.model.language.XPathExpression.class);
+ }
+ case "xquery": {
+ return asType(node, org.apache.camel.model.language.XQueryExpression.class);
+ }
+ case "xtokenize": {
+ return asType(node, org.apache.camel.model.language.XMLTokenizerExpression.class);
+ }
+ case "expression": {
+ return constructExpressionType(node);
+ }
+ case "expression-type": {
+ return constructExpressionType(node);
+ }
+ }
+ return null;
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.language.ExpressionDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ properties = {
+ @YamlProperty(name = "constant", type = "object:org.apache.camel.model.language.ConstantExpression"),
+ @YamlProperty(name = "csimple", type = "object:org.apache.camel.model.language.CSimpleExpression"),
+ @YamlProperty(name = "datasonnet", type = "object:org.apache.camel.model.language.DatasonnetExpression"),
+ @YamlProperty(name = "exchangeProperty", type = "object:org.apache.camel.model.language.ExchangePropertyExpression"),
+ @YamlProperty(name = "exchange-property", type = "object:org.apache.camel.model.language.ExchangePropertyExpression"),
+ @YamlProperty(name = "groovy", type = "object:org.apache.camel.model.language.GroovyExpression"),
+ @YamlProperty(name = "header", type = "object:org.apache.camel.model.language.HeaderExpression"),
+ @YamlProperty(name = "hl7terser", type = "object:org.apache.camel.model.language.Hl7TerserExpression"),
+ @YamlProperty(name = "joor", type = "object:org.apache.camel.model.language.JoorExpression"),
+ @YamlProperty(name = "jsonpath", type = "object:org.apache.camel.model.language.JsonPathExpression"),
+ @YamlProperty(name = "language", type = "object:org.apache.camel.model.language.LanguageExpression"),
+ @YamlProperty(name = "method", type = "object:org.apache.camel.model.language.MethodCallExpression"),
+ @YamlProperty(name = "mvel", type = "object:org.apache.camel.model.language.MvelExpression"),
+ @YamlProperty(name = "ognl", type = "object:org.apache.camel.model.language.OgnlExpression"),
+ @YamlProperty(name = "ref", type = "object:org.apache.camel.model.language.RefExpression"),
+ @YamlProperty(name = "simple", type = "object:org.apache.camel.model.language.SimpleExpression"),
+ @YamlProperty(name = "spel", type = "object:org.apache.camel.model.language.SpELExpression"),
+ @YamlProperty(name = "tokenize", type = "object:org.apache.camel.model.language.TokenizerExpression"),
+ @YamlProperty(name = "xpath", type = "object:org.apache.camel.model.language.XPathExpression"),
+ @YamlProperty(name = "xquery", type = "object:org.apache.camel.model.language.XQueryExpression"),
+ @YamlProperty(name = "xtokenize", type = "object:org.apache.camel.model.language.XMLTokenizerExpression")
+ }
+ )
+ public static class ExpressionDefinitionDeserializers implements ConstructNode {
+ @Override
+ public Object construct(Node node) {
+ return constructExpressionType(node);
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.ExpressionSubElementDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ properties = {
+ @YamlProperty(name = "constant", type = "object:org.apache.camel.model.language.ConstantExpression"),
+ @YamlProperty(name = "csimple", type = "object:org.apache.camel.model.language.CSimpleExpression"),
+ @YamlProperty(name = "datasonnet", type = "object:org.apache.camel.model.language.DatasonnetExpression"),
+ @YamlProperty(name = "exchangeProperty", type = "object:org.apache.camel.model.language.ExchangePropertyExpression"),
+ @YamlProperty(name = "exchange-property", type = "object:org.apache.camel.model.language.ExchangePropertyExpression"),
+ @YamlProperty(name = "groovy", type = "object:org.apache.camel.model.language.GroovyExpression"),
+ @YamlProperty(name = "header", type = "object:org.apache.camel.model.language.HeaderExpression"),
+ @YamlProperty(name = "hl7terser", type = "object:org.apache.camel.model.language.Hl7TerserExpression"),
+ @YamlProperty(name = "joor", type = "object:org.apache.camel.model.language.JoorExpression"),
+ @YamlProperty(name = "jsonpath", type = "object:org.apache.camel.model.language.JsonPathExpression"),
+ @YamlProperty(name = "language", type = "object:org.apache.camel.model.language.LanguageExpression"),
+ @YamlProperty(name = "method", type = "object:org.apache.camel.model.language.MethodCallExpression"),
+ @YamlProperty(name = "mvel", type = "object:org.apache.camel.model.language.MvelExpression"),
+ @YamlProperty(name = "ognl", type = "object:org.apache.camel.model.language.OgnlExpression"),
+ @YamlProperty(name = "ref", type = "object:org.apache.camel.model.language.RefExpression"),
+ @YamlProperty(name = "simple", type = "object:org.apache.camel.model.language.SimpleExpression"),
+ @YamlProperty(name = "spel", type = "object:org.apache.camel.model.language.SpELExpression"),
+ @YamlProperty(name = "tokenize", type = "object:org.apache.camel.model.language.TokenizerExpression"),
+ @YamlProperty(name = "xpath", type = "object:org.apache.camel.model.language.XPathExpression"),
+ @YamlProperty(name = "xquery", type = "object:org.apache.camel.model.language.XQueryExpression"),
+ @YamlProperty(name = "xtokenize", type = "object:org.apache.camel.model.language.XMLTokenizerExpression")
+ }
+ )
+ public static class ExpressionSubElementDefinitionDeserializers implements ConstructNode {
+ @Override
+ public Object construct(Node node) {
+ ExpressionDefinition val = constructExpressionType(node);
+ return new org.apache.camel.model.ExpressionSubElementDefinition(val);
+ }
+ }
+}
diff --git a/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ModelDeserializers.java b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ModelDeserializers.java
new file mode 100644
index 0000000..0b68363
--- /dev/null
+++ b/dsl/camel-yaml-dsl/camel-yaml-dsl-deserializers/src/generated/java/org/apache/camel/dsl/yaml/deserializers/ModelDeserializers.java
@@ -0,0 +1,16620 @@
+package org.apache.camel.dsl.yaml.deserializers;
+
+import java.lang.Override;
+import java.lang.String;
+import org.apache.camel.dsl.yaml.common.YamlDeserializerBase;
+import org.apache.camel.dsl.yaml.common.YamlDeserializerSupport;
+import org.apache.camel.model.AggregateDefinition;
+import org.apache.camel.model.BeanDefinition;
+import org.apache.camel.model.CatchDefinition;
+import org.apache.camel.model.ChoiceDefinition;
+import org.apache.camel.model.CircuitBreakerDefinition;
+import org.apache.camel.model.ClaimCheckDefinition;
+import org.apache.camel.model.ContextScanDefinition;
+import org.apache.camel.model.ConvertBodyDefinition;
+import org.apache.camel.model.DataFormatDefinition;
+import org.apache.camel.model.DelayDefinition;
+import org.apache.camel.model.DescriptionDefinition;
+import org.apache.camel.model.DynamicRouterDefinition;
+import org.apache.camel.model.EnrichDefinition;
+import org.apache.camel.model.FaultToleranceConfigurationDefinition;
+import org.apache.camel.model.FilterDefinition;
+import org.apache.camel.model.FinallyDefinition;
+import org.apache.camel.model.GlobalOptionDefinition;
+import org.apache.camel.model.GlobalOptionsDefinition;
+import org.apache.camel.model.HystrixConfigurationDefinition;
+import org.apache.camel.model.IdempotentConsumerDefinition;
+import org.apache.camel.model.InOnlyDefinition;
+import org.apache.camel.model.InOutDefinition;
+import org.apache.camel.model.InputTypeDefinition;
+import org.apache.camel.model.InterceptDefinition;
+import org.apache.camel.model.InterceptFromDefinition;
+import org.apache.camel.model.InterceptSendToEndpointDefinition;
+import org.apache.camel.model.LoadBalanceDefinition;
+import org.apache.camel.model.LoadBalancerDefinition;
+import org.apache.camel.model.LogDefinition;
+import org.apache.camel.model.LoopDefinition;
+import org.apache.camel.model.MarshalDefinition;
+import org.apache.camel.model.MulticastDefinition;
+import org.apache.camel.model.OnCompletionDefinition;
+import org.apache.camel.model.OnExceptionDefinition;
+import org.apache.camel.model.OnFallbackDefinition;
+import org.apache.camel.model.OptimisticLockRetryPolicyDefinition;
+import org.apache.camel.model.OtherwiseDefinition;
+import org.apache.camel.model.OutputDefinition;
+import org.apache.camel.model.OutputTypeDefinition;
+import org.apache.camel.model.PackageScanDefinition;
+import org.apache.camel.model.PipelineDefinition;
+import org.apache.camel.model.PolicyDefinition;
+import org.apache.camel.model.PollEnrichDefinition;
+import org.apache.camel.model.ProcessDefinition;
+import org.apache.camel.model.ProcessorDefinition;
+import org.apache.camel.model.PropertyDefinition;
+import org.apache.camel.model.RecipientListDefinition;
+import org.apache.camel.model.RedeliveryPolicyDefinition;
+import org.apache.camel.model.RemoveHeaderDefinition;
+import org.apache.camel.model.RemoveHeadersDefinition;
+import org.apache.camel.model.RemovePropertiesDefinition;
+import org.apache.camel.model.RemovePropertyDefinition;
+import org.apache.camel.model.ResequenceDefinition;
+import org.apache.camel.model.Resilience4jConfigurationDefinition;
+import org.apache.camel.model.RestContextRefDefinition;
+import org.apache.camel.model.RollbackDefinition;
+import org.apache.camel.model.RouteBuilderDefinition;
+import org.apache.camel.model.RouteContextRefDefinition;
+import org.apache.camel.model.RouteDefinition;
+import org.apache.camel.model.RouteTemplateContextRefDefinition;
+import org.apache.camel.model.RouteTemplateDefinition;
+import org.apache.camel.model.RouteTemplateParameterDefinition;
+import org.apache.camel.model.RouteTemplatesDefinition;
+import org.apache.camel.model.RoutesDefinition;
+import org.apache.camel.model.RoutingSlipDefinition;
+import org.apache.camel.model.SagaDefinition;
+import org.apache.camel.model.SamplingDefinition;
+import org.apache.camel.model.ScriptDefinition;
+import org.apache.camel.model.SetBodyDefinition;
+import org.apache.camel.model.SetExchangePatternDefinition;
+import org.apache.camel.model.SetHeaderDefinition;
+import org.apache.camel.model.SetPropertyDefinition;
+import org.apache.camel.model.SortDefinition;
+import org.apache.camel.model.SplitDefinition;
+import org.apache.camel.model.StepDefinition;
+import org.apache.camel.model.StopDefinition;
+import org.apache.camel.model.ThreadPoolProfileDefinition;
+import org.apache.camel.model.ThreadsDefinition;
+import org.apache.camel.model.ThrottleDefinition;
+import org.apache.camel.model.ThrowExceptionDefinition;
+import org.apache.camel.model.ToDefinition;
+import org.apache.camel.model.ToDynamicDefinition;
+import org.apache.camel.model.TransactedDefinition;
+import org.apache.camel.model.TransformDefinition;
+import org.apache.camel.model.TryDefinition;
+import org.apache.camel.model.UnmarshalDefinition;
+import org.apache.camel.model.ValidateDefinition;
+import org.apache.camel.model.WhenDefinition;
+import org.apache.camel.model.WhenSkipSendToEndpointDefinition;
+import org.apache.camel.model.WireTapDefinition;
+import org.apache.camel.model.cloud.BlacklistServiceCallServiceFilterConfiguration;
+import org.apache.camel.model.cloud.CachingServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.cloud.CombinedServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.cloud.CombinedServiceCallServiceFilterConfiguration;
+import org.apache.camel.model.cloud.ConsulServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.cloud.CustomServiceCallServiceFilterConfiguration;
+import org.apache.camel.model.cloud.DefaultServiceCallServiceLoadBalancerConfiguration;
+import org.apache.camel.model.cloud.DnsServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.cloud.EtcdServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.cloud.HealthyServiceCallServiceFilterConfiguration;
+import org.apache.camel.model.cloud.KubernetesServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.cloud.PassThroughServiceCallServiceFilterConfiguration;
+import org.apache.camel.model.cloud.RibbonServiceCallServiceLoadBalancerConfiguration;
+import org.apache.camel.model.cloud.ServiceCallConfigurationDefinition;
+import org.apache.camel.model.cloud.ServiceCallDefinition;
+import org.apache.camel.model.cloud.ServiceCallExpressionConfiguration;
+import org.apache.camel.model.cloud.ServiceCallServiceChooserConfiguration;
+import org.apache.camel.model.cloud.ServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.cloud.ServiceCallServiceFilterConfiguration;
+import org.apache.camel.model.cloud.ServiceCallServiceLoadBalancerConfiguration;
+import org.apache.camel.model.cloud.StaticServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.cloud.ZooKeeperServiceCallServiceDiscoveryConfiguration;
+import org.apache.camel.model.config.BatchResequencerConfig;
+import org.apache.camel.model.config.StreamResequencerConfig;
+import org.apache.camel.model.dataformat.ASN1DataFormat;
+import org.apache.camel.model.dataformat.Any23DataFormat;
+import org.apache.camel.model.dataformat.AvroDataFormat;
+import org.apache.camel.model.dataformat.BarcodeDataFormat;
+import org.apache.camel.model.dataformat.Base64DataFormat;
+import org.apache.camel.model.dataformat.BeanioDataFormat;
+import org.apache.camel.model.dataformat.BindyDataFormat;
+import org.apache.camel.model.dataformat.CBORDataFormat;
+import org.apache.camel.model.dataformat.CryptoDataFormat;
+import org.apache.camel.model.dataformat.CsvDataFormat;
+import org.apache.camel.model.dataformat.CustomDataFormat;
+import org.apache.camel.model.dataformat.DataFormatsDefinition;
+import org.apache.camel.model.dataformat.FhirJsonDataFormat;
+import org.apache.camel.model.dataformat.FhirXmlDataFormat;
+import org.apache.camel.model.dataformat.FlatpackDataFormat;
+import org.apache.camel.model.dataformat.GrokDataFormat;
+import org.apache.camel.model.dataformat.GzipDataFormat;
+import org.apache.camel.model.dataformat.HL7DataFormat;
+import org.apache.camel.model.dataformat.IcalDataFormat;
+import org.apache.camel.model.dataformat.JacksonXMLDataFormat;
+import org.apache.camel.model.dataformat.JaxbDataFormat;
+import org.apache.camel.model.dataformat.JsonApiDataFormat;
+import org.apache.camel.model.dataformat.JsonDataFormat;
+import org.apache.camel.model.dataformat.LZFDataFormat;
+import org.apache.camel.model.dataformat.MimeMultipartDataFormat;
+import org.apache.camel.model.dataformat.PGPDataFormat;
+import org.apache.camel.model.dataformat.ProtobufDataFormat;
+import org.apache.camel.model.dataformat.RssDataFormat;
+import org.apache.camel.model.dataformat.SoapJaxbDataFormat;
+import org.apache.camel.model.dataformat.SyslogDataFormat;
+import org.apache.camel.model.dataformat.TarFileDataFormat;
+import org.apache.camel.model.dataformat.ThriftDataFormat;
+import org.apache.camel.model.dataformat.TidyMarkupDataFormat;
+import org.apache.camel.model.dataformat.UniVocityCsvDataFormat;
+import org.apache.camel.model.dataformat.UniVocityFixedWidthDataFormat;
+import org.apache.camel.model.dataformat.UniVocityHeader;
+import org.apache.camel.model.dataformat.UniVocityTsvDataFormat;
+import org.apache.camel.model.dataformat.XMLSecurityDataFormat;
+import org.apache.camel.model.dataformat.XStreamDataFormat;
+import org.apache.camel.model.dataformat.XmlRpcDataFormat;
+import org.apache.camel.model.dataformat.YAMLDataFormat;
+import org.apache.camel.model.dataformat.YAMLTypeFilterDefinition;
+import org.apache.camel.model.dataformat.ZipDeflaterDataFormat;
+import org.apache.camel.model.dataformat.ZipFileDataFormat;
+import org.apache.camel.model.language.CSimpleExpression;
+import org.apache.camel.model.language.ConstantExpression;
+import org.apache.camel.model.language.DatasonnetExpression;
+import org.apache.camel.model.language.ExchangePropertyExpression;
+import org.apache.camel.model.language.ExpressionDefinition;
+import org.apache.camel.model.language.GroovyExpression;
+import org.apache.camel.model.language.HeaderExpression;
+import org.apache.camel.model.language.Hl7TerserExpression;
+import org.apache.camel.model.language.JoorExpression;
+import org.apache.camel.model.language.JsonPathExpression;
+import org.apache.camel.model.language.LanguageExpression;
+import org.apache.camel.model.language.MethodCallExpression;
+import org.apache.camel.model.language.MvelExpression;
+import org.apache.camel.model.language.OgnlExpression;
+import org.apache.camel.model.language.RefExpression;
+import org.apache.camel.model.language.SimpleExpression;
+import org.apache.camel.model.language.SpELExpression;
+import org.apache.camel.model.language.TokenizerExpression;
+import org.apache.camel.model.language.XMLTokenizerExpression;
+import org.apache.camel.model.language.XPathExpression;
+import org.apache.camel.model.language.XQueryExpression;
+import org.apache.camel.model.loadbalancer.CustomLoadBalancerDefinition;
+import org.apache.camel.model.loadbalancer.FailoverLoadBalancerDefinition;
+import org.apache.camel.model.loadbalancer.RandomLoadBalancerDefinition;
+import org.apache.camel.model.loadbalancer.RoundRobinLoadBalancerDefinition;
+import org.apache.camel.model.loadbalancer.StickyLoadBalancerDefinition;
+import org.apache.camel.model.loadbalancer.TopicLoadBalancerDefinition;
+import org.apache.camel.model.loadbalancer.WeightedLoadBalancerDefinition;
+import org.apache.camel.model.rest.DeleteVerbDefinition;
+import org.apache.camel.model.rest.GetVerbDefinition;
+import org.apache.camel.model.rest.HeadVerbDefinition;
+import org.apache.camel.model.rest.PatchVerbDefinition;
+import org.apache.camel.model.rest.PostVerbDefinition;
+import org.apache.camel.model.rest.PutVerbDefinition;
+import org.apache.camel.model.rest.RestBindingDefinition;
+import org.apache.camel.model.rest.RestConfigurationDefinition;
+import org.apache.camel.model.rest.RestDefinition;
+import org.apache.camel.model.rest.RestOperationParamDefinition;
+import org.apache.camel.model.rest.RestOperationResponseHeaderDefinition;
+import org.apache.camel.model.rest.RestOperationResponseMsgDefinition;
+import org.apache.camel.model.rest.RestPropertyDefinition;
+import org.apache.camel.model.rest.RestSecuritiesDefinition;
+import org.apache.camel.model.rest.RestSecurityApiKey;
+import org.apache.camel.model.rest.RestSecurityBasicAuth;
+import org.apache.camel.model.rest.RestSecurityOAuth2;
+import org.apache.camel.model.rest.RestsDefinition;
+import org.apache.camel.model.rest.SecurityDefinition;
+import org.apache.camel.model.rest.VerbDefinition;
+import org.apache.camel.model.transformer.CustomTransformerDefinition;
+import org.apache.camel.model.transformer.DataFormatTransformerDefinition;
+import org.apache.camel.model.transformer.EndpointTransformerDefinition;
+import org.apache.camel.model.transformer.TransformersDefinition;
+import org.apache.camel.model.validator.CustomValidatorDefinition;
+import org.apache.camel.model.validator.EndpointValidatorDefinition;
+import org.apache.camel.model.validator.PredicateValidatorDefinition;
+import org.apache.camel.model.validator.ValidatorsDefinition;
+import org.apache.camel.spi.annotations.YamlIn;
+import org.apache.camel.spi.annotations.YamlProperty;
+import org.apache.camel.spi.annotations.YamlType;
+import org.snakeyaml.engine.v2.nodes.MappingNode;
+import org.snakeyaml.engine.v2.nodes.Node;
+
+public final class ModelDeserializers extends YamlDeserializerSupport {
+ private ModelDeserializers() {
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.dataformat.ASN1DataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "asn1",
+ properties = {
+ @YamlProperty(name = "clazz-name", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "using-iterator", type = "boolean")
+ }
+ )
+ public static class ASN1DataFormatDeserializer extends YamlDeserializerBase<ASN1DataFormat> {
+ public ASN1DataFormatDeserializer() {
+ super(ASN1DataFormat.class);
+ }
+
+ @Override
+ protected ASN1DataFormat newInstance() {
+ return new ASN1DataFormat();
+ }
+
+ @Override
+ protected ASN1DataFormat newInstance(String value) {
+ return new ASN1DataFormat(value);
+ }
+
+ @Override
+ protected boolean setProperty(ASN1DataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "clazz-name": {
+ String val = asText(node);
+ target.setClazzName(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "using-iterator": {
+ String val = asText(node);
+ target.setUsingIterator(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.AggregateDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "aggregate",
+ properties = {
+ @YamlProperty(name = "aggregate-controller-ref", type = "string"),
+ @YamlProperty(name = "aggregation-repository-ref", type = "string"),
+ @YamlProperty(name = "close-correlation-key-on-completion", type = "number"),
+ @YamlProperty(name = "complete-all-on-stop", type = "boolean"),
+ @YamlProperty(name = "completion-from-batch-consumer", type = "boolean"),
+ @YamlProperty(name = "completion-interval", type = "string"),
+ @YamlProperty(name = "completion-on-new-correlation-group", type = "boolean"),
+ @YamlProperty(name = "completion-predicate", type = "object:org.apache.camel.model.ExpressionSubElementDefinition"),
+ @YamlProperty(name = "completion-size", type = "number"),
+ @YamlProperty(name = "completion-size-expression", type = "object:org.apache.camel.model.ExpressionSubElementDefinition"),
+ @YamlProperty(name = "completion-timeout", type = "string"),
+ @YamlProperty(name = "completion-timeout-checker-interval", type = "string"),
+ @YamlProperty(name = "completion-timeout-expression", type = "object:org.apache.camel.model.ExpressionSubElementDefinition"),
+ @YamlProperty(name = "correlation-expression", type = "object:org.apache.camel.model.ExpressionSubElementDefinition"),
+ @YamlProperty(name = "discard-on-aggregation-failure", type = "boolean"),
+ @YamlProperty(name = "discard-on-completion-timeout", type = "boolean"),
+ @YamlProperty(name = "eager-check-completion", type = "boolean"),
+ @YamlProperty(name = "executor-service-ref", type = "string"),
+ @YamlProperty(name = "force-completion-on-stop", type = "boolean"),
+ @YamlProperty(name = "ignore-invalid-correlation-keys", type = "boolean"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "optimistic-lock-retry-policy", type = "object:org.apache.camel.model.OptimisticLockRetryPolicyDefinition"),
+ @YamlProperty(name = "optimistic-locking", type = "boolean"),
+ @YamlProperty(name = "parallel-processing", type = "boolean"),
+ @YamlProperty(name = "strategy-method-allow-null", type = "boolean"),
+ @YamlProperty(name = "strategy-method-name", type = "string"),
+ @YamlProperty(name = "strategy-ref", type = "string"),
+ @YamlProperty(name = "timeout-checker-executor-service-ref", type = "string"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class AggregateDefinitionDeserializer extends YamlDeserializerBase<AggregateDefinition> {
+ public AggregateDefinitionDeserializer() {
+ super(AggregateDefinition.class);
+ }
+
+ @Override
+ protected AggregateDefinition newInstance() {
+ return new AggregateDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(AggregateDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "aggregate-controller-ref": {
+ String val = asText(node);
+ target.setAggregateControllerRef(val);
+ break;
+ }
+ case "aggregation-repository-ref": {
+ String val = asText(node);
+ target.setAggregationRepositoryRef(val);
+ break;
+ }
+ case "close-correlation-key-on-completion": {
+ String val = asText(node);
+ target.setCloseCorrelationKeyOnCompletion(val);
+ break;
+ }
+ case "complete-all-on-stop": {
+ String val = asText(node);
+ target.setCompleteAllOnStop(val);
+ break;
+ }
+ case "completion-from-batch-consumer": {
+ String val = asText(node);
+ target.setCompletionFromBatchConsumer(val);
+ break;
+ }
+ case "completion-interval": {
+ String val = asText(node);
+ target.setCompletionInterval(val);
+ break;
+ }
+ case "completion-on-new-correlation-group": {
+ String val = asText(node);
+ target.setCompletionOnNewCorrelationGroup(val);
+ break;
+ }
+ case "completion-predicate": {
+ org.apache.camel.model.ExpressionSubElementDefinition val = asType(node, org.apache.camel.model.ExpressionSubElementDefinition.class);
+ target.setCompletionPredicate(val);
+ break;
+ }
+ case "completion-size": {
+ String val = asText(node);
+ target.setCompletionSize(val);
+ break;
+ }
+ case "completion-size-expression": {
+ org.apache.camel.model.ExpressionSubElementDefinition val = asType(node, org.apache.camel.model.ExpressionSubElementDefinition.class);
+ target.setCompletionSizeExpression(val);
+ break;
+ }
+ case "completion-timeout": {
+ String val = asText(node);
+ target.setCompletionTimeout(val);
+ break;
+ }
+ case "completion-timeout-checker-interval": {
+ String val = asText(node);
+ target.setCompletionTimeoutCheckerInterval(val);
+ break;
+ }
+ case "completion-timeout-expression": {
+ org.apache.camel.model.ExpressionSubElementDefinition val = asType(node, org.apache.camel.model.ExpressionSubElementDefinition.class);
+ target.setCompletionTimeoutExpression(val);
+ break;
+ }
+ case "correlation-expression": {
+ org.apache.camel.model.ExpressionSubElementDefinition val = asType(node, org.apache.camel.model.ExpressionSubElementDefinition.class);
+ target.setCorrelationExpression(val);
+ break;
+ }
+ case "discard-on-aggregation-failure": {
+ String val = asText(node);
+ target.setDiscardOnAggregationFailure(val);
+ break;
+ }
+ case "discard-on-completion-timeout": {
+ String val = asText(node);
+ target.setDiscardOnCompletionTimeout(val);
+ break;
+ }
+ case "eager-check-completion": {
+ String val = asText(node);
+ target.setEagerCheckCompletion(val);
+ break;
+ }
+ case "executor-service-ref": {
+ String val = asText(node);
+ target.setExecutorServiceRef(val);
+ break;
+ }
+ case "force-completion-on-stop": {
+ String val = asText(node);
+ target.setForceCompletionOnStop(val);
+ break;
+ }
+ case "ignore-invalid-correlation-keys": {
+ String val = asText(node);
+ target.setIgnoreInvalidCorrelationKeys(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "optimistic-lock-retry-policy": {
+ org.apache.camel.model.OptimisticLockRetryPolicyDefinition val = asType(node, org.apache.camel.model.OptimisticLockRetryPolicyDefinition.class);
+ target.setOptimisticLockRetryPolicyDefinition(val);
+ break;
+ }
+ case "optimistic-locking": {
+ String val = asText(node);
+ target.setOptimisticLocking(val);
+ break;
+ }
+ case "parallel-processing": {
+ String val = asText(node);
+ target.setParallelProcessing(val);
+ break;
+ }
+ case "strategy-method-allow-null": {
+ String val = asText(node);
+ target.setStrategyMethodAllowNull(val);
+ break;
+ }
+ case "strategy-method-name": {
+ String val = asText(node);
+ target.setStrategyMethodName(val);
+ break;
+ }
+ case "strategy-ref": {
+ String val = asText(node);
+ target.setStrategyRef(val);
+ break;
+ }
+ case "timeout-checker-executor-service-ref": {
+ String val = asText(node);
+ target.setTimeoutCheckerExecutorServiceRef(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.dataformat.Any23DataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "any23",
+ properties = {
+ @YamlProperty(name = "base-uri", type = "string"),
+ @YamlProperty(name = "configuration", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "extractors", type = "array:string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "output-format", type = "string")
+ }
+ )
+ public static class Any23DataFormatDeserializer extends YamlDeserializerBase<Any23DataFormat> {
+ public Any23DataFormatDeserializer() {
+ super(Any23DataFormat.class);
+ }
+
+ @Override
+ protected Any23DataFormat newInstance() {
+ return new Any23DataFormat();
+ }
+
+ @Override
+ protected Any23DataFormat newInstance(String value) {
+ return new Any23DataFormat(value);
+ }
+
+ @Override
+ protected boolean setProperty(Any23DataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "base-uri": {
+ String val = asText(node);
+ target.setBaseURI(val);
+ break;
+ }
+ case "configuration": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setConfiguration(val);
+ break;
+ }
+ case "extractors": {
+ java.util.List<String> val = asStringList(node);
+ target.setExtractors(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "output-format": {
+ String val = asText(node);
+ target.setOutputFormat(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.dataformat.AvroDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "avro",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "instance-class-name", type = "string")
+ }
+ )
+ public static class AvroDataFormatDeserializer extends YamlDeserializerBase<AvroDataFormat> {
+ public AvroDataFormatDeserializer() {
+ super(AvroDataFormat.class);
+ }
+
+ @Override
+ protected AvroDataFormat newInstance() {
+ return new AvroDataFormat();
+ }
+
+ @Override
+ protected AvroDataFormat newInstance(String value) {
+ return new AvroDataFormat(value);
+ }
+
+ @Override
+ protected boolean setProperty(AvroDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "instance-class-name": {
+ String val = asText(node);
+ target.setInstanceClassName(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.BarcodeDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "barcode",
+ properties = {
+ @YamlProperty(name = "barcode-format", type = "string"),
+ @YamlProperty(name = "height", type = "number"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "image-type", type = "string"),
+ @YamlProperty(name = "width", type = "number")
+ }
+ )
+ public static class BarcodeDataFormatDeserializer extends YamlDeserializerBase<BarcodeDataFormat> {
+ public BarcodeDataFormatDeserializer() {
+ super(BarcodeDataFormat.class);
+ }
+
+ @Override
+ protected BarcodeDataFormat newInstance() {
+ return new BarcodeDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(BarcodeDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "barcode-format": {
+ String val = asText(node);
+ target.setBarcodeFormat(val);
+ break;
+ }
+ case "height": {
+ String val = asText(node);
+ target.setHeight(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "image-type": {
+ String val = asText(node);
+ target.setImageType(val);
+ break;
+ }
+ case "width": {
+ String val = asText(node);
+ target.setWidth(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.Base64DataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "base64",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "line-length", type = "number"),
+ @YamlProperty(name = "line-separator", type = "string"),
+ @YamlProperty(name = "url-safe", type = "boolean")
+ }
+ )
+ public static class Base64DataFormatDeserializer extends YamlDeserializerBase<Base64DataFormat> {
+ public Base64DataFormatDeserializer() {
+ super(Base64DataFormat.class);
+ }
+
+ @Override
+ protected Base64DataFormat newInstance() {
+ return new Base64DataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(Base64DataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "line-length": {
+ String val = asText(node);
+ target.setLineLength(val);
+ break;
+ }
+ case "line-separator": {
+ String val = asText(node);
+ target.setLineSeparator(val);
+ break;
+ }
+ case "url-safe": {
+ String val = asText(node);
+ target.setUrlSafe(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.config.BatchResequencerConfig.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "batch-config",
+ properties = {
+ @YamlProperty(name = "allow-duplicates", type = "boolean"),
+ @YamlProperty(name = "batch-size", type = "number"),
+ @YamlProperty(name = "batch-timeout", type = "string"),
+ @YamlProperty(name = "ignore-invalid-exchanges", type = "boolean"),
+ @YamlProperty(name = "reverse", type = "boolean")
+ }
+ )
+ public static class BatchResequencerConfigDeserializer extends YamlDeserializerBase<BatchResequencerConfig> {
+ public BatchResequencerConfigDeserializer() {
+ super(BatchResequencerConfig.class);
+ }
+
+ @Override
+ protected BatchResequencerConfig newInstance() {
+ return new BatchResequencerConfig();
+ }
+
+ @Override
+ protected boolean setProperty(BatchResequencerConfig target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "allow-duplicates": {
+ String val = asText(node);
+ target.setAllowDuplicates(val);
+ break;
+ }
+ case "batch-size": {
+ String val = asText(node);
+ target.setBatchSize(val);
+ break;
+ }
+ case "batch-timeout": {
+ String val = asText(node);
+ target.setBatchTimeout(val);
+ break;
+ }
+ case "ignore-invalid-exchanges": {
+ String val = asText(node);
+ target.setIgnoreInvalidExchanges(val);
+ break;
+ }
+ case "reverse": {
+ String val = asText(node);
+ target.setReverse(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.BeanDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "bean",
+ properties = {
+ @YamlProperty(name = "bean-type", type = "string"),
+ @YamlProperty(name = "cache", type = "boolean"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "method", type = "string"),
+ @YamlProperty(name = "ref", type = "string"),
+ @YamlProperty(name = "scope", type = "string")
+ }
+ )
+ public static class BeanDefinitionDeserializer extends YamlDeserializerBase<BeanDefinition> {
+ public BeanDefinitionDeserializer() {
+ super(BeanDefinition.class);
+ }
+
+ @Override
+ protected BeanDefinition newInstance() {
+ return new BeanDefinition();
+ }
+
+ @Override
+ protected BeanDefinition newInstance(String value) {
+ return new BeanDefinition(value);
+ }
+
+ @Override
+ protected boolean setProperty(BeanDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "bean-type": {
+ String val = asText(node);
+ target.setBeanType(val);
+ break;
+ }
+ case "cache": {
+ String val = asText(node);
+ target.setCache(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "method": {
+ String val = asText(node);
+ target.setMethod(val);
+ break;
+ }
+ case "ref": {
+ String val = asText(node);
+ target.setRef(val);
+ break;
+ }
+ case "scope": {
+ String val = asText(node);
+ target.setScope(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.BeanioDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "beanio",
+ properties = {
+ @YamlProperty(name = "bean-reader-error-handler-type", type = "string"),
+ @YamlProperty(name = "encoding", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "ignore-invalid-records", type = "boolean"),
+ @YamlProperty(name = "ignore-unexpected-records", type = "boolean"),
+ @YamlProperty(name = "ignore-unidentified-records", type = "boolean"),
+ @YamlProperty(name = "mapping", type = "string"),
+ @YamlProperty(name = "stream-name", type = "string"),
+ @YamlProperty(name = "unmarshal-single-object", type = "boolean")
+ }
+ )
+ public static class BeanioDataFormatDeserializer extends YamlDeserializerBase<BeanioDataFormat> {
+ public BeanioDataFormatDeserializer() {
+ super(BeanioDataFormat.class);
+ }
+
+ @Override
+ protected BeanioDataFormat newInstance() {
+ return new BeanioDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(BeanioDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "bean-reader-error-handler-type": {
+ String val = asText(node);
+ target.setBeanReaderErrorHandlerType(val);
+ break;
+ }
+ case "encoding": {
+ String val = asText(node);
+ target.setEncoding(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "ignore-invalid-records": {
+ String val = asText(node);
+ target.setIgnoreInvalidRecords(val);
+ break;
+ }
+ case "ignore-unexpected-records": {
+ String val = asText(node);
+ target.setIgnoreUnexpectedRecords(val);
+ break;
+ }
+ case "ignore-unidentified-records": {
+ String val = asText(node);
+ target.setIgnoreUnidentifiedRecords(val);
+ break;
+ }
+ case "mapping": {
+ String val = asText(node);
+ target.setMapping(val);
+ break;
+ }
+ case "stream-name": {
+ String val = asText(node);
+ target.setStreamName(val);
+ break;
+ }
+ case "unmarshal-single-object": {
+ String val = asText(node);
+ target.setUnmarshalSingleObject(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.BindyDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "bindy",
+ properties = {
+ @YamlProperty(name = "allow-empty-stream", type = "boolean"),
+ @YamlProperty(name = "class-type", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "locale", type = "string"),
+ @YamlProperty(name = "type", type = "string", required = true),
+ @YamlProperty(name = "unwrap-single-instance", type = "boolean")
+ }
+ )
+ public static class BindyDataFormatDeserializer extends YamlDeserializerBase<BindyDataFormat> {
+ public BindyDataFormatDeserializer() {
+ super(BindyDataFormat.class);
+ }
+
+ @Override
+ protected BindyDataFormat newInstance() {
+ return new BindyDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(BindyDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "allow-empty-stream": {
+ String val = asText(node);
+ target.setAllowEmptyStream(val);
+ break;
+ }
+ case "class-type": {
+ String val = asText(node);
+ target.setClassType(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "locale": {
+ String val = asText(node);
+ target.setLocale(val);
+ break;
+ }
+ case "type": {
+ String val = asText(node);
+ target.setType(val);
+ break;
+ }
+ case "unwrap-single-instance": {
+ String val = asText(node);
+ target.setUnwrapSingleInstance(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.BlacklistServiceCallServiceFilterConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "blacklist-service-filter",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "servers", type = "array:string")
+ }
+ )
+ public static class BlacklistServiceCallServiceFilterConfigurationDeserializer extends YamlDeserializerBase<BlacklistServiceCallServiceFilterConfiguration> {
+ public BlacklistServiceCallServiceFilterConfigurationDeserializer() {
+ super(BlacklistServiceCallServiceFilterConfiguration.class);
+ }
+
+ @Override
+ protected BlacklistServiceCallServiceFilterConfiguration newInstance() {
+ return new BlacklistServiceCallServiceFilterConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(BlacklistServiceCallServiceFilterConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ case "servers": {
+ java.util.List<String> val = asStringList(node);
+ target.setServers(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.CBORDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "cbor",
+ properties = {
+ @YamlProperty(name = "allow-jms-type", type = "boolean"),
+ @YamlProperty(name = "allow-unmarshall-type", type = "boolean"),
+ @YamlProperty(name = "collection-type-name", type = "string"),
+ @YamlProperty(name = "disable-features", type = "string"),
+ @YamlProperty(name = "enable-features", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "object-mapper", type = "string"),
+ @YamlProperty(name = "pretty-print", type = "boolean"),
+ @YamlProperty(name = "unmarshal-type-name", type = "string"),
+ @YamlProperty(name = "use-default-object-mapper", type = "boolean"),
+ @YamlProperty(name = "use-list", type = "boolean")
+ }
+ )
+ public static class CBORDataFormatDeserializer extends YamlDeserializerBase<CBORDataFormat> {
+ public CBORDataFormatDeserializer() {
+ super(CBORDataFormat.class);
+ }
+
+ @Override
+ protected CBORDataFormat newInstance() {
+ return new CBORDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(CBORDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "allow-jms-type": {
+ String val = asText(node);
+ target.setAllowJmsType(val);
+ break;
+ }
+ case "allow-unmarshall-type": {
+ String val = asText(node);
+ target.setAllowUnmarshallType(val);
+ break;
+ }
+ case "collection-type-name": {
+ String val = asText(node);
+ target.setCollectionTypeName(val);
+ break;
+ }
+ case "disable-features": {
+ String val = asText(node);
+ target.setDisableFeatures(val);
+ break;
+ }
+ case "enable-features": {
+ String val = asText(node);
+ target.setEnableFeatures(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "object-mapper": {
+ String val = asText(node);
+ target.setObjectMapper(val);
+ break;
+ }
+ case "pretty-print": {
+ String val = asText(node);
+ target.setPrettyPrint(val);
+ break;
+ }
+ case "unmarshal-type-name": {
+ String val = asText(node);
+ target.setUnmarshalTypeName(val);
+ break;
+ }
+ case "use-default-object-mapper": {
+ String val = asText(node);
+ target.setUseDefaultObjectMapper(val);
+ break;
+ }
+ case "use-list": {
+ String val = asText(node);
+ target.setUseList(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.language.CSimpleExpression.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "csimple",
+ properties = {
+ @YamlProperty(name = "expression", type = "string", required = true),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "result-type", type = "string"),
+ @YamlProperty(name = "trim", type = "boolean")
+ }
+ )
+ public static class CSimpleExpressionDeserializer extends YamlDeserializerBase<CSimpleExpression> {
+ public CSimpleExpressionDeserializer() {
+ super(CSimpleExpression.class);
+ }
+
+ @Override
+ protected CSimpleExpression newInstance() {
+ return new CSimpleExpression();
+ }
+
+ @Override
+ protected CSimpleExpression newInstance(String value) {
+ return new CSimpleExpression(value);
+ }
+
+ @Override
+ protected boolean setProperty(CSimpleExpression target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "expression": {
+ String val = asText(node);
+ target.setExpression(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "result-type": {
+ String val = asText(node);
+ target.setResultTypeName(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.CachingServiceCallServiceDiscoveryConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "caching-service-discovery",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "consul-service-discovery", type = "object:org.apache.camel.model.cloud.ConsulServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "dns-service-discovery", type = "object:org.apache.camel.model.cloud.DnsServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "etcd-service-discovery", type = "object:org.apache.camel.model.cloud.EtcdServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "kubernetes-service-discovery", type = "object:org.apache.camel.model.cloud.KubernetesServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "combined-service-discovery", type = "object:org.apache.camel.model.cloud.CombinedServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "static-service-discovery", type = "object:org.apache.camel.model.cloud.StaticServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "timeout", type = "number"),
+ @YamlProperty(name = "units", type = "string")
+ }
+ )
+ public static class CachingServiceCallServiceDiscoveryConfigurationDeserializer extends YamlDeserializerBase<CachingServiceCallServiceDiscoveryConfiguration> {
+ public CachingServiceCallServiceDiscoveryConfigurationDeserializer() {
+ super(CachingServiceCallServiceDiscoveryConfiguration.class);
+ }
+
+ @Override
+ protected CachingServiceCallServiceDiscoveryConfiguration newInstance() {
+ return new CachingServiceCallServiceDiscoveryConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(CachingServiceCallServiceDiscoveryConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ case "service-discovery-configuration": {
+ MappingNode val = asMappingNode(node);
+ setProperties(target, val);
+ break;
+ }
+ case "consul-service-discovery": {
+ org.apache.camel.model.cloud.ConsulServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.ConsulServiceCallServiceDiscoveryConfiguration.class);
+ target.setServiceDiscoveryConfiguration(val);
+ break;
+ }
+ case "dns-service-discovery": {
+ org.apache.camel.model.cloud.DnsServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.DnsServiceCallServiceDiscoveryConfiguration.class);
+ target.setServiceDiscoveryConfiguration(val);
+ break;
+ }
+ case "etcd-service-discovery": {
+ org.apache.camel.model.cloud.EtcdServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.EtcdServiceCallServiceDiscoveryConfiguration.class);
+ target.setServiceDiscoveryConfiguration(val);
+ break;
+ }
+ case "kubernetes-service-discovery": {
+ org.apache.camel.model.cloud.KubernetesServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.KubernetesServiceCallServiceDiscoveryConfiguration.class);
+ target.setServiceDiscoveryConfiguration(val);
+ break;
+ }
+ case "combined-service-discovery": {
+ org.apache.camel.model.cloud.CombinedServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.CombinedServiceCallServiceDiscoveryConfiguration.class);
+ target.setServiceDiscoveryConfiguration(val);
+ break;
+ }
+ case "static-service-discovery": {
+ org.apache.camel.model.cloud.StaticServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.StaticServiceCallServiceDiscoveryConfiguration.class);
+ target.setServiceDiscoveryConfiguration(val);
+ break;
+ }
+ case "timeout": {
+ String val = asText(node);
+ target.setTimeout(val);
+ break;
+ }
+ case "units": {
+ String val = asText(node);
+ target.setUnits(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.CatchDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "do-catch",
+ properties = {
+ @YamlProperty(name = "exception", type = "array:string"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "on-when", type = "object:org.apache.camel.model.WhenDefinition"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class CatchDefinitionDeserializer extends YamlDeserializerBase<CatchDefinition> {
+ public CatchDefinitionDeserializer() {
+ super(CatchDefinition.class);
+ }
+
+ @Override
+ protected CatchDefinition newInstance() {
+ return new CatchDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(CatchDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "exception": {
+ java.util.List<String> val = asStringList(node);
+ target.setExceptions(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "on-when": {
+ org.apache.camel.model.WhenDefinition val = asType(node, org.apache.camel.model.WhenDefinition.class);
+ target.setOnWhen(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.ChoiceDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "choice",
+ properties = {
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "otherwise", type = "object:org.apache.camel.model.OtherwiseDefinition"),
+ @YamlProperty(name = "when-clauses", type = "array:org.apache.camel.model.WhenDefinition"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class ChoiceDefinitionDeserializer extends YamlDeserializerBase<ChoiceDefinition> {
+ public ChoiceDefinitionDeserializer() {
+ super(ChoiceDefinition.class);
+ }
+
+ @Override
+ protected ChoiceDefinition newInstance() {
+ return new ChoiceDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(ChoiceDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "otherwise": {
+ org.apache.camel.model.OtherwiseDefinition val = asType(node, org.apache.camel.model.OtherwiseDefinition.class);
+ target.setOtherwise(val);
+ break;
+ }
+ case "when": {
+ java.util.List<org.apache.camel.model.WhenDefinition> val = asFlatList(node, org.apache.camel.model.WhenDefinition.class);
+ target.setWhenClauses(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.CircuitBreakerDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "circuit-breaker",
+ properties = {
+ @YamlProperty(name = "configuration-ref", type = "string"),
+ @YamlProperty(name = "fault-tolerance-configuration", type = "object:org.apache.camel.model.FaultToleranceConfigurationDefinition"),
+ @YamlProperty(name = "hystrix-configuration", type = "object:org.apache.camel.model.HystrixConfigurationDefinition"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "on-fallback", type = "object:org.apache.camel.model.OnFallbackDefinition"),
+ @YamlProperty(name = "resilience4j-configuration", type = "object:org.apache.camel.model.Resilience4jConfigurationDefinition"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class CircuitBreakerDefinitionDeserializer extends YamlDeserializerBase<CircuitBreakerDefinition> {
+ public CircuitBreakerDefinitionDeserializer() {
+ super(CircuitBreakerDefinition.class);
+ }
+
+ @Override
+ protected CircuitBreakerDefinition newInstance() {
+ return new CircuitBreakerDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(CircuitBreakerDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "configuration-ref": {
+ String val = asText(node);
+ target.setConfigurationRef(val);
+ break;
+ }
+ case "fault-tolerance-configuration": {
+ org.apache.camel.model.FaultToleranceConfigurationDefinition val = asType(node, org.apache.camel.model.FaultToleranceConfigurationDefinition.class);
+ target.setFaultToleranceConfiguration(val);
+ break;
+ }
+ case "hystrix-configuration": {
+ org.apache.camel.model.HystrixConfigurationDefinition val = asType(node, org.apache.camel.model.HystrixConfigurationDefinition.class);
+ target.setHystrixConfiguration(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "on-fallback": {
+ org.apache.camel.model.OnFallbackDefinition val = asType(node, org.apache.camel.model.OnFallbackDefinition.class);
+ target.setOnFallback(val);
+ break;
+ }
+ case "resilience4j-configuration": {
+ org.apache.camel.model.Resilience4jConfigurationDefinition val = asType(node, org.apache.camel.model.Resilience4jConfigurationDefinition.class);
+ target.setResilience4jConfiguration(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.ClaimCheckDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "claim-check",
+ properties = {
+ @YamlProperty(name = "strategy-method-name", type = "string"),
+ @YamlProperty(name = "strategy-ref", type = "string"),
+ @YamlProperty(name = "filter", type = "string"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "key", type = "string"),
+ @YamlProperty(name = "operation", type = "string")
+ }
+ )
+ public static class ClaimCheckDefinitionDeserializer extends YamlDeserializerBase<ClaimCheckDefinition> {
+ public ClaimCheckDefinitionDeserializer() {
+ super(ClaimCheckDefinition.class);
+ }
+
+ @Override
+ protected ClaimCheckDefinition newInstance() {
+ return new ClaimCheckDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(ClaimCheckDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "strategy-method-name": {
+ String val = asText(node);
+ target.setAggregationStrategyMethodName(val);
+ break;
+ }
+ case "strategy-ref": {
+ String val = asText(node);
+ target.setAggregationStrategyRef(val);
+ break;
+ }
+ case "filter": {
+ String val = asText(node);
+ target.setFilter(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "key": {
+ String val = asText(node);
+ target.setKey(val);
+ break;
+ }
+ case "operation": {
+ String val = asText(node);
+ target.setOperation(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.CombinedServiceCallServiceDiscoveryConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "combined-service-discovery",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "consul-service-discovery", type = "object:org.apache.camel.model.cloud.ConsulServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "dns-service-discovery", type = "object:org.apache.camel.model.cloud.DnsServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "etcd-service-discovery", type = "object:org.apache.camel.model.cloud.EtcdServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "kubernetes-service-discovery", type = "object:org.apache.camel.model.cloud.KubernetesServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "static-service-discovery", type = "object:org.apache.camel.model.cloud.StaticServiceCallServiceDiscoveryConfiguration"),
+ @YamlProperty(name = "caching-service-discovery", type = "object:org.apache.camel.model.cloud.CachingServiceCallServiceDiscoveryConfiguration")
+ }
+ )
+ public static class CombinedServiceCallServiceDiscoveryConfigurationDeserializer extends YamlDeserializerBase<CombinedServiceCallServiceDiscoveryConfiguration> {
+ public CombinedServiceCallServiceDiscoveryConfigurationDeserializer() {
+ super(CombinedServiceCallServiceDiscoveryConfiguration.class);
+ }
+
+ @Override
+ protected CombinedServiceCallServiceDiscoveryConfiguration newInstance() {
+ return new CombinedServiceCallServiceDiscoveryConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(CombinedServiceCallServiceDiscoveryConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ case "service-discovery-configurations": {
+ MappingNode val = asMappingNode(node);
+ setProperties(target, val);
+ break;
+ }
+ case "consul-service-discovery": {
+ org.apache.camel.model.cloud.ConsulServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.ConsulServiceCallServiceDiscoveryConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceDiscoveryConfiguration> existing = target.getServiceDiscoveryConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceDiscoveryConfigurations(existing);
+ break;
+ }
+ case "dns-service-discovery": {
+ org.apache.camel.model.cloud.DnsServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.DnsServiceCallServiceDiscoveryConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceDiscoveryConfiguration> existing = target.getServiceDiscoveryConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceDiscoveryConfigurations(existing);
+ break;
+ }
+ case "etcd-service-discovery": {
+ org.apache.camel.model.cloud.EtcdServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.EtcdServiceCallServiceDiscoveryConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceDiscoveryConfiguration> existing = target.getServiceDiscoveryConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceDiscoveryConfigurations(existing);
+ break;
+ }
+ case "kubernetes-service-discovery": {
+ org.apache.camel.model.cloud.KubernetesServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.KubernetesServiceCallServiceDiscoveryConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceDiscoveryConfiguration> existing = target.getServiceDiscoveryConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceDiscoveryConfigurations(existing);
+ break;
+ }
+ case "static-service-discovery": {
+ org.apache.camel.model.cloud.StaticServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.StaticServiceCallServiceDiscoveryConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceDiscoveryConfiguration> existing = target.getServiceDiscoveryConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceDiscoveryConfigurations(existing);
+ break;
+ }
+ case "caching-service-discovery": {
+ org.apache.camel.model.cloud.CachingServiceCallServiceDiscoveryConfiguration val = asType(node, org.apache.camel.model.cloud.CachingServiceCallServiceDiscoveryConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceDiscoveryConfiguration> existing = target.getServiceDiscoveryConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceDiscoveryConfigurations(existing);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.CombinedServiceCallServiceFilterConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "combined-service-filter",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "blacklist-service-filter", type = "object:org.apache.camel.model.cloud.BlacklistServiceCallServiceFilterConfiguration"),
+ @YamlProperty(name = "custom-service-filter", type = "object:org.apache.camel.model.cloud.CustomServiceCallServiceFilterConfiguration"),
+ @YamlProperty(name = "healthy-service-filter", type = "object:org.apache.camel.model.cloud.HealthyServiceCallServiceFilterConfiguration"),
+ @YamlProperty(name = "pass-through-service-filter", type = "object:org.apache.camel.model.cloud.PassThroughServiceCallServiceFilterConfiguration")
+ }
+ )
+ public static class CombinedServiceCallServiceFilterConfigurationDeserializer extends YamlDeserializerBase<CombinedServiceCallServiceFilterConfiguration> {
+ public CombinedServiceCallServiceFilterConfigurationDeserializer() {
+ super(CombinedServiceCallServiceFilterConfiguration.class);
+ }
+
+ @Override
+ protected CombinedServiceCallServiceFilterConfiguration newInstance() {
+ return new CombinedServiceCallServiceFilterConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(CombinedServiceCallServiceFilterConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ case "service-filter-configurations": {
+ MappingNode val = asMappingNode(node);
+ setProperties(target, val);
+ break;
+ }
+ case "blacklist-service-filter": {
+ org.apache.camel.model.cloud.BlacklistServiceCallServiceFilterConfiguration val = asType(node, org.apache.camel.model.cloud.BlacklistServiceCallServiceFilterConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceFilterConfiguration> existing = target.getServiceFilterConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceFilterConfigurations(existing);
+ break;
+ }
+ case "custom-service-filter": {
+ org.apache.camel.model.cloud.CustomServiceCallServiceFilterConfiguration val = asType(node, org.apache.camel.model.cloud.CustomServiceCallServiceFilterConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceFilterConfiguration> existing = target.getServiceFilterConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceFilterConfigurations(existing);
+ break;
+ }
+ case "healthy-service-filter": {
+ org.apache.camel.model.cloud.HealthyServiceCallServiceFilterConfiguration val = asType(node, org.apache.camel.model.cloud.HealthyServiceCallServiceFilterConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceFilterConfiguration> existing = target.getServiceFilterConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceFilterConfigurations(existing);
+ break;
+ }
+ case "pass-through-service-filter": {
+ org.apache.camel.model.cloud.PassThroughServiceCallServiceFilterConfiguration val = asType(node, org.apache.camel.model.cloud.PassThroughServiceCallServiceFilterConfiguration.class);
+ java.util.List<org.apache.camel.model.cloud.ServiceCallServiceFilterConfiguration> existing = target.getServiceFilterConfigurations();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setServiceFilterConfigurations(existing);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.language.ConstantExpression.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "constant",
+ properties = {
+ @YamlProperty(name = "expression", type = "string", required = true),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "trim", type = "boolean")
+ }
+ )
+ public static class ConstantExpressionDeserializer extends YamlDeserializerBase<ConstantExpression> {
+ public ConstantExpressionDeserializer() {
+ super(ConstantExpression.class);
+ }
+
+ @Override
+ protected ConstantExpression newInstance() {
+ return new ConstantExpression();
+ }
+
+ @Override
+ protected ConstantExpression newInstance(String value) {
+ return new ConstantExpression(value);
+ }
+
+ @Override
+ protected boolean setProperty(ConstantExpression target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "expression": {
+ String val = asText(node);
+ target.setExpression(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.ConsulServiceCallServiceDiscoveryConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "consul-service-discovery",
+ properties = {
+ @YamlProperty(name = "acl-token", type = "string"),
+ @YamlProperty(name = "block-seconds", type = "number"),
+ @YamlProperty(name = "connect-timeout-millis", type = "number"),
+ @YamlProperty(name = "datacenter", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "password", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "read-timeout-millis", type = "number"),
+ @YamlProperty(name = "url", type = "string"),
+ @YamlProperty(name = "user-name", type = "string"),
+ @YamlProperty(name = "write-timeout-millis", type = "number")
+ }
+ )
+ public static class ConsulServiceCallServiceDiscoveryConfigurationDeserializer extends YamlDeserializerBase<ConsulServiceCallServiceDiscoveryConfiguration> {
+ public ConsulServiceCallServiceDiscoveryConfigurationDeserializer() {
+ super(ConsulServiceCallServiceDiscoveryConfiguration.class);
+ }
+
+ @Override
+ protected ConsulServiceCallServiceDiscoveryConfiguration newInstance() {
+ return new ConsulServiceCallServiceDiscoveryConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(ConsulServiceCallServiceDiscoveryConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "acl-token": {
+ String val = asText(node);
+ target.setAclToken(val);
+ break;
+ }
+ case "block-seconds": {
+ String val = asText(node);
+ target.setBlockSeconds(val);
+ break;
+ }
+ case "connect-timeout-millis": {
+ String val = asText(node);
+ target.setConnectTimeoutMillis(val);
+ break;
+ }
+ case "datacenter": {
+ String val = asText(node);
+ target.setDatacenter(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "password": {
+ String val = asText(node);
+ target.setPassword(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ case "read-timeout-millis": {
+ String val = asText(node);
+ target.setReadTimeoutMillis(val);
+ break;
+ }
+ case "url": {
+ String val = asText(node);
+ target.setUrl(val);
+ break;
+ }
+ case "user-name": {
+ String val = asText(node);
+ target.setUserName(val);
+ break;
+ }
+ case "write-timeout-millis": {
+ String val = asText(node);
+ target.setWriteTimeoutMillis(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.ContextScanDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "context-scan",
+ properties = {
+ @YamlProperty(name = "excludes", type = "array:string"),
+ @YamlProperty(name = "include-non-singletons", type = "boolean"),
+ @YamlProperty(name = "includes", type = "array:string")
+ }
+ )
+ public static class ContextScanDefinitionDeserializer extends YamlDeserializerBase<ContextScanDefinition> {
+ public ContextScanDefinitionDeserializer() {
+ super(ContextScanDefinition.class);
+ }
+
+ @Override
+ protected ContextScanDefinition newInstance() {
+ return new ContextScanDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(ContextScanDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "excludes": {
+ java.util.List<String> val = asStringList(node);
+ target.setExcludes(val);
+ break;
+ }
+ case "include-non-singletons": {
+ String val = asText(node);
+ target.setIncludeNonSingletons(val);
+ break;
+ }
+ case "includes": {
+ java.util.List<String> val = asStringList(node);
+ target.setIncludes(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.ConvertBodyDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "convert-body-to",
+ properties = {
+ @YamlProperty(name = "charset", type = "string"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "type", type = "string")
+ }
+ )
+ public static class ConvertBodyDefinitionDeserializer extends YamlDeserializerBase<ConvertBodyDefinition> {
+ public ConvertBodyDefinitionDeserializer() {
+ super(ConvertBodyDefinition.class);
+ }
+
+ @Override
+ protected ConvertBodyDefinition newInstance() {
+ return new ConvertBodyDefinition();
+ }
+
+ @Override
+ protected ConvertBodyDefinition newInstance(String value) {
+ return new ConvertBodyDefinition(value);
+ }
+
+ @Override
+ protected boolean setProperty(ConvertBodyDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "charset": {
+ String val = asText(node);
+ target.setCharset(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "type": {
+ String val = asText(node);
+ target.setType(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.CryptoDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "crypto",
+ properties = {
+ @YamlProperty(name = "algorithm", type = "string"),
+ @YamlProperty(name = "algorithm-parameter-ref", type = "string"),
+ @YamlProperty(name = "buffersize", type = "number"),
+ @YamlProperty(name = "crypto-provider", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "init-vector-ref", type = "string"),
+ @YamlProperty(name = "inline", type = "boolean"),
+ @YamlProperty(name = "key-ref", type = "string"),
+ @YamlProperty(name = "mac-algorithm", type = "string"),
+ @YamlProperty(name = "should-append-hmac", type = "boolean")
+ }
+ )
+ public static class CryptoDataFormatDeserializer extends YamlDeserializerBase<CryptoDataFormat> {
+ public CryptoDataFormatDeserializer() {
+ super(CryptoDataFormat.class);
+ }
+
+ @Override
+ protected CryptoDataFormat newInstance() {
+ return new CryptoDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(CryptoDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "algorithm": {
+ String val = asText(node);
+ target.setAlgorithm(val);
+ break;
+ }
+ case "algorithm-parameter-ref": {
+ String val = asText(node);
+ target.setAlgorithmParameterRef(val);
+ break;
+ }
+ case "buffersize": {
+ String val = asText(node);
+ target.setBuffersize(val);
+ break;
+ }
+ case "crypto-provider": {
+ String val = asText(node);
+ target.setCryptoProvider(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "init-vector-ref": {
+ String val = asText(node);
+ target.setInitVectorRef(val);
+ break;
+ }
+ case "inline": {
+ String val = asText(node);
+ target.setInline(val);
+ break;
+ }
+ case "key-ref": {
+ String val = asText(node);
+ target.setKeyRef(val);
+ break;
+ }
+ case "mac-algorithm": {
+ String val = asText(node);
+ target.setMacAlgorithm(val);
+ break;
+ }
+ case "should-append-hmac": {
+ String val = asText(node);
+ target.setShouldAppendHMAC(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.dataformat.CsvDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "csv",
+ properties = {
+ @YamlProperty(name = "allow-missing-column-names", type = "boolean"),
+ @YamlProperty(name = "comment-marker", type = "string"),
+ @YamlProperty(name = "comment-marker-disabled", type = "boolean"),
+ @YamlProperty(name = "delimiter", type = "string"),
+ @YamlProperty(name = "escape", type = "string"),
+ @YamlProperty(name = "escape-disabled", type = "boolean"),
+ @YamlProperty(name = "format-name", type = "string"),
+ @YamlProperty(name = "format-ref", type = "string"),
+ @YamlProperty(name = "header", type = "array:string"),
+ @YamlProperty(name = "header-disabled", type = "boolean"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "ignore-empty-lines", type = "boolean"),
+ @YamlProperty(name = "ignore-header-case", type = "boolean"),
+ @YamlProperty(name = "ignore-surrounding-spaces", type = "boolean"),
+ @YamlProperty(name = "lazy-load", type = "boolean"),
+ @YamlProperty(name = "marshaller-factory-ref", type = "string"),
+ @YamlProperty(name = "null-string", type = "string"),
+ @YamlProperty(name = "null-string-disabled", type = "boolean"),
+ @YamlProperty(name = "quote", type = "string"),
+ @YamlProperty(name = "quote-disabled", type = "boolean"),
+ @YamlProperty(name = "quote-mode", type = "string"),
+ @YamlProperty(name = "record-converter-ref", type = "string"),
+ @YamlProperty(name = "record-separator", type = "string"),
+ @YamlProperty(name = "record-separator-disabled", type = "string"),
+ @YamlProperty(name = "skip-header-record", type = "boolean"),
+ @YamlProperty(name = "trailing-delimiter", type = "boolean"),
+ @YamlProperty(name = "trim", type = "boolean"),
+ @YamlProperty(name = "use-maps", type = "boolean"),
+ @YamlProperty(name = "use-ordered-maps", type = "boolean")
+ }
+ )
+ public static class CsvDataFormatDeserializer extends YamlDeserializerBase<CsvDataFormat> {
+ public CsvDataFormatDeserializer() {
+ super(CsvDataFormat.class);
+ }
+
+ @Override
+ protected CsvDataFormat newInstance() {
+ return new CsvDataFormat();
+ }
+
+ @Override
+ protected CsvDataFormat newInstance(String value) {
+ return new CsvDataFormat(value);
+ }
+
+ @Override
+ protected boolean setProperty(CsvDataFormat target, String propertyKey, String propertyName,
+ Node node) {
+ switch(propertyKey) {
+ case "allow-missing-column-names": {
+ String val = asText(node);
+ target.setAllowMissingColumnNames(val);
+ break;
+ }
+ case "comment-marker": {
+ String val = asText(node);
+ target.setCommentMarker(val);
+ break;
+ }
+ case "comment-marker-disabled": {
+ String val = asText(node);
+ target.setCommentMarkerDisabled(val);
+ break;
+ }
+ case "delimiter": {
+ String val = asText(node);
+ target.setDelimiter(val);
+ break;
+ }
+ case "escape": {
+ String val = asText(node);
+ target.setEscape(val);
+ break;
+ }
+ case "escape-disabled": {
+ String val = asText(node);
+ target.setEscapeDisabled(val);
+ break;
+ }
+ case "format-name": {
+ String val = asText(node);
+ target.setFormatName(val);
+ break;
+ }
+ case "format-ref": {
+ String val = asText(node);
+ target.setFormatRef(val);
+ break;
+ }
+ case "header": {
+ java.util.List<String> val = asStringList(node);
+ target.setHeader(val);
+ break;
+ }
+ case "header-disabled": {
+ String val = asText(node);
+ target.setHeaderDisabled(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "ignore-empty-lines": {
+ String val = asText(node);
+ target.setIgnoreEmptyLines(val);
+ break;
+ }
+ case "ignore-header-case": {
+ String val = asText(node);
+ target.setIgnoreHeaderCase(val);
+ break;
+ }
+ case "ignore-surrounding-spaces": {
+ String val = asText(node);
+ target.setIgnoreSurroundingSpaces(val);
+ break;
+ }
+ case "lazy-load": {
+ String val = asText(node);
+ target.setLazyLoad(val);
+ break;
+ }
+ case "marshaller-factory-ref": {
+ String val = asText(node);
+ target.setMarshallerFactoryRef(val);
+ break;
+ }
+ case "null-string": {
+ String val = asText(node);
+ target.setNullString(val);
+ break;
+ }
+ case "null-string-disabled": {
+ String val = asText(node);
+ target.setNullStringDisabled(val);
+ break;
+ }
+ case "quote": {
+ String val = asText(node);
+ target.setQuote(val);
+ break;
+ }
+ case "quote-disabled": {
+ String val = asText(node);
+ target.setQuoteDisabled(val);
+ break;
+ }
+ case "quote-mode": {
+ String val = asText(node);
+ target.setQuoteMode(val);
+ break;
+ }
+ case "record-converter-ref": {
+ String val = asText(node);
+ target.setRecordConverterRef(val);
+ break;
+ }
+ case "record-separator": {
+ String val = asText(node);
+ target.setRecordSeparator(val);
+ break;
+ }
+ case "record-separator-disabled": {
+ String val = asText(node);
+ target.setRecordSeparatorDisabled(val);
+ break;
+ }
+ case "skip-header-record": {
+ String val = asText(node);
+ target.setSkipHeaderRecord(val);
+ break;
+ }
+ case "trailing-delimiter": {
+ String val = asText(node);
+ target.setTrailingDelimiter(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ case "use-maps": {
+ String val = asText(node);
+ target.setUseMaps(val);
+ break;
+ }
+ case "use-ordered-maps": {
+ String val = asText(node);
+ target.setUseOrderedMaps(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.dataformat.CustomDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "custom-data-format",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "ref", type = "string")
+ }
+ )
+ public static class CustomDataFormatDeserializer extends YamlDeserializerBase<CustomDataFormat> {
+ public CustomDataFormatDeserializer() {
+ super(CustomDataFormat.class);
+ }
+
+ @Override
+ protected CustomDataFormat newInstance() {
+ return new CustomDataFormat();
+ }
+
+ @Override
+ protected CustomDataFormat newInstance(String value) {
+ return new CustomDataFormat(value);
+ }
+
+ @Override
+ protected boolean setProperty(CustomDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "ref": {
+ String val = asText(node);
+ target.setRef(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.loadbalancer.CustomLoadBalancerDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "custom-load-balancer",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "ref", type = "string")
+ }
+ )
+ public static class CustomLoadBalancerDefinitionDeserializer extends YamlDeserializerBase<CustomLoadBalancerDefinition> {
+ public CustomLoadBalancerDefinitionDeserializer() {
+ super(CustomLoadBalancerDefinition.class);
+ }
+
+ @Override
+ protected CustomLoadBalancerDefinition newInstance() {
+ return new CustomLoadBalancerDefinition();
+ }
+
+ @Override
+ protected CustomLoadBalancerDefinition newInstance(String value) {
+ return new CustomLoadBalancerDefinition(value);
+ }
+
+ @Override
+ protected boolean setProperty(CustomLoadBalancerDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "ref": {
+ String val = asText(node);
+ target.setRef(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.CustomServiceCallServiceFilterConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "custom-service-filter",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "ref", type = "string")
+ }
+ )
+ public static class CustomServiceCallServiceFilterConfigurationDeserializer extends YamlDeserializerBase<CustomServiceCallServiceFilterConfiguration> {
+ public CustomServiceCallServiceFilterConfigurationDeserializer() {
+ super(CustomServiceCallServiceFilterConfiguration.class);
+ }
+
+ @Override
+ protected CustomServiceCallServiceFilterConfiguration newInstance() {
+ return new CustomServiceCallServiceFilterConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(CustomServiceCallServiceFilterConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ case "ref": {
+ String val = asText(node);
+ target.setServiceFilterRef(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.transformer.CustomTransformerDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ properties = {
+ @YamlProperty(name = "class-name", type = "string"),
+ @YamlProperty(name = "from-type", type = "string"),
+ @YamlProperty(name = "ref", type = "string"),
+ @YamlProperty(name = "scheme", type = "string"),
+ @YamlProperty(name = "to-type", type = "string")
+ }
+ )
+ public static class CustomTransformerDefinitionDeserializer extends YamlDeserializerBase<CustomTransformerDefinition> {
+ public CustomTransformerDefinitionDeserializer() {
+ super(CustomTransformerDefinition.class);
+ }
+
+ @Override
+ protected CustomTransformerDefinition newInstance() {
+ return new CustomTransformerDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(CustomTransformerDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "class-name": {
+ String val = asText(node);
+ target.setClassName(val);
+ break;
+ }
+ case "from-type": {
+ String val = asText(node);
+ target.setFromType(val);
+ break;
+ }
+ case "ref": {
+ String val = asText(node);
+ target.setRef(val);
+ break;
+ }
+ case "scheme": {
+ String val = asText(node);
+ target.setScheme(val);
+ break;
+ }
+ case "to-type": {
+ String val = asText(node);
+ target.setToType(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.validator.CustomValidatorDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ properties = {
+ @YamlProperty(name = "class-name", type = "string"),
+ @YamlProperty(name = "ref", type = "string"),
+ @YamlProperty(name = "type", type = "string")
+ }
+ )
+ public static class CustomValidatorDefinitionDeserializer extends YamlDeserializerBase<CustomValidatorDefinition> {
+ public CustomValidatorDefinitionDeserializer() {
+ super(CustomValidatorDefinition.class);
+ }
+
+ @Override
+ protected CustomValidatorDefinition newInstance() {
+ return new CustomValidatorDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(CustomValidatorDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "class-name": {
+ String val = asText(node);
+ target.setClassName(val);
+ break;
+ }
+ case "ref": {
+ String val = asText(node);
+ target.setRef(val);
+ break;
+ }
+ case "type": {
+ String val = asText(node);
+ target.setType(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.DataFormatDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ properties = @YamlProperty(name = "id", type = "string")
+ )
+ public static class DataFormatDefinitionDeserializer extends YamlDeserializerBase<DataFormatDefinition> {
+ public DataFormatDefinitionDeserializer() {
+ super(DataFormatDefinition.class);
+ }
+
+ @Override
+ protected DataFormatDefinition newInstance() {
+ return new DataFormatDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(DataFormatDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.transformer.DataFormatTransformerDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ properties = {
+ @YamlProperty(name = "any23", type = "object:org.apache.camel.model.dataformat.Any23DataFormat"),
+ @YamlProperty(name = "asn1", type = "object:org.apache.camel.model.dataformat.ASN1DataFormat"),
+ @YamlProperty(name = "avro", type = "object:org.apache.camel.model.dataformat.AvroDataFormat"),
+ @YamlProperty(name = "barcode", type = "object:org.apache.camel.model.dataformat.BarcodeDataFormat"),
+ @YamlProperty(name = "base64", type = "object:org.apache.camel.model.dataformat.Base64DataFormat"),
+ @YamlProperty(name = "beanio", type = "object:org.apache.camel.model.dataformat.BeanioDataFormat"),
+ @YamlProperty(name = "bindy", type = "object:org.apache.camel.model.dataformat.BindyDataFormat"),
+ @YamlProperty(name = "cbor", type = "object:org.apache.camel.model.dataformat.CBORDataFormat"),
+ @YamlProperty(name = "crypto", type = "object:org.apache.camel.model.dataformat.CryptoDataFormat"),
+ @YamlProperty(name = "csv", type = "object:org.apache.camel.model.dataformat.CsvDataFormat"),
+ @YamlProperty(name = "custom", type = "object:org.apache.camel.model.dataformat.CustomDataFormat"),
+ @YamlProperty(name = "fhir-json", type = "object:org.apache.camel.model.dataformat.FhirJsonDataFormat"),
+ @YamlProperty(name = "fhir-xml", type = "object:org.apache.camel.model.dataformat.FhirXmlDataFormat"),
+ @YamlProperty(name = "flatpack", type = "object:org.apache.camel.model.dataformat.FlatpackDataFormat"),
+ @YamlProperty(name = "grok", type = "object:org.apache.camel.model.dataformat.GrokDataFormat"),
+ @YamlProperty(name = "gzip", type = "object:org.apache.camel.model.dataformat.GzipDataFormat"),
+ @YamlProperty(name = "hl7", type = "object:org.apache.camel.model.dataformat.HL7DataFormat"),
+ @YamlProperty(name = "ical", type = "object:org.apache.camel.model.dataformat.IcalDataFormat"),
+ @YamlProperty(name = "jacksonxml", type = "object:org.apache.camel.model.dataformat.JacksonXMLDataFormat"),
+ @YamlProperty(name = "jaxb", type = "object:org.apache.camel.model.dataformat.JaxbDataFormat"),
+ @YamlProperty(name = "json", type = "object:org.apache.camel.model.dataformat.JsonDataFormat"),
+ @YamlProperty(name = "json-api", type = "object:org.apache.camel.model.dataformat.JsonApiDataFormat"),
+ @YamlProperty(name = "lzf", type = "object:org.apache.camel.model.dataformat.LZFDataFormat"),
+ @YamlProperty(name = "mime-multipart", type = "object:org.apache.camel.model.dataformat.MimeMultipartDataFormat"),
+ @YamlProperty(name = "protobuf", type = "object:org.apache.camel.model.dataformat.ProtobufDataFormat"),
+ @YamlProperty(name = "rss", type = "object:org.apache.camel.model.dataformat.RssDataFormat"),
+ @YamlProperty(name = "secure-xml", type = "object:org.apache.camel.model.dataformat.XMLSecurityDataFormat"),
+ @YamlProperty(name = "soapjaxb", type = "object:org.apache.camel.model.dataformat.SoapJaxbDataFormat"),
+ @YamlProperty(name = "syslog", type = "object:org.apache.camel.model.dataformat.SyslogDataFormat"),
+ @YamlProperty(name = "tarfile", type = "object:org.apache.camel.model.dataformat.TarFileDataFormat"),
+ @YamlProperty(name = "thrift", type = "object:org.apache.camel.model.dataformat.ThriftDataFormat"),
+ @YamlProperty(name = "tidy-markup", type = "object:org.apache.camel.model.dataformat.TidyMarkupDataFormat"),
+ @YamlProperty(name = "univocity-csv", type = "object:org.apache.camel.model.dataformat.UniVocityCsvDataFormat"),
+ @YamlProperty(name = "univocity-fixed", type = "object:org.apache.camel.model.dataformat.UniVocityFixedWidthDataFormat"),
+ @YamlProperty(name = "univocity-tsv", type = "object:org.apache.camel.model.dataformat.UniVocityTsvDataFormat"),
+ @YamlProperty(name = "xmlrpc", type = "object:org.apache.camel.model.dataformat.XmlRpcDataFormat"),
+ @YamlProperty(name = "xstream", type = "object:org.apache.camel.model.dataformat.XStreamDataFormat"),
+ @YamlProperty(name = "pgp", type = "object:org.apache.camel.model.dataformat.PGPDataFormat"),
+ @YamlProperty(name = "yaml", type = "object:org.apache.camel.model.dataformat.YAMLDataFormat"),
+ @YamlProperty(name = "zip", type = "object:org.apache.camel.model.dataformat.ZipDeflaterDataFormat"),
+ @YamlProperty(name = "zipfile", type = "object:org.apache.camel.model.dataformat.ZipFileDataFormat"),
+ @YamlProperty(name = "from-type", type = "string"),
+ @YamlProperty(name = "ref", type = "string"),
+ @YamlProperty(name = "scheme", type = "string"),
+ @YamlProperty(name = "to-type", type = "string")
+ }
+ )
+ public static class DataFormatTransformerDefinitionDeserializer extends YamlDeserializerBase<DataFormatTransformerDefinition> {
+ public DataFormatTransformerDefinitionDeserializer() {
+ super(DataFormatTransformerDefinition.class);
+ }
+
+ @Override
+ protected DataFormatTransformerDefinition newInstance() {
+ return new DataFormatTransformerDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(DataFormatTransformerDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "data-format-type": {
+ MappingNode val = asMappingNode(node);
+ setProperties(target, val);
+ break;
+ }
+ case "any23": {
+ org.apache.camel.model.dataformat.Any23DataFormat val = asType(node, org.apache.camel.model.dataformat.Any23DataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "asn1": {
+ org.apache.camel.model.dataformat.ASN1DataFormat val = asType(node, org.apache.camel.model.dataformat.ASN1DataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "avro": {
+ org.apache.camel.model.dataformat.AvroDataFormat val = asType(node, org.apache.camel.model.dataformat.AvroDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "barcode": {
+ org.apache.camel.model.dataformat.BarcodeDataFormat val = asType(node, org.apache.camel.model.dataformat.BarcodeDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "base64": {
+ org.apache.camel.model.dataformat.Base64DataFormat val = asType(node, org.apache.camel.model.dataformat.Base64DataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "beanio": {
+ org.apache.camel.model.dataformat.BeanioDataFormat val = asType(node, org.apache.camel.model.dataformat.BeanioDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "bindy": {
+ org.apache.camel.model.dataformat.BindyDataFormat val = asType(node, org.apache.camel.model.dataformat.BindyDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "cbor": {
+ org.apache.camel.model.dataformat.CBORDataFormat val = asType(node, org.apache.camel.model.dataformat.CBORDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "crypto": {
+ org.apache.camel.model.dataformat.CryptoDataFormat val = asType(node, org.apache.camel.model.dataformat.CryptoDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "csv": {
+ org.apache.camel.model.dataformat.CsvDataFormat val = asType(node, org.apache.camel.model.dataformat.CsvDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "custom": {
+ org.apache.camel.model.dataformat.CustomDataFormat val = asType(node, org.apache.camel.model.dataformat.CustomDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "fhir-json": {
+ org.apache.camel.model.dataformat.FhirJsonDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirJsonDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "fhir-xml": {
+ org.apache.camel.model.dataformat.FhirXmlDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirXmlDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "flatpack": {
+ org.apache.camel.model.dataformat.FlatpackDataFormat val = asType(node, org.apache.camel.model.dataformat.FlatpackDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "grok": {
+ org.apache.camel.model.dataformat.GrokDataFormat val = asType(node, org.apache.camel.model.dataformat.GrokDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "gzip": {
+ org.apache.camel.model.dataformat.GzipDataFormat val = asType(node, org.apache.camel.model.dataformat.GzipDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "hl7": {
+ org.apache.camel.model.dataformat.HL7DataFormat val = asType(node, org.apache.camel.model.dataformat.HL7DataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "ical": {
+ org.apache.camel.model.dataformat.IcalDataFormat val = asType(node, org.apache.camel.model.dataformat.IcalDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "jacksonxml": {
+ org.apache.camel.model.dataformat.JacksonXMLDataFormat val = asType(node, org.apache.camel.model.dataformat.JacksonXMLDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "jaxb": {
+ org.apache.camel.model.dataformat.JaxbDataFormat val = asType(node, org.apache.camel.model.dataformat.JaxbDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "json": {
+ org.apache.camel.model.dataformat.JsonDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "json-api": {
+ org.apache.camel.model.dataformat.JsonApiDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonApiDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "lzf": {
+ org.apache.camel.model.dataformat.LZFDataFormat val = asType(node, org.apache.camel.model.dataformat.LZFDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "mime-multipart": {
+ org.apache.camel.model.dataformat.MimeMultipartDataFormat val = asType(node, org.apache.camel.model.dataformat.MimeMultipartDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "protobuf": {
+ org.apache.camel.model.dataformat.ProtobufDataFormat val = asType(node, org.apache.camel.model.dataformat.ProtobufDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "rss": {
+ org.apache.camel.model.dataformat.RssDataFormat val = asType(node, org.apache.camel.model.dataformat.RssDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "secure-xml": {
+ org.apache.camel.model.dataformat.XMLSecurityDataFormat val = asType(node, org.apache.camel.model.dataformat.XMLSecurityDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "soapjaxb": {
+ org.apache.camel.model.dataformat.SoapJaxbDataFormat val = asType(node, org.apache.camel.model.dataformat.SoapJaxbDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "syslog": {
+ org.apache.camel.model.dataformat.SyslogDataFormat val = asType(node, org.apache.camel.model.dataformat.SyslogDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "tarfile": {
+ org.apache.camel.model.dataformat.TarFileDataFormat val = asType(node, org.apache.camel.model.dataformat.TarFileDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "thrift": {
+ org.apache.camel.model.dataformat.ThriftDataFormat val = asType(node, org.apache.camel.model.dataformat.ThriftDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "tidy-markup": {
+ org.apache.camel.model.dataformat.TidyMarkupDataFormat val = asType(node, org.apache.camel.model.dataformat.TidyMarkupDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "univocity-csv": {
+ org.apache.camel.model.dataformat.UniVocityCsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityCsvDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "univocity-fixed": {
+ org.apache.camel.model.dataformat.UniVocityFixedWidthDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityFixedWidthDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "univocity-tsv": {
+ org.apache.camel.model.dataformat.UniVocityTsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityTsvDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "xmlrpc": {
+ org.apache.camel.model.dataformat.XmlRpcDataFormat val = asType(node, org.apache.camel.model.dataformat.XmlRpcDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "xstream": {
+ org.apache.camel.model.dataformat.XStreamDataFormat val = asType(node, org.apache.camel.model.dataformat.XStreamDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "pgp": {
+ org.apache.camel.model.dataformat.PGPDataFormat val = asType(node, org.apache.camel.model.dataformat.PGPDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "yaml": {
+ org.apache.camel.model.dataformat.YAMLDataFormat val = asType(node, org.apache.camel.model.dataformat.YAMLDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "zip": {
+ org.apache.camel.model.dataformat.ZipDeflaterDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipDeflaterDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "zipfile": {
+ org.apache.camel.model.dataformat.ZipFileDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipFileDataFormat.class);
+ target.setDataFormatType(val);
+ break;
+ }
+ case "from-type": {
+ String val = asText(node);
+ target.setFromType(val);
+ break;
+ }
+ case "ref": {
+ String val = asText(node);
+ target.setRef(val);
+ break;
+ }
+ case "scheme": {
+ String val = asText(node);
+ target.setScheme(val);
+ break;
+ }
+ case "to-type": {
+ String val = asText(node);
+ target.setToType(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.DataFormatsDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "data-formats",
+ properties = {
+ @YamlProperty(name = "any23", type = "object:org.apache.camel.model.dataformat.Any23DataFormat"),
+ @YamlProperty(name = "asn1", type = "object:org.apache.camel.model.dataformat.ASN1DataFormat"),
+ @YamlProperty(name = "avro", type = "object:org.apache.camel.model.dataformat.AvroDataFormat"),
+ @YamlProperty(name = "barcode", type = "object:org.apache.camel.model.dataformat.BarcodeDataFormat"),
+ @YamlProperty(name = "base64", type = "object:org.apache.camel.model.dataformat.Base64DataFormat"),
+ @YamlProperty(name = "beanio", type = "object:org.apache.camel.model.dataformat.BeanioDataFormat"),
+ @YamlProperty(name = "bindy", type = "object:org.apache.camel.model.dataformat.BindyDataFormat"),
+ @YamlProperty(name = "cbor", type = "object:org.apache.camel.model.dataformat.CBORDataFormat"),
+ @YamlProperty(name = "crypto", type = "object:org.apache.camel.model.dataformat.CryptoDataFormat"),
+ @YamlProperty(name = "csv", type = "object:org.apache.camel.model.dataformat.CsvDataFormat"),
+ @YamlProperty(name = "custom", type = "object:org.apache.camel.model.dataformat.CustomDataFormat"),
+ @YamlProperty(name = "fhir-json", type = "object:org.apache.camel.model.dataformat.FhirJsonDataFormat"),
+ @YamlProperty(name = "fhir-xml", type = "object:org.apache.camel.model.dataformat.FhirXmlDataFormat"),
+ @YamlProperty(name = "flatpack", type = "object:org.apache.camel.model.dataformat.FlatpackDataFormat"),
+ @YamlProperty(name = "grok", type = "object:org.apache.camel.model.dataformat.GrokDataFormat"),
+ @YamlProperty(name = "gzip", type = "object:org.apache.camel.model.dataformat.GzipDataFormat"),
+ @YamlProperty(name = "hl7", type = "object:org.apache.camel.model.dataformat.HL7DataFormat"),
+ @YamlProperty(name = "ical", type = "object:org.apache.camel.model.dataformat.IcalDataFormat"),
+ @YamlProperty(name = "jacksonxml", type = "object:org.apache.camel.model.dataformat.JacksonXMLDataFormat"),
+ @YamlProperty(name = "jaxb", type = "object:org.apache.camel.model.dataformat.JaxbDataFormat"),
+ @YamlProperty(name = "json", type = "object:org.apache.camel.model.dataformat.JsonDataFormat"),
+ @YamlProperty(name = "json-api", type = "object:org.apache.camel.model.dataformat.JsonApiDataFormat"),
+ @YamlProperty(name = "lzf", type = "object:org.apache.camel.model.dataformat.LZFDataFormat"),
+ @YamlProperty(name = "mime-multipart", type = "object:org.apache.camel.model.dataformat.MimeMultipartDataFormat"),
+ @YamlProperty(name = "protobuf", type = "object:org.apache.camel.model.dataformat.ProtobufDataFormat"),
+ @YamlProperty(name = "rss", type = "object:org.apache.camel.model.dataformat.RssDataFormat"),
+ @YamlProperty(name = "secure-xml", type = "object:org.apache.camel.model.dataformat.XMLSecurityDataFormat"),
+ @YamlProperty(name = "soapjaxb", type = "object:org.apache.camel.model.dataformat.SoapJaxbDataFormat"),
+ @YamlProperty(name = "syslog", type = "object:org.apache.camel.model.dataformat.SyslogDataFormat"),
+ @YamlProperty(name = "tarfile", type = "object:org.apache.camel.model.dataformat.TarFileDataFormat"),
+ @YamlProperty(name = "thrift", type = "object:org.apache.camel.model.dataformat.ThriftDataFormat"),
+ @YamlProperty(name = "tidy-markup", type = "object:org.apache.camel.model.dataformat.TidyMarkupDataFormat"),
+ @YamlProperty(name = "univocity-csv", type = "object:org.apache.camel.model.dataformat.UniVocityCsvDataFormat"),
+ @YamlProperty(name = "univocity-fixed", type = "object:org.apache.camel.model.dataformat.UniVocityFixedWidthDataFormat"),
+ @YamlProperty(name = "univocity-tsv", type = "object:org.apache.camel.model.dataformat.UniVocityTsvDataFormat"),
+ @YamlProperty(name = "xmlrpc", type = "object:org.apache.camel.model.dataformat.XmlRpcDataFormat"),
+ @YamlProperty(name = "xstream", type = "object:org.apache.camel.model.dataformat.XStreamDataFormat"),
+ @YamlProperty(name = "pgp", type = "object:org.apache.camel.model.dataformat.PGPDataFormat"),
+ @YamlProperty(name = "yaml", type = "object:org.apache.camel.model.dataformat.YAMLDataFormat"),
+ @YamlProperty(name = "zip", type = "object:org.apache.camel.model.dataformat.ZipDeflaterDataFormat"),
+ @YamlProperty(name = "zipfile", type = "object:org.apache.camel.model.dataformat.ZipFileDataFormat")
+ }
+ )
+ public static class DataFormatsDefinitionDeserializer extends YamlDeserializerBase<DataFormatsDefinition> {
+ public DataFormatsDefinitionDeserializer() {
+ super(DataFormatsDefinition.class);
+ }
+
+ @Override
+ protected DataFormatsDefinition newInstance() {
+ return new DataFormatsDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(DataFormatsDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "data-formats": {
+ MappingNode val = asMappingNode(node);
+ setProperties(target, val);
+ break;
+ }
+ case "any23": {
+ org.apache.camel.model.dataformat.Any23DataFormat val = asType(node, org.apache.camel.model.dataformat.Any23DataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "asn1": {
+ org.apache.camel.model.dataformat.ASN1DataFormat val = asType(node, org.apache.camel.model.dataformat.ASN1DataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "avro": {
+ org.apache.camel.model.dataformat.AvroDataFormat val = asType(node, org.apache.camel.model.dataformat.AvroDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "barcode": {
+ org.apache.camel.model.dataformat.BarcodeDataFormat val = asType(node, org.apache.camel.model.dataformat.BarcodeDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "base64": {
+ org.apache.camel.model.dataformat.Base64DataFormat val = asType(node, org.apache.camel.model.dataformat.Base64DataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "beanio": {
+ org.apache.camel.model.dataformat.BeanioDataFormat val = asType(node, org.apache.camel.model.dataformat.BeanioDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "bindy": {
+ org.apache.camel.model.dataformat.BindyDataFormat val = asType(node, org.apache.camel.model.dataformat.BindyDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "cbor": {
+ org.apache.camel.model.dataformat.CBORDataFormat val = asType(node, org.apache.camel.model.dataformat.CBORDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "crypto": {
+ org.apache.camel.model.dataformat.CryptoDataFormat val = asType(node, org.apache.camel.model.dataformat.CryptoDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "csv": {
+ org.apache.camel.model.dataformat.CsvDataFormat val = asType(node, org.apache.camel.model.dataformat.CsvDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "custom": {
+ org.apache.camel.model.dataformat.CustomDataFormat val = asType(node, org.apache.camel.model.dataformat.CustomDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "fhir-json": {
+ org.apache.camel.model.dataformat.FhirJsonDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirJsonDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "fhir-xml": {
+ org.apache.camel.model.dataformat.FhirXmlDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirXmlDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "flatpack": {
+ org.apache.camel.model.dataformat.FlatpackDataFormat val = asType(node, org.apache.camel.model.dataformat.FlatpackDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "grok": {
+ org.apache.camel.model.dataformat.GrokDataFormat val = asType(node, org.apache.camel.model.dataformat.GrokDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "gzip": {
+ org.apache.camel.model.dataformat.GzipDataFormat val = asType(node, org.apache.camel.model.dataformat.GzipDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "hl7": {
+ org.apache.camel.model.dataformat.HL7DataFormat val = asType(node, org.apache.camel.model.dataformat.HL7DataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "ical": {
+ org.apache.camel.model.dataformat.IcalDataFormat val = asType(node, org.apache.camel.model.dataformat.IcalDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "jacksonxml": {
+ org.apache.camel.model.dataformat.JacksonXMLDataFormat val = asType(node, org.apache.camel.model.dataformat.JacksonXMLDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "jaxb": {
+ org.apache.camel.model.dataformat.JaxbDataFormat val = asType(node, org.apache.camel.model.dataformat.JaxbDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "json": {
+ org.apache.camel.model.dataformat.JsonDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "json-api": {
+ org.apache.camel.model.dataformat.JsonApiDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonApiDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "lzf": {
+ org.apache.camel.model.dataformat.LZFDataFormat val = asType(node, org.apache.camel.model.dataformat.LZFDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "mime-multipart": {
+ org.apache.camel.model.dataformat.MimeMultipartDataFormat val = asType(node, org.apache.camel.model.dataformat.MimeMultipartDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "protobuf": {
+ org.apache.camel.model.dataformat.ProtobufDataFormat val = asType(node, org.apache.camel.model.dataformat.ProtobufDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "rss": {
+ org.apache.camel.model.dataformat.RssDataFormat val = asType(node, org.apache.camel.model.dataformat.RssDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "secure-xml": {
+ org.apache.camel.model.dataformat.XMLSecurityDataFormat val = asType(node, org.apache.camel.model.dataformat.XMLSecurityDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "soapjaxb": {
+ org.apache.camel.model.dataformat.SoapJaxbDataFormat val = asType(node, org.apache.camel.model.dataformat.SoapJaxbDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "syslog": {
+ org.apache.camel.model.dataformat.SyslogDataFormat val = asType(node, org.apache.camel.model.dataformat.SyslogDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "tarfile": {
+ org.apache.camel.model.dataformat.TarFileDataFormat val = asType(node, org.apache.camel.model.dataformat.TarFileDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "thrift": {
+ org.apache.camel.model.dataformat.ThriftDataFormat val = asType(node, org.apache.camel.model.dataformat.ThriftDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "tidy-markup": {
+ org.apache.camel.model.dataformat.TidyMarkupDataFormat val = asType(node, org.apache.camel.model.dataformat.TidyMarkupDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "univocity-csv": {
+ org.apache.camel.model.dataformat.UniVocityCsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityCsvDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "univocity-fixed": {
+ org.apache.camel.model.dataformat.UniVocityFixedWidthDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityFixedWidthDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "univocity-tsv": {
+ org.apache.camel.model.dataformat.UniVocityTsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityTsvDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "xmlrpc": {
+ org.apache.camel.model.dataformat.XmlRpcDataFormat val = asType(node, org.apache.camel.model.dataformat.XmlRpcDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "xstream": {
+ org.apache.camel.model.dataformat.XStreamDataFormat val = asType(node, org.apache.camel.model.dataformat.XStreamDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "pgp": {
+ org.apache.camel.model.dataformat.PGPDataFormat val = asType(node, org.apache.camel.model.dataformat.PGPDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "yaml": {
+ org.apache.camel.model.dataformat.YAMLDataFormat val = asType(node, org.apache.camel.model.dataformat.YAMLDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "zip": {
+ org.apache.camel.model.dataformat.ZipDeflaterDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipDeflaterDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ case "zipfile": {
+ org.apache.camel.model.dataformat.ZipFileDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipFileDataFormat.class);
+ java.util.List<org.apache.camel.model.DataFormatDefinition> existing = target.getDataFormats();
+ if (existing == null) {
+ existing = new java.util.ArrayList<>();
+ }
+ existing.add(val);
+ target.setDataFormats(existing);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.language.DatasonnetExpression.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "datasonnet",
+ properties = {
+ @YamlProperty(name = "body-media-type", type = "string"),
+ @YamlProperty(name = "expression", type = "string", required = true),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "output-media-type", type = "string"),
+ @YamlProperty(name = "result-type", type = "string"),
+ @YamlProperty(name = "trim", type = "boolean")
+ }
+ )
+ public static class DatasonnetExpressionDeserializer extends YamlDeserializerBase<DatasonnetExpression> {
+ public DatasonnetExpressionDeserializer() {
+ super(DatasonnetExpression.class);
+ }
+
+ @Override
+ protected DatasonnetExpression newInstance() {
+ return new DatasonnetExpression();
+ }
+
+ @Override
+ protected DatasonnetExpression newInstance(String value) {
+ return new DatasonnetExpression(value);
+ }
+
+ @Override
+ protected boolean setProperty(DatasonnetExpression target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "body-media-type": {
+ String val = asText(node);
+ target.setBodyMediaType(val);
+ break;
+ }
+ case "expression": {
+ String val = asText(node);
+ target.setExpression(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "output-media-type": {
+ String val = asText(node);
+ target.setOutputMediaType(val);
+ break;
+ }
+ case "result-type": {
+ String val = asText(node);
+ target.setResultTypeName(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.DefaultServiceCallServiceLoadBalancerConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "default-load-balancer",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition")
+ }
+ )
+ public static class DefaultServiceCallServiceLoadBalancerConfigurationDeserializer extends YamlDeserializerBase<DefaultServiceCallServiceLoadBalancerConfiguration> {
+ public DefaultServiceCallServiceLoadBalancerConfigurationDeserializer() {
+ super(DefaultServiceCallServiceLoadBalancerConfiguration.class);
+ }
+
+ @Override
+ protected DefaultServiceCallServiceLoadBalancerConfiguration newInstance() {
+ return new DefaultServiceCallServiceLoadBalancerConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(DefaultServiceCallServiceLoadBalancerConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.DelayDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "delay",
+ properties = {
+ @YamlProperty(name = "async-delayed", type = "boolean"),
+ @YamlProperty(name = "caller-runs-when-rejected", type = "boolean"),
+ @YamlProperty(name = "executor-service-ref", type = "string"),
+ @YamlProperty(name = "expression", type = "object:org.apache.camel.model.language.ExpressionDefinition"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "__extends", type = "object:org.apache.camel.model.language.ExpressionDefinition")
+ }
+ )
+ public static class DelayDefinitionDeserializer extends YamlDeserializerBase<DelayDefinition> {
+ public DelayDefinitionDeserializer() {
+ super(DelayDefinition.class);
+ }
+
+ @Override
+ protected DelayDefinition newInstance() {
+ return new DelayDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(DelayDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "async-delayed": {
+ String val = asText(node);
+ target.setAsyncDelayed(val);
+ break;
+ }
+ case "caller-runs-when-rejected": {
+ String val = asText(node);
+ target.setCallerRunsWhenRejected(val);
+ break;
+ }
+ case "executor-service-ref": {
+ String val = asText(node);
+ target.setExecutorServiceRef(val);
+ break;
+ }
+ case "expression": {
+ org.apache.camel.model.language.ExpressionDefinition val = asType(node, org.apache.camel.model.language.ExpressionDefinition.class);
+ target.setExpression(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.rest.DeleteVerbDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "delete",
+ properties = {
+ @YamlProperty(name = "api-docs", type = "string"),
+ @YamlProperty(name = "binding-mode", type = "string"),
+ @YamlProperty(name = "client-request-validation", type = "string"),
+ @YamlProperty(name = "consumes", type = "string"),
+ @YamlProperty(name = "enable-cors", type = "string"),
+ @YamlProperty(name = "method", type = "string"),
+ @YamlProperty(name = "out-type", type = "string"),
+ @YamlProperty(name = "params", type = "array:org.apache.camel.model.rest.RestOperationParamDefinition"),
+ @YamlProperty(name = "produces", type = "string"),
+ @YamlProperty(name = "response-msgs", type = "array:org.apache.camel.model.rest.RestOperationResponseMsgDefinition"),
+ @YamlProperty(name = "route-id", type = "string"),
+ @YamlProperty(name = "security", type = "array:org.apache.camel.model.rest.SecurityDefinition"),
+ @YamlProperty(name = "skip-binding-on-error-code", type = "string"),
+ @YamlProperty(name = "to", type = "object:org.apache.camel.model.ToDefinition"),
+ @YamlProperty(name = "to-d", type = "object:org.apache.camel.model.ToDynamicDefinition"),
+ @YamlProperty(name = "route", type = "object:org.apache.camel.model.RouteDefinition"),
+ @YamlProperty(name = "type", type = "string"),
+ @YamlProperty(name = "uri", type = "string"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class DeleteVerbDefinitionDeserializer extends YamlDeserializerBase<DeleteVerbDefinition> {
+ public DeleteVerbDefinitionDeserializer() {
+ super(DeleteVerbDefinition.class);
+ }
+
+ @Override
+ protected DeleteVerbDefinition newInstance() {
+ return new DeleteVerbDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(DeleteVerbDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "api-docs": {
+ String val = asText(node);
+ target.setApiDocs(val);
+ break;
+ }
+ case "binding-mode": {
+ String val = asText(node);
+ target.setBindingMode(val);
+ break;
+ }
+ case "client-request-validation": {
+ String val = asText(node);
+ target.setClientRequestValidation(val);
+ break;
+ }
+ case "consumes": {
+ String val = asText(node);
+ target.setConsumes(val);
+ break;
+ }
+ case "enable-cors": {
+ String val = asText(node);
+ target.setEnableCORS(val);
+ break;
+ }
+ case "method": {
+ String val = asText(node);
+ target.setMethod(val);
+ break;
+ }
+ case "out-type": {
+ String val = asText(node);
+ target.setOutType(val);
+ break;
+ }
+ case "param": {
+ java.util.List<org.apache.camel.model.rest.RestOperationParamDefinition> val = asFlatList(node, org.apache.camel.model.rest.RestOperationParamDefinition.class);
+ target.setParams(val);
+ break;
+ }
+ case "produces": {
+ String val = asText(node);
+ target.setProduces(val);
+ break;
+ }
+ case "response-message": {
+ java.util.List<org.apache.camel.model.rest.RestOperationResponseMsgDefinition> val = asFlatList(node, org.apache.camel.model.rest.RestOperationResponseMsgDefinition.class);
+ target.setResponseMsgs(val);
+ break;
+ }
+ case "route-id": {
+ String val = asText(node);
+ target.setRouteId(val);
+ break;
+ }
+ case "security": {
+ java.util.List<org.apache.camel.model.rest.SecurityDefinition> val = asFlatList(node, org.apache.camel.model.rest.SecurityDefinition.class);
+ target.setSecurity(val);
+ break;
+ }
+ case "skip-binding-on-error-code": {
+ String val = asText(node);
+ target.setSkipBindingOnErrorCode(val);
+ break;
+ }
+ case "to-or-route": {
+ MappingNode val = asMappingNode(node);
+ setProperties(target, val);
+ break;
+ }
+ case "to": {
+ org.apache.camel.model.ToDefinition val = asType(node, org.apache.camel.model.ToDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "to-d": {
+ org.apache.camel.model.ToDynamicDefinition val = asType(node, org.apache.camel.model.ToDynamicDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "route": {
+ org.apache.camel.model.RouteDefinition val = asType(node, org.apache.camel.model.RouteDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "type": {
+ String val = asText(node);
+ target.setType(val);
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.DescriptionDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "description",
+ properties = {
+ @YamlProperty(name = "lang", type = "string"),
+ @YamlProperty(name = "text", type = "string")
+ }
+ )
+ public static class DescriptionDefinitionDeserializer extends YamlDeserializerBase<DescriptionDefinition> {
+ public DescriptionDefinitionDeserializer() {
+ super(DescriptionDefinition.class);
+ }
+
+ @Override
+ protected DescriptionDefinition newInstance() {
+ return new DescriptionDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(DescriptionDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "lang": {
+ String val = asText(node);
+ target.setLang(val);
+ break;
+ }
+ case "text": {
+ String val = asText(node);
+ target.setText(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.DnsServiceCallServiceDiscoveryConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "dns-service-discovery",
+ properties = {
+ @YamlProperty(name = "domain", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "proto", type = "string")
+ }
+ )
+ public static class DnsServiceCallServiceDiscoveryConfigurationDeserializer extends YamlDeserializerBase<DnsServiceCallServiceDiscoveryConfiguration> {
+ public DnsServiceCallServiceDiscoveryConfigurationDeserializer() {
+ super(DnsServiceCallServiceDiscoveryConfiguration.class);
+ }
+
+ @Override
+ protected DnsServiceCallServiceDiscoveryConfiguration newInstance() {
+ return new DnsServiceCallServiceDiscoveryConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(DnsServiceCallServiceDiscoveryConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "domain": {
+ String val = asText(node);
+ target.setDomain(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ case "proto": {
+ String val = asText(node);
+ target.setProto(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.DynamicRouterDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "dynamic-router",
+ properties = {
+ @YamlProperty(name = "cache-size", type = "number"),
+ @YamlProperty(name = "expression", type = "object:org.apache.camel.model.language.ExpressionDefinition"),
+ @YamlProperty(name = "ignore-invalid-endpoints", type = "string"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "uri-delimiter", type = "string"),
+ @YamlProperty(name = "__extends", type = "object:org.apache.camel.model.language.ExpressionDefinition")
+ }
+ )
+ public static class DynamicRouterDefinitionDeserializer extends YamlDeserializerBase<DynamicRouterDefinition> {
+ public DynamicRouterDefinitionDeserializer() {
+ super(DynamicRouterDefinition.class);
+ }
+
+ @Override
+ protected DynamicRouterDefinition newInstance() {
+ return new DynamicRouterDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(DynamicRouterDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "cache-size": {
+ String val = asText(node);
+ target.setCacheSize(val);
+ break;
+ }
+ case "expression": {
+ org.apache.camel.model.language.ExpressionDefinition val = asType(node, org.apache.camel.model.language.ExpressionDefinition.class);
+ target.setExpression(val);
+ break;
+ }
+ case "ignore-invalid-endpoints": {
+ String val = asText(node);
+ target.setIgnoreInvalidEndpoints(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "uri-delimiter": {
+ String val = asText(node);
+ target.setUriDelimiter(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.transformer.EndpointTransformerDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ properties = {
+ @YamlProperty(name = "from-type", type = "string"),
+ @YamlProperty(name = "ref", type = "string"),
+ @YamlProperty(name = "scheme", type = "string"),
+ @YamlProperty(name = "to-type", type = "string"),
+ @YamlProperty(name = "uri", type = "string")
+ }
+ )
+ public static class EndpointTransformerDefinitionDeserializer extends YamlDeserializerBase<EndpointTransformerDefinition> {
+ public EndpointTransformerDefinitionDeserializer() {
+ super(EndpointTransformerDefinition.class);
+ }
+
+ @Override
+ protected EndpointTransformerDefinition newInstance() {
+ return new EndpointTransformerDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(EndpointTransformerDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "from-type": {
+ String val = asText(node);
+ target.setFromType(val);
+ break;
+ }
+ case "ref": {
+ String val = asText(node);
+ target.setRef(val);
+ break;
+ }
+ case "scheme": {
+ String val = asText(node);
+ target.setScheme(val);
+ break;
+ }
+ case "to-type": {
+ String val = asText(node);
+ target.setToType(val);
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.validator.EndpointValidatorDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ properties = {
+ @YamlProperty(name = "ref", type = "string"),
+ @YamlProperty(name = "type", type = "string"),
+ @YamlProperty(name = "uri", type = "string")
+ }
+ )
+ public static class EndpointValidatorDefinitionDeserializer extends YamlDeserializerBase<EndpointValidatorDefinition> {
+ public EndpointValidatorDefinitionDeserializer() {
+ super(EndpointValidatorDefinition.class);
+ }
+
+ @Override
+ protected EndpointValidatorDefinition newInstance() {
+ return new EndpointValidatorDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(EndpointValidatorDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "ref": {
+ String val = asText(node);
+ target.setRef(val);
+ break;
+ }
+ case "type": {
+ String val = asText(node);
+ target.setType(val);
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.EnrichDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "enrich",
+ properties = {
+ @YamlProperty(name = "aggregate-on-exception", type = "boolean"),
+ @YamlProperty(name = "strategy-method-allow-null", type = "string"),
+ @YamlProperty(name = "strategy-method-name", type = "string"),
+ @YamlProperty(name = "strategy-ref", type = "string"),
+ @YamlProperty(name = "cache-size", type = "number"),
+ @YamlProperty(name = "expression", type = "object:org.apache.camel.model.language.ExpressionDefinition"),
+ @YamlProperty(name = "ignore-invalid-endpoint", type = "boolean"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "share-unit-of-work", type = "boolean"),
+ @YamlProperty(name = "__extends", type = "object:org.apache.camel.model.language.ExpressionDefinition")
+ }
+ )
+ public static class EnrichDefinitionDeserializer extends YamlDeserializerBase<EnrichDefinition> {
+ public EnrichDefinitionDeserializer() {
+ super(EnrichDefinition.class);
+ }
+
+ @Override
+ protected EnrichDefinition newInstance() {
+ return new EnrichDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(EnrichDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "aggregate-on-exception": {
+ String val = asText(node);
+ target.setAggregateOnException(val);
+ break;
+ }
+ case "strategy-method-allow-null": {
+ String val = asText(node);
+ target.setAggregationStrategyMethodAllowNull(val);
+ break;
+ }
+ case "strategy-method-name": {
+ String val = asText(node);
+ target.setAggregationStrategyMethodName(val);
+ break;
+ }
+ case "strategy-ref": {
+ String val = asText(node);
+ target.setAggregationStrategyRef(val);
+ break;
+ }
+ case "cache-size": {
+ String val = asText(node);
+ target.setCacheSize(val);
+ break;
+ }
+ case "expression": {
+ org.apache.camel.model.language.ExpressionDefinition val = asType(node, org.apache.camel.model.language.ExpressionDefinition.class);
+ target.setExpression(val);
+ break;
+ }
+ case "ignore-invalid-endpoint": {
+ String val = asText(node);
+ target.setIgnoreInvalidEndpoint(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "share-unit-of-work": {
+ String val = asText(node);
+ target.setShareUnitOfWork(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.EtcdServiceCallServiceDiscoveryConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "etcd-service-discovery",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "password", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition"),
+ @YamlProperty(name = "service-path", type = "string"),
+ @YamlProperty(name = "timeout", type = "number"),
+ @YamlProperty(name = "type", type = "string"),
+ @YamlProperty(name = "uris", type = "string"),
+ @YamlProperty(name = "user-name", type = "string")
+ }
+ )
+ public static class EtcdServiceCallServiceDiscoveryConfigurationDeserializer extends YamlDeserializerBase<EtcdServiceCallServiceDiscoveryConfiguration> {
+ public EtcdServiceCallServiceDiscoveryConfigurationDeserializer() {
+ super(EtcdServiceCallServiceDiscoveryConfiguration.class);
+ }
+
+ @Override
+ protected EtcdServiceCallServiceDiscoveryConfiguration newInstance() {
+ return new EtcdServiceCallServiceDiscoveryConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(EtcdServiceCallServiceDiscoveryConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "password": {
+ String val = asText(node);
+ target.setPassword(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ case "service-path": {
+ String val = asText(node);
+ target.setServicePath(val);
+ break;
+ }
+ case "timeout": {
+ String val = asText(node);
+ target.setTimeout(val);
+ break;
+ }
+ case "type": {
+ String val = asText(node);
+ target.setType(val);
+ break;
+ }
+ case "uris": {
+ String val = asText(node);
+ target.setUris(val);
+ break;
+ }
+ case "user-name": {
+ String val = asText(node);
+ target.setUserName(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.language.ExchangePropertyExpression.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "exchange-property",
+ properties = {
+ @YamlProperty(name = "expression", type = "string", required = true),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "trim", type = "boolean")
+ }
+ )
+ public static class ExchangePropertyExpressionDeserializer extends YamlDeserializerBase<ExchangePropertyExpression> {
+ public ExchangePropertyExpressionDeserializer() {
+ super(ExchangePropertyExpression.class);
+ }
+
+ @Override
+ protected ExchangePropertyExpression newInstance() {
+ return new ExchangePropertyExpression();
+ }
+
+ @Override
+ protected ExchangePropertyExpression newInstance(String value) {
+ return new ExchangePropertyExpression(value);
+ }
+
+ @Override
+ protected boolean setProperty(ExchangePropertyExpression target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "expression": {
+ String val = asText(node);
+ target.setExpression(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.loadbalancer.FailoverLoadBalancerDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "failover",
+ properties = {
+ @YamlProperty(name = "exception", type = "array:string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "maximum-failover-attempts", type = "string"),
+ @YamlProperty(name = "round-robin", type = "string"),
+ @YamlProperty(name = "sticky", type = "string")
+ }
+ )
+ public static class FailoverLoadBalancerDefinitionDeserializer extends YamlDeserializerBase<FailoverLoadBalancerDefinition> {
+ public FailoverLoadBalancerDefinitionDeserializer() {
+ super(FailoverLoadBalancerDefinition.class);
+ }
+
+ @Override
+ protected FailoverLoadBalancerDefinition newInstance() {
+ return new FailoverLoadBalancerDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(FailoverLoadBalancerDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "exception": {
+ java.util.List<String> val = asStringList(node);
+ target.setExceptions(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "maximum-failover-attempts": {
+ String val = asText(node);
+ target.setMaximumFailoverAttempts(val);
+ break;
+ }
+ case "round-robin": {
+ String val = asText(node);
+ target.setRoundRobin(val);
+ break;
+ }
+ case "sticky": {
+ String val = asText(node);
+ target.setSticky(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.FaultToleranceConfigurationDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "fault-tolerance-configuration",
+ properties = {
+ @YamlProperty(name = "bulkhead-enabled", type = "boolean"),
+ @YamlProperty(name = "bulkhead-executor-service-ref", type = "string"),
+ @YamlProperty(name = "bulkhead-max-concurrent-calls", type = "number"),
+ @YamlProperty(name = "bulkhead-waiting-task-queue", type = "number"),
+ @YamlProperty(name = "circuit-breaker-ref", type = "string"),
+ @YamlProperty(name = "delay", type = "string"),
+ @YamlProperty(name = "failure-ratio", type = "number"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "request-volume-threshold", type = "number"),
+ @YamlProperty(name = "success-threshold", type = "number"),
+ @YamlProperty(name = "timeout-duration", type = "string"),
+ @YamlProperty(name = "timeout-enabled", type = "boolean"),
+ @YamlProperty(name = "timeout-pool-size", type = "number"),
+ @YamlProperty(name = "timeout-scheduled-executor-service-ref", type = "string")
+ }
+ )
+ public static class FaultToleranceConfigurationDefinitionDeserializer extends YamlDeserializerBase<FaultToleranceConfigurationDefinition> {
+ public FaultToleranceConfigurationDefinitionDeserializer() {
+ super(FaultToleranceConfigurationDefinition.class);
+ }
+
+ @Override
+ protected FaultToleranceConfigurationDefinition newInstance() {
+ return new FaultToleranceConfigurationDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(FaultToleranceConfigurationDefinition target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "bulkhead-enabled": {
+ String val = asText(node);
+ target.setBulkheadEnabled(val);
+ break;
+ }
+ case "bulkhead-executor-service-ref": {
+ String val = asText(node);
+ target.setBulkheadExecutorServiceRef(val);
+ break;
+ }
+ case "bulkhead-max-concurrent-calls": {
+ String val = asText(node);
+ target.setBulkheadMaxConcurrentCalls(val);
+ break;
+ }
+ case "bulkhead-waiting-task-queue": {
+ String val = asText(node);
+ target.setBulkheadWaitingTaskQueue(val);
+ break;
+ }
+ case "circuit-breaker-ref": {
+ String val = asText(node);
+ target.setCircuitBreakerRef(val);
+ break;
+ }
+ case "delay": {
+ String val = asText(node);
+ target.setDelay(val);
+ break;
+ }
+ case "failure-ratio": {
+ String val = asText(node);
+ target.setFailureRatio(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "request-volume-threshold": {
+ String val = asText(node);
+ target.setRequestVolumeThreshold(val);
+ break;
+ }
+ case "success-threshold": {
+ String val = asText(node);
+ target.setSuccessThreshold(val);
+ break;
+ }
+ case "timeout-duration": {
+ String val = asText(node);
+ target.setTimeoutDuration(val);
+ break;
+ }
+ case "timeout-enabled": {
+ String val = asText(node);
+ target.setTimeoutEnabled(val);
+ break;
+ }
+ case "timeout-pool-size": {
+ String val = asText(node);
+ target.setTimeoutPoolSize(val);
+ break;
+ }
+ case "timeout-scheduled-executor-service-ref": {
+ String val = asText(node);
+ target.setTimeoutScheduledExecutorServiceRef(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.FhirJsonDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "fhir-json",
+ properties = {
+ @YamlProperty(name = "content-type-header", type = "boolean"),
+ @YamlProperty(name = "dont-encode-elements", type = "array:string"),
+ @YamlProperty(name = "dont-strip-versions-from-references-at-paths", type = "array:string"),
+ @YamlProperty(name = "encode-elements", type = "array:string"),
+ @YamlProperty(name = "encode-elements-applies-to-child-resources-only", type = "boolean"),
+ @YamlProperty(name = "fhir-version", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "omit-resource-id", type = "boolean"),
+ @YamlProperty(name = "override-resource-id-with-bundle-entry-full-url", type = "boolean"),
+ @YamlProperty(name = "pretty-print", type = "boolean"),
+ @YamlProperty(name = "server-base-url", type = "string"),
+ @YamlProperty(name = "strip-versions-from-references", type = "boolean"),
+ @YamlProperty(name = "summary-mode", type = "boolean"),
+ @YamlProperty(name = "suppress-narratives", type = "boolean")
+ }
+ )
+ public static class FhirJsonDataFormatDeserializer extends YamlDeserializerBase<FhirJsonDataFormat> {
+ public FhirJsonDataFormatDeserializer() {
+ super(FhirJsonDataFormat.class);
+ }
+
+ @Override
+ protected FhirJsonDataFormat newInstance() {
+ return new FhirJsonDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(FhirJsonDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "content-type-header": {
+ String val = asText(node);
+ target.setContentTypeHeader(val);
+ break;
+ }
+ case "dont-encode-elements": {
+ java.util.Set<String> val = asStringSet(node);
+ target.setDontEncodeElements(val);
+ break;
+ }
+ case "dont-strip-versions-from-references-at-paths": {
+ java.util.List<String> val = asStringList(node);
+ target.setDontStripVersionsFromReferencesAtPaths(val);
+ break;
+ }
+ case "encode-elements": {
+ java.util.Set<String> val = asStringSet(node);
+ target.setEncodeElements(val);
+ break;
+ }
+ case "encode-elements-applies-to-child-resources-only": {
+ String val = asText(node);
+ target.setEncodeElementsAppliesToChildResourcesOnly(val);
+ break;
+ }
+ case "fhir-version": {
+ String val = asText(node);
+ target.setFhirVersion(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "omit-resource-id": {
+ String val = asText(node);
+ target.setOmitResourceId(val);
+ break;
+ }
+ case "override-resource-id-with-bundle-entry-full-url": {
+ String val = asText(node);
+ target.setOverrideResourceIdWithBundleEntryFullUrl(val);
+ break;
+ }
+ case "pretty-print": {
+ String val = asText(node);
+ target.setPrettyPrint(val);
+ break;
+ }
+ case "server-base-url": {
+ String val = asText(node);
+ target.setServerBaseUrl(val);
+ break;
+ }
+ case "strip-versions-from-references": {
+ String val = asText(node);
+ target.setStripVersionsFromReferences(val);
+ break;
+ }
+ case "summary-mode": {
+ String val = asText(node);
+ target.setSummaryMode(val);
+ break;
+ }
+ case "suppress-narratives": {
+ String val = asText(node);
+ target.setSuppressNarratives(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.FhirXmlDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "fhir-xml",
+ properties = {
+ @YamlProperty(name = "content-type-header", type = "boolean"),
+ @YamlProperty(name = "dont-encode-elements", type = "array:string"),
+ @YamlProperty(name = "dont-strip-versions-from-references-at-paths", type = "array:string"),
+ @YamlProperty(name = "encode-elements", type = "array:string"),
+ @YamlProperty(name = "encode-elements-applies-to-child-resources-only", type = "boolean"),
+ @YamlProperty(name = "fhir-version", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "omit-resource-id", type = "boolean"),
+ @YamlProperty(name = "override-resource-id-with-bundle-entry-full-url", type = "boolean"),
+ @YamlProperty(name = "pretty-print", type = "boolean"),
+ @YamlProperty(name = "server-base-url", type = "string"),
+ @YamlProperty(name = "strip-versions-from-references", type = "boolean"),
+ @YamlProperty(name = "summary-mode", type = "boolean"),
+ @YamlProperty(name = "suppress-narratives", type = "boolean")
+ }
+ )
+ public static class FhirXmlDataFormatDeserializer extends YamlDeserializerBase<FhirXmlDataFormat> {
+ public FhirXmlDataFormatDeserializer() {
+ super(FhirXmlDataFormat.class);
+ }
+
+ @Override
+ protected FhirXmlDataFormat newInstance() {
+ return new FhirXmlDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(FhirXmlDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "content-type-header": {
+ String val = asText(node);
+ target.setContentTypeHeader(val);
+ break;
+ }
+ case "dont-encode-elements": {
+ java.util.Set<String> val = asStringSet(node);
+ target.setDontEncodeElements(val);
+ break;
+ }
+ case "dont-strip-versions-from-references-at-paths": {
+ java.util.List<String> val = asStringList(node);
+ target.setDontStripVersionsFromReferencesAtPaths(val);
+ break;
+ }
+ case "encode-elements": {
+ java.util.Set<String> val = asStringSet(node);
+ target.setEncodeElements(val);
+ break;
+ }
+ case "encode-elements-applies-to-child-resources-only": {
+ String val = asText(node);
+ target.setEncodeElementsAppliesToChildResourcesOnly(val);
+ break;
+ }
+ case "fhir-version": {
+ String val = asText(node);
+ target.setFhirVersion(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "omit-resource-id": {
+ String val = asText(node);
+ target.setOmitResourceId(val);
+ break;
+ }
+ case "override-resource-id-with-bundle-entry-full-url": {
+ String val = asText(node);
+ target.setOverrideResourceIdWithBundleEntryFullUrl(val);
+ break;
+ }
+ case "pretty-print": {
+ String val = asText(node);
+ target.setPrettyPrint(val);
+ break;
+ }
+ case "server-base-url": {
+ String val = asText(node);
+ target.setServerBaseUrl(val);
+ break;
+ }
+ case "strip-versions-from-references": {
+ String val = asText(node);
+ target.setStripVersionsFromReferences(val);
+ break;
+ }
+ case "summary-mode": {
+ String val = asText(node);
+ target.setSummaryMode(val);
+ break;
+ }
+ case "suppress-narratives": {
+ String val = asText(node);
+ target.setSuppressNarratives(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.FilterDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "filter",
+ properties = {
+ @YamlProperty(name = "expression", type = "object:org.apache.camel.model.language.ExpressionDefinition"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition"),
+ @YamlProperty(name = "__extends", type = "object:org.apache.camel.model.language.ExpressionDefinition")
+ }
+ )
+ public static class FilterDefinitionDeserializer extends YamlDeserializerBase<FilterDefinition> {
+ public FilterDefinitionDeserializer() {
+ super(FilterDefinition.class);
+ }
+
+ @Override
+ protected FilterDefinition newInstance() {
+ return new FilterDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(FilterDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "expression": {
+ org.apache.camel.model.language.ExpressionDefinition val = asType(node, org.apache.camel.model.language.ExpressionDefinition.class);
+ target.setExpression(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.FinallyDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "do-finally",
+ properties = {
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class FinallyDefinitionDeserializer extends YamlDeserializerBase<FinallyDefinition> {
+ public FinallyDefinitionDeserializer() {
+ super(FinallyDefinition.class);
+ }
+
+ @Override
+ protected FinallyDefinition newInstance() {
+ return new FinallyDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(FinallyDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.FlatpackDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "flatpack",
+ properties = {
+ @YamlProperty(name = "allow-short-lines", type = "boolean"),
+ @YamlProperty(name = "definition", type = "string"),
+ @YamlProperty(name = "delimiter", type = "string"),
+ @YamlProperty(name = "fixed", type = "boolean"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "ignore-extra-columns", type = "boolean"),
+ @YamlProperty(name = "ignore-first-record", type = "boolean"),
+ @YamlProperty(name = "parser-factory-ref", type = "string"),
+ @YamlProperty(name = "text-qualifier", type = "string")
+ }
+ )
+ public static class FlatpackDataFormatDeserializer extends YamlDeserializerBase<FlatpackDataFormat> {
+ public FlatpackDataFormatDeserializer() {
+ super(FlatpackDataFormat.class);
+ }
+
+ @Override
+ protected FlatpackDataFormat newInstance() {
+ return new FlatpackDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(FlatpackDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "allow-short-lines": {
+ String val = asText(node);
+ target.setAllowShortLines(val);
+ break;
+ }
+ case "definition": {
+ String val = asText(node);
+ target.setDefinition(val);
+ break;
+ }
+ case "delimiter": {
+ String val = asText(node);
+ target.setDelimiter(val);
+ break;
+ }
+ case "fixed": {
+ String val = asText(node);
+ target.setFixed(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "ignore-extra-columns": {
+ String val = asText(node);
+ target.setIgnoreExtraColumns(val);
+ break;
+ }
+ case "ignore-first-record": {
+ String val = asText(node);
+ target.setIgnoreFirstRecord(val);
+ break;
+ }
+ case "parser-factory-ref": {
+ String val = asText(node);
+ target.setParserFactoryRef(val);
+ break;
+ }
+ case "text-qualifier": {
+ String val = asText(node);
+ target.setTextQualifier(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.rest.GetVerbDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "get",
+ properties = {
+ @YamlProperty(name = "api-docs", type = "string"),
+ @YamlProperty(name = "binding-mode", type = "string"),
+ @YamlProperty(name = "client-request-validation", type = "string"),
+ @YamlProperty(name = "consumes", type = "string"),
+ @YamlProperty(name = "enable-cors", type = "string"),
+ @YamlProperty(name = "method", type = "string"),
+ @YamlProperty(name = "out-type", type = "string"),
+ @YamlProperty(name = "params", type = "array:org.apache.camel.model.rest.RestOperationParamDefinition"),
+ @YamlProperty(name = "produces", type = "string"),
+ @YamlProperty(name = "response-msgs", type = "array:org.apache.camel.model.rest.RestOperationResponseMsgDefinition"),
+ @YamlProperty(name = "route-id", type = "string"),
+ @YamlProperty(name = "security", type = "array:org.apache.camel.model.rest.SecurityDefinition"),
+ @YamlProperty(name = "skip-binding-on-error-code", type = "string"),
+ @YamlProperty(name = "to", type = "object:org.apache.camel.model.ToDefinition"),
+ @YamlProperty(name = "to-d", type = "object:org.apache.camel.model.ToDynamicDefinition"),
+ @YamlProperty(name = "route", type = "object:org.apache.camel.model.RouteDefinition"),
+ @YamlProperty(name = "type", type = "string"),
+ @YamlProperty(name = "uri", type = "string"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class GetVerbDefinitionDeserializer extends YamlDeserializerBase<GetVerbDefinition> {
+ public GetVerbDefinitionDeserializer() {
+ super(GetVerbDefinition.class);
+ }
+
+ @Override
+ protected GetVerbDefinition newInstance() {
+ return new GetVerbDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(GetVerbDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "api-docs": {
+ String val = asText(node);
+ target.setApiDocs(val);
+ break;
+ }
+ case "binding-mode": {
+ String val = asText(node);
+ target.setBindingMode(val);
+ break;
+ }
+ case "client-request-validation": {
+ String val = asText(node);
+ target.setClientRequestValidation(val);
+ break;
+ }
+ case "consumes": {
+ String val = asText(node);
+ target.setConsumes(val);
+ break;
+ }
+ case "enable-cors": {
+ String val = asText(node);
+ target.setEnableCORS(val);
+ break;
+ }
+ case "method": {
+ String val = asText(node);
+ target.setMethod(val);
+ break;
+ }
+ case "out-type": {
+ String val = asText(node);
+ target.setOutType(val);
+ break;
+ }
+ case "param": {
+ java.util.List<org.apache.camel.model.rest.RestOperationParamDefinition> val = asFlatList(node, org.apache.camel.model.rest.RestOperationParamDefinition.class);
+ target.setParams(val);
+ break;
+ }
+ case "produces": {
+ String val = asText(node);
+ target.setProduces(val);
+ break;
+ }
+ case "response-message": {
+ java.util.List<org.apache.camel.model.rest.RestOperationResponseMsgDefinition> val = asFlatList(node, org.apache.camel.model.rest.RestOperationResponseMsgDefinition.class);
+ target.setResponseMsgs(val);
+ break;
+ }
+ case "route-id": {
+ String val = asText(node);
+ target.setRouteId(val);
+ break;
+ }
+ case "security": {
+ java.util.List<org.apache.camel.model.rest.SecurityDefinition> val = asFlatList(node, org.apache.camel.model.rest.SecurityDefinition.class);
+ target.setSecurity(val);
+ break;
+ }
+ case "skip-binding-on-error-code": {
+ String val = asText(node);
+ target.setSkipBindingOnErrorCode(val);
+ break;
+ }
+ case "to-or-route": {
+ MappingNode val = asMappingNode(node);
+ setProperties(target, val);
+ break;
+ }
+ case "to": {
+ org.apache.camel.model.ToDefinition val = asType(node, org.apache.camel.model.ToDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "to-d": {
+ org.apache.camel.model.ToDynamicDefinition val = asType(node, org.apache.camel.model.ToDynamicDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "route": {
+ org.apache.camel.model.RouteDefinition val = asType(node, org.apache.camel.model.RouteDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "type": {
+ String val = asText(node);
+ target.setType(val);
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.GlobalOptionDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "global-option",
+ properties = {
+ @YamlProperty(name = "key", type = "string"),
+ @YamlProperty(name = "value", type = "string")
+ }
+ )
+ public static class GlobalOptionDefinitionDeserializer extends YamlDeserializerBase<GlobalOptionDefinition> {
+ public GlobalOptionDefinitionDeserializer() {
+ super(GlobalOptionDefinition.class);
+ }
+
+ @Override
+ protected GlobalOptionDefinition newInstance() {
+ return new GlobalOptionDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(GlobalOptionDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "key": {
+ String val = asText(node);
+ target.setKey(val);
+ break;
+ }
+ case "value": {
+ String val = asText(node);
+ target.setValue(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.GlobalOptionsDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "global-options",
+ properties = @YamlProperty(name = "global-option", type = "array:org.apache.camel.model.GlobalOptionDefinition")
+ )
+ public static class GlobalOptionsDefinitionDeserializer extends YamlDeserializerBase<GlobalOptionsDefinition> {
+ public GlobalOptionsDefinitionDeserializer() {
+ super(GlobalOptionsDefinition.class);
+ }
+
+ @Override
+ protected GlobalOptionsDefinition newInstance() {
+ return new GlobalOptionsDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(GlobalOptionsDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "global-option": {
+ java.util.List<org.apache.camel.model.GlobalOptionDefinition> val = asFlatList(node, org.apache.camel.model.GlobalOptionDefinition.class);
+ target.setGlobalOptions(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.GrokDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "grok",
+ properties = {
+ @YamlProperty(name = "allow-multiple-matches-per-line", type = "boolean"),
+ @YamlProperty(name = "flattened", type = "boolean"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "named-only", type = "boolean"),
+ @YamlProperty(name = "pattern", type = "string")
+ }
+ )
+ public static class GrokDataFormatDeserializer extends YamlDeserializerBase<GrokDataFormat> {
+ public GrokDataFormatDeserializer() {
+ super(GrokDataFormat.class);
+ }
+
+ @Override
+ protected GrokDataFormat newInstance() {
+ return new GrokDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(GrokDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "allow-multiple-matches-per-line": {
+ String val = asText(node);
+ target.setAllowMultipleMatchesPerLine(val);
+ break;
+ }
+ case "flattened": {
+ String val = asText(node);
+ target.setFlattened(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "named-only": {
+ String val = asText(node);
+ target.setNamedOnly(val);
+ break;
+ }
+ case "pattern": {
+ String val = asText(node);
+ target.setPattern(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.language.GroovyExpression.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "groovy",
+ properties = {
+ @YamlProperty(name = "expression", type = "string", required = true),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "trim", type = "boolean")
+ }
+ )
+ public static class GroovyExpressionDeserializer extends YamlDeserializerBase<GroovyExpression> {
+ public GroovyExpressionDeserializer() {
+ super(GroovyExpression.class);
+ }
+
+ @Override
+ protected GroovyExpression newInstance() {
+ return new GroovyExpression();
+ }
+
+ @Override
+ protected GroovyExpression newInstance(String value) {
+ return new GroovyExpression(value);
+ }
+
+ @Override
+ protected boolean setProperty(GroovyExpression target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "expression": {
+ String val = asText(node);
+ target.setExpression(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.GzipDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "gzipdeflater",
+ properties = @YamlProperty(name = "id", type = "string")
+ )
+ public static class GzipDataFormatDeserializer extends YamlDeserializerBase<GzipDataFormat> {
+ public GzipDataFormatDeserializer() {
+ super(GzipDataFormat.class);
+ }
+
+ @Override
+ protected GzipDataFormat newInstance() {
+ return new GzipDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(GzipDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.HL7DataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "hl7",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "validate", type = "boolean")
+ }
+ )
+ public static class HL7DataFormatDeserializer extends YamlDeserializerBase<HL7DataFormat> {
+ public HL7DataFormatDeserializer() {
+ super(HL7DataFormat.class);
+ }
+
+ @Override
+ protected HL7DataFormat newInstance() {
+ return new HL7DataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(HL7DataFormat target, String propertyKey, String propertyName,
+ Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "validate": {
+ String val = asText(node);
+ target.setValidate(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.rest.HeadVerbDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "head",
+ properties = {
+ @YamlProperty(name = "api-docs", type = "string"),
+ @YamlProperty(name = "binding-mode", type = "string"),
+ @YamlProperty(name = "client-request-validation", type = "string"),
+ @YamlProperty(name = "consumes", type = "string"),
+ @YamlProperty(name = "enable-cors", type = "string"),
+ @YamlProperty(name = "method", type = "string"),
+ @YamlProperty(name = "out-type", type = "string"),
+ @YamlProperty(name = "params", type = "array:org.apache.camel.model.rest.RestOperationParamDefinition"),
+ @YamlProperty(name = "produces", type = "string"),
+ @YamlProperty(name = "response-msgs", type = "array:org.apache.camel.model.rest.RestOperationResponseMsgDefinition"),
+ @YamlProperty(name = "route-id", type = "string"),
+ @YamlProperty(name = "security", type = "array:org.apache.camel.model.rest.SecurityDefinition"),
+ @YamlProperty(name = "skip-binding-on-error-code", type = "string"),
+ @YamlProperty(name = "to", type = "object:org.apache.camel.model.ToDefinition"),
+ @YamlProperty(name = "to-d", type = "object:org.apache.camel.model.ToDynamicDefinition"),
+ @YamlProperty(name = "route", type = "object:org.apache.camel.model.RouteDefinition"),
+ @YamlProperty(name = "type", type = "string"),
+ @YamlProperty(name = "uri", type = "string"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class HeadVerbDefinitionDeserializer extends YamlDeserializerBase<HeadVerbDefinition> {
+ public HeadVerbDefinitionDeserializer() {
+ super(HeadVerbDefinition.class);
+ }
+
+ @Override
+ protected HeadVerbDefinition newInstance() {
+ return new HeadVerbDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(HeadVerbDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "api-docs": {
+ String val = asText(node);
+ target.setApiDocs(val);
+ break;
+ }
+ case "binding-mode": {
+ String val = asText(node);
+ target.setBindingMode(val);
+ break;
+ }
+ case "client-request-validation": {
+ String val = asText(node);
+ target.setClientRequestValidation(val);
+ break;
+ }
+ case "consumes": {
+ String val = asText(node);
+ target.setConsumes(val);
+ break;
+ }
+ case "enable-cors": {
+ String val = asText(node);
+ target.setEnableCORS(val);
+ break;
+ }
+ case "method": {
+ String val = asText(node);
+ target.setMethod(val);
+ break;
+ }
+ case "out-type": {
+ String val = asText(node);
+ target.setOutType(val);
+ break;
+ }
+ case "param": {
+ java.util.List<org.apache.camel.model.rest.RestOperationParamDefinition> val = asFlatList(node, org.apache.camel.model.rest.RestOperationParamDefinition.class);
+ target.setParams(val);
+ break;
+ }
+ case "produces": {
+ String val = asText(node);
+ target.setProduces(val);
+ break;
+ }
+ case "response-message": {
+ java.util.List<org.apache.camel.model.rest.RestOperationResponseMsgDefinition> val = asFlatList(node, org.apache.camel.model.rest.RestOperationResponseMsgDefinition.class);
+ target.setResponseMsgs(val);
+ break;
+ }
+ case "route-id": {
+ String val = asText(node);
+ target.setRouteId(val);
+ break;
+ }
+ case "security": {
+ java.util.List<org.apache.camel.model.rest.SecurityDefinition> val = asFlatList(node, org.apache.camel.model.rest.SecurityDefinition.class);
+ target.setSecurity(val);
+ break;
+ }
+ case "skip-binding-on-error-code": {
+ String val = asText(node);
+ target.setSkipBindingOnErrorCode(val);
+ break;
+ }
+ case "to-or-route": {
+ MappingNode val = asMappingNode(node);
+ setProperties(target, val);
+ break;
+ }
+ case "to": {
+ org.apache.camel.model.ToDefinition val = asType(node, org.apache.camel.model.ToDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "to-d": {
+ org.apache.camel.model.ToDynamicDefinition val = asType(node, org.apache.camel.model.ToDynamicDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "route": {
+ org.apache.camel.model.RouteDefinition val = asType(node, org.apache.camel.model.RouteDefinition.class);
+ target.setToOrRoute(val);
+ break;
+ }
+ case "type": {
+ String val = asText(node);
+ target.setType(val);
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.language.HeaderExpression.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "header",
+ properties = {
+ @YamlProperty(name = "expression", type = "string", required = true),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "trim", type = "boolean")
+ }
+ )
+ public static class HeaderExpressionDeserializer extends YamlDeserializerBase<HeaderExpression> {
+ public HeaderExpressionDeserializer() {
+ super(HeaderExpression.class);
+ }
+
+ @Override
+ protected HeaderExpression newInstance() {
+ return new HeaderExpression();
+ }
+
+ @Override
+ protected HeaderExpression newInstance(String value) {
+ return new HeaderExpression(value);
+ }
+
+ @Override
+ protected boolean setProperty(HeaderExpression target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "expression": {
+ String val = asText(node);
+ target.setExpression(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.cloud.HealthyServiceCallServiceFilterConfiguration.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "healthy-service-filter",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "properties", type = "array:org.apache.camel.model.PropertyDefinition")
+ }
+ )
+ public static class HealthyServiceCallServiceFilterConfigurationDeserializer extends YamlDeserializerBase<HealthyServiceCallServiceFilterConfiguration> {
+ public HealthyServiceCallServiceFilterConfigurationDeserializer() {
+ super(HealthyServiceCallServiceFilterConfiguration.class);
+ }
+
+ @Override
+ protected HealthyServiceCallServiceFilterConfiguration newInstance() {
+ return new HealthyServiceCallServiceFilterConfiguration();
+ }
+
+ @Override
+ protected boolean setProperty(HealthyServiceCallServiceFilterConfiguration target,
+ String propertyKey, String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "properties": {
+ java.util.List<org.apache.camel.model.PropertyDefinition> val = asFlatList(node, org.apache.camel.model.PropertyDefinition.class);
+ target.setProperties(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.language.Hl7TerserExpression.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "hl7terser",
+ properties = {
+ @YamlProperty(name = "expression", type = "string", required = true),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "trim", type = "boolean")
+ }
+ )
+ public static class Hl7TerserExpressionDeserializer extends YamlDeserializerBase<Hl7TerserExpression> {
+ public Hl7TerserExpressionDeserializer() {
+ super(Hl7TerserExpression.class);
+ }
+
+ @Override
+ protected Hl7TerserExpression newInstance() {
+ return new Hl7TerserExpression();
+ }
+
+ @Override
+ protected Hl7TerserExpression newInstance(String value) {
+ return new Hl7TerserExpression(value);
+ }
+
+ @Override
+ protected boolean setProperty(Hl7TerserExpression target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "expression": {
+ String val = asText(node);
+ target.setExpression(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.HystrixConfigurationDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "hystrix-configuration",
+ properties = {
+ @YamlProperty(name = "allow-maximum-size-to-diverge-from-core-size", type = "boolean"),
+ @YamlProperty(name = "circuit-breaker-enabled", type = "boolean"),
+ @YamlProperty(name = "circuit-breaker-error-threshold-percentage", type = "number"),
+ @YamlProperty(name = "circuit-breaker-force-closed", type = "boolean"),
+ @YamlProperty(name = "circuit-breaker-force-open", type = "boolean"),
+ @YamlProperty(name = "circuit-breaker-request-volume-threshold", type = "number"),
+ @YamlProperty(name = "circuit-breaker-sleep-window-in-milliseconds", type = "number"),
+ @YamlProperty(name = "core-pool-size", type = "number"),
+ @YamlProperty(name = "execution-isolation-semaphore-max-concurrent-requests", type = "number"),
+ @YamlProperty(name = "execution-isolation-strategy", type = "string"),
+ @YamlProperty(name = "execution-isolation-thread-interrupt-on-timeout", type = "boolean"),
+ @YamlProperty(name = "execution-timeout-enabled", type = "boolean"),
+ @YamlProperty(name = "execution-timeout-in-milliseconds", type = "number"),
+ @YamlProperty(name = "fallback-enabled", type = "boolean"),
+ @YamlProperty(name = "fallback-isolation-semaphore-max-concurrent-requests", type = "number"),
+ @YamlProperty(name = "group-key", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "keep-alive-time", type = "number"),
+ @YamlProperty(name = "max-queue-size", type = "number"),
+ @YamlProperty(name = "maximum-size", type = "number"),
+ @YamlProperty(name = "metrics-health-snapshot-interval-in-milliseconds", type = "number"),
+ @YamlProperty(name = "metrics-rolling-percentile-bucket-size", type = "number"),
+ @YamlProperty(name = "metrics-rolling-percentile-enabled", type = "boolean"),
+ @YamlProperty(name = "metrics-rolling-percentile-window-buckets", type = "number"),
+ @YamlProperty(name = "metrics-rolling-percentile-window-in-milliseconds", type = "number"),
+ @YamlProperty(name = "metrics-rolling-statistical-window-buckets", type = "number"),
+ @YamlProperty(name = "metrics-rolling-statistical-window-in-milliseconds", type = "number"),
+ @YamlProperty(name = "queue-size-rejection-threshold", type = "number"),
+ @YamlProperty(name = "request-log-enabled", type = "boolean"),
+ @YamlProperty(name = "thread-pool-key", type = "string"),
+ @YamlProperty(name = "thread-pool-rolling-number-statistical-window-buckets", type = "number"),
+ @YamlProperty(name = "thread-pool-rolling-number-statistical-window-in-milliseconds", type = "number")
+ }
+ )
+ public static class HystrixConfigurationDefinitionDeserializer extends YamlDeserializerBase<HystrixConfigurationDefinition> {
+ public HystrixConfigurationDefinitionDeserializer() {
+ super(HystrixConfigurationDefinition.class);
+ }
+
+ @Override
+ protected HystrixConfigurationDefinition newInstance() {
+ return new HystrixConfigurationDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(HystrixConfigurationDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "allow-maximum-size-to-diverge-from-core-size": {
+ String val = asText(node);
+ target.setAllowMaximumSizeToDivergeFromCoreSize(val);
+ break;
+ }
+ case "circuit-breaker-enabled": {
+ String val = asText(node);
+ target.setCircuitBreakerEnabled(val);
+ break;
+ }
+ case "circuit-breaker-error-threshold-percentage": {
+ String val = asText(node);
+ target.setCircuitBreakerErrorThresholdPercentage(val);
+ break;
+ }
+ case "circuit-breaker-force-closed": {
+ String val = asText(node);
+ target.setCircuitBreakerForceClosed(val);
+ break;
+ }
+ case "circuit-breaker-force-open": {
+ String val = asText(node);
+ target.setCircuitBreakerForceOpen(val);
+ break;
+ }
+ case "circuit-breaker-request-volume-threshold": {
+ String val = asText(node);
+ target.setCircuitBreakerRequestVolumeThreshold(val);
+ break;
+ }
+ case "circuit-breaker-sleep-window-in-milliseconds": {
+ String val = asText(node);
+ target.setCircuitBreakerSleepWindowInMilliseconds(val);
+ break;
+ }
+ case "core-pool-size": {
+ String val = asText(node);
+ target.setCorePoolSize(val);
+ break;
+ }
+ case "execution-isolation-semaphore-max-concurrent-requests": {
+ String val = asText(node);
+ target.setExecutionIsolationSemaphoreMaxConcurrentRequests(val);
+ break;
+ }
+ case "execution-isolation-strategy": {
+ String val = asText(node);
+ target.setExecutionIsolationStrategy(val);
+ break;
+ }
+ case "execution-isolation-thread-interrupt-on-timeout": {
+ String val = asText(node);
+ target.setExecutionIsolationThreadInterruptOnTimeout(val);
+ break;
+ }
+ case "execution-timeout-enabled": {
+ String val = asText(node);
+ target.setExecutionTimeoutEnabled(val);
+ break;
+ }
+ case "execution-timeout-in-milliseconds": {
+ String val = asText(node);
+ target.setExecutionTimeoutInMilliseconds(val);
+ break;
+ }
+ case "fallback-enabled": {
+ String val = asText(node);
+ target.setFallbackEnabled(val);
+ break;
+ }
+ case "fallback-isolation-semaphore-max-concurrent-requests": {
+ String val = asText(node);
+ target.setFallbackIsolationSemaphoreMaxConcurrentRequests(val);
+ break;
+ }
+ case "group-key": {
+ String val = asText(node);
+ target.setGroupKey(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "keep-alive-time": {
+ String val = asText(node);
+ target.setKeepAliveTime(val);
+ break;
+ }
+ case "max-queue-size": {
+ String val = asText(node);
+ target.setMaxQueueSize(val);
+ break;
+ }
+ case "maximum-size": {
+ String val = asText(node);
+ target.setMaximumSize(val);
+ break;
+ }
+ case "metrics-health-snapshot-interval-in-milliseconds": {
+ String val = asText(node);
+ target.setMetricsHealthSnapshotIntervalInMilliseconds(val);
+ break;
+ }
+ case "metrics-rolling-percentile-bucket-size": {
+ String val = asText(node);
+ target.setMetricsRollingPercentileBucketSize(val);
+ break;
+ }
+ case "metrics-rolling-percentile-enabled": {
+ String val = asText(node);
+ target.setMetricsRollingPercentileEnabled(val);
+ break;
+ }
+ case "metrics-rolling-percentile-window-buckets": {
+ String val = asText(node);
+ target.setMetricsRollingPercentileWindowBuckets(val);
+ break;
+ }
+ case "metrics-rolling-percentile-window-in-milliseconds": {
+ String val = asText(node);
+ target.setMetricsRollingPercentileWindowInMilliseconds(val);
+ break;
+ }
+ case "metrics-rolling-statistical-window-buckets": {
+ String val = asText(node);
+ target.setMetricsRollingStatisticalWindowBuckets(val);
+ break;
+ }
+ case "metrics-rolling-statistical-window-in-milliseconds": {
+ String val = asText(node);
+ target.setMetricsRollingStatisticalWindowInMilliseconds(val);
+ break;
+ }
+ case "queue-size-rejection-threshold": {
+ String val = asText(node);
+ target.setQueueSizeRejectionThreshold(val);
+ break;
+ }
+ case "request-log-enabled": {
+ String val = asText(node);
+ target.setRequestLogEnabled(val);
+ break;
+ }
+ case "thread-pool-key": {
+ String val = asText(node);
+ target.setThreadPoolKey(val);
+ break;
+ }
+ case "thread-pool-rolling-number-statistical-window-buckets": {
+ String val = asText(node);
+ target.setThreadPoolRollingNumberStatisticalWindowBuckets(val);
+ break;
+ }
+ case "thread-pool-rolling-number-statistical-window-in-milliseconds": {
+ String val = asText(node);
+ target.setThreadPoolRollingNumberStatisticalWindowInMilliseconds(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.IcalDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "ical",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "validating", type = "boolean")
+ }
+ )
+ public static class IcalDataFormatDeserializer extends YamlDeserializerBase<IcalDataFormat> {
+ public IcalDataFormatDeserializer() {
+ super(IcalDataFormat.class);
+ }
+
+ @Override
+ protected IcalDataFormat newInstance() {
+ return new IcalDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(IcalDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "validating": {
+ String val = asText(node);
+ target.setValidating(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.IdempotentConsumerDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "idempotent-consumer",
+ properties = {
+ @YamlProperty(name = "completion-eager", type = "string"),
+ @YamlProperty(name = "eager", type = "boolean"),
+ @YamlProperty(name = "expression", type = "object:org.apache.camel.model.language.ExpressionDefinition"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "message-id-repository-ref", type = "string"),
+ @YamlProperty(name = "remove-on-failure", type = "boolean"),
+ @YamlProperty(name = "skip-duplicate", type = "boolean"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition"),
+ @YamlProperty(name = "__extends", type = "object:org.apache.camel.model.language.ExpressionDefinition")
+ }
+ )
+ public static class IdempotentConsumerDefinitionDeserializer extends YamlDeserializerBase<IdempotentConsumerDefinition> {
+ public IdempotentConsumerDefinitionDeserializer() {
+ super(IdempotentConsumerDefinition.class);
+ }
+
+ @Override
+ protected IdempotentConsumerDefinition newInstance() {
+ return new IdempotentConsumerDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(IdempotentConsumerDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "completion-eager": {
+ String val = asText(node);
+ target.setCompletionEager(val);
+ break;
+ }
+ case "eager": {
+ String val = asText(node);
+ target.setEager(val);
+ break;
+ }
+ case "expression": {
+ org.apache.camel.model.language.ExpressionDefinition val = asType(node, org.apache.camel.model.language.ExpressionDefinition.class);
+ target.setExpression(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "message-id-repository-ref": {
+ String val = asText(node);
+ target.setMessageIdRepositoryRef(val);
+ break;
+ }
+ case "remove-on-failure": {
+ String val = asText(node);
+ target.setRemoveOnFailure(val);
+ break;
+ }
+ case "skip-duplicate": {
+ String val = asText(node);
+ target.setSkipDuplicate(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.InOnlyDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "in-only",
+ properties = {
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "uri", type = "string", required = true)
+ }
+ )
+ public static class InOnlyDefinitionDeserializer extends YamlDeserializerBase<InOnlyDefinition> {
+ public InOnlyDefinitionDeserializer() {
+ super(InOnlyDefinition.class);
+ }
+
+ @Override
+ protected InOnlyDefinition newInstance() {
+ return new InOnlyDefinition();
+ }
+
+ @Override
+ protected InOnlyDefinition newInstance(String value) {
+ return new InOnlyDefinition(value);
+ }
+
+ @Override
+ protected boolean setProperty(InOnlyDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.InOutDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "in-out",
+ properties = {
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "uri", type = "string", required = true)
+ }
+ )
+ public static class InOutDefinitionDeserializer extends YamlDeserializerBase<InOutDefinition> {
+ public InOutDefinitionDeserializer() {
+ super(InOutDefinition.class);
+ }
+
+ @Override
+ protected InOutDefinition newInstance() {
+ return new InOutDefinition();
+ }
+
+ @Override
+ protected InOutDefinition newInstance(String value) {
+ return new InOutDefinition(value);
+ }
+
+ @Override
+ protected boolean setProperty(InOutDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.InputTypeDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "input-type",
+ properties = {
+ @YamlProperty(name = "urn", type = "string", required = true),
+ @YamlProperty(name = "validate", type = "boolean")
+ }
+ )
+ public static class InputTypeDefinitionDeserializer extends YamlDeserializerBase<InputTypeDefinition> {
+ public InputTypeDefinitionDeserializer() {
+ super(InputTypeDefinition.class);
+ }
+
+ @Override
+ protected InputTypeDefinition newInstance() {
+ return new InputTypeDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(InputTypeDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "urn": {
+ String val = asText(node);
+ target.setUrn(val);
+ break;
+ }
+ case "validate": {
+ String val = asText(node);
+ target.setValidate(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.InterceptDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "intercept",
+ properties = {
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class InterceptDefinitionDeserializer extends YamlDeserializerBase<InterceptDefinition> {
+ public InterceptDefinitionDeserializer() {
+ super(InterceptDefinition.class);
+ }
+
+ @Override
+ protected InterceptDefinition newInstance() {
+ return new InterceptDefinition();
+ }
+
+ @Override
+ protected boolean setProperty(InterceptDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.InterceptFromDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "intercept-from",
+ properties = {
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "uri", type = "string"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class InterceptFromDefinitionDeserializer extends YamlDeserializerBase<InterceptFromDefinition> {
+ public InterceptFromDefinitionDeserializer() {
+ super(InterceptFromDefinition.class);
+ }
+
+ @Override
+ protected InterceptFromDefinition newInstance() {
+ return new InterceptFromDefinition();
+ }
+
+ @Override
+ protected InterceptFromDefinition newInstance(String value) {
+ return new InterceptFromDefinition(value);
+ }
+
+ @Override
+ protected boolean setProperty(InterceptFromDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.InterceptSendToEndpointDefinition.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "intercept-send-to-endpoint",
+ properties = {
+ @YamlProperty(name = "after-uri", type = "string"),
+ @YamlProperty(name = "inherit-error-handler", type = "boolean"),
+ @YamlProperty(name = "skip-send-to-original-endpoint", type = "string"),
+ @YamlProperty(name = "uri", type = "string"),
+ @YamlProperty(name = "steps", type = "array:org.apache.camel.model.ProcessorDefinition")
+ }
+ )
+ public static class InterceptSendToEndpointDefinitionDeserializer extends YamlDeserializerBase<InterceptSendToEndpointDefinition> {
+ public InterceptSendToEndpointDefinitionDeserializer() {
+ super(InterceptSendToEndpointDefinition.class);
+ }
+
+ @Override
+ protected InterceptSendToEndpointDefinition newInstance() {
+ return new InterceptSendToEndpointDefinition();
+ }
+
+ @Override
+ protected InterceptSendToEndpointDefinition newInstance(String value) {
+ return new InterceptSendToEndpointDefinition(value);
+ }
+
+ @Override
+ protected boolean setProperty(InterceptSendToEndpointDefinition target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "after-uri": {
+ String val = asText(node);
+ target.setAfterUri(val);
+ break;
+ }
+ case "inherit-error-handler": {
+ String val = asText(node);
+ target.setInheritErrorHandler(java.lang.Boolean.valueOf(val));
+ break;
+ }
+ case "skip-send-to-original-endpoint": {
+ String val = asText(node);
+ target.setSkipSendToOriginalEndpoint(val);
+ break;
+ }
+ case "uri": {
+ String val = asText(node);
+ target.setUri(val);
+ break;
+ }
+ case "steps": {
+ for (ProcessorDefinition<?> definition: asFlatList(node, ProcessorDefinition.class)) {
+ target.addOutput(definition);
+ }
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.JacksonXMLDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "jacksonxml",
+ properties = {
+ @YamlProperty(name = "allow-jms-type", type = "boolean"),
+ @YamlProperty(name = "allow-unmarshall-type", type = "boolean"),
+ @YamlProperty(name = "collection-type-name", type = "string"),
+ @YamlProperty(name = "content-type-header", type = "boolean"),
+ @YamlProperty(name = "disable-features", type = "string"),
+ @YamlProperty(name = "enable-features", type = "string"),
+ @YamlProperty(name = "enable-jaxb-annotation-module", type = "boolean"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "include", type = "string"),
+ @YamlProperty(name = "json-view-type-name", type = "string"),
+ @YamlProperty(name = "module-class-names", type = "string"),
+ @YamlProperty(name = "module-refs", type = "string"),
+ @YamlProperty(name = "pretty-print", type = "boolean"),
+ @YamlProperty(name = "unmarshal-type-name", type = "string"),
+ @YamlProperty(name = "use-list", type = "boolean"),
+ @YamlProperty(name = "xml-mapper", type = "string")
+ }
+ )
+ public static class JacksonXMLDataFormatDeserializer extends YamlDeserializerBase<JacksonXMLDataFormat> {
+ public JacksonXMLDataFormatDeserializer() {
+ super(JacksonXMLDataFormat.class);
+ }
+
+ @Override
+ protected JacksonXMLDataFormat newInstance() {
+ return new JacksonXMLDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(JacksonXMLDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "allow-jms-type": {
+ String val = asText(node);
+ target.setAllowJmsType(val);
+ break;
+ }
+ case "allow-unmarshall-type": {
+ String val = asText(node);
+ target.setAllowUnmarshallType(val);
+ break;
+ }
+ case "collection-type-name": {
+ String val = asText(node);
+ target.setCollectionTypeName(val);
+ break;
+ }
+ case "content-type-header": {
+ String val = asText(node);
+ target.setContentTypeHeader(val);
+ break;
+ }
+ case "disable-features": {
+ String val = asText(node);
+ target.setDisableFeatures(val);
+ break;
+ }
+ case "enable-features": {
+ String val = asText(node);
+ target.setEnableFeatures(val);
+ break;
+ }
+ case "enable-jaxb-annotation-module": {
+ String val = asText(node);
+ target.setEnableJaxbAnnotationModule(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "include": {
+ String val = asText(node);
+ target.setInclude(val);
+ break;
+ }
+ case "json-view-type-name": {
+ String val = asText(node);
+ target.setJsonViewTypeName(val);
+ break;
+ }
+ case "module-class-names": {
+ String val = asText(node);
+ target.setModuleClassNames(val);
+ break;
+ }
+ case "module-refs": {
+ String val = asText(node);
+ target.setModuleRefs(val);
+ break;
+ }
+ case "pretty-print": {
+ String val = asText(node);
+ target.setPrettyPrint(val);
+ break;
+ }
+ case "unmarshal-type-name": {
+ String val = asText(node);
+ target.setUnmarshalTypeName(val);
+ break;
+ }
+ case "use-list": {
+ String val = asText(node);
+ target.setUseList(val);
+ break;
+ }
+ case "xml-mapper": {
+ String val = asText(node);
+ target.setXmlMapper(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.JaxbDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "jaxb",
+ properties = {
+ @YamlProperty(name = "content-type-header", type = "boolean"),
+ @YamlProperty(name = "context-path", type = "string"),
+ @YamlProperty(name = "context-path-is-class-name", type = "boolean"),
+ @YamlProperty(name = "encoding", type = "string"),
+ @YamlProperty(name = "filter-non-xml-chars", type = "boolean"),
+ @YamlProperty(name = "fragment", type = "boolean"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "ignore-jaxb-element", type = "boolean"),
+ @YamlProperty(name = "jaxb-provider-properties", type = "string"),
+ @YamlProperty(name = "must-be-jaxb-element", type = "boolean"),
+ @YamlProperty(name = "namespace-prefix-ref", type = "string"),
+ @YamlProperty(name = "no-namespace-schema-location", type = "string"),
+ @YamlProperty(name = "object-factory", type = "boolean"),
+ @YamlProperty(name = "part-class", type = "string"),
+ @YamlProperty(name = "part-namespace", type = "string"),
+ @YamlProperty(name = "pretty-print", type = "boolean"),
+ @YamlProperty(name = "schema", type = "string"),
+ @YamlProperty(name = "schema-location", type = "string"),
+ @YamlProperty(name = "schema-severity-level", type = "number"),
+ @YamlProperty(name = "xml-stream-writer-wrapper", type = "string")
+ }
+ )
+ public static class JaxbDataFormatDeserializer extends YamlDeserializerBase<JaxbDataFormat> {
+ public JaxbDataFormatDeserializer() {
+ super(JaxbDataFormat.class);
+ }
+
+ @Override
+ protected JaxbDataFormat newInstance() {
+ return new JaxbDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(JaxbDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "content-type-header": {
+ String val = asText(node);
+ target.setContentTypeHeader(val);
+ break;
+ }
+ case "context-path": {
+ String val = asText(node);
+ target.setContextPath(val);
+ break;
+ }
+ case "context-path-is-class-name": {
+ String val = asText(node);
+ target.setContextPathIsClassName(val);
+ break;
+ }
+ case "encoding": {
+ String val = asText(node);
+ target.setEncoding(val);
+ break;
+ }
+ case "filter-non-xml-chars": {
+ String val = asText(node);
+ target.setFilterNonXmlChars(val);
+ break;
+ }
+ case "fragment": {
+ String val = asText(node);
+ target.setFragment(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "ignore-jaxb-element": {
+ String val = asText(node);
+ target.setIgnoreJAXBElement(val);
+ break;
+ }
+ case "jaxb-provider-properties": {
+ String val = asText(node);
+ target.setJaxbProviderProperties(val);
+ break;
+ }
+ case "must-be-jaxb-element": {
+ String val = asText(node);
+ target.setMustBeJAXBElement(val);
+ break;
+ }
+ case "namespace-prefix-ref": {
+ String val = asText(node);
+ target.setNamespacePrefixRef(val);
+ break;
+ }
+ case "no-namespace-schema-location": {
+ String val = asText(node);
+ target.setNoNamespaceSchemaLocation(val);
+ break;
+ }
+ case "object-factory": {
+ String val = asText(node);
+ target.setObjectFactory(val);
+ break;
+ }
+ case "part-class": {
+ String val = asText(node);
+ target.setPartClass(val);
+ break;
+ }
+ case "part-namespace": {
+ String val = asText(node);
+ target.setPartNamespace(val);
+ break;
+ }
+ case "pretty-print": {
+ String val = asText(node);
+ target.setPrettyPrint(val);
+ break;
+ }
+ case "schema": {
+ String val = asText(node);
+ target.setSchema(val);
+ break;
+ }
+ case "schema-location": {
+ String val = asText(node);
+ target.setSchemaLocation(val);
+ break;
+ }
+ case "schema-severity-level": {
+ String val = asText(node);
+ target.setSchemaSeverityLevel(val);
+ break;
+ }
+ case "xml-stream-writer-wrapper": {
+ String val = asText(node);
+ target.setXmlStreamWriterWrapper(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ inline = true,
+ types = org.apache.camel.model.language.JoorExpression.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "joor",
+ properties = {
+ @YamlProperty(name = "expression", type = "string", required = true),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "pre-compile", type = "boolean"),
+ @YamlProperty(name = "result-type", type = "string"),
+ @YamlProperty(name = "single-quotes", type = "boolean"),
+ @YamlProperty(name = "trim", type = "boolean")
+ }
+ )
+ public static class JoorExpressionDeserializer extends YamlDeserializerBase<JoorExpression> {
+ public JoorExpressionDeserializer() {
+ super(JoorExpression.class);
+ }
+
+ @Override
+ protected JoorExpression newInstance() {
+ return new JoorExpression();
+ }
+
+ @Override
+ protected JoorExpression newInstance(String value) {
+ return new JoorExpression(value);
+ }
+
+ @Override
+ protected boolean setProperty(JoorExpression target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "expression": {
+ String val = asText(node);
+ target.setExpression(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "pre-compile": {
+ String val = asText(node);
+ target.setPreCompile(val);
+ break;
+ }
+ case "result-type": {
+ String val = asText(node);
+ target.setResultTypeName(val);
+ break;
+ }
+ case "single-quotes": {
+ String val = asText(node);
+ target.setSingleQuotes(val);
+ break;
+ }
+ case "trim": {
+ String val = asText(node);
+ target.setTrim(val);
+ break;
+ }
+ default: {
+ ExpressionDefinition ed = target.getExpressionType();
+ if (ed != null) {
+ throw new org.apache.camel.dsl.yaml.common.exception.UnsupportedFieldException(propertyName, "an expression has already been configured (" + ed + ")");
+ }
+ ed = ExpressionDeserializers.constructExpressionType(propertyKey, node);
+ if (ed != null) {
+ target.setExpressionType(ed);
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.JsonApiDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "json-api",
+ properties = {
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "main-format-type", type = "string")
+ }
+ )
+ public static class JsonApiDataFormatDeserializer extends YamlDeserializerBase<JsonApiDataFormat> {
+ public JsonApiDataFormatDeserializer() {
+ super(JsonApiDataFormat.class);
+ }
+
+ @Override
+ protected JsonApiDataFormat newInstance() {
+ return new JsonApiDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(JsonApiDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "data-format-types": {
+ java.lang.Class<?>[] val = asClassArray(node);
+ target.setDataFormatTypes(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "main-format-type": {
+ java.lang.Class<?> val = asClass(node);
+ target.setMainFormatType(val);
+ break;
+ }
+ default: {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+
+ @YamlType(
+ types = org.apache.camel.model.dataformat.JsonDataFormat.class,
+ order = org.apache.camel.dsl.yaml.common.YamlDeserializerResolver.ORDER_LOWEST - 1,
+ nodes = "json",
+ properties = {
+ @YamlProperty(name = "allow-jms-type", type = "boolean"),
+ @YamlProperty(name = "allow-unmarshall-type", type = "boolean"),
+ @YamlProperty(name = "auto-discover-object-mapper", type = "boolean"),
+ @YamlProperty(name = "collection-type-name", type = "string"),
+ @YamlProperty(name = "content-type-header", type = "boolean"),
+ @YamlProperty(name = "disable-features", type = "string"),
+ @YamlProperty(name = "drop-root-node", type = "boolean"),
+ @YamlProperty(name = "enable-features", type = "string"),
+ @YamlProperty(name = "id", type = "string"),
+ @YamlProperty(name = "include", type = "string"),
+ @YamlProperty(name = "json-view-type-name", type = "string"),
+ @YamlProperty(name = "library", type = "enum:Fastjson,Gson,Jackson,Johnzon,Jsonb,XStream"),
+ @YamlProperty(name = "module-class-names", type = "string"),
+ @YamlProperty(name = "module-refs", type = "string"),
+ @YamlProperty(name = "object-mapper", type = "string"),
+ @YamlProperty(name = "permissions", type = "string"),
+ @YamlProperty(name = "pretty-print", type = "boolean"),
+ @YamlProperty(name = "timezone", type = "string"),
+ @YamlProperty(name = "unmarshal-type-name", type = "string"),
+ @YamlProperty(name = "use-default-object-mapper", type = "boolean"),
+ @YamlProperty(name = "use-list", type = "boolean")
+ }
+ )
+ public static class JsonDataFormatDeserializer extends YamlDeserializerBase<JsonDataFormat> {
+ public JsonDataFormatDeserializer() {
+ super(JsonDataFormat.class);
+ }
+
+ @Override
+ protected JsonDataFormat newInstance() {
+ return new JsonDataFormat();
+ }
+
+ @Override
+ protected boolean setProperty(JsonDataFormat target, String propertyKey,
+ String propertyName, Node node) {
+ switch(propertyKey) {
+ case "allow-jms-type": {
+ String val = asText(node);
+ target.setAllowJmsType(val);
+ break;
+ }
+ case "allow-unmarshall-type": {
+ String val = asText(node);
+ target.setAllowUnmarshallType(val);
+ break;
+ }
+ case "auto-discover-object-mapper": {
+ String val = asText(node);
+ target.setAutoDiscoverObjectMapper(val);
+ break;
+ }
+ case "collection-type-name": {
+ String val = asText(node);
+ target.setCollectionTypeName(val);
+ break;
+ }
+ case "content-type-header": {
+ String val = asText(node);
+ target.setContentTypeHeader(val);
+ break;
+ }
+ case "disable-features": {
+ String val = asText(node);
+ target.setDisableFeatures(val);
+ break;
+ }
+ case "drop-root-node": {
+ String val = asText(node);
+ target.setDropRootNode(val);
+ break;
+ }
+ case "enable-features": {
+ String val = asText(node);
+ target.setEnableFeatures(val);
+ break;
+ }
+ case "id": {
+ String val = asText(node);
+ target.setId(val);
+ break;
+ }
+ case "include": {
+ String val = asText(node);
+ target.setInclude(val);
+ break;
+ }
+ case "json-view-type-name": {
+ String val = asText(node);
+ target.setJsonViewTypeName(val);
+ break;
+ }
+ case "library": {
+ target.setLibrary(org.apache.camel.model.dataformat.JsonLibrary.valueOf(asText(node)));
+ break;
+ }
+ case "module-class-names": {
+ String val = asText(node);
+ target.setModuleClassNames(val);
+ break;
+ }
+ case "module-refs": {
+ String val = asText(node);
+ target.setModuleRefs(val);
+ break;
+ }
+ case "object-mapper": {
+ String val = asText(node);
+ target.setObjectMapper(val);
... 25551 lines suppressed ...