Struct JsonLinesWriter

pub struct JsonLinesWriter<W> { /* private fields */ }

A structure for writing JSON values as JSON Lines.

A JsonLinesWriter wraps a std::io::Write instance and writes serde::Serialize values to it by serializing each one as a single line of JSON and appending a newline.

Example

use serde::Serialize;
use serde_jsonlines::JsonLinesWriter;
use std::fs::{read_to_string, File};

#[derive(Serialize)]
pub struct Structure {
    pub name: String,
    pub size: i32,
    pub on: bool,
}

fn main() -> std::io::Result<()> {
    {
        let fp = File::create("example.jsonl")?;
        let mut writer = JsonLinesWriter::new(fp);
        writer.write_all([
            Structure {
                name: "Foo Bar".into(),
                size: 42,
                on: true,
            },
            Structure {
                name: "Quux".into(),
                size: 23,
                on: false,
            },
            Structure {
                name: "Gnusto Cleesh".into(),
                size: 17,
                on: true,
            },
        ])?;
        writer.flush()?;
    }
    // End the block to close the writer
    assert_eq!(
        read_to_string("example.jsonl")?,
        concat!(
            "{\"name\":\"Foo Bar\",\"size\":42,\"on\":true}\n",
            "{\"name\":\"Quux\",\"size\":23,\"on\":false}\n",
            "{\"name\":\"Gnusto Cleesh\",\"size\":17,\"on\":true}\n",
        )
    );
    Ok(())
}

Implementations

impl<W> JsonLinesWriter<W>

pub fn new(writer: W) -> Self

Construct a new JsonLinesWriter from a std::io::Write instance

pub fn into_inner(self) -> W

Consume the JsonLinesWriter and return the underlying writer

pub fn get_ref(&self) -> &W

Get a reference to the underlying writer

pub fn get_mut(&mut self) -> &mut W

Get a mutable reference to the underlying writer

impl<W: Write> JsonLinesWriter<W>

pub fn write<T>(&mut self, value: &T) -> Result<()>

where T: ?Sized + Serialize,

Serialize a value as a line of JSON and write it to the underlying writer, followed by a newline.

Note that separate calls to this method may write different types of values.

Errors

Has the same error conditions as serde_json::to_writer() and std::io::Write::write_all().

pub fn write_all<T, I>(&mut self, items: I) -> Result<()>

where I: IntoIterator<Item = T>, T: Serialize,

Serialize each item in an iterator as a line of JSON, and write out each one followed by a newline to the underlying writer.

All values in a single call to write_all() must be the same type, but separate calls may write different types.

Errors

Has the same error conditions as write().

pub fn flush(&mut self) -> Result<()>

Flush the underlying writer.

Neither write() nor write_all() flush the writer, so you must explicitly call this method if you need output flushed.

Errors

Has the same error conditions as std::io::Write::flush().

Trait Implementations

impl<W: Clone> Clone for JsonLinesWriter<W>

fn clone(&self) -> JsonLinesWriter<W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W: Debug> Debug for JsonLinesWriter<W>

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

Formats the value using the given formatter.

impl<W: PartialEq> PartialEq for JsonLinesWriter<W>

fn eq(&self, other: &JsonLinesWriter<W>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<W: Eq> Eq for JsonLinesWriter<W>

impl<W> StructuralPartialEq for JsonLinesWriter<W>