Enum valuable::Value [−][src]
#[non_exhaustive]
pub enum Value<'a> {
Show 25 variants
Bool(bool),
Char(char),
F32(f32),
F64(f64),
I8(i8),
I16(i16),
I32(i32),
I64(i64),
I128(i128),
Isize(isize),
String(&'a str),
U8(u8),
U16(u16),
U32(u32),
U64(u64),
U128(u128),
Usize(usize),
Path(&'a Path),
Error(&'a (dyn Error + 'static)),
Listable(&'a dyn Listable),
Mappable(&'a dyn Mappable),
Structable(&'a dyn Structable),
Enumerable(&'a dyn Enumerable),
Tuplable(&'a dyn Tuplable),
Unit,
}
Expand description
Any Rust value
The Value
enum is used to pass single values to the
visitor. Primitive types are enumerated and other types
are represented at trait objects.
Values are converted to Value
instances using
Valuable::as_value()
.
Examples
Convert a primitive type
use valuable::{Value, Valuable};
let num = 123;
let val = num.as_value();
assert!(matches!(val, Value::I32(v) if v == 123));
Converting a struct
use valuable::{Value, Valuable};
#[derive(Valuable, Debug)]
struct HelloWorld {
message: String,
}
let hello = HelloWorld {
message: "greetings".to_string(),
};
let val = hello.as_value();
assert!(matches!(val, Value::Structable(_v)));
// The Value `Debug` output matches the struct's
assert_eq!(
format!("{:?}", val),
format!("{:?}", hello),
);
Variants (Non-exhaustive)
This enum is marked as non-exhaustive
Bool(bool)
Tuple Fields
0: bool
Char(char)
Tuple Fields
0: char
F32(f32)
Tuple Fields
0: f32
F64(f64)
Tuple Fields
0: f64
I8(i8)
Tuple Fields
0: i8
I16(i16)
Tuple Fields
0: i16
I32(i32)
Tuple Fields
0: i32
I64(i64)
Tuple Fields
0: i64
I128(i128)
Tuple Fields
0: i128
Isize(isize)
Tuple Fields
0: isize
String(&'a str)
Tuple Fields
0: &'a str
U8(u8)
Tuple Fields
0: u8
U16(u16)
Tuple Fields
0: u16
U32(u32)
Tuple Fields
0: u32
U64(u64)
Tuple Fields
0: u64
U128(u128)
Tuple Fields
0: u128
Usize(usize)
Tuple Fields
0: usize
Path(&'a Path)
Tuple Fields
0: &'a Path
std
only.A Rust &Path
value
Examples
use valuable::Value;
use std::path::Path;
let path = Path::new("a.txt");
let v = Value::Path(path);
Error(&'a (dyn Error + 'static))
Tuple Fields
0: &'a (dyn Error + 'static)
std
only.A Rust error value
Examples
use valuable::Value;
use std::io;
let err: io::Error = io::ErrorKind::Other.into();
let v = Value::Error(&err);
Listable(&'a dyn Listable)
Tuple Fields
0: &'a dyn Listable
A Rust list value
Examples
use valuable::Value;
let vals = vec![1, 2, 3, 4, 5];
let v = Value::Listable(&vals);
Mappable(&'a dyn Mappable)
Tuple Fields
0: &'a dyn Mappable
A Rust map value
Examples
use valuable::Value;
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("foo", 1);
map.insert("bar", 2);
let v = Value::Mappable(&map);
Structable(&'a dyn Structable)
Tuple Fields
0: &'a dyn Structable
A Rust struct value
Examples
use valuable::{Value, Valuable};
#[derive(Valuable)]
struct MyStruct {
field: u32,
}
let my_struct = MyStruct {
field: 123,
};
let v = Value::Structable(&my_struct);
Enumerable(&'a dyn Enumerable)
Tuple Fields
0: &'a dyn Enumerable
A Rust enum value
Examples
use valuable::{Value, Valuable};
#[derive(Valuable)]
enum MyEnum {
Foo,
Bar,
}
let my_enum = MyEnum::Foo;
let v = Value::Enumerable(&my_enum);
Tuplable(&'a dyn Tuplable)
Tuple Fields
0: &'a dyn Tuplable
A tuple value
Examples
use valuable::{Value, Valuable};
let my_tuple = (123, 456);
let v = Value::Tuplable(&my_tuple);
Unit
Implementations
Return a bool
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::Bool(true).as_bool(), Some(true));
assert_eq!(Value::Char('c').as_bool(), None);
Return a char
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::Char('c').as_char(), Some('c'));
assert_eq!(Value::Bool(true).as_char(), None);
Return a f32
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::F32(3.1415).as_f32(), Some(3.1415));
assert_eq!(Value::Bool(true).as_f32(), None);
Return a f64
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::F64(3.1415).as_f64(), Some(3.1415));
assert_eq!(Value::Bool(true).as_f64(), None);
Return a i8
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::I8(42).as_i8(), Some(42));
assert_eq!(Value::I32(42).as_i8(), Some(42));
assert_eq!(Value::I64(i64::MAX).as_i8(), None);
assert_eq!(Value::Bool(true).as_i8(), None);
Return a i16
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::I16(42).as_i16(), Some(42));
assert_eq!(Value::I32(42).as_i16(), Some(42));
assert_eq!(Value::I64(i64::MAX).as_i16(), None);
assert_eq!(Value::Bool(true).as_i16(), None);
Return a i32
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::I32(42).as_i32(), Some(42));
assert_eq!(Value::I64(42).as_i32(), Some(42));
assert_eq!(Value::I64(i64::MAX).as_i32(), None);
assert_eq!(Value::Bool(true).as_i32(), None);
Return a i64
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::I64(42).as_i64(), Some(42));
assert_eq!(Value::I128(42).as_i64(), Some(42));
assert_eq!(Value::I128(i128::MAX).as_i64(), None);
assert_eq!(Value::Bool(true).as_i64(), None);
Return a i128
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::I128(42).as_i128(), Some(42));
assert_eq!(Value::U128(42).as_i128(), Some(42));
assert_eq!(Value::U128(u128::MAX).as_i128(), None);
assert_eq!(Value::Bool(true).as_i128(), None);
Return a isize
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::Isize(42).as_isize(), Some(42));
assert_eq!(Value::Usize(42).as_isize(), Some(42));
assert_eq!(Value::Usize(usize::MAX).as_isize(), None);
assert_eq!(Value::Bool(true).as_isize(), None);
Return a u8
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::U8(42).as_u8(), Some(42));
assert_eq!(Value::U32(42).as_u8(), Some(42));
assert_eq!(Value::U32(u32::MAX).as_u8(), None);
assert_eq!(Value::Bool(true).as_u8(), None);
Return a u16
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::U16(42).as_u16(), Some(42));
assert_eq!(Value::U32(42).as_u16(), Some(42));
assert_eq!(Value::U32(u32::MAX).as_u16(), None);
assert_eq!(Value::Bool(true).as_u16(), None);
Return a u32
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::U32(42).as_u32(), Some(42));
assert_eq!(Value::U64(42).as_u32(), Some(42));
assert_eq!(Value::U64(u64::MAX).as_u32(), None);
assert_eq!(Value::Bool(true).as_u32(), None);
Return a u64
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::U64(42).as_u64(), Some(42));
assert_eq!(Value::U128(42).as_u64(), Some(42));
assert_eq!(Value::U128(u128::MAX).as_u64(), None);
assert_eq!(Value::Bool(true).as_u64(), None);
Return a u128
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::U128(42).as_u128(), Some(42));
assert_eq!(Value::I32(42).as_u128(), Some(42));
assert_eq!(Value::I32(-5).as_u128(), None);
assert_eq!(Value::Bool(true).as_u128(), None);
Return a usize
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::Usize(42).as_usize(), Some(42));
assert_eq!(Value::I8(42).as_usize(), Some(42));
assert_eq!(Value::I8(-5).as_usize(), None);
assert_eq!(Value::Bool(true).as_usize(), None);
Return a &str
representation of self
, if possible.
Examples
use valuable::Value;
assert_eq!(Value::String("hello").as_str(), Some("hello"));
assert_eq!(Value::Bool(true).as_str(), None);
This is supported on crate feature std
only.
std
only.Return a &Path
representation of self
, if possible.
Examples
use valuable::Value;
use std::path::Path;
let path = Path::new("a.txt");
assert!(Value::Path(path).as_path().is_some());
assert!(Value::Bool(true).as_path().is_none());
This is supported on crate feature std
only.
std
only.Return a &dyn Error
representation of self
, if possible.
Examples
use valuable::Value;
use std::io;
let err: io::Error = io::ErrorKind::Other.into();
assert!(Value::Error(&err).as_error().is_some());
assert!(Value::Bool(true).as_error().is_none());
Return a &dyn Listable
representation of self
, if possible.
Examples
use valuable::Value;
let list = vec![1, 2, 3, 4];
assert!(Value::Listable(&list).as_listable().is_some());
assert!(Value::Bool(true).as_listable().is_none());
Return a &dyn Mappable
representation of self
, if possible.
Examples
use valuable::Value;
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("foo", 123);
map.insert("bar", 456);
assert!(Value::Mappable(&map).as_mappable().is_some());
assert!(Value::Bool(true).as_mappable().is_none());
Return a &dyn Structable
representation of self
, if possible.
Examples
use valuable::{Value, Valuable};
#[derive(Valuable)]
struct Hello {
message: &'static str,
}
let hello = Hello { message: "Hello world" };
assert!(Value::Structable(&hello).as_structable().is_some());
assert!(Value::Bool(true).as_structable().is_none());
Return a &dyn Enumerable
representation of self
, if possible.
Examples
use valuable::{Value, Valuable};
#[derive(Valuable)]
enum Greet {
Hello,
World,
}
let greet = Greet::Hello;
assert!(Value::Enumerable(&greet).as_enumerable().is_some());
assert!(Value::Bool(true).as_enumerable().is_none());
Return a &dyn Tuplable
representation of self
, if possible.
Examples
use valuable::Value;
let my_tuple = (123, 456);
assert!(Value::Tuplable(&my_tuple).as_tuplable().is_some());
assert!(Value::Bool(true).as_tuplable().is_none());
Trait Implementations
A Rust enum value
Examples
use valuable::{Value, Valuable};
#[derive(Valuable)]
enum MyEnum {
Foo,
Bar,
}
let my_enum = MyEnum::Foo;
let v = Value::Enumerable(&my_enum);
Performs the conversion.
A Rust error value
Examples
use valuable::Value;
use std::io;
let err: io::Error = io::ErrorKind::Other.into();
let v = Value::Error(&err);
A Rust list value
Examples
use valuable::Value;
let vals = vec![1, 2, 3, 4, 5];
let v = Value::Listable(&vals);
A Rust map value
Examples
use valuable::Value;
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("foo", 1);
map.insert("bar", 2);
let v = Value::Mappable(&map);
A Rust struct value
Examples
use valuable::{Value, Valuable};
#[derive(Valuable)]
struct MyStruct {
field: u32,
}
let my_struct = MyStruct {
field: 123,
};
let v = Value::Structable(&my_struct);
Performs the conversion.
A tuple value
Examples
use valuable::{Value, Valuable};
let my_tuple = (123, 456);
let v = Value::Tuplable(&my_tuple);
A Rust &Path
value
Examples
use valuable::Value;
use std::path::Path;
let path = Path::new("a.txt");
let v = Value::Path(path);
Calls Visit::visit_primitive_slice()
with self
. Read more
Auto Trait Implementations
impl<'a> !RefUnwindSafe for Value<'a>
impl<'a> !UnwindSafe for Value<'a>
Blanket Implementations
Mutably borrows from an owned value. Read more