rs-jsonmaps2protomaps 0.1.0

Converts the JSON maps to the protobuf structs.
Documentation
use std::io;

use std::collections::HashMap;

use io::BufRead;
use io::BufWriter;
use io::Write;

use protobuf::Message;

use protobuf::well_known_types::struct_::ListValue;
use protobuf::well_known_types::struct_::NullValue;
use protobuf::well_known_types::struct_::Struct;
use protobuf::well_known_types::struct_::Value;

pub fn null2val() -> Value {
    let mut ret: Value = Value::default();
    ret.set_null_value(NullValue::default());
    ret
}

pub fn f2value(f: f64) -> Value {
    let mut ret: Value = Value::default();
    ret.set_number_value(f);
    ret
}

pub fn s2value(s: String) -> Value {
    let mut ret: Value = Value::default();
    ret.set_string_value(s);
    ret
}

pub fn b2value(b: bool) -> Value {
    let mut ret: Value = Value::default();
    ret.set_bool_value(b);
    ret
}

pub fn struct2value(s: Struct) -> Value {
    let mut ret: Value = Value::default();
    ret.set_struct_value(s);
    ret
}

pub fn l2value(l: ListValue) -> Value {
    let mut ret: Value = Value::default();
    ret.set_list_value(l);
    ret
}

pub fn m2struct(m: HashMap<String, Value>) -> Struct {
    Struct {
        fields: m,
        ..Default::default()
    }
}

pub fn jnum2value(jnum: serde_json::Number) -> Option<Value> {
    let of: Option<f64> = jnum.as_f64();
    let f: f64 = of?;
    Some(f2value(f))
}

pub fn jval2value(jval: serde_json::Value) -> Option<Value> {
    match jval {
        serde_json::Value::Null => Some(null2val()),
        serde_json::Value::Bool(b) => Some(b2value(b)),
        serde_json::Value::Number(n) => jnum2value(n),
        serde_json::Value::String(s) => Some(s2value(s)),
        serde_json::Value::Array(arr) => {
            let mut list = ListValue::default();
            for item in arr {
                let oval: Option<Value> = jval2value(item);
                let val: Value = oval?;
                list.values.push(val);
            }
            Some(l2value(list))
        }
        serde_json::Value::Object(obj) => {
            let mut map = HashMap::new();
            for (k, v) in obj {
                let oval: Option<Value> = jval2value(v);
                let val: Value = oval?;
                map.insert(k, val);
            }
            Some(struct2value(m2struct(map)))
        }
    }
}

pub fn jmap2struct(jmap: serde_json::Map<String, serde_json::Value>) -> Option<Struct> {
    let mut fields = HashMap::new();
    for (k, v) in jmap {
        let oproto_val: Option<Value> = jval2value(v);
        let proto_val: Value = oproto_val?;
        fields.insert(k, proto_val);
    }
    Some(m2struct(fields))
}

pub fn reader2jsonmaps2structs2writer<R, W>(rdr: R, mut wtr: W) -> Result<(), io::Error>
where
    R: BufRead,
    W: Write,
{
    let deser = serde_json::de::Deserializer::from_reader(rdr);
    let maps = deser.into_iter();
    let mapd = maps.map(|r: Result<serde_json::Map<String, serde_json::Value>, _>| {
        r.map_err(io::Error::other)
    });
    let converted = mapd.map(|r| {
        r.and_then(|jm| {
            let ostr: Option<Struct> = jmap2struct(jm);
            ostr.ok_or(io::Error::other("unable to convert the json map"))
        })
    });
    for rstr in converted {
        let pstr: Struct = rstr?;
        pstr.write_length_delimited_to_writer(&mut wtr)?;
    }
    wtr.flush()
}

pub fn stdin2jsonmaps2structs2stdout() -> Result<(), io::Error> {
    let o = io::stdout();
    let mut ol = o.lock();
    reader2jsonmaps2structs2writer(io::stdin().lock(), BufWriter::new(&mut ol))?;
    ol.flush()
}