Struct AsyncJsonLinesReader

pub struct AsyncJsonLinesReader<R> { /* private fields */ }

Available on crate feature async only.

A structure for asynchronously reading JSON values from JSON Lines input.

An AsyncJsonLinesReader wraps a tokio::io::AsyncBufRead instance and parses each line as a serde::de::DeserializeOwned value in JSON.

Example

use futures_util::TryStreamExt;
use serde::Deserialize;
use serde_jsonlines::AsyncJsonLinesReader;
use tokio::fs::{write, File};
use tokio::io::BufReader;

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

#[tokio::main]
async fn main() -> std::io::Result<()> {
    write(
        "example.jsonl",
        concat!(
            "{\"name\": \"Foo Bar\", \"on\":true,\"size\": 42 }\n",
            "{ \"name\":\"Quux\", \"on\" : false ,\"size\": 23}\n",
            " {\"name\": \"Gnusto Cleesh\" , \"on\": true, \"size\": 17}\n",
        ),
    )
    .await?;
    let fp = BufReader::new(File::open("example.jsonl").await?);
    let reader = AsyncJsonLinesReader::new(fp);
    let items = reader
        .read_all::<Structure>()
        .try_collect::<Vec<_>>()
        .await?;
    assert_eq!(
        items,
        [
            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,
            },
        ]
    );
    Ok(())
}

Implementations

impl<R> AsyncJsonLinesReader<R>

pub fn new(reader: R) -> Self

Construct a new AsyncJsonLinesReader from a tokio::io::AsyncBufRead instance

pub fn into_inner(self) -> R

Consume the AsyncJsonLinesReader and return the underlying reader

pub fn get_ref(&self) -> &R

Get a reference to the underlying reader

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

Get a mutable reference to the underlying reader

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

Get a pinned mutable reference to the underlying reader

impl<R: AsyncBufRead> AsyncJsonLinesReader<R>

pub async fn read<T>(&mut self) -> Result<Option<T>>

where T: DeserializeOwned, R: Unpin,

Asynchronously read & deserialize a line of JSON from the underlying reader.

If end-of-file is reached, this method returns Ok(None).

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

Errors

Has the same error conditions as tokio::io::AsyncBufReadExt::read_line() and serde_json::from_str(). Note that, in the latter case (which can be identified by the std::io::Error having a serde_json::Error value as its payload), continuing to read from the AsyncJsonLinesReader afterwards will pick up on the next line as though the error never happened, so invalid JSON can be easily ignored if you so wish.

pub fn read_all<T>(self) -> JsonLinesStream<R, T>

Consume the AsyncJsonLinesReader and return an asynchronous stream over the deserialized JSON values from each line.

The returned stream has an Item type of std::io::Result<T>. Each call to next() has the same error conditions as read().

Note that all deserialized values will be of the same type. If you wish to read lines of varying types, use the read() method instead.

Trait Implementations

impl<R: Clone> Clone for AsyncJsonLinesReader<R>

fn clone(&self) -> AsyncJsonLinesReader<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug> Debug for AsyncJsonLinesReader<R>

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

Formats the value using the given formatter.

impl<R: PartialEq> PartialEq for AsyncJsonLinesReader<R>

fn eq(&self, other: &AsyncJsonLinesReader<R>) -> 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<R: Eq> Eq for AsyncJsonLinesReader<R>

impl<R> StructuralPartialEq for AsyncJsonLinesReader<R>

impl<'__pin, R> Unpin for AsyncJsonLinesReader<R>

where __Origin<'__pin, R>: Unpin,