Track boundaries in schema-emitted reader code
This commit is contained in:
parent
3176e5f8d0
commit
dcdfdb8dd9
|
@ -14,6 +14,54 @@ use super::context::{ModuleContext, FunctionContext};
|
||||||
use super::names;
|
use super::names;
|
||||||
use super::types::*;
|
use super::types::*;
|
||||||
|
|
||||||
|
#[derive(Clone)]
|
||||||
|
struct BoundaryTracker {
|
||||||
|
tracker_name: String,
|
||||||
|
item_expr: &'static str,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BoundaryTracker {
|
||||||
|
fn unwrap(
|
||||||
|
ctxt: &mut FunctionContext,
|
||||||
|
body: &mut Vec<Item>,
|
||||||
|
open_expr: &'static str,
|
||||||
|
e: Option<&BoundaryTracker>,
|
||||||
|
) -> Self {
|
||||||
|
match e {
|
||||||
|
None => Self::new(ctxt, body, open_expr, "_support::B::Item::SequenceValue"),
|
||||||
|
Some(b) => b.clone(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn new(
|
||||||
|
ctxt: &mut FunctionContext,
|
||||||
|
body: &mut Vec<Item>,
|
||||||
|
open_expr: &'static str,
|
||||||
|
item_expr: &'static str,
|
||||||
|
) -> Self {
|
||||||
|
let tracker_name = ctxt.gentempname();
|
||||||
|
body.push(item(open_expr));
|
||||||
|
body.push(item(seq!["let mut ", tracker_name.clone(), " = _support::B::Type::default();"]));
|
||||||
|
BoundaryTracker {
|
||||||
|
tracker_name,
|
||||||
|
item_expr,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn emit_boundary(&self, body: &mut Vec<Item>) {
|
||||||
|
body.push(item(seq![self.tracker_name.clone(), ".shift(Some(", self.item_expr, "));"]));
|
||||||
|
body.push(item(seq!["r.boundary(&", self.tracker_name.clone(), ")?;"]));
|
||||||
|
}
|
||||||
|
|
||||||
|
fn emit_loop(&self, body: &mut Vec<Item>, inner: Vec<Item>) {
|
||||||
|
body.push(item(seq![
|
||||||
|
"while !r.close_compound", parens![
|
||||||
|
seq!["&mut ", self.tracker_name.clone()],
|
||||||
|
seq!["&", self.item_expr]], "? ",
|
||||||
|
block(inner)]))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
|
pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
|
||||||
m.define_function(
|
m.define_function(
|
||||||
n,
|
n,
|
||||||
|
@ -32,7 +80,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
|
||||||
&(n.to_owned() + "::" + name),
|
&(n.to_owned() + "::" + name),
|
||||||
|mut ctxt| {
|
|mut ctxt| {
|
||||||
let mut body = Vec::new();
|
let mut body = Vec::new();
|
||||||
let dest = pattern_reader(&mut ctxt, pat, false, &mut body);
|
let dest = pattern_reader(&mut ctxt, pat, None, &mut body);
|
||||||
let dest = dest.as_ref().map(String::as_str);
|
let dest = dest.as_ref().map(String::as_str);
|
||||||
construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body);
|
construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body);
|
||||||
item(seq![
|
item(seq![
|
||||||
|
@ -54,12 +102,12 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
|
||||||
let mut ps = vec![&**pattern_0, &**pattern_1];
|
let mut ps = vec![&**pattern_0, &**pattern_1];
|
||||||
ps.extend(pattern_n);
|
ps.extend(pattern_n);
|
||||||
for e in &ps {
|
for e in &ps {
|
||||||
named_pattern_reader(&mut ctxt, e, false, &mut body);
|
named_pattern_reader(&mut ctxt, e, None, &mut body);
|
||||||
}
|
}
|
||||||
construct(&ctxt, item(names::render_constructor(n)), true, &record_type(&ps), None, &mut body);
|
construct(&ctxt, item(names::render_constructor(n)), true, &record_type(&ps), None, &mut body);
|
||||||
}
|
}
|
||||||
Definition::Pattern(p) => {
|
Definition::Pattern(p) => {
|
||||||
let dest = pattern_reader(&mut ctxt, p, false, &mut body);
|
let dest = pattern_reader(&mut ctxt, p, None, &mut body);
|
||||||
let dest = dest.as_ref().map(String::as_str);
|
let dest = dest.as_ref().map(String::as_str);
|
||||||
construct(&ctxt, item(names::render_constructor(n)), true, &pattern_type(p), dest, &mut body);
|
construct(&ctxt, item(names::render_constructor(n)), true, &pattern_type(p), dest, &mut body);
|
||||||
}
|
}
|
||||||
|
@ -175,7 +223,7 @@ fn read_expected_literal_seqs(
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
cases.extend(read_expected_literals_cases(ctxt, nested));
|
cases.extend(read_expected_literals_cases(ctxt, nested));
|
||||||
body.push(item(seq!["match r.next_token(false)? ", block(cases)]));
|
body.push(item(seq!["match r.next_token(true)? ", block(cases)]));
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_expected_literals_cases(
|
fn read_expected_literals_cases(
|
||||||
|
@ -256,19 +304,19 @@ fn read_expected_literals(
|
||||||
possibilities: LiteralCases,
|
possibilities: LiteralCases,
|
||||||
) {
|
) {
|
||||||
let cases = read_expected_literals_cases(ctxt, possibilities);
|
let cases = read_expected_literals_cases(ctxt, possibilities);
|
||||||
body.push(item(seq!["match r.next_token(false)? ", block(cases)]));
|
body.push(item(seq!["match r.next_token(true)? ", block(cases)]));
|
||||||
}
|
}
|
||||||
|
|
||||||
fn simple_pattern_reader(
|
fn simple_pattern_reader(
|
||||||
ctxt: &mut FunctionContext,
|
ctxt: &mut FunctionContext,
|
||||||
p: &SimplePattern,
|
p: &SimplePattern,
|
||||||
in_sequence: bool,
|
boundary_tracker: Option<&BoundaryTracker>,
|
||||||
body: &mut Vec<Item>,
|
body: &mut Vec<Item>,
|
||||||
) -> String {
|
) -> String {
|
||||||
let dest = ctxt.gentempname();
|
let dest = ctxt.gentempname();
|
||||||
match p {
|
match p {
|
||||||
SimplePattern::Any => {
|
SimplePattern::Any => {
|
||||||
ctxt.define_atom(body, &dest, item("r.demand_next(false)?"));
|
ctxt.define_atom(body, &dest, item("r.demand_next(true)?"));
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Atom { atom_kind: k } => {
|
SimplePattern::Atom { atom_kind: k } => {
|
||||||
|
@ -285,8 +333,9 @@ fn simple_pattern_reader(
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Embedded { .. } => {
|
SimplePattern::Embedded { .. } => {
|
||||||
|
// TODO: Is this right? If so, why doesn't it expect *two* Embedded tags in a row??
|
||||||
body.push(item("r.open_embedded()?;"));
|
body.push(item("r.open_embedded()?;"));
|
||||||
ctxt.define_atom(body, &dest, item("r.demand_next(false)?.value().to_embedded()?.clone()"));
|
ctxt.define_atom(body, &dest, item("r.demand_next(true)?.value().to_embedded()?.clone()"));
|
||||||
body.push(item("r.close_embedded()?;"));
|
body.push(item("r.close_embedded()?;"));
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
|
@ -297,38 +346,45 @@ fn simple_pattern_reader(
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Seqof { pattern } => {
|
SimplePattern::Seqof { pattern } => {
|
||||||
if !in_sequence {
|
let boundary_tracker = BoundaryTracker::unwrap(
|
||||||
body.push(item("r.open_sequence()?;"));
|
ctxt, body, "r.open_sequence()?;", boundary_tracker);
|
||||||
}
|
|
||||||
let mut inner = Vec::new();
|
let mut inner = Vec::new();
|
||||||
let item_dest = simple_pattern_reader(ctxt, pattern, false, &mut inner);
|
boundary_tracker.emit_boundary(&mut inner);
|
||||||
|
let item_dest = simple_pattern_reader(ctxt, pattern, None, &mut inner);
|
||||||
inner.push(item(seq![dest.to_owned(), ".push(",
|
inner.push(item(seq![dest.to_owned(), ".push(",
|
||||||
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
|
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
|
||||||
ctxt.declare_compound(body, &dest, item("std::vec::Vec::new()"));
|
ctxt.declare_compound(body, &dest, item("std::vec::Vec::new()"));
|
||||||
body.push(item(seq!["while !(r.close_compound()?) ", block(inner)]));
|
boundary_tracker.emit_loop(body, inner);
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Setof { pattern } => {
|
SimplePattern::Setof { pattern } => {
|
||||||
body.push(item("r.open_set()?;"));
|
let boundary_tracker = BoundaryTracker::new(
|
||||||
|
ctxt, body, "r.open_set()?;", "_support::B::Item::SetValue");
|
||||||
let mut inner = Vec::new();
|
let mut inner = Vec::new();
|
||||||
let item_dest = simple_pattern_reader(ctxt, pattern, false, &mut inner);
|
boundary_tracker.emit_boundary(&mut inner);
|
||||||
|
let item_dest = simple_pattern_reader(ctxt, pattern, None, &mut inner);
|
||||||
inner.push(item(seq![dest.to_owned(), ".insert(",
|
inner.push(item(seq![dest.to_owned(), ".insert(",
|
||||||
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
|
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
|
||||||
ctxt.declare_compound(body, &dest, item("preserves::value::Set::new()"));
|
ctxt.declare_compound(body, &dest, item("preserves::value::Set::new()"));
|
||||||
body.push(item(seq!["while !(r.close_compound()?) ", block(inner)]));
|
boundary_tracker.emit_loop(body, inner);
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Dictof { key, value } => {
|
SimplePattern::Dictof { key, value } => {
|
||||||
body.push(item("r.open_dictionary()?;"));
|
let mut boundary_tracker = BoundaryTracker::new(
|
||||||
|
ctxt, body, "r.open_dictionary()?;", "_support::B::Item::DictionaryKey");
|
||||||
let mut inner = Vec::new();
|
let mut inner = Vec::new();
|
||||||
let key_dest = simple_pattern_reader(ctxt, key, false, &mut inner);
|
boundary_tracker.emit_boundary(&mut inner);
|
||||||
let value_dest = simple_pattern_reader(ctxt, value, false, &mut inner);
|
let key_dest = simple_pattern_reader(ctxt, key, None, &mut inner);
|
||||||
|
boundary_tracker.item_expr = "_support::B::Item::DictionaryValue";
|
||||||
|
boundary_tracker.emit_boundary(&mut inner);
|
||||||
|
let value_dest = simple_pattern_reader(ctxt, value, None, &mut inner);
|
||||||
inner.push(item(seq![
|
inner.push(item(seq![
|
||||||
dest.to_owned(), ".insert(",
|
dest.to_owned(), ".insert(",
|
||||||
store_wrap(true, &field_type(key), &key_dest), ", ",
|
store_wrap(true, &field_type(key), &key_dest), ", ",
|
||||||
store_wrap(true, &field_type(value), &value_dest), ");"]));
|
store_wrap(true, &field_type(value), &value_dest), ");"]));
|
||||||
ctxt.declare_compound(body, &dest, item("preserves::value::Map::new()"));
|
ctxt.declare_compound(body, &dest, item("preserves::value::Map::new()"));
|
||||||
body.push(item(seq!["while !(r.close_compound()?) ", block(inner)]));
|
boundary_tracker.item_expr = "_support::B::Item::DictionaryKey";
|
||||||
|
boundary_tracker.emit_loop(body, inner);
|
||||||
dest
|
dest
|
||||||
},
|
},
|
||||||
SimplePattern::Ref(r) => {
|
SimplePattern::Ref(r) => {
|
||||||
|
@ -342,16 +398,16 @@ fn simple_pattern_reader(
|
||||||
fn named_pattern_reader(
|
fn named_pattern_reader(
|
||||||
ctxt: &mut FunctionContext,
|
ctxt: &mut FunctionContext,
|
||||||
p: &NamedPattern,
|
p: &NamedPattern,
|
||||||
in_sequence: bool,
|
boundary_tracker: Option<&BoundaryTracker>,
|
||||||
body: &mut Vec<Item>,
|
body: &mut Vec<Item>,
|
||||||
) {
|
) {
|
||||||
match p {
|
match p {
|
||||||
NamedPattern::Anonymous(p) => {
|
NamedPattern::Anonymous(p) => {
|
||||||
pattern_reader(ctxt, p, in_sequence, body);
|
pattern_reader(ctxt, p, boundary_tracker, body);
|
||||||
},
|
},
|
||||||
NamedPattern::Named(b) => {
|
NamedPattern::Named(b) => {
|
||||||
let Binding { name, pattern} = &**b;
|
let Binding { name, pattern} = &**b;
|
||||||
let dest = simple_pattern_reader(ctxt, pattern, in_sequence, body);
|
let dest = simple_pattern_reader(ctxt, pattern, boundary_tracker, body);
|
||||||
let capture_ty = field_type(pattern);
|
let capture_ty = field_type(pattern);
|
||||||
ctxt.capture(names::render_fieldname(name), capture_ty, dest);
|
ctxt.capture(names::render_fieldname(name), capture_ty, dest);
|
||||||
}
|
}
|
||||||
|
@ -361,48 +417,63 @@ fn named_pattern_reader(
|
||||||
fn pattern_reader(
|
fn pattern_reader(
|
||||||
ctxt: &mut FunctionContext,
|
ctxt: &mut FunctionContext,
|
||||||
p: &Pattern,
|
p: &Pattern,
|
||||||
in_sequence: bool,
|
boundary_tracker: Option<&BoundaryTracker>,
|
||||||
body: &mut Vec<Item>,
|
body: &mut Vec<Item>,
|
||||||
) -> Option<String> {
|
) -> Option<String> {
|
||||||
match p {
|
match p {
|
||||||
Pattern::SimplePattern(s) =>
|
Pattern::SimplePattern(s) =>
|
||||||
Some(simple_pattern_reader(ctxt, s, in_sequence, body)),
|
Some(simple_pattern_reader(ctxt, s, boundary_tracker, body)),
|
||||||
Pattern::CompoundPattern(c) => {
|
Pattern::CompoundPattern(c) => {
|
||||||
match &**c {
|
match &**c {
|
||||||
CompoundPattern::Rec { label, fields } => {
|
CompoundPattern::Rec { label, fields } => {
|
||||||
body.push(item("r.open_record(None)?;"));
|
let mut boundary_tracker = BoundaryTracker::new(
|
||||||
named_pattern_reader(ctxt, &**label, false, body);
|
ctxt, body, "r.open_record(None)?;", "_support::B::Item::RecordLabel");
|
||||||
named_pattern_reader(ctxt, &**fields, true, body);
|
boundary_tracker.emit_boundary(body);
|
||||||
|
boundary_tracker.item_expr = "_support::B::Item::RecordField";
|
||||||
|
named_pattern_reader(ctxt, &**label, None, body);
|
||||||
|
named_pattern_reader(ctxt, &**fields, Some(&boundary_tracker), body);
|
||||||
},
|
},
|
||||||
CompoundPattern::Tuple { patterns } => {
|
CompoundPattern::Tuple { patterns } => {
|
||||||
if !in_sequence {
|
let boundary_tracker = BoundaryTracker::unwrap(
|
||||||
body.push(item("r.open_sequence()?;"));
|
ctxt, body, "r.open_sequence()?;", boundary_tracker);
|
||||||
|
for p in patterns {
|
||||||
|
boundary_tracker.emit_boundary(body);
|
||||||
|
named_pattern_reader(ctxt, p, None, body);
|
||||||
}
|
}
|
||||||
for p in patterns { named_pattern_reader(ctxt, p, false, body); }
|
body.push(item(seq!["r.ensure_complete", parens![
|
||||||
body.push(item("r.ensure_complete()?;"));
|
boundary_tracker.tracker_name.clone(),
|
||||||
|
seq!["&", boundary_tracker.item_expr]], "?;"]));
|
||||||
},
|
},
|
||||||
CompoundPattern::TuplePrefix { fixed, variable } => {
|
CompoundPattern::TuplePrefix { fixed, variable } => {
|
||||||
if !in_sequence {
|
let boundary_tracker = BoundaryTracker::unwrap(
|
||||||
body.push(item("r.open_sequence()?;"));
|
ctxt, body, "r.open_sequence()?;", boundary_tracker);
|
||||||
|
for p in fixed {
|
||||||
|
boundary_tracker.emit_boundary(body);
|
||||||
|
named_pattern_reader(ctxt, p, None, body);
|
||||||
}
|
}
|
||||||
for p in fixed { named_pattern_reader(ctxt, p, false, body); }
|
named_pattern_reader(ctxt, &promote(variable), Some(&boundary_tracker), body);
|
||||||
named_pattern_reader(ctxt, &promote(variable), true, body);
|
|
||||||
},
|
},
|
||||||
CompoundPattern::Dict { entries } => {
|
CompoundPattern::Dict { entries } => {
|
||||||
body.push(item("r.open_dictionary()?;"));
|
let boundary_tracker = BoundaryTracker::new(
|
||||||
|
ctxt, body, "r.open_dictionary()?;", "_support::B::Item::DictionaryKey");
|
||||||
let mut inner = Vec::new();
|
let mut inner = Vec::new();
|
||||||
|
boundary_tracker.emit_boundary(&mut inner);
|
||||||
|
let mut val_boundary_tracker = boundary_tracker.clone();
|
||||||
|
val_boundary_tracker.item_expr = "_support::B::Item::DictionaryValue";
|
||||||
body.extend(ctxt.with_indefinite_mode(|ctxt| {
|
body.extend(ctxt.with_indefinite_mode(|ctxt| {
|
||||||
read_expected_literals(ctxt, &mut inner, entries.0.iter().map(move |(key_lit, value_pat)| {
|
read_expected_literals(ctxt, &mut inner, entries.0.iter().map(move |(key_lit, value_pat)| {
|
||||||
let value_pat = value_pat.clone();
|
let value_pat = value_pat.clone();
|
||||||
|
let val_boundary_tracker = val_boundary_tracker.clone();
|
||||||
let f: LiteralContinuation = Box::new(
|
let f: LiteralContinuation = Box::new(
|
||||||
move |ctxt: &mut FunctionContext, innerinner: &mut Vec<Item>| {
|
move |ctxt: &mut FunctionContext, innerinner: &mut Vec<Item>| {
|
||||||
named_pattern_reader(ctxt, &promote(&value_pat), false, innerinner);
|
val_boundary_tracker.emit_boundary(innerinner);
|
||||||
|
named_pattern_reader(ctxt, &promote(&value_pat), None, innerinner);
|
||||||
innerinner.push(item("continue;"));
|
innerinner.push(item("continue;"));
|
||||||
});
|
});
|
||||||
(key_lit.clone(), f)
|
(key_lit.clone(), f)
|
||||||
}).collect());
|
}).collect());
|
||||||
}));
|
}));
|
||||||
body.push(item(seq!["while !(r.close_compound()?) ", block(inner)]));
|
boundary_tracker.emit_loop(body, inner);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
None
|
None
|
||||||
|
|
|
@ -244,7 +244,7 @@ impl std::convert::From<&AtomKind> for _Any {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "Boolean" => {}
|
preserves::value::Value::Symbol(w) if w == "Boolean" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean"))?,
|
||||||
|
@ -256,7 +256,7 @@ fn read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
fn read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "Float" => {}
|
preserves::value::Value::Symbol(w) if w == "Float" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Float"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Float"))?,
|
||||||
|
@ -268,7 +268,7 @@ fn read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) ->
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
fn read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "Double" => {}
|
preserves::value::Value::Symbol(w) if w == "Double" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Double"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Double"))?,
|
||||||
|
@ -280,7 +280,7 @@ fn read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "SignedInteger" => {}
|
preserves::value::Value::Symbol(w) if w == "SignedInteger" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger"))?,
|
||||||
|
@ -292,7 +292,7 @@ fn read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
fn read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "String" => {}
|
preserves::value::Value::Symbol(w) if w == "String" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::String"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::String"))?,
|
||||||
|
@ -304,7 +304,7 @@ fn read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "ByteString" => {}
|
preserves::value::Value::Symbol(w) if w == "ByteString" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString"))?,
|
||||||
|
@ -316,7 +316,7 @@ fn read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_atom_kind_symbol<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
fn read_atom_kind_symbol<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<AtomKind, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "Symbol" => {}
|
preserves::value::Value::Symbol(w) if w == "Symbol" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol"))?,
|
||||||
|
@ -369,18 +369,25 @@ impl std::convert::From<&Binding> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Binding {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Binding {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "named" => {}
|
preserves::value::Value::Symbol(w) if w == "named" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Binding"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Binding"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Binding"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Binding"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = r.next_symbol()?.into_owned();
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
let _tmp2 = SimplePattern::deserialize(r)?;
|
r.boundary(&_tmp0)?;
|
||||||
r.ensure_complete()?;
|
let _tmp2 = r.next_symbol()?.into_owned();
|
||||||
Ok(Binding {name: _tmp1, pattern: _tmp2})
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
let _tmp3 = SimplePattern::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(Binding {name: _tmp2, pattern: _tmp3})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -410,17 +417,22 @@ impl std::convert::From<&Bundle> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Bundle {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Bundle {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "bundle" => {}
|
preserves::value::Value::Symbol(w) if w == "bundle" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Bundle"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Bundle"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Bundle"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Bundle"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = Modules::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
r.ensure_complete()?;
|
r.boundary(&_tmp0)?;
|
||||||
Ok(Bundle {modules: _tmp1})
|
let _tmp2 = Modules::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(Bundle {modules: _tmp2})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -520,68 +532,104 @@ impl std::convert::From<&CompoundPattern> for _Any {
|
||||||
|
|
||||||
fn read_compound_pattern_rec<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern, _support::ParseError> {
|
fn read_compound_pattern_rec<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "rec" => {}
|
preserves::value::Value::Symbol(w) if w == "rec" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = NamedPattern::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
let _tmp2 = NamedPattern::deserialize(r)?;
|
let _tmp2 = NamedPattern::deserialize(r)?;
|
||||||
r.ensure_complete()?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp1), fields: std::boxed::Box::new(_tmp2)})
|
r.boundary(&_tmp0)?;
|
||||||
|
let _tmp3 = NamedPattern::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp2), fields: std::boxed::Box::new(_tmp3)})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern, _support::ParseError> {
|
fn read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "tuple" => {}
|
preserves::value::Value::Symbol(w) if w == "tuple" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
r.open_sequence()?;
|
r.open_sequence()?;
|
||||||
let mut _tmp1 = std::vec::Vec::new();
|
let mut _tmp3 = _support::B::Type::default();
|
||||||
while !(r.close_compound()?) {let _tmp2 = NamedPattern::deserialize(r)?; _tmp1.push(_tmp2);}
|
let mut _tmp2 = std::vec::Vec::new();
|
||||||
r.ensure_complete()?;
|
while !r.close_compound(&mut _tmp3, &_support::B::Item::SequenceValue)? {
|
||||||
Ok(CompoundPattern::Tuple {patterns: _tmp1})
|
_tmp3.shift(Some(_support::B::Item::SequenceValue));
|
||||||
|
r.boundary(&_tmp3)?;
|
||||||
|
let _tmp4 = NamedPattern::deserialize(r)?;
|
||||||
|
_tmp2.push(_tmp4);
|
||||||
|
}
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(CompoundPattern::Tuple {patterns: _tmp2})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern, _support::ParseError> {
|
fn read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "tuplePrefix" => {}
|
preserves::value::Value::Symbol(w) if w == "tuplePrefix" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
r.open_sequence()?;
|
r.open_sequence()?;
|
||||||
let mut _tmp1 = std::vec::Vec::new();
|
let mut _tmp3 = _support::B::Type::default();
|
||||||
while !(r.close_compound()?) {let _tmp2 = NamedPattern::deserialize(r)?; _tmp1.push(_tmp2);}
|
let mut _tmp2 = std::vec::Vec::new();
|
||||||
let _tmp3 = NamedSimplePattern::deserialize(r)?;
|
while !r.close_compound(&mut _tmp3, &_support::B::Item::SequenceValue)? {
|
||||||
r.ensure_complete()?;
|
_tmp3.shift(Some(_support::B::Item::SequenceValue));
|
||||||
Ok(CompoundPattern::TuplePrefix {fixed: _tmp1, variable: std::boxed::Box::new(_tmp3)})
|
r.boundary(&_tmp3)?;
|
||||||
|
let _tmp4 = NamedPattern::deserialize(r)?;
|
||||||
|
_tmp2.push(_tmp4);
|
||||||
|
}
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
let _tmp5 = NamedSimplePattern::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp5)})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_compound_pattern_dict<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern, _support::ParseError> {
|
fn read_compound_pattern_dict<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<CompoundPattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "dict" => {}
|
preserves::value::Value::Symbol(w) if w == "dict" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = DictionaryEntries::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
r.ensure_complete()?;
|
r.boundary(&_tmp0)?;
|
||||||
Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp1)})
|
let _tmp2 = DictionaryEntries::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for CompoundPattern {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for CompoundPattern {
|
||||||
|
@ -682,47 +730,77 @@ impl std::convert::From<&Definition> for _Any {
|
||||||
|
|
||||||
fn read_definition_or<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Definition, _support::ParseError> {
|
fn read_definition_or<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Definition, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "or" => {}
|
preserves::value::Value::Symbol(w) if w == "or" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Definition::or"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Definition::or"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Definition::or"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Definition::or"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
r.open_sequence()?;
|
r.open_sequence()?;
|
||||||
let _tmp1 = NamedAlternative::deserialize(r)?;
|
let mut _tmp2 = _support::B::Type::default();
|
||||||
let _tmp2 = NamedAlternative::deserialize(r)?;
|
_tmp2.shift(Some(_support::B::Item::SequenceValue));
|
||||||
let mut _tmp3 = std::vec::Vec::new();
|
r.boundary(&_tmp2)?;
|
||||||
while !(r.close_compound()?) {let _tmp4 = NamedAlternative::deserialize(r)?; _tmp3.push(_tmp4);}
|
let _tmp3 = NamedAlternative::deserialize(r)?;
|
||||||
r.ensure_complete()?;
|
_tmp2.shift(Some(_support::B::Item::SequenceValue));
|
||||||
|
r.boundary(&_tmp2)?;
|
||||||
|
let _tmp4 = NamedAlternative::deserialize(r)?;
|
||||||
|
let mut _tmp5 = std::vec::Vec::new();
|
||||||
|
while !r.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? {
|
||||||
|
_tmp2.shift(Some(_support::B::Item::SequenceValue));
|
||||||
|
r.boundary(&_tmp2)?;
|
||||||
|
let _tmp6 = NamedAlternative::deserialize(r)?;
|
||||||
|
_tmp5.push(_tmp6);
|
||||||
|
}
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
Ok(Definition::Or {
|
Ok(Definition::Or {
|
||||||
pattern_0: std::boxed::Box::new(_tmp1),
|
pattern_0: std::boxed::Box::new(_tmp3),
|
||||||
pattern_1: std::boxed::Box::new(_tmp2),
|
pattern_1: std::boxed::Box::new(_tmp4),
|
||||||
pattern_n: _tmp3
|
pattern_n: _tmp5
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_definition_and<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Definition, _support::ParseError> {
|
fn read_definition_and<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Definition, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "and" => {}
|
preserves::value::Value::Symbol(w) if w == "and" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Definition::and"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Definition::and"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Definition::and"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Definition::and"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
r.open_sequence()?;
|
r.open_sequence()?;
|
||||||
let _tmp1 = NamedPattern::deserialize(r)?;
|
let mut _tmp2 = _support::B::Type::default();
|
||||||
let _tmp2 = NamedPattern::deserialize(r)?;
|
_tmp2.shift(Some(_support::B::Item::SequenceValue));
|
||||||
let mut _tmp3 = std::vec::Vec::new();
|
r.boundary(&_tmp2)?;
|
||||||
while !(r.close_compound()?) {let _tmp4 = NamedPattern::deserialize(r)?; _tmp3.push(_tmp4);}
|
let _tmp3 = NamedPattern::deserialize(r)?;
|
||||||
r.ensure_complete()?;
|
_tmp2.shift(Some(_support::B::Item::SequenceValue));
|
||||||
|
r.boundary(&_tmp2)?;
|
||||||
|
let _tmp4 = NamedPattern::deserialize(r)?;
|
||||||
|
let mut _tmp5 = std::vec::Vec::new();
|
||||||
|
while !r.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? {
|
||||||
|
_tmp2.shift(Some(_support::B::Item::SequenceValue));
|
||||||
|
r.boundary(&_tmp2)?;
|
||||||
|
let _tmp6 = NamedPattern::deserialize(r)?;
|
||||||
|
_tmp5.push(_tmp6);
|
||||||
|
}
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
Ok(Definition::And {
|
Ok(Definition::And {
|
||||||
pattern_0: std::boxed::Box::new(_tmp1),
|
pattern_0: std::boxed::Box::new(_tmp3),
|
||||||
pattern_1: std::boxed::Box::new(_tmp2),
|
pattern_1: std::boxed::Box::new(_tmp4),
|
||||||
pattern_n: _tmp3
|
pattern_n: _tmp5
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -764,11 +842,16 @@ impl std::convert::From<&Definitions> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Definitions {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Definitions {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_dictionary()?;
|
r.open_dictionary()?;
|
||||||
|
let mut _tmp1 = _support::B::Type::default();
|
||||||
let mut _tmp0 = preserves::value::Map::new();
|
let mut _tmp0 = preserves::value::Map::new();
|
||||||
while !(r.close_compound()?) {
|
while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
|
||||||
let _tmp1 = r.next_symbol()?.into_owned();
|
_tmp1.shift(Some(_support::B::Item::DictionaryKey));
|
||||||
let _tmp2 = Definition::deserialize(r)?;
|
r.boundary(&_tmp1)?;
|
||||||
_tmp0.insert(_tmp1, _tmp2);
|
let _tmp2 = r.next_symbol()?.into_owned();
|
||||||
|
_tmp1.shift(Some(_support::B::Item::DictionaryValue));
|
||||||
|
r.boundary(&_tmp1)?;
|
||||||
|
let _tmp3 = Definition::deserialize(r)?;
|
||||||
|
_tmp0.insert(_tmp2, _tmp3);
|
||||||
}
|
}
|
||||||
Ok(Definitions(_tmp0))
|
Ok(Definitions(_tmp0))
|
||||||
}
|
}
|
||||||
|
@ -797,11 +880,16 @@ impl std::convert::From<&DictionaryEntries> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for DictionaryEntries {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for DictionaryEntries {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_dictionary()?;
|
r.open_dictionary()?;
|
||||||
|
let mut _tmp1 = _support::B::Type::default();
|
||||||
let mut _tmp0 = preserves::value::Map::new();
|
let mut _tmp0 = preserves::value::Map::new();
|
||||||
while !(r.close_compound()?) {
|
while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
|
||||||
let _tmp1 = r.demand_next(false)?;
|
_tmp1.shift(Some(_support::B::Item::DictionaryKey));
|
||||||
let _tmp2 = NamedSimplePattern::deserialize(r)?;
|
r.boundary(&_tmp1)?;
|
||||||
_tmp0.insert(_tmp1, _tmp2);
|
let _tmp2 = r.demand_next(true)?;
|
||||||
|
_tmp1.shift(Some(_support::B::Item::DictionaryValue));
|
||||||
|
r.boundary(&_tmp1)?;
|
||||||
|
let _tmp3 = NamedSimplePattern::deserialize(r)?;
|
||||||
|
_tmp0.insert(_tmp2, _tmp3);
|
||||||
}
|
}
|
||||||
Ok(DictionaryEntries(_tmp0))
|
Ok(DictionaryEntries(_tmp0))
|
||||||
}
|
}
|
||||||
|
@ -842,7 +930,7 @@ fn read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mu
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
|
fn read_embedded_type_name_false<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Boolean(w) if !*w => {}
|
preserves::value::Value::Boolean(w) if !*w => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false"))?,
|
||||||
|
@ -886,8 +974,14 @@ impl std::convert::From<&ModulePath> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for ModulePath {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for ModulePath {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_sequence()?;
|
r.open_sequence()?;
|
||||||
|
let mut _tmp1 = _support::B::Type::default();
|
||||||
let mut _tmp0 = std::vec::Vec::new();
|
let mut _tmp0 = std::vec::Vec::new();
|
||||||
while !(r.close_compound()?) {let _tmp1 = r.next_symbol()?.into_owned(); _tmp0.push(_tmp1);}
|
while !r.close_compound(&mut _tmp1, &_support::B::Item::SequenceValue)? {
|
||||||
|
_tmp1.shift(Some(_support::B::Item::SequenceValue));
|
||||||
|
r.boundary(&_tmp1)?;
|
||||||
|
let _tmp2 = r.next_symbol()?.into_owned();
|
||||||
|
_tmp0.push(_tmp2);
|
||||||
|
}
|
||||||
Ok(ModulePath(_tmp0))
|
Ok(ModulePath(_tmp0))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -915,11 +1009,16 @@ impl std::convert::From<&Modules> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Modules {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Modules {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_dictionary()?;
|
r.open_dictionary()?;
|
||||||
|
let mut _tmp1 = _support::B::Type::default();
|
||||||
let mut _tmp0 = preserves::value::Map::new();
|
let mut _tmp0 = preserves::value::Map::new();
|
||||||
while !(r.close_compound()?) {
|
while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
|
||||||
let _tmp1 = ModulePath::deserialize(r)?;
|
_tmp1.shift(Some(_support::B::Item::DictionaryKey));
|
||||||
let _tmp2 = Schema::deserialize(r)?;
|
r.boundary(&_tmp1)?;
|
||||||
_tmp0.insert(_tmp1, _tmp2);
|
let _tmp2 = ModulePath::deserialize(r)?;
|
||||||
|
_tmp1.shift(Some(_support::B::Item::DictionaryValue));
|
||||||
|
r.boundary(&_tmp1)?;
|
||||||
|
let _tmp3 = Schema::deserialize(r)?;
|
||||||
|
_tmp0.insert(_tmp2, _tmp3);
|
||||||
}
|
}
|
||||||
Ok(Modules(_tmp0))
|
Ok(Modules(_tmp0))
|
||||||
}
|
}
|
||||||
|
@ -951,10 +1050,15 @@ impl std::convert::From<&NamedAlternative> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedAlternative {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedAlternative {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_sequence()?;
|
r.open_sequence()?;
|
||||||
let _tmp0 = r.next_str()?.into_owned();
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
let _tmp1 = Pattern::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::SequenceValue));
|
||||||
r.ensure_complete()?;
|
r.boundary(&_tmp0)?;
|
||||||
Ok(NamedAlternative {variant_label: _tmp0, pattern: _tmp1})
|
let _tmp1 = r.next_str()?.into_owned();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::SequenceValue));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
let _tmp2 = Pattern::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::SequenceValue)?;
|
||||||
|
Ok(NamedAlternative {variant_label: _tmp1, pattern: _tmp2})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1127,18 +1231,25 @@ impl std::convert::From<&Ref> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Ref {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Ref {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "ref" => {}
|
preserves::value::Value::Symbol(w) if w == "ref" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Ref"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Ref"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Ref"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Ref"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = ModulePath::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
let _tmp2 = r.next_symbol()?.into_owned();
|
r.boundary(&_tmp0)?;
|
||||||
r.ensure_complete()?;
|
let _tmp2 = ModulePath::deserialize(r)?;
|
||||||
Ok(Ref {module: _tmp1, name: _tmp2})
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
let _tmp3 = r.next_symbol()?.into_owned();
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(Ref {module: _tmp2, name: _tmp3})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1182,34 +1293,57 @@ impl std::convert::From<&Schema> for _Any {
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Schema {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Schema {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "schema" => {}
|
preserves::value::Value::Symbol(w) if w == "schema" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
r.open_dictionary()?;
|
r.open_dictionary()?;
|
||||||
let mut _tmp1 = None;
|
let mut _tmp2 = _support::B::Type::default();
|
||||||
let mut _tmp2 = None;
|
|
||||||
let mut _tmp3 = None;
|
let mut _tmp3 = None;
|
||||||
while !(r.close_compound()?) {
|
let mut _tmp4 = None;
|
||||||
match r.next_token(false)? {
|
let mut _tmp5 = None;
|
||||||
|
while !r.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? {
|
||||||
|
_tmp2.shift(Some(_support::B::Item::DictionaryKey));
|
||||||
|
r.boundary(&_tmp2)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "definitions" => {_tmp1 = Some(Definitions::deserialize(r)?); continue;}
|
preserves::value::Value::Symbol(w) if w == "definitions" => {
|
||||||
preserves::value::Value::Symbol(w) if w == "embeddedType" => {_tmp2 = Some(EmbeddedTypeName::deserialize(r)?); continue;}
|
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
|
||||||
preserves::value::Value::Symbol(w) if w == "version" => {_tmp3 = Some(Version::deserialize(r)?); continue;}
|
r.boundary(&_tmp2)?;
|
||||||
|
_tmp3 = Some(Definitions::deserialize(r)?);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
preserves::value::Value::Symbol(w) if w == "embeddedType" => {
|
||||||
|
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
|
||||||
|
r.boundary(&_tmp2)?;
|
||||||
|
_tmp4 = Some(EmbeddedTypeName::deserialize(r)?);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
preserves::value::Value::Symbol(w) if w == "version" => {
|
||||||
|
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
|
||||||
|
r.boundary(&_tmp2)?;
|
||||||
|
_tmp5 = Some(Version::deserialize(r)?);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
r.ensure_complete()?;
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
Ok(Schema {
|
Ok(Schema {
|
||||||
definitions: _tmp1.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
|
definitions: _tmp3.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
|
||||||
embedded_type: _tmp2.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
|
embedded_type: _tmp4.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
|
||||||
version: _tmp3.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?
|
version: _tmp5.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1336,7 +1470,7 @@ impl std::convert::From<&SimplePattern> for _Any {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "any" => {}
|
preserves::value::Value::Symbol(w) if w == "any" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::any"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::any"))?,
|
||||||
|
@ -1349,93 +1483,125 @@ fn read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R)
|
||||||
|
|
||||||
fn read_simple_pattern_atom<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
fn read_simple_pattern_atom<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "atom" => {}
|
preserves::value::Value::Symbol(w) if w == "atom" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = AtomKind::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
r.ensure_complete()?;
|
r.boundary(&_tmp0)?;
|
||||||
Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp1)})
|
let _tmp2 = AtomKind::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
fn read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "embedded" => {}
|
preserves::value::Value::Symbol(w) if w == "embedded" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = SimplePattern::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
r.ensure_complete()?;
|
r.boundary(&_tmp0)?;
|
||||||
Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp1)})
|
let _tmp2 = SimplePattern::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_simple_pattern_lit<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
fn read_simple_pattern_lit<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "lit" => {}
|
preserves::value::Value::Symbol(w) if w == "lit" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = r.demand_next(false)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
r.ensure_complete()?;
|
r.boundary(&_tmp0)?;
|
||||||
Ok(SimplePattern::Lit {value: _tmp1})
|
let _tmp2 = r.demand_next(true)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(SimplePattern::Lit {value: _tmp2})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
fn read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "seqof" => {}
|
preserves::value::Value::Symbol(w) if w == "seqof" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = SimplePattern::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
r.ensure_complete()?;
|
r.boundary(&_tmp0)?;
|
||||||
Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp1)})
|
let _tmp2 = SimplePattern::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_simple_pattern_setof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
fn read_simple_pattern_setof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "setof" => {}
|
preserves::value::Value::Symbol(w) if w == "setof" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = SimplePattern::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
r.ensure_complete()?;
|
r.boundary(&_tmp0)?;
|
||||||
Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp1)})
|
let _tmp2 = SimplePattern::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
fn read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
||||||
r.open_record(None)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
let mut _tmp0 = _support::B::Type::default();
|
||||||
|
_tmp0.shift(Some(_support::B::Item::RecordLabel));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::Symbol(w) if w == "dictof" => {}
|
preserves::value::Value::Symbol(w) if w == "dictof" => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof"))?,
|
||||||
}
|
}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof"))?,
|
||||||
}
|
}
|
||||||
let _tmp0 = ();
|
let _tmp1 = ();
|
||||||
let _tmp1 = SimplePattern::deserialize(r)?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
|
r.boundary(&_tmp0)?;
|
||||||
let _tmp2 = SimplePattern::deserialize(r)?;
|
let _tmp2 = SimplePattern::deserialize(r)?;
|
||||||
r.ensure_complete()?;
|
_tmp0.shift(Some(_support::B::Item::RecordField));
|
||||||
Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp1), value: std::boxed::Box::new(_tmp2)})
|
r.boundary(&_tmp0)?;
|
||||||
|
let _tmp3 = SimplePattern::deserialize(r)?;
|
||||||
|
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
|
||||||
|
Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp2), value: std::boxed::Box::new(_tmp3)})
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_simple_pattern_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
fn read_simple_pattern_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<SimplePattern, _support::ParseError> {
|
||||||
|
@ -1473,7 +1639,7 @@ impl std::convert::From<&Version> for _Any {
|
||||||
|
|
||||||
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Version {
|
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Version {
|
||||||
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
match r.next_token(false)? {
|
match r.next_token(true)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
preserves::value::Token::Atom(v) => match v.value() {
|
||||||
preserves::value::Value::SignedInteger(w) if *w == (1).into() => {}
|
preserves::value::Value::SignedInteger(w) if *w == (1).into() => {}
|
||||||
_ => return Err(_support::ParseError::conformance_error("schema.Version"))?,
|
_ => return Err(_support::ParseError::conformance_error("schema.Version"))?,
|
||||||
|
|
|
@ -1,6 +1,7 @@
|
||||||
pub use lazy_static::lazy_static;
|
pub use lazy_static::lazy_static;
|
||||||
|
|
||||||
pub use preserves::value::Reader;
|
pub use preserves::value::Reader;
|
||||||
|
pub use preserves::value::boundary as B;
|
||||||
|
|
||||||
use preserves::value::ArcValue;
|
use preserves::value::ArcValue;
|
||||||
use preserves::value::Domain;
|
use preserves::value::Domain;
|
||||||
|
|
|
@ -17,6 +17,7 @@ pub enum Item {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Type {
|
impl Type {
|
||||||
|
#[inline]
|
||||||
pub fn shift(&mut self, i: Option<Item>) {
|
pub fn shift(&mut self, i: Option<Item>) {
|
||||||
let tmp = std::mem::replace(&mut self.opening, i);
|
let tmp = std::mem::replace(&mut self.opening, i);
|
||||||
self.closing = tmp;
|
self.closing = tmp;
|
||||||
|
|
|
@ -388,6 +388,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: Binar
|
||||||
self.next_compound(Tag::Dictionary, ExpectedKind::Dictionary)
|
self.next_compound(Tag::Dictionary, ExpectedKind::Dictionary)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
fn boundary(&mut self, _b: &B::Type) -> ReaderResult<()> {
|
fn boundary(&mut self, _b: &B::Type) -> ReaderResult<()> {
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
|
@ -127,6 +127,7 @@ impl WriteWriter for BinaryOrderWriter {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<W: io::Write> CompoundWriter for PackedWriter<W> {
|
impl<W: io::Write> CompoundWriter for PackedWriter<W> {
|
||||||
|
#[inline]
|
||||||
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
|
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
|
||||||
if let Some(B::Item::Annotation) = b.opening {
|
if let Some(B::Item::Annotation) = b.opening {
|
||||||
self.write_tag(Tag::Annotation)?;
|
self.write_tag(Tag::Annotation)?;
|
||||||
|
@ -136,6 +137,7 @@ impl<W: io::Write> CompoundWriter for PackedWriter<W> {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl CompoundWriter for BinaryOrderWriter {
|
impl CompoundWriter for BinaryOrderWriter {
|
||||||
|
#[inline]
|
||||||
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
|
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
|
||||||
match b.closing {
|
match b.closing {
|
||||||
Some(B::Item::DictionaryValue) |
|
Some(B::Item::DictionaryValue) |
|
||||||
|
|
|
@ -519,6 +519,7 @@ impl<'a, 'de, D: Embeddable, N: NestedValue<D>, Dec: DomainParse<D>> Reader<'de,
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
fn boundary(&mut self, b: &B::Type) -> ReaderResult<()> {
|
fn boundary(&mut self, b: &B::Type) -> ReaderResult<()> {
|
||||||
match b {
|
match b {
|
||||||
B::Type {
|
B::Type {
|
||||||
|
|
|
@ -98,6 +98,7 @@ impl<W: io::Write> TextWriter<W> {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<W: io::Write> CompoundWriter for TextWriter<W> {
|
impl<W: io::Write> CompoundWriter for TextWriter<W> {
|
||||||
|
#[inline]
|
||||||
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
|
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
|
||||||
match (b.closing.as_ref(), b.opening.as_ref()) {
|
match (b.closing.as_ref(), b.opening.as_ref()) {
|
||||||
(None, Some(B::Item::RecordLabel)) |
|
(None, Some(B::Item::RecordLabel)) |
|
||||||
|
|
Loading…
Reference in New Issue