[−][src]Enum sj::Value

pub enum Value {
    String(String),
    Number(Number),
    Boolean(bool),
    Null,
    Object(Object),
    Array(Array),
}

A value

Usage

Formatting as JSON string

To format as compacted JSON string, you can use to_string() or implementation of From<Value> for Vec<u8>, or into_bytes().

To format with default tab width (4), you can use # (via Formatter):

format!(
    "{:#}",
    sj::parse(&mut &br#"["test"]"#[..]).unwrap(),
);

You can set tab width (required) and tab level (optional):

format!(
    "{:width$.level$}",
    sj::parse(&mut &br#"["test"]"#[..]).unwrap(),
    width=4, level=0,
);

Writing as JSON string to `Write`

Can be done via write() or write_nicely().

Converting Rust types to `Value` and vice versa

There are some implementations:

impl From<...> for Value;
impl TryFrom<&Value> for ...;
impl TryFrom<Value> for ...;

About TryFrom implementations:

For primitives, since they're cheap, they have implementations on either a borrowed or an owned value.
For collections such as String, Vec..., they only have implementations on an owned value. So data is moved, not copied.

Shortcuts

A root JSON value can be either an object or an array. For your convenience, there are some shortcuts, like below examples.

let mut object = sj::object();
object.insert("first", true)?;
object.insert("second", Some(9))?;
object.insert(String::from("third"), "...")?;
assert!(object.as_mut_object()?.remove("second").is_some());
assert_eq!(object.to_string(), r#"{"first":true,"third":"..."}"#);

let mut array = sj::array();
array.push(false)?;
array.push("a string")?;
array.push(Some(sj::object()))?;
assert_eq!(array.to_string(), r#"[false,"a string",{}]"#);

Variants

String(String)

String

Number(Number)

Number

Boolean(bool)

Boolean

Null

Null

Object(Object)

Object

Array(Array)

Array

Methods

`impl Value`[src]

`pub fn into_bytes(self) -> Vec<u8>`[src]

Formats this value as a compacted JSON string

`pub fn as_str(&self) -> Result<&str>`[src]

If the value is a string, returns an immutable reference of it

Returns an error if the value is not a string.

`pub fn push<T>(&mut self, value: T) -> Result<()> where T: Into<Self>,` [src]

If the value is an array, pushes new item into it

Returns an error if the value is not an array.

`pub fn as_array(&self) -> Result<&Array>`[src]

If the value is an array, returns an immutable reference of it

Returns an error if the value is not an array.

`pub fn as_mut_array(&mut self) -> Result<&mut Array>`[src]

If the value is an array, returns a mutable reference of it

Returns an error if the value is not an array.

`pub fn insert<S, T>(&mut self, key: S, value: T) -> Result<Option<Self>> where S: Into<String>, T: Into<Self>,` [src]

If the value is an object, inserts new item into it

On success, returns previous value (if it existed).

Returns an error if the value is not an object.

`pub fn as_object(&self) -> Result<&Object>`[src]

If the value is an object, returns an immutable reference of it

Returns an error if the value is not an object.

`pub fn as_mut_object(&mut self) -> Result<&mut Object>`[src]

If the value is an object, returns a mutable reference of it

Returns an error if the value is not an object.

`pub fn write<W>(&self, stream: &mut W) -> IoResult<()> where W: Write,` [src]

Writes this value as compacted JSON string to a stream

Notes

The stream is used as-is. For better performance, you should wrap your stream inside a BufWriter.
This function does not flush the stream when done.

`pub fn write_nicely<W>( &self, tab: Option<usize>, stream: &mut W ) -> IoResult<()> where W: Write,` [src]

Writes this value as nicely formatted JSON string to a stream

Notes

If you don't provide tab size, default (4) will be used.
The stream is used as-is. For better performance, you should wrap your stream inside a BufWriter.
This function does not flush the stream when done.