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,
}

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.

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 [impl_from_body_via_serde!].

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.