Struct AsyncJsonLinesWriter 

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

Available on crate feature async only.

A structure for asynchronously writing JSON values as JSON Lines.

An AsyncJsonLinesWriter wraps a tokio::io::AsyncWrite 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::AsyncJsonLinesWriter;
use tokio::fs::{read_to_string, File};

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

#[tokio::main]
async fn main() -> std::io::Result<()> {
    {
        let fp = File::create("example.jsonl").await?;
        let mut writer = AsyncJsonLinesWriter::new(fp);
        writer
            .write(&Structure {
                name: "Foo Bar".into(),
                size: 42,
                on: true,
            })
            .await?;
        writer
            .write(&Structure {
                name: "Quux".into(),
                size: 23,
                on: false,
            })
            .await?;
        writer
            .write(&Structure {
                name: "Gnusto Cleesh".into(),
                size: 17,
                on: true,
            })
            .await?;
        writer.flush().await?;
    }
    // End the block to close the writer
    assert_eq!(
        read_to_string("example.jsonl").await?,
        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> AsyncJsonLinesWriter<W>

pub fn new(writer: W) -> Self

Construct a new AsyncJsonLinesWriter from a tokio::io::AsyncWrite instance

pub fn into_inner(self) -> W

Consume the AsyncJsonLinesWriter 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

pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut W>

Get a pinned mutable reference to the underlying writer

pub fn into_sink<T>(self) -> JsonLinesSink<W, T>

Consume the AsyncJsonLinesWriter and return an asynchronous sink for serializing values as JSON and writing them to the underlying writer.

The returned sink consumes T values and has an Error type of std::io::Error. Each call to send() has the same error conditions as write().

Note that all values sent to the sink must be of the same type. If you wish to write values of varying types, use the write() method.

impl<W: AsyncWrite> AsyncJsonLinesWriter<W>

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

where T: ?Sized + Serialize, W: Unpin,

Serialize a value as a line of JSON and write it asynchronously 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 tokio::io::AsyncWriteExt::write_all().

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

where W: Unpin,

Flush the underlying writer.

write() does not flush the writer, so you must explicitly call this method if you need output flushed.

Errors

Has the same error conditions as tokio::io::AsyncWriteExt::flush().

Trait Implementations

impl<W: Clone> Clone for AsyncJsonLinesWriter<W>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W: Debug> Debug for AsyncJsonLinesWriter<W>

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

Formats the value using the given formatter.

impl<W: PartialEq> PartialEq for AsyncJsonLinesWriter<W>

fn eq(&self, other: &AsyncJsonLinesWriter<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 AsyncJsonLinesWriter<W>

impl<W> StructuralPartialEq for AsyncJsonLinesWriter<W>

impl<'__pin, W> Unpin for AsyncJsonLinesWriter<W>

where __Origin<'__pin, W>: Unpin,