#serialization #no-std

no-std valuable

Object-safe value inspection, used to pass un-typed structured data across trait-object boundaries

2 unstable releases

0.1.0 Jan 3, 2022
0.0.0 Mar 9, 2021

#637 in Debugging

Download history 491404/week @ 2023-11-02 489858/week @ 2023-11-09 439178/week @ 2023-11-16 359917/week @ 2023-11-23 416194/week @ 2023-11-30 437331/week @ 2023-12-07 451263/week @ 2023-12-14 284291/week @ 2023-12-21 317679/week @ 2023-12-28 489578/week @ 2024-01-04 506373/week @ 2024-01-11 528768/week @ 2024-01-18 495728/week @ 2024-01-25 521628/week @ 2024-02-01 519784/week @ 2024-02-08 427902/week @ 2024-02-15

2,062,622 downloads per month
Used in 6,966 crates (23 directly)

MIT license

130KB
1.5K SLoC

Valuable

Valuable provides object-safe value inspection. Use cases include passing structured data to trait objects and object-safe serialization.

License

This project is licensed under the MIT license.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Valuable by you, shall be licensed as MIT, without any additional terms or conditions.


lib.rs:

Valuable provides object-safe value inspection. Use cases include passing structured data to trait objects and object-safe serialization.

Getting started

First, derive [Valuable][macro@crate::Valuable] on your types.

use valuable::Valuable;

#[derive(Valuable)]
struct HelloWorld {
    message: Message,
}

#[derive(Valuable)]
enum Message {
    HelloWorld,
    Custom(String),
}

Then, implement a [visitor][Visit] to inspect the data.

use valuable::{NamedValues, Value, Valuable, Visit};

struct Print;

impl Visit for Print {
    fn visit_value(&mut self, value: Value<'_>) {
        match value {
            Value::Structable(v) => {
                println!("struct {}", v.definition().name());
                v.visit(self);
            }
            Value::Enumerable(v) => {
                println!("enum {}::{}", v.definition().name(), v.variant().name());
                v.visit(self);
            }
            Value::Listable(v) => {
                println!("list");
                v.visit(self);
            }
            Value::Mappable(v) => {
                println!("map");
                v.visit(self);
            }
            _ => {
                println!("value {:?}", value);
            }
        }
    }

    fn visit_named_fields(&mut self, named_fields: &NamedValues<'_>) {
        for (field, value) in named_fields.iter() {
            println!("named field {}", field.name());
            value.visit(self);
        }
    }

    fn visit_unnamed_fields(&mut self, values: &[Value<'_>]) {
        for value in values {
            value.visit(self);
        }
    }

    fn visit_entry(&mut self, key: Value<'_>, value: Value<'_>) {
        println!("key / value");
        key.visit(self);
        value.visit(self);
    }
}

Then, use the visitor to visit the value.

let hello_world = HelloWorld { message: Message::HelloWorld };
hello_world.visit(&mut Print);

Dependencies

~215KB