syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

Track boundaries in schema-emitted reader code

This commit is contained in:
Tony Garnock-Jones 2021-08-02 20:55:44 +02:00
parent 3176e5f8d0
commit dcdfdb8dd9
8 changed files with 413 additions and 169 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
implementations/rust/preserves-schema/src/compiler/readers.rs
View File

@ -14,6 +14,54 @@ use super::context::{ModuleContext, FunctionContext};
use super::names;
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) {
m.define_function(
n,
@ -32,7 +80,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
&(n.to_owned() + "::" + name),
|mut ctxt| {
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);
construct(&ctxt, ctorname, false, &pattern_type(pat), dest, &mut body);
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];
ps.extend(pattern_n);
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);
}
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);
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));
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(
@ -256,19 +304,19 @@ fn read_expected_literals(
possibilities: LiteralCases,
) {
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(
ctxt: &mut FunctionContext,
p: &SimplePattern,
in_sequence: bool,
boundary_tracker: Option<&BoundaryTracker>,
body: &mut Vec<Item>,
) -> String {
let dest = ctxt.gentempname();
match p {
SimplePattern::Any => {
ctxt.define_atom(body, &dest, item("r.demand_next(false)?"));
ctxt.define_atom(body, &dest, item("r.demand_next(true)?"));
dest
},
SimplePattern::Atom { atom_kind: k } => {
@ -285,8 +333,9 @@ fn simple_pattern_reader(
dest
},
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()?;"));
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()?;"));
dest
},
@ -297,38 +346,45 @@ fn simple_pattern_reader(
dest
},
SimplePattern::Seqof { pattern } => {
if !in_sequence {
body.push(item("r.open_sequence()?;"));
}
let boundary_tracker = BoundaryTracker::unwrap(
ctxt, body, "r.open_sequence()?;", boundary_tracker);
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(",
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
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
},
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 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(",
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
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
},
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 key_dest = simple_pattern_reader(ctxt, key, false, &mut inner);
let value_dest = simple_pattern_reader(ctxt, value, false, &mut inner);
boundary_tracker.emit_boundary(&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![
dest.to_owned(), ".insert(",
store_wrap(true, &field_type(key), &key_dest), ", ",
store_wrap(true, &field_type(value), &value_dest), ");"]));
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
},
SimplePattern::Ref(r) => {
@ -342,16 +398,16 @@ fn simple_pattern_reader(
fn named_pattern_reader(
ctxt: &mut FunctionContext,
p: &NamedPattern,
in_sequence: bool,
boundary_tracker: Option<&BoundaryTracker>,
body: &mut Vec<Item>,
) {
match p {
NamedPattern::Anonymous(p) => {
pattern_reader(ctxt, p, in_sequence, body);
pattern_reader(ctxt, p, boundary_tracker, body);
},
NamedPattern::Named(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);
ctxt.capture(names::render_fieldname(name), capture_ty, dest);
}
@ -361,48 +417,63 @@ fn named_pattern_reader(
fn pattern_reader(
ctxt: &mut FunctionContext,
p: &Pattern,
in_sequence: bool,
boundary_tracker: Option<&BoundaryTracker>,
body: &mut Vec<Item>,
) -> Option<String> {
match p {
Pattern::SimplePattern(s) =>
Some(simple_pattern_reader(ctxt, s, in_sequence, body)),
Some(simple_pattern_reader(ctxt, s, boundary_tracker, body)),
Pattern::CompoundPattern(c) => {
match &**c {
CompoundPattern::Rec { label, fields } => {
body.push(item("r.open_record(None)?;"));
named_pattern_reader(ctxt, &**label, false, body);
named_pattern_reader(ctxt, &**fields, true, body);
let mut boundary_tracker = BoundaryTracker::new(
ctxt, body, "r.open_record(None)?;", "_support::B::Item::RecordLabel");
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 } => {
if !in_sequence {
body.push(item("r.open_sequence()?;"));
let boundary_tracker = BoundaryTracker::unwrap(
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("r.ensure_complete()?;"));
body.push(item(seq!["r.ensure_complete", parens![
boundary_tracker.tracker_name.clone(),
seq!["&", boundary_tracker.item_expr]], "?;"]));
},
CompoundPattern::TuplePrefix { fixed, variable } => {
if !in_sequence {
body.push(item("r.open_sequence()?;"));
let boundary_tracker = BoundaryTracker::unwrap(
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), true, body);
named_pattern_reader(ctxt, &promote(variable), Some(&boundary_tracker), body);
},
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();
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| {
read_expected_literals(ctxt, &mut inner, entries.0.iter().map(move |(key_lit, value_pat)| {
let value_pat = value_pat.clone();
let val_boundary_tracker = val_boundary_tracker.clone();
let f: LiteralContinuation = Box::new(
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;"));
});
(key_lit.clone(), f)
}).collect());
}));
body.push(item(seq!["while !(r.close_compound()?) ", block(inner)]));
boundary_tracker.emit_loop(body, inner);
}
}
None

426
implementations/rust/preserves-schema/src/gen/schema.rs
View File

@ -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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
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::Value::Symbol(w) if w == "named" => {}
_ => return Err(_support::ParseError::conformance_error("schema.Binding"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.Binding"))?,
}
let _tmp0 = ();
let _tmp1 = r.next_symbol()?.into_owned();
let _tmp2 = SimplePattern::deserialize(r)?;
r.ensure_complete()?;
Ok(Binding {name: _tmp1, pattern: _tmp2})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
let _tmp2 = r.next_symbol()?.into_owned();
_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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
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::Value::Symbol(w) if w == "bundle" => {}
_ => return Err(_support::ParseError::conformance_error("schema.Bundle"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.Bundle"))?,
}
let _tmp0 = ();
let _tmp1 = Modules::deserialize(r)?;
r.ensure_complete()?;
Ok(Bundle {modules: _tmp1})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
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> {
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::Value::Symbol(w) if w == "rec" => {}
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec"))?,
}
let _tmp0 = ();
let _tmp1 = NamedPattern::deserialize(r)?;
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
let _tmp2 = NamedPattern::deserialize(r)?;
r.ensure_complete()?;
Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp1), fields: std::boxed::Box::new(_tmp2)})
_tmp0.shift(Some(_support::B::Item::RecordField));
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> {
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::Value::Symbol(w) if w == "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()?;
let mut _tmp1 = std::vec::Vec::new();
while !(r.close_compound()?) {let _tmp2 = NamedPattern::deserialize(r)?; _tmp1.push(_tmp2);}
r.ensure_complete()?;
Ok(CompoundPattern::Tuple {patterns: _tmp1})
let mut _tmp3 = _support::B::Type::default();
let mut _tmp2 = std::vec::Vec::new();
while !r.close_compound(&mut _tmp3, &_support::B::Item::SequenceValue)? {
_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> {
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::Value::Symbol(w) if w == "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()?;
let mut _tmp1 = std::vec::Vec::new();
while !(r.close_compound()?) {let _tmp2 = NamedPattern::deserialize(r)?; _tmp1.push(_tmp2);}
let _tmp3 = NamedSimplePattern::deserialize(r)?;
r.ensure_complete()?;
Ok(CompoundPattern::TuplePrefix {fixed: _tmp1, variable: std::boxed::Box::new(_tmp3)})
let mut _tmp3 = _support::B::Type::default();
let mut _tmp2 = std::vec::Vec::new();
while !r.close_compound(&mut _tmp3, &_support::B::Item::SequenceValue)? {
_tmp3.shift(Some(_support::B::Item::SequenceValue));
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> {
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::Value::Symbol(w) if w == "dict" => {}
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict"))?,
}
let _tmp0 = ();
let _tmp1 = DictionaryEntries::deserialize(r)?;
r.ensure_complete()?;
Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp1)})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
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 {
@ -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> {
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::Value::Symbol(w) if w == "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()?;
let _tmp1 = NamedAlternative::deserialize(r)?;
let _tmp2 = NamedAlternative::deserialize(r)?;
let mut _tmp3 = std::vec::Vec::new();
while !(r.close_compound()?) {let _tmp4 = NamedAlternative::deserialize(r)?; _tmp3.push(_tmp4);}
r.ensure_complete()?;
let mut _tmp2 = _support::B::Type::default();
_tmp2.shift(Some(_support::B::Item::SequenceValue));
r.boundary(&_tmp2)?;
let _tmp3 = NamedAlternative::deserialize(r)?;
_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 {
pattern_0: std::boxed::Box::new(_tmp1),
pattern_1: std::boxed::Box::new(_tmp2),
pattern_n: _tmp3
pattern_0: std::boxed::Box::new(_tmp3),
pattern_1: std::boxed::Box::new(_tmp4),
pattern_n: _tmp5
})
}
fn read_definition_and<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Definition, _support::ParseError> {
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::Value::Symbol(w) if w == "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()?;
let _tmp1 = NamedPattern::deserialize(r)?;
let _tmp2 = NamedPattern::deserialize(r)?;
let mut _tmp3 = std::vec::Vec::new();
while !(r.close_compound()?) {let _tmp4 = NamedPattern::deserialize(r)?; _tmp3.push(_tmp4);}
r.ensure_complete()?;
let mut _tmp2 = _support::B::Type::default();
_tmp2.shift(Some(_support::B::Item::SequenceValue));
r.boundary(&_tmp2)?;
let _tmp3 = NamedPattern::deserialize(r)?;
_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 {
pattern_0: std::boxed::Box::new(_tmp1),
pattern_1: std::boxed::Box::new(_tmp2),
pattern_n: _tmp3
pattern_0: std::boxed::Box::new(_tmp3),
pattern_1: std::boxed::Box::new(_tmp4),
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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
r.open_dictionary()?;
let mut _tmp1 = _support::B::Type::default();
let mut _tmp0 = preserves::value::Map::new();
while !(r.close_compound()?) {
let _tmp1 = r.next_symbol()?.into_owned();
let _tmp2 = Definition::deserialize(r)?;
_tmp0.insert(_tmp1, _tmp2);
while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
_tmp1.shift(Some(_support::B::Item::DictionaryKey));
r.boundary(&_tmp1)?;
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))
}
@ -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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
r.open_dictionary()?;
let mut _tmp1 = _support::B::Type::default();
let mut _tmp0 = preserves::value::Map::new();
while !(r.close_compound()?) {
let _tmp1 = r.demand_next(false)?;
let _tmp2 = NamedSimplePattern::deserialize(r)?;
_tmp0.insert(_tmp1, _tmp2);
while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
_tmp1.shift(Some(_support::B::Item::DictionaryKey));
r.boundary(&_tmp1)?;
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))
}
@ -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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Boolean(w) if !*w => {}
_ => 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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
r.open_sequence()?;
let mut _tmp1 = _support::B::Type::default();
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))
}
}
@ -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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
r.open_dictionary()?;
let mut _tmp1 = _support::B::Type::default();
let mut _tmp0 = preserves::value::Map::new();
while !(r.close_compound()?) {
let _tmp1 = ModulePath::deserialize(r)?;
let _tmp2 = Schema::deserialize(r)?;
_tmp0.insert(_tmp1, _tmp2);
while !r.close_compound(&mut _tmp1, &_support::B::Item::DictionaryKey)? {
_tmp1.shift(Some(_support::B::Item::DictionaryKey));
r.boundary(&_tmp1)?;
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))
}
@ -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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
r.open_sequence()?;
let _tmp0 = r.next_str()?.into_owned();
let _tmp1 = Pattern::deserialize(r)?;
r.ensure_complete()?;
Ok(NamedAlternative {variant_label: _tmp0, pattern: _tmp1})
let mut _tmp0 = _support::B::Type::default();
_tmp0.shift(Some(_support::B::Item::SequenceValue));
r.boundary(&_tmp0)?;
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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
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::Value::Symbol(w) if w == "ref" => {}
_ => return Err(_support::ParseError::conformance_error("schema.Ref"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.Ref"))?,
}
let _tmp0 = ();
let _tmp1 = ModulePath::deserialize(r)?;
let _tmp2 = r.next_symbol()?.into_owned();
r.ensure_complete()?;
Ok(Ref {module: _tmp1, name: _tmp2})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
let _tmp2 = ModulePath::deserialize(r)?;
_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 {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
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::Value::Symbol(w) if w == "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()?;
let mut _tmp1 = None;
let mut _tmp2 = None;
let mut _tmp2 = _support::B::Type::default();
let mut _tmp3 = None;
while !(r.close_compound()?) {
match r.next_token(false)? {
let mut _tmp4 = None;
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::Value::Symbol(w) if w == "definitions" => {_tmp1 = Some(Definitions::deserialize(r)?); continue;}
preserves::value::Value::Symbol(w) if w == "embeddedType" => {_tmp2 = Some(EmbeddedTypeName::deserialize(r)?); continue;}
preserves::value::Value::Symbol(w) if w == "version" => {_tmp3 = Some(Version::deserialize(r)?); continue;}
preserves::value::Value::Symbol(w) if w == "definitions" => {
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
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"))?,
}
}
r.ensure_complete()?;
r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(Schema {
definitions: _tmp1.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
embedded_type: _tmp2.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
version: _tmp3.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?
definitions: _tmp3.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
embedded_type: _tmp4.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> {
match r.next_token(false)? {
match r.next_token(true)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "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> {
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::Value::Symbol(w) if w == "atom" => {}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom"))?,
}
let _tmp0 = ();
let _tmp1 = AtomKind::deserialize(r)?;
r.ensure_complete()?;
Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp1)})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
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> {
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::Value::Symbol(w) if w == "embedded" => {}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded"))?,
}
let _tmp0 = ();
let _tmp1 = SimplePattern::deserialize(r)?;
r.ensure_complete()?;
Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp1)})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
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> {
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::Value::Symbol(w) if w == "lit" => {}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit"))?,
}
let _tmp0 = ();
let _tmp1 = r.demand_next(false)?;
r.ensure_complete()?;
Ok(SimplePattern::Lit {value: _tmp1})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
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> {
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::Value::Symbol(w) if w == "seqof" => {}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof"))?,
}
let _tmp0 = ();
let _tmp1 = SimplePattern::deserialize(r)?;
r.ensure_complete()?;
Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp1)})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
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> {
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::Value::Symbol(w) if w == "setof" => {}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof"))?,
}
let _tmp0 = ();
let _tmp1 = SimplePattern::deserialize(r)?;
r.ensure_complete()?;
Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp1)})
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
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> {
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::Value::Symbol(w) if w == "dictof" => {}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof"))?,
}
let _tmp0 = ();
let _tmp1 = SimplePattern::deserialize(r)?;
let _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
r.boundary(&_tmp0)?;
let _tmp2 = SimplePattern::deserialize(r)?;
r.ensure_complete()?;
Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp1), value: std::boxed::Box::new(_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(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> {
@ -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 {
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::Value::SignedInteger(w) if *w == (1).into() => {}
_ => return Err(_support::ParseError::conformance_error("schema.Version"))?,

1
implementations/rust/preserves-schema/src/support/mod.rs
View File

@ -1,6 +1,7 @@
pub use lazy_static::lazy_static;
pub use preserves::value::Reader;
pub use preserves::value::boundary as B;
use preserves::value::ArcValue;
use preserves::value::Domain;

1
implementations/rust/preserves/src/value/boundary.rs
View File

@ -17,6 +17,7 @@ pub enum Item {
}
impl Type {
#[inline]
pub fn shift(&mut self, i: Option<Item>) {
let tmp = std::mem::replace(&mut self.opening, i);
self.closing = tmp;

1
implementations/rust/preserves/src/value/packed/reader.rs
View File

@ -388,6 +388,7 @@ impl<'de, 'src, D: Embeddable, N: NestedValue<D>, Dec: DomainDecode<D>, S: Binar
self.next_compound(Tag::Dictionary, ExpectedKind::Dictionary)
}
#[inline]
fn boundary(&mut self, _b: &B::Type) -> ReaderResult<()> {
Ok(())
}

2
implementations/rust/preserves/src/value/packed/writer.rs
View File

@ -127,6 +127,7 @@ impl WriteWriter for BinaryOrderWriter {
}
impl<W: io::Write> CompoundWriter for PackedWriter<W> {
#[inline]
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
if let Some(B::Item::Annotation) = b.opening {
self.write_tag(Tag::Annotation)?;
@ -136,6 +137,7 @@ impl<W: io::Write> CompoundWriter for PackedWriter<W> {
}
impl CompoundWriter for BinaryOrderWriter {
#[inline]
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
match b.closing {
Some(B::Item::DictionaryValue) |

1
implementations/rust/preserves/src/value/text/reader.rs
View File

@ -519,6 +519,7 @@ impl<'a, 'de, D: Embeddable, N: NestedValue<D>, Dec: DomainParse<D>> Reader<'de,
Ok(())
}
#[inline]
fn boundary(&mut self, b: &B::Type) -> ReaderResult<()> {
match b {
B::Type {

1
implementations/rust/preserves/src/value/text/writer.rs
View File

@ -98,6 +98,7 @@ impl<W: io::Write> TextWriter<W> {
}
impl<W: io::Write> CompoundWriter for TextWriter<W> {
#[inline]
fn boundary(&mut self, b: &B::Type) -> io::Result<()> {
match (b.closing.as_ref(), b.opening.as_ref()) {
(None, Some(B::Item::RecordLabel)) |