dxr 0.8.0

Declarative XML-RPC
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#![cfg_attr(docsrs, feature(doc_cfg))]

//! # dxr
//!
//! This crate provides an implementation of XML-RPC types, (de)serialization support, and
//! conversion between XML-RPC values and Rust values (with optional support for non-standard `i8`
//! and `nil` types, which can be enabled with the respective feature flags).
//!
//! Support for writing XML-RPC clients / servers is provided in separate crates:
//!
//! - `dxr_client`: generic XML-RPC client code and a default implementation based on `reqwest`
//! - `dxr_server`: generic XML-RPC server code and a default implementation based on `axum`
//!
//! The table below lists XML-RPC types and their equivalent Rust types.
//!
//! | XML-RPC value type | Rust type             |
//! |: ----------------- |: -------------------- |
//! | `i4`               | [`i32`]               |
//! | `i8`               | [`i64`]               |
//! | `boolean`          | [`bool`]              |
//! | `string`           | [`String`] / [`&str`] |
//! | `double`           | [`f64`]               |
//! | `dateTime.iso8601` | [`DateTime`]          |
//! | `base64`           | [`Vec<u8>`]           |
//! | `nil`              | [`Option<T>`]         |
//!
//! Additionally, the [`TryFromValue`] and [`TryToValue`] traits (which implement the conversion
//! between XML-RPC value types and Rust types) are implemented for
//!
//! - [`Vec<T>`], slices `&[T]`, and fixed-size arrays `[T; N]`,
//! - smart pointer types like [`Box<T>`], [`Cow<T>`], [`Rc<T>`], and [`Arc<T>`],
//! - mappings like [`HashMap<String, T>`] / [`HashMap<&str, T>`],
//! - tuples `(T, ...)` with up to eight members
//!
//! (as long as the inner type `T` also implement these traits).
//!
//! ## Features
//!
//! This crate provides optional features, all of which are disabled by default:
//!
//! - `derive`: include procedural macros for deriving the [`TryFromValue`] and [`TryToValue`]
//!   traits for custom structs
//! - `i8`: enable support for the non-standard `i8` value type
//! - `nil`: enable support for the non-standard `nil` value type

// imports for intra-doc links
#[cfg(doc)]
use std::{borrow::Cow, collections::HashMap, rc::Rc, sync::Arc};

mod base64;
mod datetime;
mod error;
mod fault;
mod impls;
mod serde;
mod traits;
mod types;
mod xml;

#[cfg(feature = "derive")]
pub use dxr_derive::{TryFromValue, TryToValue};

#[cfg(feature = "multicall")]
pub mod multicall;

pub use datetime::DateTime;
pub use error::Error;
pub use fault::Fault;
pub use traits::{TryFromParams, TryFromValue, TryToParams, TryToValue};
pub use types::{FaultResponse, MethodCall, MethodResponse, Value};