signalapp/serde_json
signalapp/serde_json
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format in rfc style

Browse Source
This commit is contained in:
David Tolnay 2017-04-18 14:23:59 -07:00
parent 64bd06cd50
commit 4595e1a7bd
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
13 changed files with 1413 additions and 1296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -1,3 +1,4 @@
.cargo/
Cargo.lock
target/
**/*.rs.bk
*.sw[po]
Cargo.lock

5
rustfmt.toml Normal file
View File

@ -0,0 +1,5 @@
fn_args_layout = "Block"
array_layout = "Block"
where_style = "Rfc"
generics_indent = "Block"
fn_call_style = "Block"

223
src/de.rs
View File

@ -30,7 +30,8 @@ pub struct Deserializer<R> {
}
impl<'de, R> Deserializer<R>
where R: read::Read<'de>
where
R: read::Read<'de>,
{
/// Create a JSON deserializer from one of the possible serde_json input
/// sources.
@ -51,7 +52,8 @@ impl<'de, R> Deserializer<R>
}
impl<I> Deserializer<read::IteratorRead<I>>
where I: Iterator<Item = io::Result<u8>>
where
I: Iterator<Item = io::Result<u8>>,
{
/// Creates a JSON deserializer from a `std::iter::Iterator`.
pub fn from_iter(iter: I) -> Self {
@ -60,7 +62,8 @@ impl<I> Deserializer<read::IteratorRead<I>>
}
impl<R> Deserializer<read::IoRead<R>>
where R: io::Read
where
R: io::Read,
{
/// Creates a JSON deserializer from an `io::Read`.
pub fn from_reader(reader: R) -> Self {
@ -101,7 +104,8 @@ impl<'de, R: Read<'de>> Deserializer<R> {
/// Turn a JSON deserializer into an iterator over values of type T.
pub fn into_iter<T>(self) -> StreamDeserializer<'de, R, T>
where T: de::Deserialize<'de>
where
T: de::Deserialize<'de>,
{
// This cannot be an implementation of std::iter::IntoIterator because
// we need the caller to choose what T is.
@ -162,7 +166,8 @@ impl<'de, R: Read<'de>> Deserializer<R> {
}
fn parse_value<V>(&mut self, visitor: V) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
let peek = match try!(self.parse_whitespace()) {
Some(b) => b,
@ -258,15 +263,14 @@ impl<'de, R: Read<'de>> Deserializer<R> {
}
fn parse_integer<V>(&mut self, pos: bool, visitor: V) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
match try!(self.next_char_or_null()) {
b'0' => {
// There can be only one leading '0'.
match try!(self.peek_or_null()) {
b'0'...b'9' => {
Err(self.peek_error(ErrorCode::InvalidNumber))
}
b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
_ => self.parse_number(pos, 0, visitor),
}
}
@ -283,10 +287,12 @@ impl<'de, R: Read<'de>> Deserializer<R> {
// number as a `u64` until we grow too large. At that point, switch to
// parsing the value as a `f64`.
if overflow!(res * 10 + digit, u64::MAX) {
return self.parse_long_integer(pos,
res,
1, // res * 10^1
visitor);
return self.parse_long_integer(
pos,
res,
1, // res * 10^1
visitor,
);
}
res = res * 10 + digit;
@ -306,9 +312,10 @@ impl<'de, R: Read<'de>> Deserializer<R> {
pos: bool,
significand: u64,
mut exponent: i32,
visitor: V
visitor: V,
) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
loop {
match try!(self.peek_or_null()) {
@ -325,22 +332,15 @@ impl<'de, R: Read<'de>> Deserializer<R> {
return self.parse_exponent(pos, significand, exponent, visitor);
}
_ => {
return self.visit_f64_from_parts(pos,
significand,
exponent,
visitor);
return self.visit_f64_from_parts(pos, significand, exponent, visitor);
}
}
}
}
fn parse_number<V>(
&mut self,
pos: bool,
significand: u64,
visitor: V
) -> Result<V::Value>
where V: de::Visitor<'de>,
fn parse_number<V>(&mut self, pos: bool, significand: u64, visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
match try!(self.peek_or_null()) {
b'.' => self.parse_decimal(pos, significand, 0, visitor),
@ -367,9 +367,10 @@ impl<'de, R: Read<'de>> Deserializer<R> {
pos: bool,
mut significand: u64,
mut exponent: i32,
visitor: V
visitor: V,
) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
self.eat_char();
@ -397,9 +398,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
}
match try!(self.peek_or_null()) {
b'e' | b'E' => {
self.parse_exponent(pos, significand, exponent, visitor)
}
b'e' | b'E' => self.parse_exponent(pos, significand, exponent, visitor),
_ => self.visit_f64_from_parts(pos, significand, exponent, visitor),
}
}
@ -409,9 +408,10 @@ impl<'de, R: Read<'de>> Deserializer<R> {
pos: bool,
significand: u64,
starting_exp: i32,
visitor: V
visitor: V,
) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
self.eat_char();
@ -440,10 +440,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
let digit = (c - b'0') as i32;
if overflow!(exp * 10 + digit, i32::MAX) {
return self.parse_exponent_overflow(pos,
significand,
pos_exp,
visitor);
return self.parse_exponent_overflow(pos, significand, pos_exp, visitor);
}
exp = exp * 10 + digit;
@ -467,9 +464,10 @@ impl<'de, R: Read<'de>> Deserializer<R> {
pos: bool,
significand: u64,
pos_exp: bool,
visitor: V
visitor: V,
) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
// Error instead of +/- infinity.
if significand != 0 && pos_exp {
@ -479,11 +477,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
while let b'0'...b'9' = try!(self.peek_or_null()) {
self.eat_char();
}
visitor.visit_f64(if pos {
0.0
} else {
-0.0
})
visitor.visit_f64(if pos { 0.0 } else { -0.0 })
}
fn visit_f64_from_parts<V>(
@ -491,9 +485,10 @@ impl<'de, R: Read<'de>> Deserializer<R> {
pos: bool,
significand: u64,
mut exponent: i32,
visitor: V
visitor: V,
) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
let mut f = significand as f64;
loop {
@ -521,11 +516,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
}
}
}
visitor.visit_f64(if pos {
f
} else {
-f
})
visitor.visit_f64(if pos { f } else { -f })
}
fn parse_object_colon(&mut self) -> Result<()> {
@ -562,6 +553,7 @@ impl<'de, R: Read<'de>> Deserializer<R> {
}
}
#[cfg_attr(rustfmt, rustfmt_skip)]
static POW10: [f64; 309] =
[1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009,
1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019,
@ -600,7 +592,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
self.parse_value(visitor)
}
@ -608,7 +601,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
/// Parses a `null` as a None, and any other values as a `Some(...)`.
#[inline]
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
match try!(self.parse_whitespace()) {
Some(b'n') => {
@ -622,12 +616,9 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
/// Parses a newtype struct as the underlying value.
#[inline]
fn deserialize_newtype_struct<V>(
self,
_name: &str,
visitor: V
) -> Result<V::Value>
where V: de::Visitor<'de>,
fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
@ -639,9 +630,10 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V
visitor: V,
) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
match try!(self.parse_whitespace()) {
Some(b'{') => {
@ -752,7 +744,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
/// # }
/// ```
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
match try!(self.parse_whitespace()) {
Some(b'"') => {
@ -770,7 +763,8 @@ impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
#[inline]
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
where V: de::Visitor<'de>
where
V: de::Visitor<'de>,
{
self.deserialize_bytes(visitor)
}
@ -799,7 +793,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
type Error = Error;
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match try!(self.de.parse_whitespace()) {
Some(b']') => {
@ -812,8 +807,7 @@ impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
if self.first {
self.first = false;
} else {
return Err(self.de
.peek_error(ErrorCode::ExpectedListCommaOrEnd));
return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
}
}
None => {
@ -844,7 +838,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
type Error = Error;
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
where K: de::DeserializeSeed<'de>,
where
K: de::DeserializeSeed<'de>,
{
let peek = match try!(self.de.parse_whitespace()) {
Some(b'}') => {
@ -859,13 +854,11 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
self.first = false;
Some(b)
} else {
return Err(self.de
.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
}
}
None => {
return Err(self.de
.peek_error(ErrorCode::EofWhileParsingObject));
return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
}
};
@ -877,7 +870,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
}
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
where V: de::DeserializeSeed<'de>,
where
V: de::DeserializeSeed<'de>,
{
try!(self.de.parse_object_colon());
@ -891,9 +885,7 @@ struct VariantAccess<'a, R: 'a> {
impl<'a, R: 'a> VariantAccess<'a, R> {
fn new(de: &'a mut Deserializer<R>) -> Self {
VariantAccess {
de: de,
}
VariantAccess { de: de }
}
}
@ -902,7 +894,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> {
type Variant = Self;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
where V: de::DeserializeSeed<'de>,
where
V: de::DeserializeSeed<'de>,
{
let val = try!(seed.deserialize(&mut *self.de));
try!(self.de.parse_object_colon());
@ -918,23 +911,22 @@ impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R>
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
seed.deserialize(self.de)
}
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
de::Deserializer::deserialize_any(self.de, visitor)
}
fn struct_variant<V>(
self,
_fields: &'static [&'static str],
visitor: V
) -> Result<V::Value>
where V: de::Visitor<'de>,
fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
de::Deserializer::deserialize_any(self.de, visitor)
}
@ -946,9 +938,7 @@ struct UnitVariantAccess<'a, R: 'a> {
impl<'a, R: 'a> UnitVariantAccess<'a, R> {
fn new(de: &'a mut Deserializer<R>) -> Self {
UnitVariantAccess {
de: de,
}
UnitVariantAccess { de: de }
}
}
@ -957,7 +947,8 @@ impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R
type Variant = Self;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
where V: de::DeserializeSeed<'de>,
where
V: de::DeserializeSeed<'de>,
{
let variant = try!(seed.deserialize(&mut *self.de));
Ok((variant, self))
@ -972,25 +963,24 @@ impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for UnitVariantAccess<'a
}
fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"))
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),)
}
fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),)
}
fn struct_variant<V>(
self,
_fields: &'static [&'static str],
_visitor: V
) -> Result<V::Value>
where V: de::Visitor<'de>,
fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
where
V: de::Visitor<'de>,
{
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),)
}
}
@ -1028,8 +1018,9 @@ pub struct StreamDeserializer<'de, R, T> {
}
impl<'de, R, T> StreamDeserializer<'de, R, T>
where R: read::Read<'de>,
T: de::Deserialize<'de>
where
R: read::Read<'de>,
T: de::Deserialize<'de>,
{
/// Create a JSON stream deserializer from one of the possible serde_json
/// input sources.
@ -1087,8 +1078,9 @@ impl<'de, R, T> StreamDeserializer<'de, R, T>
}
impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T>
where R: Read<'de>,
T: de::Deserialize<'de>,
where
R: Read<'de>,
T: de::Deserialize<'de>,
{
type Item = Result<T>;
@ -1109,9 +1101,7 @@ impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T>
}
Some(result)
}
Ok(Some(_)) => {
Some(Err(self.de.peek_error(ErrorCode::ExpectedObjectOrArray)))
}
Ok(Some(_)) => Some(Err(self.de.peek_error(ErrorCode::ExpectedObjectOrArray))),
Err(e) => Some(Err(e)),
}
}
@ -1120,8 +1110,9 @@ impl<'de, R, T> Iterator for StreamDeserializer<'de, R, T>
//////////////////////////////////////////////////////////////////////////////
fn from_trait<'de, R, T>(read: R) -> Result<T>
where R: Read<'de>,
T: de::Deserialize<'de>,
where
R: Read<'de>,
T: de::Deserialize<'de>,
{
let mut de = Deserializer::new(read);
let value = try!(de::Deserialize::deserialize(&mut de));
@ -1141,8 +1132,9 @@ fn from_trait<'de, R, T>(read: R) -> Result<T>
/// the JSON map or some number is too big to fit in the expected primitive
/// type.
pub fn from_iter<I, T>(iter: I) -> Result<T>
where I: Iterator<Item = io::Result<u8>>,
T: de::DeserializeOwned,
where
I: Iterator<Item = io::Result<u8>>,
T: de::DeserializeOwned,
{
from_trait(read::IteratorRead::new(iter))
}
@ -1157,8 +1149,9 @@ pub fn from_iter<I, T>(iter: I) -> Result<T>
/// the JSON map or some number is too big to fit in the expected primitive
/// type.
pub fn from_reader<R, T>(rdr: R) -> Result<T>
where R: io::Read,
T: de::DeserializeOwned,
where
R: io::Read,
T: de::DeserializeOwned,
{
from_iter(rdr.bytes())
}
@ -1173,7 +1166,8 @@ pub fn from_reader<R, T>(rdr: R) -> Result<T>
/// the JSON map or some number is too big to fit in the expected primitive
/// type.
pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T>
where T: de::Deserialize<'a>,
where
T: de::Deserialize<'a>,
{
from_trait(read::SliceRead::new(v))
}
@ -1188,7 +1182,8 @@ pub fn from_slice<'a, T>(v: &'a [u8]) -> Result<T>
/// the JSON map or some number is too big to fit in the expected primitive
/// type.
pub fn from_str<'a, T>(s: &'a str) -> Result<T>
where T: de::Deserialize<'a>,
where
T: de::Deserialize<'a>,
{
from_trait(read::StrRead::new(s))
}

141
src/error.rs
View File

@ -169,12 +169,8 @@ impl From<Error> for io::Error {
} else {
match j.classify() {
Category::Io => unreachable!(),
Category::Syntax | Category::Data => {
io::Error::new(io::ErrorKind::InvalidData, j)
}
Category::Eof => {
io::Error::new(io::ErrorKind::UnexpectedEof, j)
}
Category::Syntax | Category::Data => io::Error::new(io::ErrorKind::InvalidData, j),
Category::Eof => io::Error::new(io::ErrorKind::UnexpectedEof, j),
}
}
}
@ -263,14 +259,21 @@ impl Error {
#[doc(hidden)]
pub fn syntax(code: ErrorCode, line: usize, column: usize) -> Self {
Error {
err: Box::new(ErrorImpl { code: code, line: line, column: column }),
err: Box::new(
ErrorImpl {
code: code,
line: line,
column: column,
},
),
}
}
// Not public API. Should be pub(crate).
#[doc(hidden)]
pub fn fix_position<F>(self, f: F) -> Self
where F: FnOnce(ErrorCode) -> Error
where
F: FnOnce(ErrorCode) -> Error,
{
if self.err.line == 0 {
f(self.err.code)
@ -285,66 +288,28 @@ impl Display for ErrorCode {
match *self {
ErrorCode::Message(ref msg) => f.write_str(msg),
ErrorCode::Io(ref err) => Display::fmt(err, f),
ErrorCode::EofWhileParsingList => {
f.write_str("EOF while parsing a list")
}
ErrorCode::EofWhileParsingObject => {
f.write_str("EOF while parsing an object")
}
ErrorCode::EofWhileParsingString => {
f.write_str("EOF while parsing a string")
}
ErrorCode::EofWhileParsingValue => {
f.write_str("EOF while parsing a value")
}
ErrorCode::ExpectedColon => {
f.write_str("expected `:`")
}
ErrorCode::ExpectedListCommaOrEnd => {
f.write_str("expected `,` or `]`")
}
ErrorCode::ExpectedObjectCommaOrEnd => {
f.write_str("expected `,` or `}`")
}
ErrorCode::ExpectedObjectOrArray => {
f.write_str("expected `{` or `[`")
}
ErrorCode::ExpectedSomeIdent => {
f.write_str("expected ident")
}
ErrorCode::ExpectedSomeValue => {
f.write_str("expected value")
}
ErrorCode::ExpectedSomeString => {
f.write_str("expected string")
}
ErrorCode::InvalidEscape => {
f.write_str("invalid escape")
}
ErrorCode::InvalidNumber => {
f.write_str("invalid number")
}
ErrorCode::NumberOutOfRange => {
f.write_str("number out of range")
}
ErrorCode::InvalidUnicodeCodePoint => {
f.write_str("invalid unicode code point")
}
ErrorCode::KeyMustBeAString => {
f.write_str("key must be a string")
}
ErrorCode::EofWhileParsingList => f.write_str("EOF while parsing a list"),
ErrorCode::EofWhileParsingObject => f.write_str("EOF while parsing an object"),
ErrorCode::EofWhileParsingString => f.write_str("EOF while parsing a string"),
ErrorCode::EofWhileParsingValue => f.write_str("EOF while parsing a value"),
ErrorCode::ExpectedColon => f.write_str("expected `:`"),
ErrorCode::ExpectedListCommaOrEnd => f.write_str("expected `,` or `]`"),
ErrorCode::ExpectedObjectCommaOrEnd => f.write_str("expected `,` or `}`"),
ErrorCode::ExpectedObjectOrArray => f.write_str("expected `{` or `[`"),
ErrorCode::ExpectedSomeIdent => f.write_str("expected ident"),
ErrorCode::ExpectedSomeValue => f.write_str("expected value"),
ErrorCode::ExpectedSomeString => f.write_str("expected string"),
ErrorCode::InvalidEscape => f.write_str("invalid escape"),
ErrorCode::InvalidNumber => f.write_str("invalid number"),
ErrorCode::NumberOutOfRange => f.write_str("number out of range"),
ErrorCode::InvalidUnicodeCodePoint => f.write_str("invalid unicode code point"),
ErrorCode::KeyMustBeAString => f.write_str("key must be a string"),
ErrorCode::LoneLeadingSurrogateInHexEscape => {
f.write_str("lone leading surrogate in hex escape")
}
ErrorCode::TrailingCharacters => {
f.write_str("trailing characters")
}
ErrorCode::UnexpectedEndOfHexEscape => {
f.write_str("unexpected end of hex escape")
}
ErrorCode::RecursionLimitExceeded => {
f.write_str("recursion limit exceeded")
}
ErrorCode::TrailingCharacters => f.write_str("trailing characters"),
ErrorCode::UnexpectedEndOfHexEscape => f.write_str("unexpected end of hex escape"),
ErrorCode::RecursionLimitExceeded => f.write_str("recursion limit exceeded"),
}
}
}
@ -379,7 +344,13 @@ impl Display for ErrorImpl {
if self.line == 0 {
Display::fmt(&self.code, f)
} else {
write!(f, "{} at line {} column {}", self.code, self.line, self.column)
write!(
f,
"{} at line {} column {}",
self.code,
self.line,
self.column
)
}
}
}
@ -393,17 +364,21 @@ impl Debug for Error {
}
impl From<ErrorImpl> for Error {
fn from(error: ErrorImpl) -> Error {
Error {
err: Box::new(error),
}
fn from(error: ErrorImpl) -> Error {
Error { err: Box::new(error) }
}
}
impl From<io::Error> for Error {
fn from(error: io::Error) -> Error {
Error {
err: Box::new(ErrorImpl { code: ErrorCode::Io(error), line: 0, column: 0 }),
err: Box::new(
ErrorImpl {
code: ErrorCode::Io(error),
line: 0,
column: 0,
},
),
}
}
}
@ -411,7 +386,13 @@ impl From<io::Error> for Error {
impl From<de::value::Error> for Error {
fn from(error: de::value::Error) -> Error {
Error {
err: Box::new(ErrorImpl { code: ErrorCode::Message(error.to_string()), line: 0, column: 0 }),
err: Box::new(
ErrorImpl {
code: ErrorCode::Message(error.to_string()),
line: 0,
column: 0,
},
),
}
}
}
@ -419,7 +400,13 @@ impl From<de::value::Error> for Error {
impl de::Error for Error {
fn custom<T: Display>(msg: T) -> Error {
Error {
err: Box::new(ErrorImpl { code: ErrorCode::Message(msg.to_string()), line: 0, column: 0 }),
err: Box::new(
ErrorImpl {
code: ErrorCode::Message(msg.to_string()),
line: 0,
column: 0,
},
),
}
}
}
@ -427,7 +414,13 @@ impl de::Error for Error {
impl ser::Error for Error {
fn custom<T: Display>(msg: T) -> Error {
Error {
err: Box::new(ErrorImpl { code: ErrorCode::Message(msg.to_string()), line: 0, column: 0 }),
err: Box::new(
ErrorImpl {
code: ErrorCode::Message(msg.to_string()),
line: 0,
column: 0,
},
),
}
}
}

6
src/iter.rs
View File

@ -28,7 +28,8 @@ pub struct LineColIterator<I> {
}
impl<I> LineColIterator<I>
where I: Iterator<Item = io::Result<u8>>
where
I: Iterator<Item = io::Result<u8>>,
{
pub fn new(iter: I) -> LineColIterator<I> {
LineColIterator {
@ -53,7 +54,8 @@ impl<I> LineColIterator<I>
}
impl<I> Iterator for LineColIterator<I>
where I: Iterator<Item = io::Result<u8>>
where
I: Iterator<Item = io::Result<u8>>,
{
type Item = io::Result<u8>;

7
src/lib.rs
View File

@ -330,13 +330,12 @@ extern crate dtoa;
extern crate linked_hash_map;
#[doc(inline)]
pub use self::de::{Deserializer, StreamDeserializer, from_iter, from_reader,
from_slice, from_str};
pub use self::de::{Deserializer, StreamDeserializer, from_iter, from_reader, from_slice, from_str};
#[doc(inline)]
pub use self::error::{Error, Result};
#[doc(inline)]
pub use self::ser::{Serializer, to_string, to_string_pretty, to_vec,
to_vec_pretty, to_writer, to_writer_pretty};
pub use self::ser::{Serializer, to_string, to_string_pretty, to_vec, to_vec_pretty, to_writer,
to_writer_pretty};
#[doc(inline)]
pub use self::value::{Map, Number, Value, from_value, to_value};

118
src/map.rs
View File

@ -39,9 +39,7 @@ impl Map<String, Value> {
/// Makes a new empty Map.
#[inline]
pub fn new() -> Self {
Map {
map: MapImpl::new(),
}
Map { map: MapImpl::new() }
}
#[cfg(not(feature = "preserve_order"))]
@ -50,18 +48,14 @@ impl Map<String, Value> {
pub fn with_capacity(capacity: usize) -> Self {
// does not support with_capacity
let _ = capacity;
Map {
map: BTreeMap::new(),
}
Map { map: BTreeMap::new() }
}
#[cfg(feature = "preserve_order")]
/// Makes a new empty Map with the given initial capacity.
#[inline]
pub fn with_capacity(capacity: usize) -> Self {
Map {
map: LinkedHashMap::with_capacity(capacity),
}
Map { map: LinkedHashMap::with_capacity(capacity) }
}
/// Clears the map, removing all values.
@ -76,8 +70,9 @@ impl Map<String, Value> {
/// on the borrowed form *must* match the ordering on the key type.
#[inline]
pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&Value>
where String: Borrow<Q>,
Q: Ord + Eq + Hash
where
String: Borrow<Q>,
Q: Ord + Eq + Hash,
{
self.map.get(key)
}
@ -88,8 +83,9 @@ impl Map<String, Value> {
/// on the borrowed form *must* match the ordering on the key type.
#[inline]
pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
where String: Borrow<Q>,
Q: Ord + Eq + Hash
where
String: Borrow<Q>,
Q: Ord + Eq + Hash,
{
self.map.contains_key(key)
}
@ -100,8 +96,9 @@ impl Map<String, Value> {
/// on the borrowed form *must* match the ordering on the key type.
#[inline]
pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut Value>
where String: Borrow<Q>,
Q: Ord + Eq + Hash
where
String: Borrow<Q>,
Q: Ord + Eq + Hash,
{
self.map.get_mut(key)
}
@ -125,8 +122,9 @@ impl Map<String, Value> {
/// on the borrowed form *must* match the ordering on the key type.
#[inline]
pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<Value>
where String: Borrow<Q>,
Q: Ord + Eq + Hash
where
String: Borrow<Q>,
Q: Ord + Eq + Hash,
{
self.map.remove(key)
}
@ -134,7 +132,8 @@ impl Map<String, Value> {
/// Gets the given key's corresponding entry in the map for in-place
/// manipulation.
pub fn entry<S>(&mut self, key: S) -> Entry
where S: Into<String>
where
S: Into<String>,
{
#[cfg(not(feature = "preserve_order"))]
use std::collections::btree_map::Entry as EntryImpl;
@ -142,12 +141,8 @@ impl Map<String, Value> {
use linked_hash_map::Entry as EntryImpl;
match self.map.entry(key.into()) {
EntryImpl::Vacant(vacant) => {
Entry::Vacant(VacantEntry { vacant: vacant })
}
EntryImpl::Occupied(occupied) => {
Entry::Occupied(OccupiedEntry { occupied: occupied })
}
EntryImpl::Vacant(vacant) => Entry::Vacant(VacantEntry { vacant: vacant }),
EntryImpl::Occupied(occupied) => Entry::Occupied(OccupiedEntry { occupied: occupied }),
}
}
@ -166,51 +161,39 @@ impl Map<String, Value> {
/// Gets an iterator over the entries of the map.
#[inline]
pub fn iter(&self) -> Iter {
Iter {
iter: self.map.iter(),
}
Iter { iter: self.map.iter() }
}
/// Gets a mutable iterator over the entries of the map.
#[inline]
pub fn iter_mut(&mut self) -> IterMut {
IterMut {
iter: self.map.iter_mut(),
}
IterMut { iter: self.map.iter_mut() }
}
/// Gets an iterator over the keys of the map.
#[inline]
pub fn keys(&self) -> Keys {
Keys {
iter: self.map.keys(),
}
Keys { iter: self.map.keys() }
}
/// Gets an iterator over the values of the map.
#[inline]
pub fn values(&self) -> Values {
Values {
iter: self.map.values(),
}
Values { iter: self.map.values() }
}
}
impl Default for Map<String, Value> {
#[inline]
fn default() -> Self {
Map {
map: MapImpl::new(),
}
Map { map: MapImpl::new() }
}
}
impl Clone for Map<String, Value> {
#[inline]
fn clone(&self) -> Self {
Map {
map: self.map.clone(),
}
Map { map: self.map.clone() }
}
}
@ -238,8 +221,9 @@ impl PartialEq for Map<String, Value> {
/// # ;
/// ```
impl<'a, Q: ?Sized> ops::Index<&'a Q> for Map<String, Value>
where String: Borrow<Q>,
Q: Ord + Eq + Hash
where
String: Borrow<Q>,
Q: Ord + Eq + Hash,
{
type Output = Value;
@ -263,8 +247,9 @@ impl<'a, Q: ?Sized> ops::Index<&'a Q> for Map<String, Value>
/// # }
/// ```
impl<'a, Q: ?Sized> ops::IndexMut<&'a Q> for Map<String, Value>
where String: Borrow<Q>,
Q: Ord + Eq + Hash
where
String: Borrow<Q>,
Q: Ord + Eq + Hash,
{
fn index_mut(&mut self, index: &Q) -> &mut Value {
self.map.get_mut(index).expect("no entry found for key")
@ -281,7 +266,8 @@ impl Debug for Map<String, Value> {
impl ser::Serialize for Map<String, Value> {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer
where
S: ser::Serializer,
{
use serde::ser::SerializeMap;
let mut map = try!(serializer.serialize_map(Some(self.len())));
@ -296,7 +282,8 @@ impl ser::Serialize for Map<String, Value> {
impl<'de> de::Deserialize<'de> for Map<String, Value> {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: de::Deserializer<'de>
where
D: de::Deserializer<'de>,
{
struct Visitor;
@ -309,14 +296,16 @@ impl<'de> de::Deserialize<'de> for Map<String, Value> {
#[inline]
fn visit_unit<E>(self) -> Result<Self::Value, E>
where E: de::Error
where
E: de::Error,
{
Ok(Map::new())
}
#[inline]
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where V: de::MapAccess<'de>
where
V: de::MapAccess<'de>,
{
let mut values = Map::new();
@ -333,15 +322,19 @@ impl<'de> de::Deserialize<'de> for Map<String, Value> {
}
impl FromIterator<(String, Value)> for Map<String, Value> {
fn from_iter<T>(iter: T) -> Self where T: IntoIterator<Item=(String, Value)> {
Map {
map: FromIterator::from_iter(iter)
}
fn from_iter<T>(iter: T) -> Self
where
T: IntoIterator<Item = (String, Value)>,
{
Map { map: FromIterator::from_iter(iter) }
}
}
impl Extend<(String, Value)> for Map<String, Value> {
fn extend<T>(&mut self, iter: T) where T: IntoIterator<Item=(String, Value)> {
fn extend<T>(&mut self, iter: T)
where
T: IntoIterator<Item = (String, Value)>,
{
self.map.extend(iter);
}
}
@ -471,7 +464,8 @@ impl<'a> Entry<'a> {
/// # }
/// ```
pub fn or_insert_with<F>(self, default: F) -> &'a mut Value
where F: FnOnce() -> Value
where
F: FnOnce() -> Value,
{
match self {
Entry::Vacant(entry) => entry.insert(default()),
@ -708,9 +702,7 @@ impl<'a> IntoIterator for &'a Map<String, Value> {
type IntoIter = Iter<'a>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
Iter {
iter: self.map.iter(),
}
Iter { iter: self.map.iter() }
}
}
@ -733,9 +725,7 @@ impl<'a> IntoIterator for &'a mut Map<String, Value> {
type IntoIter = IterMut<'a>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
IterMut {
iter: self.map.iter_mut(),
}
IterMut { iter: self.map.iter_mut() }
}
}
@ -758,9 +748,7 @@ impl IntoIterator for Map<String, Value> {
type IntoIter = IntoIter;
#[inline]
fn into_iter(self) -> Self::IntoIter {
IntoIter {
iter: self.map.into_iter(),
}
IntoIter { iter: self.map.into_iter() }
}
}

15
src/number.rs
View File

@ -240,7 +240,8 @@ impl Debug for Number {
impl Serialize for Number {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
where
S: Serializer,
{
match self.n {
N::PosInt(i) => serializer.serialize_u64(i),
@ -253,7 +254,8 @@ impl Serialize for Number {
impl<'de> Deserialize<'de> for Number {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Number, D::Error>
where D: Deserializer<'de>
where
D: Deserializer<'de>,
{
struct NumberVisitor;
@ -276,7 +278,8 @@ impl<'de> Deserialize<'de> for Number {
#[inline]
fn visit_f64<E>(self, value: f64) -> Result<Number, E>
where E: de::Error
where
E: de::Error,
{
Number::from_f64(value).ok_or_else(|| de::Error::custom("not a JSON number"))
}
@ -291,7 +294,8 @@ impl<'de> Deserializer<'de> for Number {
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: Visitor<'de>
where
V: Visitor<'de>,
{
match self.n {
N::PosInt(i) => visitor.visit_u64(i),
@ -312,7 +316,8 @@ impl<'de, 'a> Deserializer<'de> for &'a Number {
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: Visitor<'de>
where
V: Visitor<'de>,
{
match self.n {
N::PosInt(i) => visitor.visit_u64(i),

216
src/read.rs
View File

@ -51,16 +51,13 @@ pub trait Read<'de>: private::Sealed {
/// Offset from the beginning of the input to the next byte that would be
/// returned by next() or peek().
#[doc(hidden)]
fn byte_offset(&self) -> usize;
fn byte_offset(&self) -> usize;
/// Assumes the previous byte was a quotation mark. Parses a JSON-escaped
/// string until the next quotation mark using the given scratch space if
/// necessary. The scratch space is initially empty.
#[doc(hidden)]
fn parse_str<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
) -> Result<Reference<'de, 's, str>>;
fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>>;
/// Assumes the previous byte was a quotation mark. Parses a JSON-escaped
/// string until the next quotation mark using the given scratch space if
@ -71,7 +68,7 @@ pub trait Read<'de>: private::Sealed {
#[doc(hidden)]
fn parse_str_raw<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
scratch: &'s mut Vec<u8>,
) -> Result<Reference<'de, 's, [u8]>>;
}
@ -87,7 +84,8 @@ pub enum Reference<'b, 'c, T: ?Sized + 'static> {
/// JSON input source that reads from an iterator of bytes.
pub struct IteratorRead<Iter>
where Iter: Iterator<Item = io::Result<u8>>,
where
Iter: Iterator<Item = io::Result<u8>>,
{
iter: LineColIterator<Iter>,
/// Temporary storage of peeked byte.
@ -96,7 +94,8 @@ pub struct IteratorRead<Iter>
/// JSON input source that reads from a std::io input stream.
pub struct IoRead<R>
where R: io::Read
where
R: io::Read,
{
delegate: IteratorRead<io::Bytes<R>>,
}
@ -126,7 +125,8 @@ mod private {
//////////////////////////////////////////////////////////////////////////////
impl<Iter> IteratorRead<Iter>
where Iter: Iterator<Item = io::Result<u8>>,
where
Iter: Iterator<Item = io::Result<u8>>,
{
/// Create a JSON input source to read from an iterator of bytes.
pub fn new(iter: Iter) -> Self {
@ -138,19 +138,24 @@ impl<Iter> IteratorRead<Iter>
}
impl<Iter> private::Sealed for IteratorRead<Iter>
where Iter: Iterator<Item = io::Result<u8>> {}
where
Iter: Iterator<Item = io::Result<u8>>,
{
}
impl<Iter> IteratorRead<Iter>
where Iter: Iterator<Item = io::Result<u8>>
where
Iter: Iterator<Item = io::Result<u8>>,
{
fn parse_str_bytes<'s, T, F>(
&'s mut self,
scratch: &'s mut Vec<u8>,
validate: bool,
result: F
result: F,
) -> Result<T>
where T: 's,
F: FnOnce(&'s Self, &'s [u8]) -> Result<T>,
where
T: 's,
F: FnOnce(&'s Self, &'s [u8]) -> Result<T>,
{
loop {
let ch = try!(next_or_eof(self));
@ -177,7 +182,8 @@ impl<Iter> IteratorRead<Iter>
}
impl<'de, Iter> Read<'de> for IteratorRead<Iter>
where Iter: Iterator<Item = io::Result<u8>>,
where
Iter: Iterator<Item = io::Result<u8>>,
{
#[inline]
fn next(&mut self) -> io::Result<Option<u8>> {
@ -235,39 +241,41 @@ impl<'de, Iter> Read<'de> for IteratorRead<Iter>
}
}
fn parse_str<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
) -> Result<Reference<'de, 's, str>> {
self.parse_str_bytes(scratch, true, as_str).map(Reference::Copied)
fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>> {
self.parse_str_bytes(scratch, true, as_str)
.map(Reference::Copied)
}
fn parse_str_raw<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
scratch: &'s mut Vec<u8>,
) -> Result<Reference<'de, 's, [u8]>> {
self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes)).map(Reference::Copied)
self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes))
.map(Reference::Copied)
}
}
//////////////////////////////////////////////////////////////////////////////
impl<R> IoRead<R>
where R: io::Read
where
R: io::Read,
{
/// Create a JSON input source to read from a std::io input stream.
pub fn new(reader: R) -> Self {
IoRead {
delegate: IteratorRead::new(reader.bytes()),
}
IoRead { delegate: IteratorRead::new(reader.bytes()) }
}
}
impl<R> private::Sealed for IoRead<R>
where R: io::Read {}
where
R: io::Read,
{
}
impl<'de, R> Read<'de> for IoRead<R>
where R: io::Read
where
R: io::Read,
{
#[inline]
fn next(&mut self) -> io::Result<Option<u8>> {
@ -300,17 +308,14 @@ impl<'de, R> Read<'de> for IoRead<R>
}
#[inline]
fn parse_str<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
) -> Result<Reference<'de, 's, str>> {
fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'de, 's, str>> {
self.delegate.parse_str(scratch)
}
#[inline]
fn parse_str_raw<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
scratch: &'s mut Vec<u8>,
) -> Result<Reference<'de, 's, [u8]>> {
self.delegate.parse_str_raw(scratch)
}
@ -328,10 +333,7 @@ impl<'a> SliceRead<'a> {
}
fn position_of_index(&self, i: usize) -> Position {
let mut pos = Position {
line: 1,
column: 0,
};
let mut pos = Position { line: 1, column: 0 };
for ch in &self.slice[..i] {
match *ch {
b'\n' => {
@ -353,17 +355,17 @@ impl<'a> SliceRead<'a> {
&'s mut self,
scratch: &'s mut Vec<u8>,
validate: bool,
result: F
result: F,
) -> Result<Reference<'a, 's, T>>
where T: 's,
F: for<'f> FnOnce(&'s Self, &'f [u8]) -> Result<&'f T>,
where
T: 's,
F: for<'f> FnOnce(&'s Self, &'f [u8]) -> Result<&'f T>,
{
// Index of the first byte not yet copied into the scratch space.
let mut start = self.index;
loop {
while self.index < self.slice.len() &&
!ESCAPE[self.slice[self.index] as usize] {
while self.index < self.slice.len() && !ESCAPE[self.slice[self.index] as usize] {
self.index += 1;
}
if self.index == self.slice.len() {
@ -378,7 +380,7 @@ impl<'a> SliceRead<'a> {
self.index += 1;
return result(self, borrowed).map(Reference::Borrowed);
} else {
scratch.extend_from_slice(&self.slice[start .. self.index]);
scratch.extend_from_slice(&self.slice[start..self.index]);
// "as &[u8]" is required for rustc 1.8.0
let copied = scratch as &[u8];
self.index += 1;
@ -409,24 +411,28 @@ impl<'a> Read<'a> for SliceRead<'a> {
fn next(&mut self) -> io::Result<Option<u8>> {
// `Ok(self.slice.get(self.index).map(|ch| { self.index += 1; *ch }))`
// is about 10% slower.
Ok(if self.index < self.slice.len() {
let ch = self.slice[self.index];
self.index += 1;
Some(ch)
} else {
None
})
Ok(
if self.index < self.slice.len() {
let ch = self.slice[self.index];
self.index += 1;
Some(ch)
} else {
None
},
)
}
#[inline]
fn peek(&mut self) -> io::Result<Option<u8>> {
// `Ok(self.slice.get(self.index).map(|ch| *ch))` is about 10% slower
// for some reason.
Ok(if self.index < self.slice.len() {
Some(self.slice[self.index])
} else {
None
})
Ok(
if self.index < self.slice.len() {
Some(self.slice[self.index])
} else {
None
},
)
}
#[inline]
@ -448,20 +454,16 @@ impl<'a> Read<'a> for SliceRead<'a> {
self.index
}
fn parse_str<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
) -> Result<Reference<'a, 's, str>> {
fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> {
self.parse_str_bytes(scratch, true, as_str)
}
fn parse_str_raw<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
scratch: &'s mut Vec<u8>,
) -> Result<Reference<'a, 's, [u8]>> {
self.parse_str_bytes(scratch, false, |_, bytes| Ok(bytes))
}
}
//////////////////////////////////////////////////////////////////////////////
@ -469,9 +471,7 @@ impl<'a> Read<'a> for SliceRead<'a> {
impl<'a> StrRead<'a> {
/// Create a JSON input source to read from a UTF-8 string.
pub fn new(s: &'a str) -> Self {
StrRead {
delegate: SliceRead::new(s.as_bytes()),
}
StrRead { delegate: SliceRead::new(s.as_bytes()) }
}
}
@ -505,20 +505,20 @@ impl<'a> Read<'a> for StrRead<'a> {
self.delegate.byte_offset()
}
fn parse_str<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
) -> Result<Reference<'a, 's, str>> {
self.delegate.parse_str_bytes(scratch, true, |_, bytes| {
// The input is assumed to be valid UTF-8 and the \u-escapes are
// checked along the way, so don't need to check here.
Ok(unsafe { str::from_utf8_unchecked(bytes) })
})
fn parse_str<'s>(&'s mut self, scratch: &'s mut Vec<u8>) -> Result<Reference<'a, 's, str>> {
self.delegate
.parse_str_bytes(
scratch, true, |_, bytes| {
// The input is assumed to be valid UTF-8 and the \u-escapes are
// checked along the way, so don't need to check here.
Ok(unsafe { str::from_utf8_unchecked(bytes) })
}
)
}
fn parse_str_raw<'s>(
&'s mut self,
scratch: &'s mut Vec<u8>
scratch: &'s mut Vec<u8>,
) -> Result<Reference<'a, 's, [u8]>> {
self.delegate.parse_str_raw(scratch)
}
@ -567,8 +567,7 @@ fn error<'de, R: Read<'de>, T>(read: &R, reason: ErrorCode) -> Result<T> {
}
fn as_str<'de, 's, R: Read<'de>>(read: &R, slice: &'s [u8]) -> Result<&'s str> {
str::from_utf8(slice)
.or_else(|_| error(read, ErrorCode::InvalidUnicodeCodePoint))
str::from_utf8(slice).or_else(|_| error(read, ErrorCode::InvalidUnicodeCodePoint))
}
/// Parses a JSON escape sequence and appends it into the scratch space. Assumes
@ -586,49 +585,46 @@ fn parse_escape<'de, R: Read<'de>>(read: &mut R, scratch: &mut Vec<u8>) -> Resul
b'r' => scratch.push(b'\r'),
b't' => scratch.push(b'\t'),
b'u' => {
let c =
match try!(decode_hex_escape(read)) {
0xDC00...0xDFFF => {
let c = match try!(decode_hex_escape(read)) {
0xDC00...0xDFFF => {
return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
}
// Non-BMP characters are encoded as a sequence of
// two hex escapes, representing UTF-16 surrogates.
n1 @ 0xD800...0xDBFF => {
if try!(next_or_eof(read)) != b'\\' {
return error(read, ErrorCode::UnexpectedEndOfHexEscape);
}
if try!(next_or_eof(read)) != b'u' {
return error(read, ErrorCode::UnexpectedEndOfHexEscape);
}
let n2 = try!(decode_hex_escape(read));
if n2 < 0xDC00 || n2 > 0xDFFF {
return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
}
// Non-BMP characters are encoded as a sequence of
// two hex escapes, representing UTF-16 surrogates.
n1 @ 0xD800...0xDBFF => {
if try!(next_or_eof(read)) != b'\\' {
return error(read, ErrorCode::UnexpectedEndOfHexEscape);
}
if try!(next_or_eof(read)) != b'u' {
return error(read, ErrorCode::UnexpectedEndOfHexEscape);
}
let n = (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000;
let n2 = try!(decode_hex_escape(read));
if n2 < 0xDC00 || n2 > 0xDFFF {
return error(read, ErrorCode::LoneLeadingSurrogateInHexEscape);
}
let n = (((n1 - 0xD800) as u32) << 10 |
(n2 - 0xDC00) as u32) +
0x1_0000;
match char::from_u32(n as u32) {
Some(c) => c,
None => {
return error(read, ErrorCode::InvalidUnicodeCodePoint);
}
match char::from_u32(n as u32) {
Some(c) => c,
None => {
return error(read, ErrorCode::InvalidUnicodeCodePoint);
}
}
}
n => {
match char::from_u32(n as u32) {
Some(c) => c,
None => {
return error(read, ErrorCode::InvalidUnicodeCodePoint);
}
n => {
match char::from_u32(n as u32) {
Some(c) => c,
None => {
return error(read, ErrorCode::InvalidUnicodeCodePoint);
}
}
};
}
};
// FIXME: this allocation is required in order to be compatible with stable
// rust, which doesn't support encoding a `char` into a stack buffer.

493
src/ser.rs
View File

File diff suppressed because it is too large Load Diff

367
src/value.rs
View File

@ -779,7 +779,10 @@ impl Value {
if !pointer.starts_with('/') {
return None;
}
let tokens = pointer.split('/').skip(1).map(|x| x.replace("~1", "/").replace("~0", "~"));
let tokens = pointer
.split('/')
.skip(1)
.map(|x| x.replace("~1", "/").replace("~0", "~"));
let mut target = self;
for token in tokens {
@ -842,7 +845,10 @@ impl Value {
if !pointer.starts_with('/') {
return None;
}
let tokens = pointer.split('/').skip(1).map(|x| x.replace("~1", "/").replace("~0", "~"));
let tokens = pointer
.split('/')
.skip(1)
.map(|x| x.replace("~1", "/").replace("~0", "~"));
let mut target = self;
for token in tokens {
@ -851,7 +857,9 @@ impl Value {
let target_once = target;
let target_opt = match *target_once {
Value::Object(ref mut map) => map.get_mut(&token),
Value::Array(ref mut list) => parse_index(&token).and_then(move |x| list.get_mut(x)),
Value::Array(ref mut list) => {
parse_index(&token).and_then(move |x| list.get_mut(x))
}
_ => return None,
};
if let Some(t) = target_opt {
@ -944,10 +952,16 @@ impl Index for usize {
match *v {
Value::Array(ref mut vec) => {
let len = vec.len();
vec.get_mut(*self).unwrap_or_else(|| {
panic!("cannot access index {} of JSON array of length {}",
self, len)
})
vec.get_mut(*self)
.unwrap_or_else(
|| {
panic!(
"cannot access index {} of JSON array of length {}",
self,
len
)
},
)
}
_ => panic!("cannot access index {} of JSON {}", self, Type(v)),
}
@ -999,7 +1013,10 @@ impl Index for String {
}
}
impl<'a, T: ?Sized> Index for &'a T where T: Index {
impl<'a, T: ?Sized> Index for &'a T
where
T: Index,
{
fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
(**self).index_into(v)
}
@ -1017,7 +1034,11 @@ mod private {
impl Sealed for usize {}
impl Sealed for str {}
impl Sealed for String {}
impl<'a, T: ?Sized> Sealed for &'a T where T: Sealed {}
impl<'a, T: ?Sized> Sealed for &'a T
where
T: Sealed,
{
}
}
/// Used in panic messages.
@ -1055,7 +1076,10 @@ impl<'a> fmt::Display for Type<'a> {
// as_array, or match. The value of this impl is that it adds a way of working
// with Value that is not well served by the existing approaches: concise and
// careless and sometimes that is exactly what you want.
impl<I> ops::Index<I> for Value where I: Index {
impl<I> ops::Index<I> for Value
where
I: Index,
{
type Output = Value;
/// Index into a `serde_json::Value` using the syntax `value[0]` or
@ -1095,7 +1119,10 @@ impl<I> ops::Index<I> for Value where I: Index {
}
}
impl<I> ops::IndexMut<I> for Value where I: Index {
impl<I> ops::IndexMut<I> for Value
where
I: Index,
{
/// Write into a `serde_json::Value` using the syntax `value[0] = ...` or
/// `value["k"] = ...`.
///
@ -1458,7 +1485,7 @@ impl<T: Into<Value>> ::std::iter::FromIterator<T> for Value {
/// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
/// # }
/// ```
fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> Self {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
let vec: Vec<Value> = iter.into_iter().map(|x| x.into()).collect();
Value::Array(vec)
@ -1468,7 +1495,8 @@ impl<T: Into<Value>> ::std::iter::FromIterator<T> for Value {
impl ser::Serialize for Value {
#[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: ser::Serializer,
where
S: ser::Serializer,
{
match *self {
Value::Null => serializer.serialize_unit(),
@ -1492,7 +1520,8 @@ impl ser::Serialize for Value {
impl<'de> de::Deserialize<'de> for Value {
#[inline]
fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
where D: de::Deserializer<'de>,
where
D: de::Deserializer<'de>,
{
struct ValueVisitor;
@ -1525,7 +1554,8 @@ impl<'de> de::Deserialize<'de> for Value {
#[inline]
fn visit_str<E>(self, value: &str) -> Result<Value, E>
where E: de::Error,
where
E: de::Error,
{
self.visit_string(String::from(value))
}
@ -1541,11 +1571,9 @@ impl<'de> de::Deserialize<'de> for Value {
}
#[inline]
fn visit_some<D>(
self,
deserializer: D
) -> Result<Value, D::Error>
where D: de::Deserializer<'de>,
fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
where
D: de::Deserializer<'de>,
{
de::Deserialize::deserialize(deserializer)
}
@ -1557,7 +1585,8 @@ impl<'de> de::Deserialize<'de> for Value {
#[inline]
fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
where V: de::SeqAccess<'de>,
where
V: de::SeqAccess<'de>,
{
let mut vec = Vec::new();
@ -1569,7 +1598,8 @@ impl<'de> de::Deserialize<'de> for Value {
}
fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
where V: de::MapAccess<'de>,
where
V: de::MapAccess<'de>,
{
let mut values = Map::new();
@ -1636,9 +1666,7 @@ impl fmt::Display for Value {
/// ```
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let alternate = f.alternate();
let mut wr = WriterFormatter {
inner: f,
};
let mut wr = WriterFormatter { inner: f };
if alternate {
// {:#}
super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error)
@ -1747,10 +1775,7 @@ impl ser::Serializer for Serializer {
}
#[inline]
fn serialize_unit_struct(
self,
_name: &'static str
) -> Result<Value, Error> {
fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, Error> {
self.serialize_unit()
}
@ -1759,7 +1784,7 @@ impl ser::Serializer for Serializer {
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str
variant: &'static str,
) -> Result<Value, Error> {
self.serialize_str(variant)
}
@ -1768,9 +1793,10 @@ impl ser::Serializer for Serializer {
fn serialize_newtype_struct<T: ?Sized>(
self,
_name: &'static str,
value: &T
value: &T,
) -> Result<Value, Error>
where T: ser::Serialize,
where
T: ser::Serialize,
{
value.serialize(self)
}
@ -1780,9 +1806,10 @@ impl ser::Serializer for Serializer {
_name: &'static str,
_variant_index: u32,
variant: &'static str,
value: &T
value: &T,
) -> Result<Value, Error>
where T: ser::Serialize,
where
T: ser::Serialize,
{
let mut values = Map::new();
values.insert(String::from(variant), try!(to_value(&value)));
@ -1796,18 +1823,14 @@ impl ser::Serializer for Serializer {
#[inline]
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Value, Error>
where T: ser::Serialize,
where
T: ser::Serialize,
{
value.serialize(self)
}
fn serialize_seq(
self,
len: Option<usize>
) -> Result<Self::SerializeSeq, Error> {
Ok(SerializeVec {
vec: Vec::with_capacity(len.unwrap_or(0))
})
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
Ok(SerializeVec { vec: Vec::with_capacity(len.unwrap_or(0)) })
}
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Error> {
@ -1817,7 +1840,7 @@ impl ser::Serializer for Serializer {
fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize
len: usize,
) -> Result<Self::SerializeTupleStruct, Error> {
self.serialize_seq(Some(len))
}
@ -1827,28 +1850,29 @@ impl ser::Serializer for Serializer {
_name: &'static str,
_variant_index: u32,
variant: &'static str,
len: usize
len: usize,
) -> Result<Self::SerializeTupleVariant, Error> {
Ok(SerializeTupleVariant {
name: String::from(variant),
vec: Vec::with_capacity(len),
})
Ok(
SerializeTupleVariant {
name: String::from(variant),
vec: Vec::with_capacity(len),
},
)
}
fn serialize_map(
self,
_len: Option<usize>
) -> Result<Self::SerializeMap, Error> {
Ok(SerializeMap {
map: Map::new(),
next_key: None,
})
fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
Ok(
SerializeMap {
map: Map::new(),
next_key: None,
},
)
}
fn serialize_struct(
self,
_name: &'static str,
len: usize
len: usize,
) -> Result<Self::SerializeStruct, Error> {
self.serialize_map(Some(len))
}
@ -1858,12 +1882,14 @@ impl ser::Serializer for Serializer {
_name: &'static str,
_variant_index: u32,
variant: &'static str,
_len: usize
_len: usize,
) -> Result<Self::SerializeStructVariant, Error> {
Ok(SerializeStructVariant {
name: String::from(variant),
map: Map::new(),
})
Ok(
SerializeStructVariant {
name: String::from(variant),
map: Map::new(),
},
)
}
}
@ -1895,7 +1921,8 @@ impl ser::SerializeSeq for SerializeVec {
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
where
T: ser::Serialize,
{
self.vec.push(try!(to_value(&value)));
Ok(())
@ -1911,7 +1938,8 @@ impl ser::SerializeTuple for SerializeVec {
type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
where
T: ser::Serialize,
{
ser::SerializeSeq::serialize_element(self, value)
}
@ -1926,7 +1954,8 @@ impl ser::SerializeTupleStruct for SerializeVec {
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
where
T: ser::Serialize,
{
ser::SerializeSeq::serialize_element(self, value)
}
@ -1941,7 +1970,8 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant {
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
where
T: ser::Serialize,
{
self.vec.push(try!(to_value(&value)));
Ok(())
@ -1961,7 +1991,8 @@ impl ser::SerializeMap for SerializeMap {
type Error = Error;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
where T: ser::Serialize
where
T: ser::Serialize,
{
match try!(to_value(&key)) {
Value::String(s) => self.next_key = Some(s),
@ -1969,7 +2000,7 @@ impl ser::SerializeMap for SerializeMap {
if n.is_u64() || n.is_i64() {
self.next_key = Some(n.to_string())
} else {
return Err(Error::syntax(ErrorCode::KeyMustBeAString, 0, 0))
return Err(Error::syntax(ErrorCode::KeyMustBeAString, 0, 0));
}
}
_ => return Err(Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)),
@ -1978,7 +2009,8 @@ impl ser::SerializeMap for SerializeMap {
}
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
where T: ser::Serialize
where
T: ser::Serialize,
{
let key = self.next_key.take();
// Panic because this indicates a bug in the program rather than an
@ -1998,7 +2030,8 @@ impl ser::SerializeStruct for SerializeMap {
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where T: ser::Serialize
where
T: ser::Serialize,
{
try!(ser::SerializeMap::serialize_key(self, key));
ser::SerializeMap::serialize_value(self, value)
@ -2014,9 +2047,11 @@ impl ser::SerializeStructVariant for SerializeStructVariant {
type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where T: ser::Serialize
where
T: ser::Serialize,
{
self.map.insert(String::from(key), try!(to_value(&value)));
self.map
.insert(String::from(key), try!(to_value(&value)));
Ok(())
}
@ -2034,7 +2069,8 @@ impl<'de> de::Deserializer<'de> for Value {
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
match self {
Value::Null => visitor.visit_unit(),
@ -2067,11 +2103,9 @@ impl<'de> de::Deserializer<'de> for Value {
}
#[inline]
fn deserialize_option<V>(
self,
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
match self {
Value::Null => visitor.visit_none(),
@ -2084,9 +2118,10 @@ impl<'de> de::Deserializer<'de> for Value {
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V
visitor: V,
) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
let (variant, value) = match self {
Value::Object(value) => {
@ -2094,34 +2129,42 @@ impl<'de> de::Deserializer<'de> for Value {
let (variant, value) = match iter.next() {
Some(v) => v,
None => {
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"));
return Err(
de::Error::invalid_value(
Unexpected::Map,
&"map with a single key",
),
);
}
};
// enums are encoded in json as maps with a single key:value pair
if iter.next().is_some() {
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"));
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"),);
}
(variant, Some(value))
}
Value::String(variant) => (variant, None),
other => {
return Err(de::Error::invalid_type(other.unexpected(), &"string or map"));
return Err(de::Error::invalid_type(other.unexpected(), &"string or map"),);
}
};
visitor.visit_enum(EnumDeserializer {
variant: variant,
value: value,
})
visitor.visit_enum(
EnumDeserializer {
variant: variant,
value: value,
},
)
}
#[inline]
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V
visitor: V,
) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
@ -2143,7 +2186,8 @@ impl<'de> de::EnumAccess<'de> for EnumDeserializer {
type Variant = VariantDeserializer;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
where V: de::DeserializeSeed<'de>,
where
V: de::DeserializeSeed<'de>,
{
let variant = self.variant.into_deserializer();
let visitor = VariantDeserializer { value: self.value };
@ -2166,43 +2210,42 @@ impl<'de> de::VariantAccess<'de> for VariantDeserializer {
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match self.value {
Some(value) => seed.deserialize(value),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),),
}
}
fn tuple_variant<V>(
self,
_len: usize,
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
match self.value {
Some(Value::Array(v)) => {
de::Deserializer::deserialize_any(SeqDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant"),),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),),
}
}
fn struct_variant<V>(
self,
_fields: &'static [&'static str],
visitor: V
visitor: V,
) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
match self.value {
Some(Value::Object(v)) => {
de::Deserializer::deserialize_any(MapDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
_ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant"),),
_ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),),
}
}
}
@ -2213,9 +2256,7 @@ struct SeqDeserializer {
impl SeqDeserializer {
fn new(vec: Vec<Value>) -> Self {
SeqDeserializer {
iter: vec.into_iter(),
}
SeqDeserializer { iter: vec.into_iter() }
}
}
@ -2224,7 +2265,8 @@ impl<'de> de::Deserializer<'de> for SeqDeserializer {
#[inline]
fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
let len = self.iter.len();
if len == 0 {
@ -2251,7 +2293,8 @@ impl<'de> de::SeqAccess<'de> for SeqDeserializer {
type Error = Error;
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some(value) => seed.deserialize(value).map(Some),
@ -2285,7 +2328,8 @@ impl<'de> de::MapAccess<'de> for MapDeserializer {
type Error = Error;
fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some((key, value)) => {
@ -2297,7 +2341,8 @@ impl<'de> de::MapAccess<'de> for MapDeserializer {
}
fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match self.value.take() {
Some(value) => seed.deserialize(value),
@ -2318,7 +2363,8 @@ impl<'de> de::Deserializer<'de> for MapDeserializer {
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_map(self)
}
@ -2334,7 +2380,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a Value {
type Error = Error;
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
match *self {
Value::Null => visitor.visit_unit(),
@ -2366,11 +2413,9 @@ impl<'de, 'a> de::Deserializer<'de> for &'a Value {
}
}
fn deserialize_option<V>(
self,
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
match *self {
Value::Null => visitor.visit_none(),
@ -2382,9 +2427,10 @@ impl<'de, 'a> de::Deserializer<'de> for &'a Value {
self,
_name: &str,
_variants: &'static [&'static str],
visitor: V
visitor: V,
) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
let (variant, value) = match *self {
Value::Object(ref value) => {
@ -2392,34 +2438,42 @@ impl<'de, 'a> de::Deserializer<'de> for &'a Value {
let (variant, value) = match iter.next() {
Some(v) => v,
None => {
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"));
return Err(
de::Error::invalid_value(
Unexpected::Map,
&"map with a single key",
),
);
}
};
// enums are encoded in json as maps with a single key:value pair
if iter.next().is_some() {
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"));
return Err(de::Error::invalid_value(Unexpected::Map, &"map with a single key"),);
}
(variant, Some(value))
}
Value::String(ref variant) => (variant, None),
ref other => {
return Err(de::Error::invalid_type(other.unexpected(), &"string or map"));
return Err(de::Error::invalid_type(other.unexpected(), &"string or map"),);
}
};
visitor.visit_enum(EnumRefDeserializer {
variant: variant,
value: value,
})
visitor.visit_enum(
EnumRefDeserializer {
variant: variant,
value: value,
},
)
}
#[inline]
fn deserialize_newtype_struct<V>(
self,
_name: &'static str,
visitor: V
visitor: V,
) -> Result<V::Value, Self::Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_newtype_struct(self)
}
@ -2441,7 +2495,8 @@ impl<'de, 'a> de::EnumAccess<'de> for EnumRefDeserializer<'a> {
type Variant = VariantRefDeserializer<'a>;
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
where V: de::DeserializeSeed<'de>,
where
V: de::DeserializeSeed<'de>,
{
let variant = self.variant.into_deserializer();
let visitor = VariantRefDeserializer { value: self.value };
@ -2464,43 +2519,42 @@ impl<'de, 'a> de::VariantAccess<'de> for VariantRefDeserializer<'a> {
}
fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match self.value {
Some(value) => seed.deserialize(value),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant")),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),),
}
}
fn tuple_variant<V>(
self,
_len: usize,
visitor: V
) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
where
V: de::Visitor<'de>,
{
match self.value {
Some(&Value::Array(ref v)) => {
de::Deserializer::deserialize_any(SeqRefDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"))
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant"),),
None => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),),
}
}
fn struct_variant<V>(
self,
_fields: &'static [&'static str],
visitor: V
visitor: V,
) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
match self.value {
Some(&Value::Object(ref v)) => {
de::Deserializer::deserialize_any(MapRefDeserializer::new(v), visitor)
}
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
_ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"))
Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant"),),
_ => Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),),
}
}
}
@ -2511,9 +2565,7 @@ struct SeqRefDeserializer<'a> {
impl<'a> SeqRefDeserializer<'a> {
fn new(slice: &'a [Value]) -> Self {
SeqRefDeserializer {
iter: slice.iter(),
}
SeqRefDeserializer { iter: slice.iter() }
}
}
@ -2522,7 +2574,8 @@ impl<'de, 'a> de::Deserializer<'de> for SeqRefDeserializer<'a> {
#[inline]
fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
let len = self.iter.len();
if len == 0 {
@ -2549,7 +2602,8 @@ impl<'de, 'a> de::SeqAccess<'de> for SeqRefDeserializer<'a> {
type Error = Error;
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some(value) => seed.deserialize(value).map(Some),
@ -2583,7 +2637,8 @@ impl<'de, 'a> de::MapAccess<'de> for MapRefDeserializer<'a> {
type Error = Error;
fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match self.iter.next() {
Some((key, value)) => {
@ -2595,7 +2650,8 @@ impl<'de, 'a> de::MapAccess<'de> for MapRefDeserializer<'a> {
}
fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
where T: de::DeserializeSeed<'de>,
where
T: de::DeserializeSeed<'de>,
{
match self.value.take() {
Some(value) => seed.deserialize(value),
@ -2616,7 +2672,8 @@ impl<'de, 'a> de::Deserializer<'de> for MapRefDeserializer<'a> {
#[inline]
fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
where V: de::Visitor<'de>,
where
V: de::Visitor<'de>,
{
visitor.visit_map(self)
}
@ -2667,7 +2724,8 @@ impl Value {
// Taking by value is more friendly to iterator adapters, option and result
// consumers, etc. See https://github.com/serde-rs/json/pull/149.
pub fn to_value<T>(value: T) -> Result<Value, Error>
where T: ser::Serialize,
where
T: ser::Serialize,
{
value.serialize(Serializer)
}
@ -2682,7 +2740,8 @@ pub fn to_value<T>(value: T) -> Result<Value, Error>
/// the JSON map or some number is too big to fit in the expected primitive
/// type.
pub fn from_value<T>(value: Value) -> Result<T, Error>
where T: de::DeserializeOwned,
where
T: de::DeserializeOwned,
{
de::Deserialize::deserialize(value)
}

78
tests/stream.rs
View File

@ -49,69 +49,79 @@ macro_rules! test_stream {
fn test_json_stream_newlines() {
let data = "{\"x\":39} {\"x\":40}{\"x\":41}\n{\"x\":42}";
test_stream!(data, Value, |stream| {
assert_eq!(stream.next().unwrap().unwrap()["x"], 39);
assert_eq!(stream.byte_offset(), 8);
test_stream!(
data, Value, |stream| {
assert_eq!(stream.next().unwrap().unwrap()["x"], 39);
assert_eq!(stream.byte_offset(), 8);
assert_eq!(stream.next().unwrap().unwrap()["x"], 40);
assert_eq!(stream.byte_offset(), 17);
assert_eq!(stream.next().unwrap().unwrap()["x"], 40);
assert_eq!(stream.byte_offset(), 17);
assert_eq!(stream.next().unwrap().unwrap()["x"], 41);
assert_eq!(stream.byte_offset(), 25);
assert_eq!(stream.next().unwrap().unwrap()["x"], 41);
assert_eq!(stream.byte_offset(), 25);
assert_eq!(stream.next().unwrap().unwrap()["x"], 42);
assert_eq!(stream.byte_offset(), 34);
assert_eq!(stream.next().unwrap().unwrap()["x"], 42);
assert_eq!(stream.byte_offset(), 34);
assert!(stream.next().is_none());
assert_eq!(stream.byte_offset(), 34);
});
assert!(stream.next().is_none());
assert_eq!(stream.byte_offset(), 34);
}
);
}
#[test]
fn test_json_stream_trailing_whitespaces() {
let data = "{\"x\":42} \t\n";
test_stream!(data, Value, |stream| {
assert_eq!(stream.next().unwrap().unwrap()["x"], 42);
assert_eq!(stream.byte_offset(), 8);
test_stream!(
data, Value, |stream| {
assert_eq!(stream.next().unwrap().unwrap()["x"], 42);
assert_eq!(stream.byte_offset(), 8);
assert!(stream.next().is_none());
assert_eq!(stream.byte_offset(), 11);
});
assert!(stream.next().is_none());
assert_eq!(stream.byte_offset(), 11);
}
);
}
#[test]
fn test_json_stream_truncated() {
let data = "{\"x\":40}\n{\"x\":";
test_stream!(data, Value, |stream| {
assert_eq!(stream.next().unwrap().unwrap()["x"], 40);
assert_eq!(stream.byte_offset(), 8);
test_stream!(
data, Value, |stream| {
assert_eq!(stream.next().unwrap().unwrap()["x"], 40);
assert_eq!(stream.byte_offset(), 8);
assert!(stream.next().unwrap().unwrap_err().is_eof());
assert_eq!(stream.byte_offset(), 9);
});
assert!(stream.next().unwrap().unwrap_err().is_eof());
assert_eq!(stream.byte_offset(), 9);
}
);
}
#[test]
fn test_json_stream_empty() {
let data = "";
test_stream!(data, Value, |stream| {
assert!(stream.next().is_none());
assert_eq!(stream.byte_offset(), 0);
});
test_stream!(
data, Value, |stream| {
assert!(stream.next().is_none());
assert_eq!(stream.byte_offset(), 0);
}
);
}
#[test]
fn test_json_stream_primitive() {
let data = "{} true";
test_stream!(data, Value, |stream| {
assert_eq!(stream.next().unwrap().unwrap(), json!({}));
assert_eq!(stream.byte_offset(), 2);
test_stream!(
data, Value, |stream| {
assert_eq!(stream.next().unwrap().unwrap(), json!({}));
assert_eq!(stream.byte_offset(), 2);
let second = stream.next().unwrap().unwrap_err();
assert_eq!(second.to_string(), "expected `{` or `[` at line 1 column 4");
});
let second = stream.next().unwrap().unwrap_err();
assert_eq!(second.to_string(), "expected `{` or `[` at line 1 column 4");
}
);
}

1035
tests/test.rs
View File

File diff suppressed because it is too large Load Diff