Remove misleading prefix on branch readers
This commit is contained in:
parent
cae254ef21
commit
9b88db6790
|
@ -26,8 +26,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
|
||||||
ps.extend(pattern_n);
|
ps.extend(pattern_n);
|
||||||
ctxt.define_atom(&mut body, "_mark", item("r.mark()?"));
|
ctxt.define_atom(&mut body, "_mark", item("r.mark()?"));
|
||||||
for NamedAlternative { variant_label: name, pattern: pat } in ps {
|
for NamedAlternative { variant_label: name, pattern: pat } in ps {
|
||||||
let fname = seq![ctxt.m.target_prefix(), "read_",
|
let fname = seq!["read_", names::render_fieldname(n), "_", names::render_fieldname(name)];
|
||||||
names::render_fieldname(n), "_", names::render_fieldname(name)];
|
|
||||||
let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]);
|
let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]);
|
||||||
ctxt.m.define_function(
|
ctxt.m.define_function(
|
||||||
&(n.to_owned() + "::" + name),
|
&(n.to_owned() + "::" + name),
|
||||||
|
|
|
@ -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)? {
|
match r.next_token(false)? {
|
||||||
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" => {}
|
||||||
|
@ -255,7 +255,7 @@ fn _any_read_atom_kind_boolean<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mu
|
||||||
Ok(AtomKind::Boolean)
|
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)? {
|
match r.next_token(false)? {
|
||||||
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" => {}
|
||||||
|
@ -267,7 +267,7 @@ fn _any_read_atom_kind_float<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut
|
||||||
Ok(AtomKind::Float)
|
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)? {
|
match r.next_token(false)? {
|
||||||
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" => {}
|
||||||
|
@ -279,7 +279,7 @@ fn _any_read_atom_kind_double<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut
|
||||||
Ok(AtomKind::Double)
|
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)? {
|
match r.next_token(false)? {
|
||||||
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" => {}
|
||||||
|
@ -291,7 +291,7 @@ fn _any_read_atom_kind_signed_integer<'de, R: _support::Reader<'de, _Ptr, _Any>>
|
||||||
Ok(AtomKind::SignedInteger)
|
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)? {
|
match r.next_token(false)? {
|
||||||
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" => {}
|
||||||
|
@ -303,7 +303,7 @@ fn _any_read_atom_kind_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &mut
|
||||||
Ok(AtomKind::String)
|
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)? {
|
match r.next_token(false)? {
|
||||||
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" => {}
|
||||||
|
@ -315,7 +315,7 @@ fn _any_read_atom_kind_byte_string<'de, R: _support::Reader<'de, _Ptr, _Any>>(r:
|
||||||
Ok(AtomKind::ByteString)
|
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)? {
|
match r.next_token(false)? {
|
||||||
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" => {}
|
||||||
|
@ -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 {
|
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> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
let _mark = r.mark()?;
|
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 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 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 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 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 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 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_symbol(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
|
||||||
Err(_support::ParseError::conformance_error("schema.AtomKind"))
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)})
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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})
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)})
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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 {
|
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> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
let _mark = r.mark()?;
|
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 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 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 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_dict(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
|
||||||
Err(_support::ParseError::conformance_error("schema.CompoundPattern"))
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)?;
|
let _tmp0 = Pattern::deserialize(r)?;
|
||||||
Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
|
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 {
|
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> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
let _mark = r.mark()?;
|
let _mark = r.mark()?;
|
||||||
match _any_read_definition_or(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 _any_read_definition_and(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 _any_read_definition_pattern(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"))
|
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)?;
|
let _tmp0 = Ref::deserialize(r)?;
|
||||||
Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
|
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)? {
|
match r.next_token(false)? {
|
||||||
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 => {}
|
||||||
|
@ -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 {
|
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> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
let _mark = r.mark()?;
|
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 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_false(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
|
||||||
Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName"))
|
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)?;
|
let _tmp0 = Binding::deserialize(r)?;
|
||||||
Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
|
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)?;
|
let _tmp0 = Pattern::deserialize(r)?;
|
||||||
Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
|
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 {
|
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> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
let _mark = r.mark()?;
|
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 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_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
|
||||||
Err(_support::ParseError::conformance_error("schema.NamedPattern"))
|
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)?;
|
let _tmp0 = Binding::deserialize(r)?;
|
||||||
Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
|
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)?;
|
let _tmp0 = SimplePattern::deserialize(r)?;
|
||||||
Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
|
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 {
|
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> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
let _mark = r.mark()?;
|
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 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_anonymous(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
|
||||||
Err(_support::ParseError::conformance_error("schema.NamedSimplePattern"))
|
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)?;
|
let _tmp0 = SimplePattern::deserialize(r)?;
|
||||||
Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
|
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)?;
|
let _tmp0 = CompoundPattern::deserialize(r)?;
|
||||||
Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
|
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 {
|
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> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
let _mark = r.mark()?;
|
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 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_compound_pattern(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
|
||||||
Err(_support::ParseError::conformance_error("schema.Pattern"))
|
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)? {
|
match r.next_token(false)? {
|
||||||
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" => {}
|
||||||
|
@ -1347,7 +1347,7 @@ fn _any_read_simple_pattern_any<'de, R: _support::Reader<'de, _Ptr, _Any>>(r: &m
|
||||||
Ok(SimplePattern::Any)
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)})
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)})
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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})
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)})
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)})
|
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)?;
|
r.open_record(None)?;
|
||||||
match r.next_token(false)? {
|
match r.next_token(false)? {
|
||||||
preserves::value::Token::Atom(v) => match v.value() {
|
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)})
|
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)?;
|
let _tmp0 = Ref::deserialize(r)?;
|
||||||
Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
|
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 {
|
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> {
|
fn deserialize(r: &mut R) -> std::result::Result<Self, _support::ParseError> {
|
||||||
let _mark = r.mark()?;
|
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 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 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 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 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 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 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 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_ref(r) { Err(e) if e.is_conformance_error() => r.restore(&_mark)?, result => return result }
|
||||||
Err(_support::ParseError::conformance_error("schema.SimplePattern"))
|
Err(_support::ParseError::conformance_error("schema.SimplePattern"))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue