Cleanups; make as_float etc return Float, add as_f32 etc

This commit is contained in:
Tony Garnock-Jones 2021-06-30 10:10:38 +02:00
parent 3156180601
commit fc8709706c
7 changed files with 101 additions and 67 deletions

View File

@ -103,12 +103,12 @@ impl<'r, 'de, 'a, R: Reader<'de>> serde::de::Deserializer<'de> for &'a mut Deser
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
visitor.visit_f32(self.read.next_float()?)
visitor.visit_f32(self.read.next_f32()?)
}
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
visitor.visit_f64(self.read.next_double()?)
visitor.visit_f64(self.read.next_f64()?)
}
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>

View File

@ -164,18 +164,18 @@ mod value_tests {
#[test] fn float_mut() {
let mut f = VV::from(1.0f32);
assert!(f.is_float());
*(f.as_float_mut().unwrap()) = 123.45;
assert!(f.is_f32());
*(f.as_f32_mut().unwrap()) = 123.45;
assert_eq!(f, VV::from(123.45f32));
assert_eq!((f.as_float().unwrap() - 123.45f32).abs() < std::f32::EPSILON, true);
assert_eq!((f.as_f32().unwrap() - 123.45f32).abs() < std::f32::EPSILON, true);
}
#[test] fn double_mut() {
let mut f = VV::from(1.0);
assert!(f.is_double());
*(f.as_double_mut().unwrap()) = 123.45;
assert!(f.is_f64());
*(f.as_f64_mut().unwrap()) = 123.45;
assert_eq!(f, VV::from(123.45));
assert_eq!((f.as_double().unwrap() - 123.45).abs() < std::f64::EPSILON, true);
assert_eq!((f.as_f64().unwrap() - 123.45).abs() < std::f64::EPSILON, true);
}
#[test] fn signedinteger_mut() {

View File

@ -118,17 +118,17 @@ impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut Deserializer<'de>
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
match self.input.value().as_double() {
match self.input.value().as_f64() {
Some(d) => visitor.visit_f32(d as f32),
None => visitor.visit_f32(self.input.value().to_float()?),
None => visitor.visit_f32(self.input.value().to_f32()?),
}
}
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
{
match self.input.value().as_float() {
match self.input.value().as_f32() {
Some(f) => visitor.visit_f64(f as f64),
None => visitor.visit_f64(self.input.value().to_double()?),
None => visitor.visit_f64(self.input.value().to_f64()?),
}
}

View File

@ -16,6 +16,8 @@ pub use reader::Reader;
pub use repr::AnnotatedValue;
pub use repr::ArcValue;
pub use repr::Domain;
pub use repr::Double;
pub use repr::Float;
pub use repr::IOValue;
pub use repr::Map;
pub use repr::NestedValue;

View File

@ -401,7 +401,7 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
fn next_u64(&mut self) -> ReaderResult<u64> { self.next_unsigned(|n| n.to_u64()) }
fn next_u128(&mut self) -> ReaderResult<u128> { self.next_unsigned(|n| n.to_u128()) }
fn next_float(&mut self) -> ReaderResult<f32> {
fn next_f32(&mut self) -> ReaderResult<f32> {
match self.peek_next_nonannotation_tag()? {
Tag::Float => {
self.skip()?;
@ -419,7 +419,7 @@ impl<'de, S: BinarySource<'de>> Reader<'de> for PackedReader<'de, S> {
}
}
fn next_double(&mut self) -> ReaderResult<f64> {
fn next_f64(&mut self) -> ReaderResult<f64> {
match self.peek_next_nonannotation_tag()? {
Tag::Float => {
self.skip()?;

View File

@ -41,8 +41,8 @@ pub trait Reader<'de> {
fn next_u64(&mut self) -> ReaderResult<u64> { self.demand_next(false)?.value().to_u64() }
fn next_i128(&mut self) -> ReaderResult<i128> { self.demand_next(false)?.value().to_i128() }
fn next_u128(&mut self) -> ReaderResult<u128> { self.demand_next(false)?.value().to_u128() }
fn next_float(&mut self) -> ReaderResult<f32> { self.demand_next(false)?.value().to_float() }
fn next_double(&mut self) -> ReaderResult<f64> { self.demand_next(false)?.value().to_double() }
fn next_f32(&mut self) -> ReaderResult<f32> { self.demand_next(false)?.value().to_f32() }
fn next_f64(&mut self) -> ReaderResult<f64> { self.demand_next(false)?.value().to_f64() }
fn next_char(&mut self) -> ReaderResult<char> { self.demand_next(false)?.value().to_char() }
fn next_str(&mut self) -> ReaderResult<Cow<'de, str>> {

View File

@ -242,13 +242,13 @@ impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
Value::Float(Float(v)) => write!(f, "{:?}f", v),
Value::Double(Double(v)) => write!(f, "{:?}", v),
Value::SignedInteger(v) => write!(f, "{}", v),
Value::String(ref v) => write!(f, "{:?}", v), // TODO: proper escaping!
Value::ByteString(ref v) => {
Value::String(v) => write!(f, "{:?}", v), // TODO: proper escaping!
Value::ByteString(v) => {
f.write_str("#x\"")?;
for b in v { write!(f, "{:02x}", b)? }
f.write_str("\"")
}
Value::Symbol(ref v) => {
Value::Symbol(v) => {
// TODO: proper escaping!
if v.is_empty() {
f.write_str("||")
@ -256,7 +256,7 @@ impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
write!(f, "{}", v)
}
}
Value::Record(ref r) => {
Value::Record(r) => {
f.write_str("<")?;
r.label().fmt(f)?;
for v in r.fields() {
@ -265,13 +265,13 @@ impl<N: NestedValue<D>, D: Domain> Debug for Value<N, D> {
}
f.write_str(">")
}
Value::Sequence(ref v) => v.fmt(f),
Value::Set(ref v) => {
Value::Sequence(v) => v.fmt(f),
Value::Set(v) => {
f.write_str("#")?;
f.debug_set().entries(v.iter()).finish()
}
Value::Dictionary(ref v) => f.debug_map().entries(v.iter()).finish(),
Value::Domain(ref d) => write!(f, "#!{:?}", d),
Value::Dictionary(v) => f.debug_map().entries(v.iter()).finish(),
Value::Domain(d) => write!(f, "#!{:?}", d),
}
}
}
@ -292,15 +292,15 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_boolean(&self) -> Option<bool> {
if let Value::Boolean(b) = *self {
Some(b)
if let Value::Boolean(b) = self {
Some(*b)
} else {
None
}
}
pub fn as_boolean_mut(&mut self) -> Option<&mut bool> {
if let Value::Boolean(ref mut b) = *self {
if let Value::Boolean(b) = self {
Some(b)
} else {
None
@ -315,56 +315,88 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
self.as_float().is_some()
}
pub fn as_float(&self) -> Option<f32> {
if let Value::Float(Float(f)) = *self {
pub fn as_float(&self) -> Option<&Float> {
if let Value::Float(f) = self {
Some(f)
} else {
None
}
}
pub fn as_float_mut(&mut self) -> Option<&mut f32> {
if let Value::Float(Float(ref mut f)) = *self {
pub fn as_float_mut(&mut self) -> Option<&mut Float> {
if let Value::Float(f) = self {
Some(f)
} else {
None
}
}
pub fn to_float(&self) -> Result<f32, Error> {
pub fn to_float(&self) -> Result<&Float, Error> {
self.as_float().ok_or_else(|| self.expected(ExpectedKind::Float))
}
pub fn is_f32(&self) -> bool {
self.is_float()
}
pub fn as_f32(&self) -> Option<f32> {
self.as_float().map(|f| f.0)
}
pub fn as_f32_mut(&mut self) -> Option<&mut f32> {
self.as_float_mut().map(|f| &mut f.0)
}
pub fn to_f32(&self) -> Result<f32, Error> {
self.to_float().map(|f| f.0)
}
pub fn is_double(&self) -> bool {
self.as_double().is_some()
}
pub fn as_double(&self) -> Option<f64> {
if let Value::Double(Double(f)) = *self {
pub fn as_double(&self) -> Option<&Double> {
if let Value::Double(f) = self {
Some(f)
} else {
None
}
}
pub fn as_double_mut(&mut self) -> Option<&mut f64> {
if let Value::Double(Double(ref mut f)) = *self {
pub fn as_double_mut(&mut self) -> Option<&mut Double> {
if let Value::Double(f) = self {
Some(f)
} else {
None
}
}
pub fn to_double(&self) -> Result<f64, Error> {
pub fn to_double(&self) -> Result<&Double, Error> {
self.as_double().ok_or_else(|| self.expected(ExpectedKind::Double))
}
pub fn is_f64(&self) -> bool {
self.is_double()
}
pub fn as_f64(&self) -> Option<f64> {
self.as_double().map(|f| f.0)
}
pub fn as_f64_mut(&mut self) -> Option<&mut f64> {
self.as_double_mut().map(|f| &mut f.0)
}
pub fn to_f64(&self) -> Result<f64, Error> {
self.to_double().map(|f| f.0)
}
pub fn is_signedinteger(&self) -> bool {
self.as_signedinteger().is_some()
}
pub fn as_signedinteger(&self) -> Option<&SignedInteger> {
if let Value::SignedInteger(ref n) = *self {
if let Value::SignedInteger(n) = self {
Some(n)
} else {
None
@ -372,7 +404,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_signedinteger_mut(&mut self) -> Option<&mut SignedInteger> {
if let Value::SignedInteger(ref mut n) = *self {
if let Value::SignedInteger(n) = self {
Some(n)
} else {
None
@ -499,7 +531,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_string(&self) -> Option<&String> {
if let Value::String(ref s) = *self {
if let Value::String(s) = self {
Some(s)
} else {
None
@ -507,7 +539,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_string_mut(&mut self) -> Option<&mut String> {
if let Value::String(ref mut s) = *self {
if let Value::String(s) = self {
Some(s)
} else {
None
@ -523,7 +555,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_bytestring(&self) -> Option<&Vec<u8>> {
if let Value::ByteString(ref s) = *self {
if let Value::ByteString(s) = self {
Some(s)
} else {
None
@ -531,7 +563,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_bytestring_mut(&mut self) -> Option<&mut Vec<u8>> {
if let Value::ByteString(ref mut s) = *self {
if let Value::ByteString(s) = self {
Some(s)
} else {
None
@ -551,7 +583,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_symbol(&self) -> Option<&String> {
if let Value::Symbol(ref s) = *self {
if let Value::Symbol(s) = self {
Some(s)
} else {
None
@ -559,7 +591,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_symbol_mut(&mut self) -> Option<&mut String> {
if let Value::Symbol(ref mut s) = *self {
if let Value::Symbol(s) = self {
Some(s)
} else {
None
@ -581,7 +613,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_record(&self, arity: Option<usize>) -> Option<&Record<N>> {
if let Value::Record(ref r) = *self {
if let Value::Record(r) = self {
match arity {
Some(expected) if r.arity() == expected => Some(r),
Some(_other) => None,
@ -593,7 +625,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_record_mut(&mut self, arity: Option<usize>) -> Option<&mut Record<N>> {
if let Value::Record(ref mut r) = *self {
if let Value::Record(r) = self {
match arity {
Some(expected) if r.arity() == expected => Some(r),
Some(_other) => None,
@ -629,7 +661,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
pub fn as_simple_record(&self, label: &str, arity: Option<usize>) -> Option<&[N]> {
self.as_record(arity).and_then(|r| {
match r.label().value() {
Value::Symbol(ref s) if s == label => Some(r.fields()),
Value::Symbol(s) if s == label => Some(r.fields()),
_ => None
}
})
@ -657,7 +689,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_sequence(&self) -> Option<&Vec<N>> {
if let Value::Sequence(ref s) = *self {
if let Value::Sequence(s) = self {
Some(s)
} else {
None
@ -665,7 +697,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_sequence_mut(&mut self) -> Option<&mut Vec<N>> {
if let Value::Sequence(ref mut s) = *self {
if let Value::Sequence(s) = self {
Some(s)
} else {
None
@ -681,7 +713,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_set(&self) -> Option<&Set<N>> {
if let Value::Set(ref s) = *self {
if let Value::Set(s) = self {
Some(s)
} else {
None
@ -689,7 +721,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_set_mut(&mut self) -> Option<&mut Set<N>> {
if let Value::Set(ref mut s) = *self {
if let Value::Set(s) = self {
Some(s)
} else {
None
@ -705,7 +737,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_dictionary(&self) -> Option<&Map<N, N>> {
if let Value::Dictionary(ref s) = *self {
if let Value::Dictionary(s) = self {
Some(s)
} else {
None
@ -713,7 +745,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_dictionary_mut(&mut self) -> Option<&mut Map<N, N>> {
if let Value::Dictionary(ref mut s) = *self {
if let Value::Dictionary(s) = self {
Some(s)
} else {
None
@ -729,7 +761,7 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
}
pub fn as_embedded(&self) -> Option<&D> {
if let Value::Domain(ref d) = *self {
if let Value::Domain(d) = self {
Some(d)
} else {
None
@ -748,18 +780,18 @@ impl<N: NestedValue<D>, D: Domain> Value<N, D> {
Value::Boolean(b) => Value::Boolean(*b),
Value::Float(f) => Value::Float(f.clone()),
Value::Double(d) => Value::Double(d.clone()),
Value::SignedInteger(ref n) => Value::SignedInteger(n.clone()),
Value::String(ref s) => Value::String(s.clone()),
Value::ByteString(ref v) => Value::ByteString(v.clone()),
Value::Symbol(ref v) => Value::Symbol(v.clone()),
Value::Record(ref r) =>
Value::SignedInteger(n) => Value::SignedInteger(n.clone()),
Value::String(s) => Value::String(s.clone()),
Value::ByteString(v) => Value::ByteString(v.clone()),
Value::Symbol(v) => Value::Symbol(v.clone()),
Value::Record(r) =>
Value::Record(Record(r.fields_vec().iter().map(|a| a.copy_via(f))
.collect::<Result<Vec<_>, _>>()?)),
Value::Sequence(ref v) => Value::Sequence(v.iter().map(|a| a.copy_via(f))
Value::Sequence(v) => Value::Sequence(v.iter().map(|a| a.copy_via(f))
.collect::<IOResult<Vec<_>>>()?),
Value::Set(ref v) => Value::Set(v.iter().map(|a| a.copy_via(f))
Value::Set(v) => Value::Set(v.iter().map(|a| a.copy_via(f))
.collect::<IOResult<Set<_>>>()?),
Value::Dictionary(ref v) =>
Value::Dictionary(v) =>
Value::Dictionary(v.iter().map(|(a,b)| Ok((a.copy_via(f)?, b.copy_via(f)?)))
.collect::<IOResult<Map<_, _>>>()?),
Value::Domain(d) => f(d)?,
@ -833,9 +865,9 @@ impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
}
pub fn maybe_slice(&self) -> Option<&[N]> {
match self.0 {
match &self.0 {
None => None,
Some(ref b) => Some(&&b[..]),
Some(b) => Some(&b[..]),
}
}
@ -857,10 +889,10 @@ impl<N: NestedValue<D>, D: Domain> Annotations<N, D> {
where
F: Fn(&D) -> IOResult<Value<M, E>>
{
Ok(match self.0 {
Ok(match &self.0 {
None =>
Annotations(None, PhantomData),
Some(ref b) =>
Some(b) =>
Annotations(Some(b.iter().map(|a| a.copy_via(f)).collect::<Result<Vec<_>, _>>()?),
PhantomData),
})