| use crate::{Enumerable, Listable, Mappable, Structable, Tuplable, Valuable, Visit}; |
| |
| use core::fmt; |
| |
| macro_rules! value { |
| ( |
| $( |
| $(#[$attrs:meta])* |
| $variant:ident($ty:ty), |
| )* |
| ) => { |
| /// Any Rust value |
| /// |
| /// The `Value` enum is used to pass single values to the |
| /// [visitor][`Visit`]. 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), |
| /// ); |
| /// ``` |
| /// |
| /// [visitor]: Visit |
| #[non_exhaustive] |
| #[derive(Clone, Copy)] |
| pub enum Value<'a> { |
| $( |
| $(#[$attrs])* |
| $variant($ty), |
| )* |
| |
| /// A Rust `()` or `None` value. |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::Unit; |
| /// ``` |
| Unit, |
| } |
| |
| $( |
| $(#[$attrs])* |
| impl<'a> From<$ty> for Value<'a> { |
| fn from(src: $ty) -> Value<'a> { |
| Value::$variant(src) |
| } |
| } |
| )* |
| |
| impl<'a> From<()> for Value<'a> { |
| fn from(_: ()) -> Value<'a> { |
| Value::Tuplable(&()) |
| } |
| } |
| |
| impl fmt::Debug for Value<'_> { |
| fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { |
| use Value::*; |
| |
| // Doc comments are expanded into the branch arms, which results |
| // in a warning. It isn't a big deal, so silence it. |
| #[allow(unused_doc_comments)] |
| match self { |
| $( |
| $(#[$attrs])* |
| $variant(v) => fmt::Debug::fmt(v, fmt), |
| )* |
| Unit => ().fmt(fmt), |
| } |
| } |
| } |
| } |
| } |
| |
| value! { |
| /// A Rust `bool` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::Bool(true); |
| /// ``` |
| Bool(bool), |
| |
| /// A Rust `char` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::Char('h'); |
| /// ``` |
| Char(char), |
| |
| /// A Rust `f32` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::F32(3.1415); |
| /// ``` |
| F32(f32), |
| |
| /// A Rust `f64` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::F64(3.1415); |
| /// ``` |
| F64(f64), |
| |
| /// A Rust `i8` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::I8(42); |
| /// ``` |
| I8(i8), |
| |
| /// A Rust `i16` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::I16(42); |
| /// ``` |
| I16(i16), |
| |
| /// A Rust `i32` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::I32(42); |
| /// ``` |
| I32(i32), |
| |
| /// A Rust `i64` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::I64(42); |
| /// ``` |
| I64(i64), |
| |
| /// A Rust `i128` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::I128(42); |
| /// ``` |
| I128(i128), |
| |
| /// A Rust `isize` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::Isize(42); |
| /// ``` |
| Isize(isize), |
| |
| /// A Rust `&str` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::String("hello"); |
| /// ``` |
| String(&'a str), |
| |
| /// A Rust `u8` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::U8(42); |
| /// ``` |
| U8(u8), |
| |
| /// A Rust `u16` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::U16(42); |
| /// ``` |
| U16(u16), |
| |
| /// A Rust `u32` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::U32(42); |
| /// ``` |
| U32(u32), |
| |
| /// A Rust `u64` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::U64(42); |
| /// ``` |
| U64(u64), |
| |
| /// A Rust `u128` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::U128(42); |
| /// ``` |
| U128(u128), |
| |
| /// A Rust `usize` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let v = Value::Usize(42); |
| /// ``` |
| Usize(usize), |
| |
| /// A Rust `&Path` value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// use std::path::Path; |
| /// |
| /// let path = Path::new("a.txt"); |
| /// let v = Value::Path(path); |
| /// ``` |
| #[cfg(feature = "std")] |
| Path(&'a std::path::Path), |
| |
| /// A Rust error value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// use std::io; |
| /// |
| /// let err: io::Error = io::ErrorKind::Other.into(); |
| /// let v = Value::Error(&err); |
| /// ``` |
| #[cfg(feature = "std")] |
| Error(&'a (dyn std::error::Error +'static)), |
| |
| /// A Rust list value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::Value; |
| /// |
| /// let vals = vec![1, 2, 3, 4, 5]; |
| /// let v = Value::Listable(&vals); |
| /// ``` |
| Listable(&'a dyn Listable), |
| |
| /// 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); |
| /// ``` |
| Mappable(&'a dyn Mappable), |
| |
| /// 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); |
| /// ``` |
| Structable(&'a dyn Structable), |
| |
| /// 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); |
| /// ``` |
| Enumerable(&'a dyn Enumerable), |
| |
| /// A tuple value |
| /// |
| /// # Examples |
| /// |
| /// ``` |
| /// use valuable::{Value, Valuable}; |
| /// |
| /// let my_tuple = (123, 456); |
| /// let v = Value::Tuplable(&my_tuple); |
| /// ``` |
| Tuplable(&'a dyn Tuplable), |
| } |
| |
| impl Valuable for Value<'_> { |
| fn as_value(&self) -> Value<'_> { |
| *self |
| } |
| |
| fn visit(&self, visit: &mut dyn Visit) { |
| visit.visit_value(*self); |
| } |
| } |
| |
| impl Default for Value<'_> { |
| fn default() -> Self { |
| Value::Unit |
| } |
| } |
| |
| macro_rules! convert { |
| ( |
| $( |
| $(#[$attrs:meta])* |
| $ty:ty => $as:ident, |
| )* |
| ) => { |
| impl<'a> Value<'a> { |
| /// 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); |
| /// ``` |
| pub fn as_bool(&self) -> Option<bool> { |
| match *self { |
| Value::Bool(v) => Some(v), |
| _ => 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); |
| /// ``` |
| pub fn as_char(&self) -> Option<char> { |
| match *self { |
| Value::Char(v) => Some(v), |
| _ => 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); |
| /// ``` |
| pub fn as_f32(&self) -> Option<f32> { |
| match *self { |
| Value::F32(v) => Some(v), |
| _ => 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); |
| /// ``` |
| pub fn as_f64(&self) -> Option<f64> { |
| match *self { |
| Value::F64(v) => Some(v), |
| _ => None, |
| } |
| } |
| |
| $( |
| $(#[$attrs])* |
| pub fn $as(&self) -> Option<$ty> { |
| use Value::*; |
| use core::convert::TryInto; |
| |
| match *self { |
| I8(v) => v.try_into().ok(), |
| I16(v) => v.try_into().ok(), |
| I32(v) => v.try_into().ok(), |
| I64(v) => v.try_into().ok(), |
| I128(v) => v.try_into().ok(), |
| Isize(v) => v.try_into().ok(), |
| U8(v) => v.try_into().ok(), |
| U16(v) => v.try_into().ok(), |
| U32(v) => v.try_into().ok(), |
| U64(v) => v.try_into().ok(), |
| U128(v) => v.try_into().ok(), |
| Usize(v) => v.try_into().ok(), |
| _ => 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); |
| /// ``` |
| pub fn as_str(&self) -> Option<&str> { |
| match *self { |
| Value::String(v) => Some(v), |
| _ => None, |
| } |
| } |
| |
| /// 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()); |
| /// ``` |
| #[cfg(feature = "std")] |
| pub fn as_path(&self) -> Option<&std::path::Path> { |
| match *self { |
| Value::Path(v) => Some(v), |
| _ => None, |
| } |
| } |
| |
| /// 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()); |
| /// ``` |
| #[cfg(feature = "std")] |
| pub fn as_error(&self) -> Option<&(dyn std::error::Error + 'static)> { |
| match *self { |
| Value::Error(v) => Some(v), |
| _ => 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()); |
| /// ``` |
| pub fn as_listable(&self) -> Option<&dyn Listable> { |
| match *self { |
| Value::Listable(v) => Some(v), |
| _ => 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()); |
| /// ``` |
| pub fn as_mappable(&self) -> Option<&dyn Mappable> { |
| match *self { |
| Value::Mappable(v) => Some(v), |
| _ => 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()); |
| /// ``` |
| pub fn as_structable(&self) -> Option<&dyn Structable> { |
| match *self { |
| Value::Structable(v) => Some(v), |
| _ => 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()); |
| /// ``` |
| pub fn as_enumerable(&self) -> Option<&dyn Enumerable> { |
| match *self { |
| Value::Enumerable(v) => Some(v), |
| _ => 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()); |
| /// ``` |
| pub fn as_tuplable(&self) -> Option<&dyn Tuplable> { |
| match *self { |
| Value::Tuplable(v) => Some(v), |
| _ => None, |
| } |
| } |
| } |
| } |
| } |
| |
| convert! { |
| /// 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); |
| /// ``` |
| i8 => as_i8, |
| |
| /// 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); |
| /// ``` |
| i16 => as_i16, |
| |
| /// 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); |
| /// ``` |
| i32 => as_i32, |
| |
| /// 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); |
| /// ``` |
| i64 => as_i64, |
| |
| /// 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); |
| /// ``` |
| i128 => as_i128, |
| |
| /// 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); |
| /// ``` |
| isize => as_isize, |
| |
| /// 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); |
| /// ``` |
| u8 => as_u8, |
| |
| /// 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); |
| /// ``` |
| u16 => as_u16, |
| |
| /// 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); |
| /// ``` |
| u32 => as_u32, |
| |
| /// 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); |
| /// ``` |
| u64 => as_u64, |
| |
| /// 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); |
| /// ``` |
| u128 => as_u128, |
| |
| /// 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); |
| /// ``` |
| usize => as_usize, |
| } |
