Crate streamson_lib

This library is able to process large JSON data.

It can have various matchers which matches the path (see matcher)

And various handlers to do something with found data (see handlers)

Examples

use streamson_lib::{handler::{self, Handler}, matcher, strategy::{self, Strategy}};
use std::{io, fs, sync::{Arc, Mutex}};

let stdout_handler = Arc::new(Mutex::new(handler::Output::new(io::stdout())));

let file = fs::File::create("out.txt").unwrap();
let handler = handler::Group::new()
    .add_handler(Arc::new(Mutex::new(handler::Output::new(file))))
    .add_handler(stdout_handler.clone());

let first_matcher = matcher::Simple::new(r#"{"users"}[]"#).unwrap();
let second_matcher = matcher::Simple::new(r#"{"groups"}[]"#).unwrap();

let mut trigger = strategy::Trigger::new();

// exports users to stdout and out.txt
trigger.add_matcher(
    Box::new(first_matcher),
    Arc::new(Mutex::new(handler.clone())),
);

// groups are going to be expoted only to stdout
trigger.add_matcher(
    Box::new(second_matcher),
    stdout_handler,
);

for input in vec![
    br#"{"users": [1,2]"#.to_vec(),
    br#", "groups": [3, 4]}"#.to_vec(),
] {
    trigger.process(&input).unwrap();
}

use streamson_lib::{handler::{self, Handler}, matcher, strategy::{Strategy, self}};
use std::{fs, io, sync::{Arc, Mutex}};

let file = fs::File::create("out.txt").unwrap();
let file_handler = Arc::new(
    Mutex::new(handler::Output::new(file))
);
let stdout_handler = Arc::new(Mutex::new(handler::Output::new(io::stdout())));
let handler = handler::Group::new()
    .add_handler(stdout_handler)
    .add_handler(file_handler);

let first_matcher = matcher::Depth::new(1, Some(2));
let second_matcher = matcher::Simple::new(r#"{"users"}[]"#).unwrap();
let matcher = matcher::Combinator::new(first_matcher) |
    matcher::Combinator::new(second_matcher);

let mut trigger = strategy::Trigger::new();

// Paths with depths 1, 2 are exported to out.txt
trigger.add_matcher(
    Box::new(matcher),
    Arc::new(Mutex::new(handler)),
);

for input in vec![
    br#"{"users": [1,2]"#.to_vec(),
    br#", "groups": [3, 4]}"#.to_vec(),
] {
    trigger.process(&input).unwrap();
}

use streamson_lib::{handler::{self, Handler}, matcher, strategy::{Strategy, self}};
use std::{io, fs, sync::{Arc, Mutex}};

let file = fs::File::create("out.txt").unwrap();
let file_handler = Arc::new(
    Mutex::new(handler::Output::new(file))
);
let stdout_handler = Arc::new(Mutex::new(handler::Output::new(io::stdout())));
let handler = handler::Group::new()
    .add_handler(stdout_handler)
    .add_handler(file_handler);

let matcher = matcher::Depth::new(1, Some(2));

let mut trigger = strategy::Trigger::new();

// Paths with depths 1, 2 are exported to out.txt
trigger.add_matcher(
    Box::new(matcher),
    Arc::new(Mutex::new(handler)),
);

for input in vec![
    br#"{"users": [1,2]"#.to_vec(),
    br#", "groups": [3, 4]}"#.to_vec(),
] {
    trigger.process(&input).unwrap();
}

Re-exports

pub use handler::Handler;

pub use path::Path;

pub use streamer::Streamer;

pub use streamer::Token;

Modules

error	Module containing errors
handler	Collections of handler (what to do with matched paths and data).
matcher	Collections of path matchers (matches the path).
path	Structs to handle abstraction over a path in JSON
strategy	Collection of json processing strategies
streamer	Streams significant point of JSON from input data