#http #serde #serialization #deserialize #url

http-serde-ext

serde support for http crate types Request, Response, Uri, StatusCode, HeaderMap, Method, in Option or other collections

12 releases (3 stable)

new 1.0.2 Feb 19, 2024
1.0.1 Feb 11, 2024
1.0.0 Nov 26, 2023
0.1.8 Nov 9, 2023
0.1.6 Oct 27, 2023

#252 in Encoding

Download history 74/week @ 2023-10-30 108/week @ 2023-11-06 62/week @ 2023-11-13 132/week @ 2023-11-20 154/week @ 2023-11-27 106/week @ 2023-12-04 167/week @ 2023-12-11 300/week @ 2023-12-18 66/week @ 2023-12-25 234/week @ 2024-01-01 174/week @ 2024-01-08 151/week @ 2024-01-15 212/week @ 2024-01-22 185/week @ 2024-01-29 222/week @ 2024-02-05 181/week @ 2024-02-12

801 downloads per month
Used in 3 crates (2 directly)

MIT license

59KB
1K SLoC

serde extensions for the http crate types

Allows serializing and deserializing the following types from http:

Allows serializing and deserializing the above types wrapped in the following std container types:

  • Option
  • Result in the Ok position
  • Vec
  • VecDeque
  • LinkedList
  • HashMap as the Key for all except HeaderMap, Request, and Response. As the Value for all types.
  • BTreeMap as the Key only for HeaderValue, StatusCode, and Version. As the Value for all types.
  • HashSet for all except HeaderMap, Request, and Response
  • BTreeSet only for HeaderValue, StatusCode, and Version

Installation

Run the following Cargo command in your project directory:

cargo add http-serde-ext

Or add the following line to your Cargo.toml:

http-serde-ext = "1.0.2"

Usage

This library is intended to be used with serde's derive feature. Fields should use the appropriate #[serde(with = "...")] annotation for that type. Full examples are provided in each module section of the docs.

use std::collections::*;

use http::*;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct MyStruct {
    #[serde(with = "http_serde_ext::response")]
    base: Response<Vec<u8>>,

    #[serde(with = "http_serde_ext::request::option", default)]
    option: Option<Request<String>>,

    #[serde(with = "http_serde_ext::method::vec")]
    vec: Vec<Method>,

    #[serde(with = "http_serde_ext::uri::vec_deque")]
    vec_deque: VecDeque<Uri>,

    #[serde(with = "http_serde_ext::header_map::linked_list")]
    linked_list: LinkedList<HeaderMap>,

    #[serde(with = "http_serde_ext::header_map_generic::hash_map")]
    hash_map: HashMap<String, HeaderMap<String>>,

    #[serde(with = "http_serde_ext::status_code::btree_map_key")]
    btree_map: BTreeMap<StatusCode, i32>,

    #[serde(with = "http_serde_ext::authority::hash_set")]
    hash_set: HashSet<uri::Authority>,
}

This library can also be used to manually De/Serialize types if given a De/Serializer. For example, when using serde_json:

let uri = http::Uri::default();
let serialized = http_serde_ext::uri::serialize(&uri, serde_json::value::Serializer).unwrap();
let deserialized = http_serde_ext::uri::deserialize(serialized).unwrap();
assert_eq!(uri, deserialized);

let mut responses: Vec<http::Response<()>> = vec![http::Response::default()];
let serialized =
    http_serde_ext::response::vec::serialize(&responses, serde_json::value::Serializer)
        .unwrap();
let mut deserialized: Vec<http::Response<()>> =
    http_serde_ext::response::vec::deserialize(serialized).unwrap();

let original = responses.remove(0).into_parts();
let deserialized = deserialized.remove(0).into_parts();

assert_eq!(original.0.status, deserialized.0.status);
assert_eq!(original.0.version, deserialized.0.version);
assert_eq!(original.0.headers, deserialized.0.headers);
assert_eq!(original.1, deserialized.1);

Acknowledgements

This crate is heavily inspired by Kornel's http-serde.

Dependencies

~1–1.7MB
~34K SLoC