Struct struson::writer::simple::SimpleJsonWriter

pub struct SimpleJsonWriter<J: JsonWriter> { /* private fields */ }

Available on crate feature experimental only.

JSON writer variant which is easier to use than JsonWriter

This JSON writer variant ensures correct usage at compile-time making it easier and less error-prone to use than JsonWriter, which validates correct usage at runtime and panics on incorrect usage. However, this comes at the cost of SimpleJsonWriter being less flexible to use, and it not offerring all features of JsonWriter.

When an error is returned by one of the methods of the writer, the error should be propagated (for example by using Rust’s ? operator), processing should be aborted and the writer should not be used any further.

Examples

// In this example JSON bytes are stored in a Vec;
// normally they would be written to a file or network connection
let mut writer = Vec::<u8>::new();
let json_writer = SimpleJsonWriter::new(&mut writer);
json_writer.write_object(|object_writer| {
    object_writer.write_number_member("a", 1)?;
    object_writer.write_bool_member("b", true)?;
    Ok(())
})?;

let json = String::from_utf8(writer)?;
assert_eq!(json, r#"{"a":1,"b":true}"#);

Implementations

impl<J: JsonWriter> SimpleJsonWriter<J>

pub fn from_json_writer(json_writer: J) -> Self

Creates a new SimpleJsonWriter from the given JsonWriter

The JsonWriter acts as delegate which performs the actual JSON writing. It should not have written any JSON data yet, otherwise the behavior of the created SimpleJsonWriter is unspecified and it may panic.

Examples

let mut writer = Vec::<u8>::new();
let json_writer = SimpleJsonWriter::from_json_writer(
    JsonStreamWriter::new_custom(
        &mut writer,
        WriterSettings {
            pretty_print: true,
            // For all other settings use the default
            ..Default::default()
        },
    )
);

impl<W: Write> SimpleJsonWriter<JsonStreamWriter<W>>

pub fn new(writer: W) -> Self

Creates a new JSON writer

The JSON data will be written UTF-8 encoded to the writer. Internally this creates a JsonStreamWriter which acts as delegate; see its documentation for more information about the writing behavior.

Trait Implementations

impl<J: Debug + JsonWriter> Debug for SimpleJsonWriter<J>

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

Formats the value using the given formatter.

impl<J: JsonWriter> ValueWriter<J> for SimpleJsonWriter<J>

fn write_null(self) -> Result<(), Error>

Writes a JSON null value

fn write_bool(self, value: bool) -> Result<(), Error>

Writes a JSON boolean value

fn write_string(self, value: &str) -> Result<(), Error>

Writes a JSON string value

fn write_string_with_writer( self, f: impl FnOnce(StringValueWriter<'_>) -> Result<(), Box<dyn Error>> ) -> Result<(), Box<dyn Error>>

Writes a JSON string value using a Write

fn write_number<N: FiniteNumber>(self, value: N) -> Result<(), Error>

Writes a JSON number value

fn write_fp_number<N: FloatingPointNumber>( self, value: N ) -> Result<(), JsonNumberError>

Writes a floating point JSON number value

fn write_number_string(self, value: &str) -> Result<(), JsonNumberError>

Writes the string representation of a JSON number value

fn write_serialize<S: Serialize>(self, value: &S) -> Result<(), SerializerError>

Available on crate feature serde only.

Serializes a Serde Serialize as next value

fn write_array( self, f: impl FnOnce(&mut ArrayWriter<'_, J>) -> Result<(), Box<dyn Error>> ) -> Result<(), Box<dyn Error>>

Writes a JSON array

fn write_object( self, f: impl FnOnce(&mut ObjectWriter<'_, J>) -> Result<(), Box<dyn Error>> ) -> Result<(), Box<dyn Error>>

Writes a JSON object