Struct Exchange 

pub struct Exchange {
    pub input: Message,
    pub output: Option<Message>,
    pub properties: HashMap<String, Value>,
    pub extensions: HashMap<String, Arc<dyn Any + Send + Sync>>,
    pub error: Option<CamelError>,
    pub pattern: ExchangePattern,
    pub correlation_id: String,
    pub otel_context: Context,
    pub in_flight_claim: Option<InFlightClaim>,
}

An Exchange represents a message being routed through the framework.

It contains the input message, an optional output message, properties for passing data between processors, and error state.

Fields

input: Message

The input (incoming) message.

output: Option<Message>

The output (response) message, populated for InOut patterns.

properties: HashMap<String, Value>

Exchange-scoped properties for passing data between processors.

extensions: HashMap<String, Arc<dyn Any + Send + Sync>>

Non-serializable extension values (e.g., channel senders). Stored as Arc<dyn Any + Send + Sync> so cloning is cheap (ref-count bump).

error: Option<CamelError>

Error state, if processing failed.

pattern: ExchangePattern

The exchange pattern.

correlation_id: String

Unique correlation ID for distributed tracing.

otel_context: Context

OpenTelemetry context for distributed tracing propagation. Carries the active span context between processing steps. Defaults to an empty context (noop span) if OTel is not active.

in_flight_claim: Option<InFlightClaim>

RAII claim on the context-global accepted-not-completed counter (drainclaim, claimfamily). Pipeline drain sites split a sibling of the envelope’s claim onto the exchange so residency inside pipeline-embedded stash sites (resequencer buffers, aggregator buckets — raw-Exchange territory with no envelope) stays counted. None on every constructor, on clones, and on exchanges accepted through uncounted paths.

Implementations

impl Exchange

pub fn new(input: Message) -> Self

Create a new exchange with the given input message.

pub fn new_in_out(input: Message) -> Self

Create a new exchange with the InOut pattern.

pub fn correlation_id(&self) -> &str

Get the correlation ID for this exchange.

pub fn property(&self, key: &str) -> Option<&Value>

Get a property value.

pub fn set_property(&mut self, key: impl Into<String>, value: impl Into<Value>)

Set a property value.

pub fn has_error(&self) -> bool

Check if the exchange has an error.

pub fn set_error(&mut self, error: CamelError)

Set an error on this exchange.

Automatically populates exchange properties with error context so that all languages can access error information via their property mechanisms:

• CamelExceptionMessage — the error’s Display string
• CamelExceptionKind — the error variant name (via CamelError::classify())
• CamelExceptionCaught — alias for Java Camel parity

pub fn clear_error(&mut self)

Clear the error and remove all exception properties.

Called after handled:true in on_exception steps to prevent stale error state from leaking into subsequent processing.

pub fn handle_error(&mut self)

Mark the exception as handled and clear the error.

Sets CamelExceptionHandled = true then calls clear_error(). This matches Java Camel’s Exchange.EXCEPTION_HANDLED semantics.

pub fn set_extension( &mut self, key: impl Into<String>, value: Arc<dyn Any + Send + Sync>, )

Store a non-serializable extension value (e.g. a channel sender).

pub fn get_extension<T: Any>(&self, key: &str) -> Option<&T>

Retrieve a typed extension value. Returns None if the key is absent or the stored value is not of type T.

pub fn body_as<T: FromBody>(&self) -> Result<T, CamelError>

Deserialize the body into type T.

Uses built-in conversions for String, Vec<u8>, bytes::Bytes, and serde_json::Value. For custom types, implement FromBody or use the impl_from_body_via_serde! macro.

Example

let text: String = exchange.body_as::<String>()?;
let raw: Vec<u8> = exchange.body_as::<Vec<u8>>()?;

Trait Implementations

impl Clone for Exchange

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Exchange

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Exchange

fn default() -> Self

Returns the “default value” for a type.

impl Service<Exchange> for IdentityProcessor

type Response = Exchange

Responses given by the service.

type Error = CamelError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<Exchange, CamelError>> + Send>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, exchange: Exchange) -> Self::Future

Process the request and return the response asynchronously.

impl<F, Fut> Service<Exchange> for ProcessorFn<F>

where F: Fn(Exchange) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Exchange, CamelError>> + Send + 'static,

type Response = Exchange

Responses given by the service.

type Error = CamelError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<Exchange, CamelError>> + Send>>

The future response value.

fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, exchange: Exchange) -> Self::Future

Process the request and return the response asynchronously.