Enum ValueType 

pub enum ValueType {
    List(Box<ValueType>),
    Map(Box<ValueType>),
    Optional(Box<ValueType>),
    Primitive(PrimitiveType),
    Text,
    Custom,
}

Represents value types (primitive or complex). Assumes that complex types will contain the same inner type and does not vary

Variants

List(Box<ValueType>)

Map(Box<ValueType>)

Optional(Box<ValueType>)

Primitive(PrimitiveType)

Text

Custom

Implementations

impl ValueType

pub fn is_primitive_type(&self) -> bool

pub fn to_primitive_type(&self) -> Option<PrimitiveType>

pub fn from_type_name(name: &str) -> Result<Self, ParseError>

Constructs a value type from a Rust-based type string similar to what you would find from std::any::type_name

Examples

use entity::{ValueType as VT, PrimitiveType as PVT, NumberType as NT};

assert_eq!(
    VT::from_type_name("u8").expect("one"),
    VT::Primitive(PVT::Number(NT::U8)),
);

assert_eq!(
    VT::from_type_name("std::vec::Vec<std::string::String>").expect("two"),
    VT::List(Box::from(VT::Text)),
);

assert_eq!(
    VT::from_type_name("Vec<Option<u8>>").expect("three"),
    VT::List(Box::from(VT::Optional(Box::from(VT::Primitive(PVT::Number(NT::U8)))))),
);

assert_eq!(
    VT::from_type_name("HashMap<String, u8>").expect("four"),
    VT::Map(Box::from(VT::Primitive(PVT::Number(NT::U8)))),
);

Trait Implementations

impl Clone for ValueType

fn clone(&self) -> ValueType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ValueType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ValueType

fn default() -> Self

Returns default value type of primitive unit

impl Display for ValueType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<&'a Value> for ValueType

fn from(v: &'a Value) -> Self

Produces the type of the referenced value by recursively iterating through complex types, assuming that the first value in types like list represent the entire set, defaulting to a primitive unit if a complex value does not have any items

impl From<NumberType> for ValueType

fn from(t: NumberType) -> Self

Converts number type (subclass of primitive type) to a value type

impl From<PrimitiveType> for ValueType

fn from(t: PrimitiveType) -> Self

Converts primitive value type to a value type

impl From<Value> for ValueType

fn from(value: Value) -> Self

Converts to this type from the input type.

impl FromStr for ValueType

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string delimited by colons into a nested value type

Examples

use entity::{ValueType as VT, PrimitiveType as PVT, NumberType as NT};
use strum::ParseError;
use std::str::FromStr;

assert_eq!(VT::from_str("char").unwrap(), VT::Primitive(PVT::Char));
assert_eq!(VT::from_str("u32").unwrap(), VT::Primitive(PVT::Number(NT::U32)));
assert_eq!(VT::from_str("number:u32").unwrap(), VT::Primitive(PVT::Number(NT::U32)));
assert_eq!(VT::from_str("primitive:number:u32").unwrap(), VT::Primitive(PVT::Number(NT::U32)));
assert_eq!(VT::from_str("list:u32").unwrap(), VT::List(Box::from(VT::Primitive(PVT::Number(NT::U32)))));
assert_eq!(VT::from_str("list:number:u32").unwrap(), VT::List(Box::from(VT::Primitive(PVT::Number(NT::U32)))));
assert_eq!(VT::from_str("list:primitive:number:u32").unwrap(), VT::List(Box::from(VT::Primitive(PVT::Number(NT::U32)))));
assert_eq!(VT::from_str("unknown").unwrap_err(), ParseError::VariantNotFound);

type Err = ParseError

The associated error which can be returned from parsing.

impl PartialEq for ValueType

fn eq(&self, other: &ValueType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ValueType

impl StructuralPartialEq for ValueType