Struct Content 

pub struct Content<B: Deref<Target = [u8]> + Debug>(/* private fields */);

Text content of a JSON token identified by a FixedAnalyzer.

See the lexical::Content trait, implemented by this struct, for detailed conceptual documentation.

Implementations

impl Content<Vec<u8>>

pub fn from_static(s: &'static str) -> Self

Constructs a new Content value from a static lifetime string that contains a valid JSON token.

The entire string must be a single valid lexical token. It may be the empty string, which is equivalent to Token::Eof; or may be all whitespace, equivalent to Token::White. String token content must begin and end with a double quote character.

Panics

Panics if the string is not valid JSON token content.

Example

let obj_begin = Content::from_static("{");
assert_eq!("{", obj_begin.literal());
assert!(!obj_begin.is_escaped());

let str_escaped = Content::from_static(r#""hello\nworld""#);
assert_eq!(r#""hello\nworld""#, str_escaped.literal());
assert!(str_escaped.is_escaped());
assert_eq!(r#""hello
world""#, str_escaped.unescaped());

impl<B: Deref<Target = [u8]> + Debug> Content<B>

pub fn literal(&self) -> &str

Returns the literal content of the token exactly as it appears in the JSON text.

This is an inherent implementation of lexical::Content::literal for convenience, so it is available even when you don’t have the trait imported. Refer to the trait documentation for conceptual details.

pub fn literal_len(&self) -> usize

Returns the number of bytes in the literal value.

pub fn is_escaped(&self) -> bool

Indicates whether the token content contains escape sequences.

This is an inherent implementation of lexical::Content::is_escaped for convenience, so it is available even when you don’t have the trait imported. Refer to the trait documentation for conceptual details.

pub fn unescaped(&self) -> Unescaped<&str>

Returns a normalized version of literal` with all escape sequences in the JSON text fully expanded.

This is an inherent implementation of lexical::Content::unescaped for convenience, so it is available even when you don’t have the trait imported. Refer to the trait documentation for conceptual details.

Performance considerations

• If this content belongs to a non-string token, or a string token that contains no escape sequences, does not allocate, and simply returns an Unescaped::Literal wrapping the borrow returned by literal, which is a reference to the internals of this content.
• If this content belongs to a string token containing at least one escape sequence, allocates a new owned string value containing the unescaped string content and returns it wrapped in Unescaped::Expanded.

pub fn unescaped_cmp(&self, other: &str) -> Ordering

Compares the token content to another string, expanding embedded escape sequences.

For non-string tokens, and string tokens for which is_escaped returns false, this method returns the equivalent of self.literal().cmp(other).

For string tokens with one or more escape sequences, this method compares a normalized version of the string value with escape sequences expanded to other. It gives the same result as self.unescaped().cmp(other), but is faster because it avoids the accompanying allocations and copying.

Note two important details. First, no unescaping is done on other, which is assumed to contain a string with escape sequences fully expanded. Second, apart from expanding escape sequences, self is compared byte-for-byte against other, so if self contains the content of a string token, then other will need to begin and end with a quotation mark character, " (U+0022) in order to compare equal.

Performance considerations

Does not allocate.

Since this method is marginally less efficient than comparing directly against the literal value, it is preferable to use it only when is_escaped returns true.

Example

use bufjson::lexical::{Token, fixed::FixedAnalyzer};
use std::cmp::Ordering;

let mut an = FixedAnalyzer::new(&br#""hello\nworld! \ud83c\udf0d""#[..]);

assert_eq!(Token::Str, an.next());
assert_eq!(
    Ordering::Equal, an.content().unescaped_cmp(r#""hello
world! 🌍""#));

pub fn parse_i64(&self) -> Result<i64, NumError>

Available on crate feature num only.

Converts the token content to a 64-bit signed integer.

This is an inherent implementation of lexical::Content::parse_i64 for convenience, so it is available even when you don’t have the trait imported.

Performance considerations

This implementation is faster than lexical::parse_i64 because it is optimized for the fixed-size buffer case and does not need to handle the possibility that the number text might be split across multiple buffers. It never allocates or copies.

Example

use bufjson::lexical::{Token, fixed::FixedAnalyzer};

let mut an = FixedAnalyzer::new(&b"[123]"[..]);

assert_eq!(Token::ArrBegin, an.next());
assert_eq!(Token::Num, an.next());
assert_eq!(Ok(123), an.content().parse_i64());
assert_eq!(Token::ArrEnd, an.next());

pub fn parse_u64(&self) -> Result<u64, NumError>

Available on crate feature num only.

Converts the token content to a 64-bit unsigned integer.

This is an inherent implementation of lexical::Content::parse_u64 for convenience, so it is available even when you don’t have the trait imported.

Performance considerations

This implementation is faster than lexical::parse_u64 because it is optimized for the fixed-size buffer case and does not need to handle the possibility that the number text might be split across multiple buffers. It never allocates or copies.

Example

use bufjson::lexical::{Token, fixed::FixedAnalyzer};

let mut an = FixedAnalyzer::new(&b"[123]"[..]);

assert_eq!(Token::ArrBegin, an.next());
assert_eq!(Token::Num, an.next());
assert_eq!(Ok(123), an.content().parse_u64());
assert_eq!(Token::ArrEnd, an.next());

pub fn parse_i128(&self) -> Result<i128, NumError>

Available on crate feature num_ext only.

Converts the token content to a 128-bit signed integer.

This is an inherent implementation of lexical::Content::parse_i128 for convenience, so it is available even when you don’t have the trait imported.

Performance considerations

This method is faster than lexical::parse_i128 because it is optimized for the fixed-size buffer case and does not need to handle the possibility that the number text might be split across multiple buffers. It never allocates or copies.

Example

use bufjson::lexical::{Token, fixed::FixedAnalyzer};

const TEXT: &str = r#"{"10^38":100000000000000000000000000000000000000}"#;

let mut an = FixedAnalyzer::new(TEXT.as_bytes());

assert_eq!(Token::ObjBegin, an.next());
assert_eq!(Token::Str, an.next());
assert_eq!(Token::NameSep, an.next());
assert_eq!(Token::Num, an.next());
assert_eq!(Ok(10_i128.pow(38)), an.content().parse_i128());
assert_eq!(Token::ObjEnd, an.next());

pub fn parse_f64(&self) -> Result<f64, NumError>

Available on crate feature num only.

Converts the token content to a 64-bit IEEE double precision floating point number.

This is an inherent implementation of lexical::Content::parse_f64 for convenience, so it is available even when you don’t have the trait imported.

Performance considerations

This method is faster than lexical::parse_f64 because it is optimized for the fixed-size buffer case and does not need to handle the possibility that the number text might be split across multiple buffers. It never allocates or copies.

Example

use bufjson::lexical::{Token, fixed::FixedAnalyzer};

let mut an = FixedAnalyzer::new(&br#"{"pi":3.14159}"#[..]);

assert_eq!(Token::ObjBegin, an.next());
assert_eq!(Token::Str, an.next());
assert_eq!(Token::NameSep, an.next());
assert_eq!(Token::Num, an.next());
assert_eq!(Ok(3.14159), an.content().parse_f64());
assert_eq!(Token::ObjEnd, an.next());

Trait Implementations

impl<B: Clone + Deref<Target = [u8]> + Debug> Clone for Content<B>

fn clone(&self) -> Content<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Deref<Target = [u8]> + Debug> Content for Content<B>

type Literal<'a> = &'a str where Self: 'a

Type that contains the literal string of the token exactly as it appears in the JSON text.

fn literal<'a>(&'a self) -> Self::Literal<'a>

Returns the literal content of the token exactly as it appears in the JSON text.

fn literal_len(&self) -> usize

Returns the number of bytes in the literal value.

fn is_escaped(&self) -> bool

Indicates whether the token content contains escape sequences.

fn unescaped<'a>(&'a self) -> Unescaped<Self::Literal<'a>>

Returns a normalized version of literal with all escape sequences in the JSON text fully expanded.

fn unescaped_cmp(&self, other: &str) -> Ordering

Compares the token content to another string, expanding embedded escape sequences.

fn parse_i64(&self) -> Result<i64, NumError>

Available on crate feature num only.

Converts the token content to a 64-bit signed integer.

fn parse_u64(&self) -> Result<u64, NumError>

Available on crate feature num only.

Converts the token content to a 64-bit unsigned integer.

fn parse_i128(&self) -> Result<i128, NumError>

Available on crate feature num_ext only.

Converts the token content to a 128-bit signed integer.

fn parse_f64(&self) -> Result<f64, NumError>

Available on crate feature num only.

Converts the token content to a 64-bit IEEE double precision floating point number.

impl<B: Debug + Deref<Target = [u8]> + Debug> Debug for Content<B>

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

Formats the value using the given formatter.

impl Default for Content<Vec<u8>>

fn default() -> Self

Returns the “default value” for a type.

impl<B: Deref<Target = [u8]> + Debug> Display for Content<B>

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

Formats the value using the given formatter.