This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/main by this push:
new d20dedbfb3c Regen for commit 0093cdd8990663ba09769c4ae91fc8695b218e5b
d20dedbfb3c is described below
commit d20dedbfb3c4e94efe6a4a6f9a3babcba81393f7
Author: davsclaus <[email protected]>
AuthorDate: Sun Mar 26 13:41:28 2023 +0000
Regen for commit 0093cdd8990663ba09769c4ae91fc8695b218e5b
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 d0d578bee11..19eccf3d812 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
@@ -5674,18 +5674,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>
</xs:attribute>
@@ -5709,18 +5713,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>
</xs:attribute>
@@ -12104,18 +12112,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>
</xs:attribute>
@@ -12139,18 +12151,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>
</xs:attribute>
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 b0c9cf6c4c1..b664cd7f9fa 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 ead6899aab0..57c109400dc 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 c8520cbe5f4..22f977d5fc1 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
