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()
}