camel-component 0.5.0

# camel-component

> Component trait and registry for rust-camel

## Overview

`camel-component` defines the core `Component`, `Endpoint`, `Consumer`, and `Producer` traits that all rust-camel components must implement. This crate provides the foundation for creating new components that can integrate with the rust-camel routing engine.

If you're building a custom component (e.g., for a proprietary protocol or service), you'll implement the traits defined in this crate.

## Features

- **Component trait**: Factory for creating endpoints from URIs
- **Endpoint trait**: Represents a communication endpoint with consumer/producer support
- **Consumer trait**: Consumes messages from external sources
- **Producer trait**: Sends messages to external destinations
- **Concurrency support**: Built-in support for concurrent message processing

## Installation

Add to your `Cargo.toml`:

```toml
[dependencies]
camel-component = "0.2"
```

## Usage

### Implementing a Custom Component

```rust
use camel_component::{Component, Endpoint, Consumer, ProducerContext, ConsumerContext};
use camel_api::{BoxProcessor, CamelError};

pub struct MyComponent;

impl Component for MyComponent {
    fn scheme(&self) -> &str {
        "mycomponent"
    }

    fn create_endpoint(&self, uri: &str) -> Result<Box<dyn Endpoint>, CamelError> {
        // Parse URI and create endpoint
        Ok(Box::new(MyEndpoint { uri: uri.to_string() }))
    }
}

struct MyEndpoint {
    uri: String,
}

impl Endpoint for MyEndpoint {
    fn uri(&self) -> &str {
        &self.uri
    }

    fn create_consumer(&self) -> Result<Box<dyn Consumer>, CamelError> {
        Ok(Box::new(MyConsumer))
    }

    fn create_producer(&self, ctx: &ProducerContext) -> Result<BoxProcessor, CamelError> {
        // Create and return a producer that processes exchanges
        // See camel-service crate for processor implementation details
        Err(CamelError::NotImplemented("producer not implemented".into()))
    }
}
```

## Core Types

| Type | Description |
|------|-------------|
| `Component` | Factory for creating endpoints |
| `Endpoint` | Communication endpoint (consumer/producer) |
| `Consumer` | Trait for consuming messages from endpoints |
| `ConsumerContext` | Context provided to Consumer implementations |
| `ProducerContext` | Context for creating producers |
| `ExchangeEnvelope` | Message envelope with optional reply channel |
| `ConcurrencyModel` | Sequential or Concurrent message processing |

## ConcurrencyModel

- **Sequential**: Process messages one at a time in order. Use for simpler consumers where ordering matters.
- **Concurrent**: Process multiple messages simultaneously. Use for higher throughput when order doesn't matter.

## Documentation

- [API Documentation](https://docs.rs/camel-component)
- [Repository](https://github.com/kennycallado/rust-camel)

## License

Apache-2.0

## Contributing

Contributions are welcome! Please see the [main repository](https://github.com/kennycallado/rust-camel) for details.