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

Remove misleading prefix on branch readers

This commit is contained in:
Tony Garnock-Jones 2021-07-21 22:34:02 +02:00
parent cae254ef21
commit 9b88db6790
2 changed files with 61 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,8 +26,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
ps.extend(pattern_n);
ctxt.define_atom(&mut body, "_mark", item("r.mark()?"));
for NamedAlternative { variant_label: name, pattern: pat } in ps {
let fname = seq![ctxt.m.target_prefix(), "read_",
names::render_fieldname(n), "_", names::render_fieldname(name)];
let fname = seq!["read_", names::render_fieldname(n), "_", names::render_fieldname(name)];
let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]);
ctxt.m.define_function(
&(n.to_owned() + "::" + name),

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

@ -243,7 +243,7 @@ impl std::convert::From<&AtomKind> for _Any {
}
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "Boolean" => {}
@ -255,7 +255,7 @@ fn _any_read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mu
Ok(AtomKind::Boolean)
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "Float" => {}
@ -267,7 +267,7 @@ fn _any_read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut
Ok(AtomKind::Float)
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "Double" => {}
@ -279,7 +279,7 @@ fn _any_read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut
Ok(AtomKind::Double)
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "SignedInteger" => {}
@ -291,7 +291,7 @@ fn _any_read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>
Ok(AtomKind::SignedInteger)
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "String" => {}
@ -303,7 +303,7 @@ fn _any_read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut
Ok(AtomKind::String)
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "ByteString" => {}
@ -315,7 +315,7 @@ fn _any_read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r:
Ok(AtomKind::ByteString)
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "Symbol" => {}
@ -330,13 +330,13 @@ fn _any_read_atom_kind_symbol<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for AtomKind {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
let _mark = r.mark()?;
match _any_read_atom_kind_boolean(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_atom_kind_float(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_atom_kind_double(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_atom_kind_signed_integer(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_atom_kind_string(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_atom_kind_byte_string(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_atom_kind_symbol(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_atom_kind_boolean(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_atom_kind_float(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_atom_kind_double(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_atom_kind_signed_integer(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_atom_kind_string(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_atom_kind_byte_string(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_atom_kind_symbol(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.AtomKind"))
}
}
@ -518,7 +518,7 @@ impl std::convert::From<&CompoundPattern> for _Any {
}
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -534,7 +534,7 @@ fn _any_read_compound_pattern_rec<'de, R: _support::Reader<'de, _Ptr, _Any>>(r:
Ok(CompoundPattern::Rec {label: std::boxed::Box::new(_tmp1), fields: std::boxed::Box::new(_tmp2)})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -551,7 +551,7 @@ fn _any_read_compound_pattern_tuple<'de, R: _support::Reader<'de, _Ptr, _Any>>(r
Ok(CompoundPattern::Tuple {patterns: _tmp1})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -569,7 +569,7 @@ fn _any_read_compound_pattern_tuple_prefix<'de, R: _support::Reader<'de, _Ptr, _
Ok(CompoundPattern::TuplePrefix {fixed: _tmp1, variable: std::boxed::Box::new(_tmp3)})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -587,10 +587,10 @@ fn _any_read_compound_pattern_dict<'de, R: _support::Reader<'de, _Ptr, _Any>>(r:
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for CompoundPattern {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
let _mark = r.mark()?;
match _any_read_compound_pattern_rec(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_compound_pattern_tuple(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_compound_pattern_tuple_prefix(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_compound_pattern_dict(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_compound_pattern_rec(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_compound_pattern_tuple(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_compound_pattern_tuple_prefix(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_compound_pattern_dict(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.CompoundPattern"))
}
}
@ -680,7 +680,7 @@ impl std::convert::From<&Definition> for _Any {
}
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -703,7 +703,7 @@ fn _any_read_definition_or<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R)
})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -726,7 +726,7 @@ fn _any_read_definition_and<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R
})
}
fn _any_read_definition_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Definition, _support::ParseError> {
fn read_definition_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Definition, _support::ParseError> {
let _tmp0 = Pattern::deserialize(r)?;
Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
}
@ -734,9 +734,9 @@ fn _any_read_definition_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &m
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Definition {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
let _mark = r.mark()?;
match _any_read_definition_or(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_definition_and(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_definition_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_definition_or(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_definition_and(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_definition_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.Definition"))
}
}
@ -836,12 +836,12 @@ impl std::convert::From<&EmbeddedTypeName> for _Any {
}
}
fn _any_read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
fn read_embedded_type_name_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<EmbeddedTypeName, _support::ParseError> {
let _tmp0 = Ref::deserialize(r)?;
Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Boolean(w) if !*w => {}
@ -856,8 +856,8 @@ fn _any_read_embedded_type_name_false<'de, R: _support::Reader<'de, _Ptr, _Any>>
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for EmbeddedTypeName {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
let _mark = r.mark()?;
match _any_read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_embedded_type_name_false(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_embedded_type_name_false(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName"))
}
}
@ -986,12 +986,12 @@ impl std::convert::From<&NamedPattern> for _Any {
}
}
fn _any_read_named_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<NamedPattern, _support::ParseError> {
fn read_named_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<NamedPattern, _support::ParseError> {
let _tmp0 = Binding::deserialize(r)?;
Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
}
fn _any_read_named_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<NamedPattern, _support::ParseError> {
fn read_named_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<NamedPattern, _support::ParseError> {
let _tmp0 = Pattern::deserialize(r)?;
Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
}
@ -999,8 +999,8 @@ fn _any_read_named_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedPattern {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
let _mark = r.mark()?;
match _any_read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_named_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_named_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.NamedPattern"))
}
}
@ -1033,12 +1033,12 @@ impl std::convert::From<&NamedSimplePattern> for _Any {
}
}
fn _any_read_named_simple_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<NamedSimplePattern, _support::ParseError> {
fn read_named_simple_pattern_named<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<NamedSimplePattern, _support::ParseError> {
let _tmp0 = Binding::deserialize(r)?;
Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
}
fn _any_read_named_simple_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<NamedSimplePattern, _support::ParseError> {
fn read_named_simple_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<NamedSimplePattern, _support::ParseError> {
let _tmp0 = SimplePattern::deserialize(r)?;
Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
}
@ -1046,8 +1046,8 @@ fn _any_read_named_simple_pattern_anonymous<'de, R: _support::Reader<'de, _Ptr,
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for NamedSimplePattern {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
let _mark = r.mark()?;
match _any_read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_named_simple_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_named_simple_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.NamedSimplePattern"))
}
}
@ -1080,12 +1080,12 @@ impl std::convert::From<&Pattern> for _Any {
}
}
fn _any_read_pattern_simple_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Pattern, _support::ParseError> {
fn read_pattern_simple_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Pattern, _support::ParseError> {
let _tmp0 = SimplePattern::deserialize(r)?;
Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
}
fn _any_read_pattern_compound_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Pattern, _support::ParseError> {
fn read_pattern_compound_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut R) -> std::result::Result<Pattern, _support::ParseError> {
let _tmp0 = CompoundPattern::deserialize(r)?;
Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
}
@ -1093,8 +1093,8 @@ fn _any_read_pattern_compound_pattern<'de, R: _support::Reader<'de, _Ptr, _Any>>
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for Pattern {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
let _mark = r.mark()?;
match _any_read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_pattern_compound_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_pattern_compound_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.Pattern"))
}
}
@ -1335,7 +1335,7 @@ impl std::convert::From<&SimplePattern> for _Any {
}
}
fn _any_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)? {
preserves::value::Token::Atom(v) => match v.value() {
preserves::value::Value::Symbol(w) if w == "any" => {}
@ -1347,7 +1347,7 @@ fn _any_read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &m
Ok(SimplePattern::Any)
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -1362,7 +1362,7 @@ fn _any_read_simple_pattern_atom<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &
Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp1)})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -1377,7 +1377,7 @@ fn _any_read_simple_pattern_embedded<'de, R: _support::Reader<'de, _Ptr, _Any>>(
Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp1)})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -1392,7 +1392,7 @@ fn _any_read_simple_pattern_lit<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &m
Ok(SimplePattern::Lit {value: _tmp1})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -1407,7 +1407,7 @@ fn _any_read_simple_pattern_seqof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r:
Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp1)})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -1422,7 +1422,7 @@ fn _any_read_simple_pattern_setof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r:
Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp1)})
}
fn _any_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)?;
match r.next_token(false)? {
preserves::value::Token::Atom(v) => match v.value() {
@ -1438,7 +1438,7 @@ fn _any_read_simple_pattern_dictof<'de, R: _support::Reader<'de, _Ptr, _Any>>(r:
Ok(SimplePattern::Dictof {key: std::boxed::Box::new(_tmp1), value: std::boxed::Box::new(_tmp2)})
}
fn _any_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> {
let _tmp0 = Ref::deserialize(r)?;
Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
}
@ -1446,14 +1446,14 @@ fn _any_read_simple_pattern_ref<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &m
impl<'de, R: _support::Reader<'de, _Ptr, _Any>> _support::Deserialize<'de, _Ptr, _Any, R> for SimplePattern {
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
let _mark = r.mark()?;
match _any_read_simple_pattern_any(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_simple_pattern_atom(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_simple_pattern_embedded(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_simple_pattern_lit(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_simple_pattern_seqof(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_simple_pattern_setof(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_simple_pattern_dictof(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match _any_read_simple_pattern_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_simple_pattern_any(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_simple_pattern_atom(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_simple_pattern_embedded(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_simple_pattern_lit(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_simple_pattern_seqof(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_simple_pattern_setof(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_simple_pattern_dictof(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
match read_simple_pattern_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.SimplePattern"))
}
}