This crate provides Service, MutService, and AsyncService traits and associated utilities to facilitiate service-oriented design.
These traits and tools in this library provide concrete guidelines to help make a service-oriented design successful.
In the context of this crate, a service is simply a trait that accepts an input and produces a result.
Traits can be composed or chained together using the ServiceChain found in this crate.
This crate in and of itself does not provide mechanisms to expose services on a network or facilitiate service discovery.
Those implementation details are to be provided in sod-* crates, which will often simply encapsulate other open source libraries to expose them as services.
Instead, this crate provides the core mechanisms to define services and in a way that helps guarantee they will be interoperable with one another at a library level.
```rust use sod::{Service, ServiceChain};
// define a service, which adds a constant number to the input, producing the result as output
struct AddService {
n: usize,
}
impl AddService {
pub fn new(n: usize) -> Self {
Self { n }
}
}
impl Service // chain together multiple add services, where each service's output is processed as the next service's input
let chain = ServiceChain::start(AddService::new(1))
.next(AddService::new(2))
.next(AddService::new(4))
.end(); // pass 100 to the service chain, which should result in 100 + 1 + 2 + 4 = 107
let result = chain.process(100).unwrap();
assert_eq!(107, result);
```