Fix clippyisms
This commit is contained in:
parent
ccc3b5780b
commit
488bfdc59c
|
@ -12,7 +12,7 @@ impl serde::Serialize for Symbol {
|
||||||
impl<'de> serde::Deserialize<'de> for Symbol {
|
impl<'de> serde::Deserialize<'de> for Symbol {
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
||||||
let v = PlainValue::deserialize(deserializer)?;
|
let v = PlainValue::deserialize(deserializer)?;
|
||||||
let s = v.value().as_symbol().ok_or(serde::de::Error::custom("Expected symbol"))?;
|
let s = v.value().as_symbol().ok_or_else(|| serde::de::Error::custom("Expected symbol"))?;
|
||||||
Ok(Symbol(s.clone()))
|
Ok(Symbol(s.clone()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -54,10 +54,7 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
self.deserialize_unit(visitor)
|
self.deserialize_unit(visitor)
|
||||||
} else if v.is_simple_record("UnicodeScalar", Some(1)) {
|
} else if v.is_simple_record("UnicodeScalar", Some(1)) {
|
||||||
self.deserialize_char(visitor)
|
self.deserialize_char(visitor)
|
||||||
} else
|
} else if v.is_simple_record("None", Some(0)) || v.is_simple_record("Some", Some(1)) {
|
||||||
if v.is_simple_record("None", Some(0)) ||
|
|
||||||
v.is_simple_record("Some", Some(1))
|
|
||||||
{
|
|
||||||
self.deserialize_option(visitor)
|
self.deserialize_option(visitor)
|
||||||
} else if v.is_simple_record("tuple", None) {
|
} else if v.is_simple_record("tuple", None) {
|
||||||
visitor.visit_seq(VecSeq::new(self, v.as_simple_record("tuple", None).unwrap()))
|
visitor.visit_seq(VecSeq::new(self, v.as_simple_record("tuple", None).unwrap()))
|
||||||
|
@ -78,49 +75,49 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_i8(i.to_i8().ok_or(Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_i8(i.to_i8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_i16(i.to_i16().ok_or(Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_i16(i.to_i16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_i32(i.to_i32().ok_or(Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_i32(i.to_i32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_i64(i.to_i64().ok_or(Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_i64(i.to_i64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_u8(i.to_u8().ok_or(Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_u8(i.to_u8().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_u16(i.to_u16().ok_or(Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_u16(i.to_u16().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_u32(i.to_u32().ok_or(Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_u32(i.to_u32().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
{
|
{
|
||||||
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
let i = self.check(|v| v.as_signedinteger(), ExpectedKind::SignedInteger)?;
|
||||||
visitor.visit_u64(i.to_u64().ok_or(Error::NumberTooLarge(i.clone()))?)
|
visitor.visit_u64(i.to_u64().ok_or_else(|| Error::NumberTooLarge(i.clone()))?)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
|
||||||
|
@ -269,12 +266,12 @@ impl<'de, 'a, N: NestedValue> serde::de::Deserializer<'de> for &'a mut Deseriali
|
||||||
|
|
||||||
pub struct VecSeq<'a, 'de: 'a, N: NestedValue> {
|
pub struct VecSeq<'a, 'de: 'a, N: NestedValue> {
|
||||||
index: usize,
|
index: usize,
|
||||||
vec: &'de Vec<N>,
|
vec: &'de [N],
|
||||||
de: &'a mut Deserializer<'de, N>,
|
de: &'a mut Deserializer<'de, N>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue> VecSeq<'a, 'de, N> {
|
impl<'de, 'a, N: NestedValue> VecSeq<'a, 'de, N> {
|
||||||
fn new(de: &'a mut Deserializer<'de, N>, vec: &'de Vec<N>) -> Self {
|
fn new(de: &'a mut Deserializer<'de, N>, vec: &'de [N]) -> Self {
|
||||||
VecSeq{ index: 0, vec, de }
|
VecSeq{ index: 0, vec, de }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -290,7 +287,7 @@ impl<'de, 'a, N: NestedValue> SeqAccess<'de> for VecSeq<'a, 'de, N> {
|
||||||
}
|
}
|
||||||
|
|
||||||
self.de.input = &self.vec[self.index];
|
self.de.input = &self.vec[self.index];
|
||||||
self.index = self.index + 1;
|
self.index += 1;
|
||||||
let value = seed.deserialize(&mut *self.de)?;
|
let value = seed.deserialize(&mut *self.de)?;
|
||||||
Ok(Some(value))
|
Ok(Some(value))
|
||||||
}
|
}
|
||||||
|
@ -304,7 +301,7 @@ pub struct DictMap<'a, 'de: 'a, N: NestedValue> {
|
||||||
|
|
||||||
impl<'de, 'a, N: NestedValue> DictMap<'a, 'de, N> {
|
impl<'de, 'a, N: NestedValue> DictMap<'a, 'de, N> {
|
||||||
fn new(de: &'a mut Deserializer<'de, N>, d: &'de Map<N, N>) -> Self {
|
fn new(de: &'a mut Deserializer<'de, N>, d: &'de Map<N, N>) -> Self {
|
||||||
DictMap{ pending: None, iter: Box::new(d.into_iter()), de }
|
DictMap{ pending: None, iter: Box::new(d.iter()), de }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -50,10 +50,17 @@ impl Error {
|
||||||
|
|
||||||
pub type DecodePlaceholderMap<N> = Map<usize, Value<N>>;
|
pub type DecodePlaceholderMap<N> = Map<usize, Value<N>>;
|
||||||
|
|
||||||
|
#[derive(PartialEq, Eq)]
|
||||||
|
enum PeekState {
|
||||||
|
Empty,
|
||||||
|
Eof,
|
||||||
|
Full(u8),
|
||||||
|
}
|
||||||
|
|
||||||
pub struct Decoder<'a, 'b, R: Read, N: NestedValue> {
|
pub struct Decoder<'a, 'b, R: Read, N: NestedValue> {
|
||||||
read: &'a mut R,
|
read: &'a mut R,
|
||||||
index: usize,
|
index: usize,
|
||||||
buf: Box<Option<Option<u8>>>,
|
buf: Box<PeekState>,
|
||||||
placeholders: Option<&'b DecodePlaceholderMap<N>>,
|
placeholders: Option<&'b DecodePlaceholderMap<N>>,
|
||||||
read_annotations: bool,
|
read_annotations: bool,
|
||||||
}
|
}
|
||||||
|
@ -67,46 +74,47 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
|
||||||
Decoder{
|
Decoder{
|
||||||
read,
|
read,
|
||||||
index: 0,
|
index: 0,
|
||||||
buf: Box::new(None),
|
buf: Box::new(PeekState::Empty),
|
||||||
placeholders,
|
placeholders,
|
||||||
read_annotations: true,
|
read_annotations: true,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn set_read_annotations(&mut self, read_annotations: bool) -> () {
|
pub fn set_read_annotations(&mut self, read_annotations: bool) {
|
||||||
self.read_annotations = read_annotations
|
self.read_annotations = read_annotations
|
||||||
}
|
}
|
||||||
|
|
||||||
fn prime(&mut self) -> Result<()> {
|
fn prime(&mut self) -> Result<()> {
|
||||||
match *self.buf {
|
match *self.buf {
|
||||||
None => {
|
PeekState::Empty => {
|
||||||
let bs = &mut [0];
|
let bs = &mut [0];
|
||||||
*self.buf = Some(match self.read.read(bs)? {
|
*self.buf = match self.read.read(bs)? {
|
||||||
0 => None,
|
0 => PeekState::Eof,
|
||||||
1 => {
|
1 => {
|
||||||
self.index = self.index + 1;
|
self.index += 1;
|
||||||
Some(bs[0])
|
PeekState::Full(bs[0])
|
||||||
},
|
},
|
||||||
_ => panic!("buffer overrun")
|
_ => panic!("buffer overrun")
|
||||||
})
|
|
||||||
}
|
}
|
||||||
Some(_) => ()
|
}
|
||||||
|
PeekState::Eof => (),
|
||||||
|
PeekState::Full(_) => (),
|
||||||
}
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn skip(&mut self) -> Result<()> {
|
pub fn skip(&mut self) -> Result<()> {
|
||||||
self.prime()?;
|
self.prime()?;
|
||||||
*self.buf = None;
|
*self.buf = PeekState::Empty;
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn peek(&mut self) -> Result<u8> {
|
pub fn peek(&mut self) -> Result<u8> {
|
||||||
self.prime()?;
|
self.prime()?;
|
||||||
match *self.buf {
|
match *self.buf {
|
||||||
Some(Some(v)) => Ok(v),
|
PeekState::Full(v) => Ok(v),
|
||||||
Some(None) => Err(Error::Eof),
|
PeekState::Eof => Err(Error::Eof),
|
||||||
None => unreachable!()
|
PeekState::Empty => unreachable!()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -117,7 +125,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn readbytes(&mut self, n: usize) -> Result<Vec<u8>> {
|
pub fn readbytes(&mut self, n: usize) -> Result<Vec<u8>> {
|
||||||
if (*self.buf).is_some() {
|
if *self.buf != PeekState::Empty {
|
||||||
unreachable!();
|
unreachable!();
|
||||||
}
|
}
|
||||||
let mut bs = vec![0; n];
|
let mut bs = vec![0; n];
|
||||||
|
@ -139,7 +147,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
|
||||||
let mut pieces: Vec<N> = Vec::with_capacity(count);
|
let mut pieces: Vec<N> = Vec::with_capacity(count);
|
||||||
while count > 0 {
|
while count > 0 {
|
||||||
pieces.push(self.next()?);
|
pieces.push(self.next()?);
|
||||||
count = count - 1;
|
count -= 1;
|
||||||
}
|
}
|
||||||
Ok(pieces)
|
Ok(pieces)
|
||||||
}
|
}
|
||||||
|
@ -190,7 +198,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
|
||||||
pub fn decodecompound(minor: CompoundMinor, mut pieces: Vec<N>) -> Result<N> {
|
pub fn decodecompound(minor: CompoundMinor, mut pieces: Vec<N>) -> Result<N> {
|
||||||
match minor {
|
match minor {
|
||||||
CompoundMinor::Record =>
|
CompoundMinor::Record =>
|
||||||
if pieces.len() == 0 {
|
if pieces.is_empty() {
|
||||||
Err(Error::Syntax("Too few elements in encoded record"))
|
Err(Error::Syntax("Too few elements in encoded record"))
|
||||||
} else {
|
} else {
|
||||||
let label = pieces.remove(0);
|
let label = pieces.remove(0);
|
||||||
|
@ -257,7 +265,7 @@ impl<'a, 'b, R: Read, N: NestedValue> Decoder<'a, 'b, R, N> {
|
||||||
annotations.push(self.next()?);
|
annotations.push(self.next()?);
|
||||||
}
|
}
|
||||||
let v = self.next()?;
|
let v = self.next()?;
|
||||||
assert!(v.annotations().len() == 0);
|
assert!(v.annotations().is_empty());
|
||||||
Ok(N::wrap_ann(annotations, v.value_owned()))
|
Ok(N::wrap_ann(annotations, v.value_owned()))
|
||||||
} else {
|
} else {
|
||||||
self.next()?;
|
self.next()?;
|
||||||
|
|
|
@ -99,19 +99,23 @@ impl<'a, 'b, W: Write, N: NestedValue> Encoder<'a, 'b, W, N> {
|
||||||
Value::Record((ref l, ref fs)) => {
|
Value::Record((ref l, ref fs)) => {
|
||||||
self.write_header(Op::Compound(CompoundMinor::Record), fs.len() + 1)?;
|
self.write_header(Op::Compound(CompoundMinor::Record), fs.len() + 1)?;
|
||||||
self.write(N::boxunwrap(l))?;
|
self.write(N::boxunwrap(l))?;
|
||||||
Ok(for f in fs { self.write(f)?; })
|
for f in fs { self.write(f)?; }
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
Value::Sequence(ref vs) => {
|
Value::Sequence(ref vs) => {
|
||||||
self.write_header(Op::Compound(CompoundMinor::Sequence), vs.len())?;
|
self.write_header(Op::Compound(CompoundMinor::Sequence), vs.len())?;
|
||||||
Ok(for v in vs { self.write(v)?; })
|
for v in vs { self.write(v)?; }
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
Value::Set(ref vs) => {
|
Value::Set(ref vs) => {
|
||||||
self.write_header(Op::Compound(CompoundMinor::Set), vs.len())?;
|
self.write_header(Op::Compound(CompoundMinor::Set), vs.len())?;
|
||||||
Ok(for v in vs { self.write(v)?; })
|
for v in vs { self.write(v)?; }
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
Value::Dictionary(ref vs) => {
|
Value::Dictionary(ref vs) => {
|
||||||
self.write_header(Op::Compound(CompoundMinor::Dictionary), vs.len() << 1)?;
|
self.write_header(Op::Compound(CompoundMinor::Dictionary), vs.len() << 1)?;
|
||||||
Ok(for (k, v) in vs { self.write(k)?; self.write(v)?; })
|
for (k, v) in vs { self.write(k)?; self.write(v)?; }
|
||||||
|
Ok(())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -92,8 +92,8 @@ impl Ord for Float {
|
||||||
fn cmp(&self, other: &Self) -> Ordering {
|
fn cmp(&self, other: &Self) -> Ordering {
|
||||||
let mut a: u32 = self.0.to_bits();
|
let mut a: u32 = self.0.to_bits();
|
||||||
let mut b: u32 = other.0.to_bits();
|
let mut b: u32 = other.0.to_bits();
|
||||||
if a & 0x80000000 != 0 { a ^= 0x7fffffff; }
|
if a & 0x8000_0000 != 0 { a ^= 0x7fff_ffff; }
|
||||||
if b & 0x80000000 != 0 { b ^= 0x7fffffff; }
|
if b & 0x8000_0000 != 0 { b ^= 0x7fff_ffff; }
|
||||||
(a as i32).cmp(&(b as i32))
|
(a as i32).cmp(&(b as i32))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -126,7 +126,7 @@ impl Hash for Double {
|
||||||
|
|
||||||
impl PartialEq for Double {
|
impl PartialEq for Double {
|
||||||
fn eq(&self, other: &Self) -> bool {
|
fn eq(&self, other: &Self) -> bool {
|
||||||
return self.0.to_bits() == other.0.to_bits();
|
self.0.to_bits() == other.0.to_bits()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -134,8 +134,8 @@ impl Ord for Double {
|
||||||
fn cmp(&self, other: &Self) -> Ordering {
|
fn cmp(&self, other: &Self) -> Ordering {
|
||||||
let mut a: u64 = self.0.to_bits();
|
let mut a: u64 = self.0.to_bits();
|
||||||
let mut b: u64 = other.0.to_bits();
|
let mut b: u64 = other.0.to_bits();
|
||||||
if a & 0x8000000000000000 != 0 { a ^= 0x7fffffffffffffff; }
|
if a & 0x8000_0000_0000_0000 != 0 { a ^= 0x7fff_ffff_ffff_ffff; }
|
||||||
if b & 0x8000000000000000 != 0 { b ^= 0x7fffffffffffffff; }
|
if b & 0x8000_0000_0000_0000 != 0 { b ^= 0x7fff_ffff_ffff_ffff; }
|
||||||
(a as i64).cmp(&(b as i64))
|
(a as i64).cmp(&(b as i64))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -153,14 +153,14 @@ impl<N: NestedValue> From<bool> for Value<N> { fn from(v: bool) -> Self { Value:
|
||||||
impl<N: NestedValue> From<f32> for Value<N> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
|
impl<N: NestedValue> From<f32> for Value<N> { fn from(v: f32) -> Self { Value::Float(Float::from(v)) } }
|
||||||
impl<N: NestedValue> From<f64> for Value<N> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
|
impl<N: NestedValue> From<f64> for Value<N> { fn from(v: f64) -> Self { Value::Double(Double::from(v)) } }
|
||||||
|
|
||||||
impl<N: NestedValue> From<u8> for Value<N> { fn from(v: u8) -> Self { Value::from(v as i128) } }
|
impl<N: NestedValue> From<u8> for Value<N> { fn from(v: u8) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<i8> for Value<N> { fn from(v: i8) -> Self { Value::from(v as i128) } }
|
impl<N: NestedValue> From<i8> for Value<N> { fn from(v: i8) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<u16> for Value<N> { fn from(v: u16) -> Self { Value::from(v as i128) } }
|
impl<N: NestedValue> From<u16> for Value<N> { fn from(v: u16) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<i16> for Value<N> { fn from(v: i16) -> Self { Value::from(v as i128) } }
|
impl<N: NestedValue> From<i16> for Value<N> { fn from(v: i16) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<u32> for Value<N> { fn from(v: u32) -> Self { Value::from(v as i128) } }
|
impl<N: NestedValue> From<u32> for Value<N> { fn from(v: u32) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<i32> for Value<N> { fn from(v: i32) -> Self { Value::from(v as i128) } }
|
impl<N: NestedValue> From<i32> for Value<N> { fn from(v: i32) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<u64> for Value<N> { fn from(v: u64) -> Self { Value::from(v as i128) } }
|
impl<N: NestedValue> From<u64> for Value<N> { fn from(v: u64) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<i64> for Value<N> { fn from(v: i64) -> Self { Value::from(v as i128) } }
|
impl<N: NestedValue> From<i64> for Value<N> { fn from(v: i64) -> Self { Value::from(i128::from(v)) } }
|
||||||
impl<N: NestedValue> From<u128> for Value<N> { fn from(v: u128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
|
impl<N: NestedValue> From<u128> for Value<N> { fn from(v: u128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
|
||||||
impl<N: NestedValue> From<i128> for Value<N> { fn from(v: i128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
|
impl<N: NestedValue> From<i128> for Value<N> { fn from(v: i128) -> Self { Value::SignedInteger(BigInt::from(v)) } }
|
||||||
impl<N: NestedValue> From<BigInt> for Value<N> { fn from(v: BigInt) -> Self { Value::SignedInteger(v) } }
|
impl<N: NestedValue> From<BigInt> for Value<N> { fn from(v: BigInt) -> Self { Value::SignedInteger(v) } }
|
||||||
|
@ -193,7 +193,7 @@ impl<N: NestedValue> Debug for Value<N> {
|
||||||
}
|
}
|
||||||
Value::Symbol(ref v) => {
|
Value::Symbol(ref v) => {
|
||||||
// TODO: proper escaping!
|
// TODO: proper escaping!
|
||||||
if v.len() == 0 {
|
if v.is_empty() {
|
||||||
f.write_str("||")
|
f.write_str("||")
|
||||||
} else {
|
} else {
|
||||||
write!(f, "{}", v)
|
write!(f, "{}", v)
|
||||||
|
@ -558,7 +558,7 @@ impl<N: NestedValue> serde::Serialize for Value<N> {
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
|
||||||
let mut buf: Vec<u8> = Vec::new();
|
let mut buf: Vec<u8> = Vec::new();
|
||||||
crate::value::Encoder::new(&mut buf, None).write_value(self)
|
crate::value::Encoder::new(&mut buf, None).write_value(self)
|
||||||
.or(Err(serde::ser::Error::custom("Internal error")))?;
|
.or_else(|_| Err(serde::ser::Error::custom("Internal error")))?;
|
||||||
ValueWrapper(buf).serialize(serializer)
|
ValueWrapper(buf).serialize(serializer)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -567,18 +567,18 @@ impl<'de, N: NestedValue> serde::Deserialize<'de> for Value<N> {
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de> {
|
||||||
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
|
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
|
||||||
let v: N = crate::value::Decoder::new(&mut &buf[..], None).next()
|
let v: N = crate::value::Decoder::new(&mut &buf[..], None).next()
|
||||||
.or(Err(serde::de::Error::custom("Internal error")))?;
|
.or_else(|_| Err(serde::de::Error::custom("Internal error")))?;
|
||||||
Ok(v.value_owned())
|
Ok(v.value_owned())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn serialize_nested_value<'de, S, N>(v: &N, serializer: S) ->
|
pub fn serialize_nested_value<S, N>(v: &N, serializer: S) ->
|
||||||
Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue
|
Result<S::Ok, S::Error> where S: serde::Serializer, N: NestedValue
|
||||||
{
|
{
|
||||||
use serde::Serialize;
|
use serde::Serialize;
|
||||||
let mut buf: Vec<u8> = Vec::new();
|
let mut buf: Vec<u8> = Vec::new();
|
||||||
crate::value::Encoder::new(&mut buf, None).write(v)
|
crate::value::Encoder::new(&mut buf, None).write(v)
|
||||||
.or(Err(serde::ser::Error::custom("Internal error")))?;
|
.or_else(|_| Err(serde::ser::Error::custom("Internal error")))?;
|
||||||
ValueWrapper(buf).serialize(serializer)
|
ValueWrapper(buf).serialize(serializer)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -588,7 +588,7 @@ pub fn deserialize_nested_value<'de, D, N>(deserializer: D) ->
|
||||||
use serde::Deserialize;
|
use serde::Deserialize;
|
||||||
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
|
let ValueWrapper(buf) = ValueWrapper::deserialize(deserializer)?;
|
||||||
crate::value::Decoder::new(&mut &buf[..], None).next()
|
crate::value::Decoder::new(&mut &buf[..], None).next()
|
||||||
.or(Err(serde::de::Error::custom("Internal error")))
|
.or_else(|_| Err(serde::de::Error::custom("Internal error")))
|
||||||
}
|
}
|
||||||
|
|
||||||
//---------------------------------------------------------------------------
|
//---------------------------------------------------------------------------
|
||||||
|
|
Loading…
Reference in New Issue