This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a commit to branch camel-3.x
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/camel-3.x by this push:
new dba173bf371 Regen for commit cac64f9e585dac3c99b49bc69afc7f45f6797523
dba173bf371 is described below
commit dba173bf37152689f0eba897c953fb32fd67bbfe
Author: davsclaus <[email protected]>
AuthorDate: Sun Mar 26 13:38:17 2023 +0000
Regen for commit cac64f9e585dac3c99b49bc69afc7f45f6797523
Signed-off-by: GitHub <[email protected]>
---
.../apache/camel/catalog/schemas/camel-spring.xsd | 112 ++++++++++++---------
.../builder/LegacyDefaultErrorHandlerBuilder.java | 14 +--
.../apache/camel/model/OnCompletionDefinition.java | 7 +-
.../apache/camel/model/OnExceptionDefinition.java | 14 +--
.../DefaultErrorHandlerDefinition.java | 28 +++---
5 files changed, 100 insertions(+), 75 deletions(-)
diff --git
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
index ce158a0628e..758fda6c398 100644
---
a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
+++
b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
@@ -6637,18 +6637,22 @@ that the former includes both the original body and
headers, where as the latter
only includes the original body. You can use the latter to enrich the message
with custom headers and include the original message body. The former wont let
you do this, as its using the original message body and headers as they are.
You
-cannot enable both useOriginalMessage and useOriginalBody. Important: The
-original input means the input message that are bounded by the current
-org.apache.camel.spi.UnitOfWork . An unit of work typically spans one route, or
-multiple routes if they are connected using internal endpoints such as direct
or
-seda. When messages is passed via external endpoints such as JMS or HTTP then
-the consumer will create a new unit of work, with the message it received as
-input as the original input. Also some EIP patterns such as splitter,
multicast,
-will create a new unit of work boundary for the messages in their sub-route (eg
-the splitted message); however these EIPs have an option named shareUnitOfWork
-which allows to combine with the parent unit of work in regard to error
handling
-and therefore use the parent original message. By default this feature is off.
-Default value: false
+cannot enable both useOriginalMessage and useOriginalBody. The original input
+message is defensively copied, and the copied message body is converted to
+org.apache.camel.StreamCache if possible, to ensure the body can be read when
+the original message is being used later. If the body is not converted to
+org.apache.camel.StreamCache then the body will not be able to re-read when
+accessed later. Important: The original input means the input message that are
+bounded by the current org.apache.camel.spi.UnitOfWork . An unit of work
+typically spans one route, or multiple routes if they are connected using
+internal endpoints such as direct or seda. When messages is passed via external
+endpoints such as JMS or HTTP then the consumer will create a new unit of work,
+with the message it received as input as the original input. Also some EIP
+patterns such as splitter, multicast, will create a new unit of work boundary
+for the messages in their sub-route (eg the splitted message); however these
+EIPs have an option named shareUnitOfWork which allows to combine with the
+parent unit of work in regard to error handling and therefore use the parent
+original message. By default this feature is off. Default value: false
]]>
</xs:documentation>
</xs:annotation>
@@ -6674,18 +6678,22 @@ that the former includes both the original body and
headers, where as the latter
only includes the original body. You can use the latter to enrich the message
with custom headers and include the original message body. The former wont let
you do this, as its using the original message body and headers as they are.
You
-cannot enable both useOriginalMessage and useOriginalBody. Important: The
-original input means the input message that are bounded by the current
-org.apache.camel.spi.UnitOfWork . An unit of work typically spans one route, or
-multiple routes if they are connected using internal endpoints such as direct
or
-seda. When messages is passed via external endpoints such as JMS or HTTP then
-the consumer will create a new unit of work, with the message it received as
-input as the original input. Also some EIP patterns such as splitter,
multicast,
-will create a new unit of work boundary for the messages in their sub-route (eg
-the splitted message); however these EIPs have an option named shareUnitOfWork
-which allows to combine with the parent unit of work in regard to error
handling
-and therefore use the parent original message. By default this feature is off.
-Default value: false
+cannot enable both useOriginalMessage and useOriginalBody. The original input
+message is defensively copied, and the copied message body is converted to
+org.apache.camel.StreamCache if possible, to ensure the body can be read when
+the original message is being used later. If the body is not converted to
+org.apache.camel.StreamCache then the body will not be able to re-read when
+accessed later. Important: The original input means the input message that are
+bounded by the current org.apache.camel.spi.UnitOfWork . An unit of work
+typically spans one route, or multiple routes if they are connected using
+internal endpoints such as direct or seda. When messages is passed via external
+endpoints such as JMS or HTTP then the consumer will create a new unit of work,
+with the message it received as input as the original input. Also some EIP
+patterns such as splitter, multicast, will create a new unit of work boundary
+for the messages in their sub-route (eg the splitted message); however these
+EIPs have an option named shareUnitOfWork which allows to combine with the
+parent unit of work in regard to error handling and therefore use the parent
+original message. By default this feature is off. Default value: false
]]>
</xs:documentation>
</xs:annotation>
@@ -14160,18 +14168,22 @@ that the former includes both the original body and
headers, where as the latter
only includes the original body. You can use the latter to enrich the message
with custom headers and include the original message body. The former wont let
you do this, as its using the original message body and headers as they are.
You
-cannot enable both useOriginalMessage and useOriginalBody. Important: The
-original input means the input message that are bounded by the current
-org.apache.camel.spi.UnitOfWork . An unit of work typically spans one route, or
-multiple routes if they are connected using internal endpoints such as direct
or
-seda. When messages is passed via external endpoints such as JMS or HTTP then
-the consumer will create a new unit of work, with the message it received as
-input as the original input. Also some EIP patterns such as splitter,
multicast,
-will create a new unit of work boundary for the messages in their sub-route (eg
-the split message); however these EIPs have an option named shareUnitOfWork
-which allows to combine with the parent unit of work in regard to error
handling
-and therefore use the parent original message. By default this feature is off.
-Default value: false
+cannot enable both useOriginalMessage and useOriginalBody. The original input
+message is defensively copied, and the copied message body is converted to
+org.apache.camel.StreamCache if possible, to ensure the body can be read when
+the original message is being used later. If the body is not converted to
+org.apache.camel.StreamCache then the body will not be able to re-read when
+accessed later. Important: The original input means the input message that are
+bounded by the current org.apache.camel.spi.UnitOfWork . An unit of work
+typically spans one route, or multiple routes if they are connected using
+internal endpoints such as direct or seda. When messages is passed via external
+endpoints such as JMS or HTTP then the consumer will create a new unit of work,
+with the message it received as input as the original input. Also some EIP
+patterns such as splitter, multicast, will create a new unit of work boundary
+for the messages in their sub-route (eg the split message); however these EIPs
+have an option named shareUnitOfWork which allows to combine with the parent
+unit of work in regard to error handling and therefore use the parent original
+message. By default this feature is off. Default value: false
]]>
</xs:documentation>
</xs:annotation>
@@ -14197,18 +14209,22 @@ that the former includes both the original body and
headers, where as the latter
only includes the original body. You can use the latter to enrich the message
with custom headers and include the original message body. The former wont let
you do this, as its using the original message body and headers as they are.
You
-cannot enable both useOriginalMessage and useOriginalBody. Important: The
-original input means the input message that are bounded by the current
-org.apache.camel.spi.UnitOfWork . An unit of work typically spans one route, or
-multiple routes if they are connected using internal endpoints such as direct
or
-seda. When messages is passed via external endpoints such as JMS or HTTP then
-the consumer will create a new unit of work, with the message it received as
-input as the original input. Also some EIP patterns such as splitter,
multicast,
-will create a new unit of work boundary for the messages in their sub-route (eg
-the split message); however these EIPs have an option named shareUnitOfWork
-which allows to combine with the parent unit of work in regard to error
handling
-and therefore use the parent original message. By default this feature is off.
-Default value: false
+cannot enable both useOriginalMessage and useOriginalBody. The original input
+message is defensively copied, and the copied message body is converted to
+org.apache.camel.StreamCache if possible, to ensure the body can be read when
+the original message is being used later. If the body is not converted to
+org.apache.camel.StreamCache then the body will not be able to re-read when
+accessed later. Important: The original input means the input message that are
+bounded by the current org.apache.camel.spi.UnitOfWork . An unit of work
+typically spans one route, or multiple routes if they are connected using
+internal endpoints such as direct or seda. When messages is passed via external
+endpoints such as JMS or HTTP then the consumer will create a new unit of work,
+with the message it received as input as the original input. Also some EIP
+patterns such as splitter, multicast, will create a new unit of work boundary
+for the messages in their sub-route (eg the split message); however these EIPs
+have an option named shareUnitOfWork which allows to combine with the parent
+unit of work in regard to error handling and therefore use the parent original
+message. By default this feature is off. Default value: false
]]>
</xs:documentation>
</xs:annotation>
diff --git
a/core/camel-core-model/src/main/java/org/apache/camel/builder/LegacyDefaultErrorHandlerBuilder.java
b/core/camel-core-model/src/main/java/org/apache/camel/builder/LegacyDefaultErrorHandlerBuilder.java
index 40795a73a4c..94bc0e27a34 100644
---
a/core/camel-core-model/src/main/java/org/apache/camel/builder/LegacyDefaultErrorHandlerBuilder.java
+++
b/core/camel-core-model/src/main/java/org/apache/camel/builder/LegacyDefaultErrorHandlerBuilder.java
@@ -348,9 +348,10 @@ public class LegacyDefaultErrorHandlerBuilder extends
LegacyErrorHandlerBuilderS
* with custom headers and include the original message body. The former
wont let you do this, as its using the
* original message body and headers as they are. You cannot enable both
useOriginalMessage and useOriginalBody.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
@@ -389,9 +390,10 @@ public class LegacyDefaultErrorHandlerBuilder extends
LegacyErrorHandlerBuilderS
* with custom headers and include the original message body. The former
wont let you do this, as its using the
* original message body and headers as they are. You cannot enable both
useOriginalMessage and useOriginalBody.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
diff --git
a/core/camel-core-model/src/main/java/org/apache/camel/model/OnCompletionDefinition.java
b/core/camel-core-model/src/main/java/org/apache/camel/model/OnCompletionDefinition.java
index ce8f5a2d185..3826478429d 100644
---
a/core/camel-core-model/src/main/java/org/apache/camel/model/OnCompletionDefinition.java
+++
b/core/camel-core-model/src/main/java/org/apache/camel/model/OnCompletionDefinition.java
@@ -214,9 +214,10 @@ public class OnCompletionDefinition extends
OutputDefinition<OnCompletionDefinit
/**
* Will use the original input message body when an {@link
org.apache.camel.Exchange} for this on completion.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
diff --git
a/core/camel-core-model/src/main/java/org/apache/camel/model/OnExceptionDefinition.java
b/core/camel-core-model/src/main/java/org/apache/camel/model/OnExceptionDefinition.java
index d09f94835f1..e61d92dc1a9 100644
---
a/core/camel-core-model/src/main/java/org/apache/camel/model/OnExceptionDefinition.java
+++
b/core/camel-core-model/src/main/java/org/apache/camel/model/OnExceptionDefinition.java
@@ -668,9 +668,10 @@ public class OnExceptionDefinition extends
OutputDefinition<OnExceptionDefinitio
* with custom headers and include the original message body. The former
wont let you do this, as its using the
* original message body and headers as they are. You cannot enable both
useOriginalMessage and useOriginalBody.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
@@ -709,9 +710,10 @@ public class OnExceptionDefinition extends
OutputDefinition<OnExceptionDefinitio
* with custom headers and include the original message body. The former
wont let you do this, as its using the
* original message body and headers as they are. You cannot enable both
useOriginalMessage and useOriginalBody.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
diff --git
a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerDefinition.java
b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerDefinition.java
index 22b32223487..8727b35f787 100644
---
a/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerDefinition.java
+++
b/core/camel-core-model/src/main/java/org/apache/camel/model/errorhandler/DefaultErrorHandlerDefinition.java
@@ -198,9 +198,10 @@ public class DefaultErrorHandlerDefinition extends
BaseErrorHandlerDefinition {
* with custom headers and include the original message body. The former
wont let you do this, as its using the
* original message body and headers as they are. You cannot enable both
useOriginalMessage and useOriginalBody.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
@@ -239,9 +240,10 @@ public class DefaultErrorHandlerDefinition extends
BaseErrorHandlerDefinition {
* with custom headers and include the original message body. The former
wont let you do this, as its using the
* original message body and headers as they are. You cannot enable both
useOriginalMessage and useOriginalBody.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
@@ -690,9 +692,10 @@ public class DefaultErrorHandlerDefinition extends
BaseErrorHandlerDefinition {
* with custom headers and include the original message body. The former
wont let you do this, as its using the
* original message body and headers as they are. You cannot enable both
useOriginalMessage and useOriginalBody.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
@@ -731,9 +734,10 @@ public class DefaultErrorHandlerDefinition extends
BaseErrorHandlerDefinition {
* with custom headers and include the original message body. The former
wont let you do this, as its using the
* original message body and headers as they are. You cannot enable both
useOriginalMessage and useOriginalBody.
* <p/>
- * The original input message is defensively copied, and the copied
message body is converted to {@link org.apache.camel.StreamCache}
- * if possible, to ensure the body can be read when the original message
is being used later. If the body is not
- * converted to {@link org.apache.camel.StreamCache} then the body will
not be able to re-read when accessed later.
+ * The original input message is defensively copied, and the copied
message body is converted to
+ * {@link org.apache.camel.StreamCache} if possible, to ensure the body
can be read when the original message is
+ * being used later. If the body is not converted to {@link
org.apache.camel.StreamCache} then the body will not be
+ * able to re-read when accessed later.
* <p/>
* <b>Important:</b> The original input means the input message that are
bounded by the current
* {@link org.apache.camel.spi.UnitOfWork}. An unit of work typically
spans one route, or multiple routes if they
