Crate valuable

Source
Expand description

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

§Getting started

First, derive Valuable on your types.

use valuable::Valuable;

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

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

Then, implement a visitor 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);

Structs§

NamedField
A named field
NamedValues
Set of values from a Structable or Enumerable with named fields.
VariantDef
An enum variant definition.

Enums§

EnumDef
An enum’s variants, variant fields, and other enum-level information.
Fields
Data stored within a Structable or an Enumerable.
Slice
A slice containing primitive values.
StructDef
A struct’s name, fields, and other struct-level information.
TupleDef
The number of fields and other tuple-level information.
Value
Any Rust value
Variant
An enum variant

Traits§

Enumerable
An enum-like Valuable sub-type.
Listable
A list-like Valuable sub-type.
Mappable
A map-like Valuable sub-type.
Structable
A struct-like Valuable sub-type.
Tuplable
A tuple-like Valuable sub-type.
Valuable
A type that can be converted to a Value.
Visit
Traverse a value’s fields and variants.

Functions§

visit
Inspects a value by calling the relevant Visit methods with value’s data.

Derive Macros§

Valuablederive
Derive a Valuable implementation for a struct or enum.