🗂️ type_reg

Serializable map of any type.

This library provides a map that can store any serializable type, and retrieve it as the strong type. Serialization and deserialization is also done without requiring the consumer to implement custom serde logic.

Usage

Add the following to Cargo.toml

```toml typereg = { version = "0.3.0", features = ["tagged"] } typereg = { version = "0.3.0", features = ["untagged"] }

Values must impl Debug, and TypeMap's Debug impl will

print the debug string of each value.

type_reg = { version = "0.3.0", features = ["debug"] }

Use insertion order for TypeMap and TypeReg iteration order.

type_reg = { version = "0.3.0", features = ["ordered"] } ```

Tagged Type Registry

⚠️ Note: This uses [std::any::type_name] internally, which is not stable.

Serialization

```rust use serde::{Deserialize, Serialize}; use type_reg::tagged::TypeMap;

[derive(Clone, Copy, Debug, Deserialize, Serialize)]

struct A(u32);

fn main() { let mut typemap = TypeMap::new(); typemap.insert("one", 1u32); typemap.insert("two", 2u64); typemap.insert("three", A(3));

println!("{}", serde_yaml::to_string(&type_map).unwrap());

// ---
// one:
//   u32: 1
// three:
//   "rust_out::A": 3
// two:
//   u64: 2

} ```

Deserialization

```rust use serde::{Deserialize, Serialize}; use type_reg::tagged::{TypeMap, TypeReg};

[derive(Clone, Copy, Debug, Deserialize, Serialize)]

struct A(u32);

fn main() { let mut typereg = TypeReg::new(); typereg.register::(); typereg.register::(); typereg.register::();

let serialized = "---\n\
    one:   { u32: 1 }\n\
    two:   { u64: 2 }\n\
    three: { 'tagged_deserialize_map::A': 3 }\n\
    ";

let deserializer = serde_yaml::Deserializer::from_str(serialized);
let type_map: TypeMap<String> = type_reg.deserialize_map(deserializer).unwrap();

let data_u32 = type_map.get::<u32, _>("one").copied().unwrap();
let data_u64 = type_map.get::<u64, _>("two").copied().unwrap();
let data_a = type_map.get::<A, _>("three").copied().unwrap();

println!("{data_u32}, {data_u64}, {data_a:?}");

// 1, 2, A(3)

println!("{}", serde_yaml::to_string(&type_map).unwrap());

// ---
// two: 2
// one: 1
// three: 3

fn main() { let mut typereg = TypeReg::::new(); typereg.register::(String::from("one")); typereg.register::(String::from("two")); typereg.register::(String::from("three"));

let serialized = "---\n\
    one: 1\n\
    two: 2\n\
    three: 3\n\
    ";

let deserializer = serde_yaml::Deserializer::from_str(serialized);
let type_map: TypeMap<String> = type_reg.deserialize_map(deserializer).unwrap();

let data_u32 = type_map.get::<u32, _>("one").copied().unwrap();
let data_u64 = type_map.get::<u64, _>("two").copied().unwrap();
let data_a = type_map.get::<A, _>("three").copied().unwrap();

println!("{data_u32}, {data_u64}, {data_a:?}");

// 1, 2, A(3)

• Apache License, Version 2.0, ([LICENSE-APACHE] or https://www.apache.org/licenses/LICENSE-2.0)
• MIT license ([LICENSE-MIT] or https://opensource.org/licenses/MIT)

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.