1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
extern crate core; extern crate alloc; use alloc::string::String; use alloc::vec::Vec; use alloc::collections::btree_map::BTreeMap; use ser::{Serializer, Serialize}; #[derive(Debug, PartialEq, PartialOrd, Ord, Eq, Clone)] pub enum Value { Null, Int(u64), NegativeInt(u64), String(String), Bytes(Vec<u8>), Text(String), Array(Vec<Value>), Map(BTreeMap<Value, Value>), } impl Serialize for Value { fn serialize<S>(&mut self, serializer: &mut S) where S: Serializer { match *self { Value::Int(n) => serializer.serialize_unsigned(n as u64, 0), Value::Bytes(ref bytes) => serializer.serialize_bytes(bytes.to_vec()), Value::String(ref string) => serializer.serialize_string(string), Value::Array(ref mut array) => { serializer.serialize_seq(array.len()); for value in array { value.serialize(serializer); } }, Value::Map(ref mut map) => { serializer.serialize_map(map.len()); for(key, value) in map { key.clone().serialize(serializer); value.serialize(serializer); } }, Value::Null => serializer.serialize_simple(22), _ => unreachable!(), } } } impl Value { pub fn as_array(&self) -> Option<&Vec<Value>> { if let Value::Array(ref v) = *self { Some(v) } else { None } } pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> { if let Value::Array(ref mut v) = *self { Some(v) } else { None } } pub fn as_bytes(&self) -> Option<&Vec<u8>> { if let Value::Bytes(ref v) = *self { Some(v) } else { None } } pub fn as_bytes_mut(&mut self) -> Option<&mut Vec<u8>> { if let Value::Bytes(ref mut v) = *self { Some(v) } else { None } } pub fn as_string(&self) -> Option<&String> { if let Value::String(ref v) = *self { Some(v) } else { None } } pub fn as_string_mut(&mut self) -> Option<&mut String> { if let Value::String(ref mut v) = *self { Some(v) } else { None } } pub fn as_int(&self) -> Option<u64> { match *self { Value::Int(n) => Some(n), _ => None, } } pub fn as_map(&self) -> Option<&BTreeMap<Value, Value>> { if let Value::Map(ref v) = *self { Some(v) } else { None } } pub fn as_map_mut(&mut self) -> Option<&BTreeMap<Value, Value>> { if let Value::Map(ref mut v) = *self { Some(v) } else { None } } } impl From<Value> for BTreeMap<Value, Value> { fn from(mut value: Value) -> BTreeMap<Value, Value> { value.as_map_mut().unwrap().clone() } } impl From<()> for Value { fn from(_value: ()) -> Value { Value::Null } } impl From<u32> for Value { fn from(value: u32) -> Value { Value::Int(value as u64) } } impl From<u64> for Value { fn from(value: u64) -> Value { Value::Int(value as u64) } } impl From<Vec<u8>> for Value { fn from(value: Vec<u8>) -> Value { Value::Bytes(value) } } impl From<BTreeMap<Value, Value>> for Value { fn from(map: BTreeMap<Value, Value>) -> Value { Value::Map(map) } }