diff --git a/README.md b/README.md
index fffa652..c0928ea 100644
--- a/README.md
+++ b/README.md
@@ -64,6 +64,7 @@ Implementations of the data model, plus Syrup transfer syntax:
## Additional resources
+ - [Cheat sheet(s) for Preserves syntax](cheatsheet.html)
- Some [conventions for common data types](conventions.html)
- [Open questions](questions.html); see also the
[issues list]({{page.projectpages}}/issues)
diff --git a/_includes/cheatsheet-binary.md b/_includes/cheatsheet-binary.md
new file mode 100644
index 0000000..292daab
--- /dev/null
+++ b/_includes/cheatsheet-binary.md
@@ -0,0 +1 @@
+(TODO)
diff --git a/_layouts/redirect.html b/_layouts/redirect.html
new file mode 100644
index 0000000..5db4f53
--- /dev/null
+++ b/_layouts/redirect.html
@@ -0,0 +1,9 @@
+---
+layout: skeleton
+extra_html_headers: |
+
+
+---
+
Redirecting
+
+Redirecting you to {{ page.redirect_target }}.
diff --git a/cheatsheet.md b/cheatsheet.md
new file mode 100644
index 0000000..7f391e6
--- /dev/null
+++ b/cheatsheet.md
@@ -0,0 +1,11 @@
+---
+no_site_title: true
+title: "Preserves Cheatsheets"
+---
+
+Tony Garnock-Jones
+{{ site.version_date }}. Version {{ site.version }}.
+
+## Machine-Oriented Binary Syntax
+
+{% include cheatsheet-binary.md %}
diff --git a/conventions.md b/conventions.md
index 7dc9c90..6280ab5 100644
--- a/conventions.md
+++ b/conventions.md
@@ -106,17 +106,10 @@ such media types following the general rules for ordering of
**Examples.**
- «»
- = B4 B3 04 "mime" B3 18 "application/octet-stream" B2 05 "abcde"
-
- «»
- = B4 B3 04 "mime" B3 0A "text/plain" B2 03 "ABC" 84
-
- «">»
- = B4 B3 04 "mime" B3 0F "application/xml" B2 08 "" 84
-
- «»
- = B4 B3 04 "mime" B3 08 "text/csv" B2 0B "123,234,345" 84
+
+
+ ">
+
## Unicode normalization forms.
diff --git a/implementations/rust/preserves-schema/src/compiler/context.rs b/implementations/rust/preserves-schema/src/compiler/context.rs
index 57859b2..d6499d1 100644
--- a/implementations/rust/preserves-schema/src/compiler/context.rs
+++ b/implementations/rust/preserves-schema/src/compiler/context.rs
@@ -215,7 +215,7 @@ impl<'m, 'b> ModuleContext<'m, 'b> {
"'a",
seq!["_L: Copy",
seq(lts.into_iter().map(|t| item(seq![" + Into<&'a ", t, ">"])).collect())],
- seq![self.any_type(), ": preserves::value::NestedValue + 'a"]])
+ seq![self.any_type(), ": _support::preserves::value::NestedValue + 'a"]])
}
pub fn extract(&mut self) -> Vec- {
diff --git a/implementations/rust/preserves-schema/src/compiler/mod.rs b/implementations/rust/preserves-schema/src/compiler/mod.rs
index 1fda19e..58ae888 100644
--- a/implementations/rust/preserves-schema/src/compiler/mod.rs
+++ b/implementations/rust/preserves-schema/src/compiler/mod.rs
@@ -108,8 +108,8 @@ pub struct CompilerConfig {
pub fn load_schema_or_bundle(bundle: &mut Map, i: &PathBuf) -> io::Result<()> {
let mut f = File::open(&i)?;
let mut src = IOBinarySource::new(&mut f);
- let mut reader = src.packed_iovalues();
- let blob = reader.demand_next(false)?;
+ let mut reader = src.packed();
+ let blob = reader.next_iovalue(false)?;
let language = Language::default();
if let Ok(s) = language.parse(&blob) {
@@ -139,8 +139,8 @@ impl CompilerConfig {
) -> Self {
CompilerConfig {
bundle: Map::new(),
- output_dir: output_dir,
- fully_qualified_module_prefix: fully_qualified_module_prefix,
+ output_dir,
+ fully_qualified_module_prefix,
support_crate: "preserves_schema".to_owned(),
external_modules: Map::new(),
plugins: vec![
@@ -274,9 +274,8 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> {
"use _support::Deserialize;",
"use _support::Parse;",
"use _support::Unparse;",
- "use _support::preserves;",
- "use preserves::value::Domain;",
- "use preserves::value::NestedValue;",
+ "use _support::preserves::value::Domain;",
+ "use _support::preserves::value::NestedValue;",
""])));
let mut emit_items = |items: Vec
- | {
@@ -306,18 +305,17 @@ pub fn compile(config: &CompilerConfig) -> io::Result<()> {
lines.push("".to_owned());
lines.push(format!("use {}::support as _support;", &config.support_crate));
- lines.push("use _support::preserves;".to_owned());
lines.push("".to_owned());
lines.push("#[allow(non_snake_case)]".to_owned());
lines.push(Formatter::to_string(item(seq![
- "pub struct ", b.language_struct_name(), anglebrackets!["N: preserves::value::NestedValue"], " ",
+ "pub struct ", b.language_struct_name(), anglebrackets!["N: _support::preserves::value::NestedValue"], " ",
vertical(false, braces(b.literals.iter().map(
|(value, name)| item(format!("pub {}: N /* {:?} */", name, value))).collect()))
])));
lines.push("".to_owned());
lines.push(Formatter::to_string(item(seq![
- "impl", anglebrackets!["N: preserves::value::NestedValue"],
+ "impl", anglebrackets!["N: _support::preserves::value::NestedValue"],
" Default for ", b.language_struct_name(), " ", codeblock![
seq!["fn default() -> Self ", codeblock![
seq![b.language_struct_name(), " ", vertical(false, braces(b.literals.iter().map(|(value, name)| {
diff --git a/implementations/rust/preserves-schema/src/compiler/parsers.rs b/implementations/rust/preserves-schema/src/compiler/parsers.rs
index 5c9419d..bc25553 100644
--- a/implementations/rust/preserves-schema/src/compiler/parsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/parsers.rs
@@ -175,7 +175,7 @@ fn simple_pattern_parser(
let item_dest = simple_pattern_parser(ctxt, pattern, &tmp, 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()"));
+ ctxt.declare_compound(body, &dest, item("_support::preserves::value::Set::new()"));
body.push(item(seq!["for ", tmp.to_owned(),
" in ", src.to_owned(), ".value().to_set()?",
" ", codeblock(inner)]));
@@ -191,7 +191,7 @@ fn simple_pattern_parser(
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()"));
+ ctxt.declare_compound(body, &dest, item("_support::preserves::value::Map::new()"));
body.push(item(seq!["for (", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")",
" in ", src.to_owned(), ".value().to_dictionary()?",
" ", codeblock(inner)]));
diff --git a/implementations/rust/preserves-schema/src/compiler/readers.rs b/implementations/rust/preserves-schema/src/compiler/readers.rs
index a620df1..5ece82c 100644
--- a/implementations/rust/preserves-schema/src/compiler/readers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/readers.rs
@@ -65,12 +65,12 @@ impl BoundaryTracker {
fn emit_boundary(&self, body: &mut Vec
- ) {
body.push(item(seq![self.tracker_name.clone(), ".shift(Some(", self.item_expr, "));"]));
- body.push(item(seq!["r.boundary(&", self.tracker_name.clone(), ")?;"]));
+ body.push(item(seq!["r.reader.boundary(&", self.tracker_name.clone(), ")?;"]));
}
fn emit_loop(&self, body: &mut Vec
- , inner: Vec
- ) {
body.push(item(seq![
- "while !r.close_compound", parens![
+ "while !r.reader.close_compound", parens![
seq!["&mut ", self.tracker_name.clone()],
seq!["&", self.item_expr]], "? ",
codeblock(inner)]))
@@ -89,7 +89,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
Definition::Or { pattern_0, pattern_1, pattern_n } => {
let mut ps = vec![&**pattern_0, &**pattern_1];
ps.extend(pattern_n);
- ctxt.define_atom(&mut body, "_mark", item("r.mark()?"));
+ ctxt.define_atom(&mut body, "_mark", item("r.reader.mark()?"));
for NamedAlternative { variant_label: name, pattern: pat } in ps {
let fname = seq!["read_", names::render_fieldname(n), "_", names::render_fieldname(name)];
let ctorname = item(name![names::render_constructor(n), names::render_constructor(name)]);
@@ -103,9 +103,10 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
item(seq![
"fn ", fname.clone(), anglebrackets![
"'de",
- seq![ctxt.m.any_type(), ": preserves::value::NestedValue"],
- seq!["R: _support::Reader<'de, ", ctxt.m.any_type(), ">"]],
- "(r: &mut R) -> ",
+ seq![ctxt.m.any_type(), ": _support::preserves::value::NestedValue"],
+ seq!["_Dec: _support::DomainDecode<", ctxt.m.any_type(), "::Embedded>"],
+ "_R: _support::Reader<'de>"],
+ seq!["(r: &mut _support::preserves::value::ConfiguredReader<'de, ", ctxt.m.any_type(), ", _Dec, _R>) -> "],
"std::result::Result<",
names::render_constructor(n), ty.generic_arg(ctxt.m),
", _support::ParseError> ",
@@ -113,7 +114,7 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
});
body.push(item(seq![
"match ", fname, "(r) { ",
- "Err(e) if e.is_conformance_error() => r.restore(&_mark)?, ",
+ "Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, ",
"result => return result }"]));
}
body.push(item(seq![ctxt.err_code()]));
@@ -122,10 +123,10 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
let mut ps = vec![&**pattern_0, &**pattern_1];
let mut need_restore = false;
ps.extend(pattern_n);
- ctxt.define_atom(&mut body, "_mark", item("r.mark()?"));
+ ctxt.define_atom(&mut body, "_mark", item("r.reader.mark()?"));
for e in &ps {
if need_restore {
- body.push(item("r.restore(&_mark)?;"));
+ body.push(item("r.reader.restore(&_mark)?;"));
} else {
need_restore = true;
}
@@ -141,13 +142,14 @@ pub fn gen_definition_reader(m: &mut ModuleContext, n: &str, d: &Definition) {
}
item(seq![
- "impl", anglebrackets![seq![ctxt.m.any_type(), ": preserves::value::NestedValue"]],
- " _support::Deserialize", anglebrackets![ctxt.m.any_type()], " for ",
- names::render_constructor(n), ty.generic_arg(ctxt.m), " ", codeblock![
- seq!["fn deserialize",
- anglebrackets!["'de",
- seq!["R: _support::Reader<'de, ", ctxt.m.any_type(), ">"]],
- "(r: &mut R) -> ",
+ "impl", anglebrackets![
+ "'de",
+ seq![ctxt.m.any_type(), ": _support::preserves::value::NestedValue"],
+ seq!["_Dec: _support::DomainDecode<", ctxt.m.any_type(), "::Embedded>"],
+ "_R: _support::Reader<'de>"], " ",
+ "_support::Deserialize", anglebrackets!["'de", ctxt.m.any_type(), "_Dec", "_R"], " ",
+ "for ", names::render_constructor(n), ty.generic_arg(ctxt.m), " ", codeblock![
+ seq!["fn deserialize(r: &mut _support::preserves::value::ConfiguredReader<'de, ", ctxt.m.any_type(), ", _Dec, _R>) -> ",
"std::result::Result ",
codeblock(body)]]])
});
@@ -239,7 +241,7 @@ fn read_expected_literal_seqs(
None => {
let mut inner = Vec::new();
group.into_iter().next().unwrap().1(ctxt, &mut inner);
- cases.push(item(seq!["preserves::value::Token::End => ", codeblock(inner)]));
+ cases.push(item(seq!["_support::preserves::value::Token::End => ", codeblock(inner)]));
},
Some(h) => {
let tails = group.into_iter().map(|(mut vs, f)| {
@@ -253,7 +255,7 @@ fn read_expected_literal_seqs(
}
}
cases.extend(read_expected_literals_cases(ctxt, nested));
- body.push(item(seq!["match r.next_token(true)? ", codeblock(cases)]));
+ body.push(item(seq!["match r.next_token()? ", codeblock(cases)]));
}
fn read_expected_literals_cases(
@@ -269,7 +271,7 @@ fn read_expected_literals_cases(
let mut inner = Vec::new();
p.1(ctxt, &mut inner);
subcases.push(item(seq![
- format!("preserves::value::Value::{:?}(w)", cls),
+ format!("_support::preserves::value::Value::{:?}(w)", cls),
match cls {
AtomClass::Boolean => match p.0.value().to_boolean().unwrap() {
true => " if *w".to_owned(),
@@ -291,7 +293,7 @@ fn read_expected_literals_cases(
codeblock(inner)]));
}
subcases.push(item(seq!["_ => return ", ctxt.err_code(), "?,"]));
- item(seq!["preserves::value::Token::Atom(v) => match v.value() ", codeblock(subcases)])
+ item(seq!["_support::preserves::value::Token::Atom(v) => match v.value() ", codeblock(subcases)])
}
ValueClass::Compound(CompoundClass::Record) => {
let mut subcases = Vec::new();
@@ -300,7 +302,7 @@ fn read_expected_literals_cases(
(r.0.clone(), f)
}).collect());
item(seq![
- "preserves::value::Token::Compound(preserves::value::CompoundClass::Record) => ",
+ "_support::preserves::value::Token::Compound(_support::preserves::value::CompoundClass::Record) => ",
codeblock(subcases)])
}
ValueClass::Compound(CompoundClass::Sequence) => {
@@ -310,7 +312,7 @@ fn read_expected_literals_cases(
(s, f)
}).collect());
item(seq![
- "preserves::value::Token::Compound(preserves::value::CompoundClass::Sequence) => ",
+ "_support::preserves::value::Token::Compound(_support::preserves::value::CompoundClass::Sequence) => ",
codeblock(subcases)])
}
ValueClass::Compound(CompoundClass::Set) => {
@@ -334,7 +336,7 @@ fn read_expected_literals(
possibilities: LiteralCases,
) {
let cases = read_expected_literals_cases(ctxt, possibilities);
- body.push(item(seq!["match r.next_token(true)? ", codeblock(cases)]));
+ body.push(item(seq!["match r.next_token()? ", codeblock(cases)]));
}
fn simple_pattern_reader(
@@ -346,27 +348,27 @@ fn simple_pattern_reader(
let dest = ctxt.gentempname();
match p {
SimplePattern::Any => {
- ctxt.define_atom(body, &dest, item("r.demand_next(true)?"));
+ ctxt.define_atom(body, &dest, item("r.demand_next()?"));
dest
},
SimplePattern::Atom { atom_kind: k } => {
let reader = match &**k {
- AtomKind::Boolean => "r.next_boolean()?",
- AtomKind::Float => "r.next_float()?",
- AtomKind::Double => "r.next_double()?",
- AtomKind::SignedInteger => "r.next_signedinteger()?",
- AtomKind::String => "r.next_str()?.into_owned()",
- AtomKind::ByteString => "r.next_bytestring()?.into_owned()",
- AtomKind::Symbol => "r.next_symbol()?.into_owned()",
+ AtomKind::Boolean => "r.reader.next_boolean()?",
+ AtomKind::Float => "r.reader.next_float()?",
+ AtomKind::Double => "r.reader.next_double()?",
+ AtomKind::SignedInteger => "r.reader.next_signedinteger()?",
+ AtomKind::String => "r.reader.next_str()?.into_owned()",
+ AtomKind::ByteString => "r.reader.next_bytestring()?.into_owned()",
+ AtomKind::Symbol => "r.reader.next_symbol()?.into_owned()",
};
ctxt.define_atom(body, &dest, item(reader.to_owned()));
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(true)?.value().to_embedded()?.clone()"));
- body.push(item("r.close_embedded()?;"));
+ body.push(item("r.reader.open_embedded()?;"));
+ ctxt.define_atom(body, &dest, item("r.demand_next()?.value().to_embedded()?.clone()"));
+ body.push(item("r.reader.close_embedded()?;"));
dest
},
SimplePattern::Lit { value } => {
@@ -379,7 +381,7 @@ fn simple_pattern_reader(
let compound_dest = ctxt.gentempname();
ctxt.with_definite_mode(|ctxt| {
let boundary_tracker = BoundaryTracker::unwrap(
- ctxt, body, "r.open_sequence()?;", boundary_tracker);
+ ctxt, body, "r.reader.open_sequence()?;", boundary_tracker);
let mut inner = Vec::new();
boundary_tracker.emit_boundary(&mut inner);
let item_dest = simple_pattern_reader(ctxt, pattern, None, &mut inner);
@@ -395,13 +397,13 @@ fn simple_pattern_reader(
let compound_dest = ctxt.gentempname();
ctxt.with_definite_mode(|ctxt| {
let boundary_tracker = BoundaryTracker::new(
- ctxt, body, "r.open_set()?;", "_support::B::Item::SetValue");
+ ctxt, body, "r.reader.open_set()?;", "_support::B::Item::SetValue");
let mut inner = Vec::new();
boundary_tracker.emit_boundary(&mut inner);
let item_dest = simple_pattern_reader(ctxt, pattern, None, &mut inner);
inner.push(item(seq![compound_dest.to_owned(), ".insert(",
store_wrap(true, &field_type(pattern), &item_dest), ");"]));
- ctxt.declare_compound(body, &compound_dest, item("preserves::value::Set::new()"));
+ ctxt.declare_compound(body, &compound_dest, item("_support::preserves::value::Set::new()"));
boundary_tracker.emit_loop(body, inner);
});
ctxt.define_atom(body, &dest, item(compound_dest));
@@ -411,7 +413,7 @@ fn simple_pattern_reader(
let compound_dest = ctxt.gentempname();
ctxt.with_definite_mode(|ctxt| {
let mut boundary_tracker = BoundaryTracker::new(
- ctxt, body, "r.open_dictionary()?;", "_support::B::Item::DictionaryKey");
+ ctxt, body, "r.reader.open_dictionary()?;", "_support::B::Item::DictionaryKey");
let mut inner = Vec::new();
boundary_tracker.emit_boundary(&mut inner);
let key_dest = simple_pattern_reader(ctxt, key, None, &mut inner);
@@ -422,7 +424,7 @@ fn simple_pattern_reader(
compound_dest.to_owned(), ".insert(",
store_wrap(true, &field_type(key), &key_dest), ", ",
store_wrap(true, &field_type(value), &value_dest), ");"]));
- ctxt.declare_compound(body, &compound_dest, item("preserves::value::Map::new()"));
+ ctxt.declare_compound(body, &compound_dest, item("_support::preserves::value::Map::new()"));
boundary_tracker.item_expr = "_support::B::Item::DictionaryKey";
boundary_tracker.emit_loop(body, inner);
});
@@ -469,7 +471,7 @@ fn pattern_reader(
match &**c {
CompoundPattern::Rec { label, fields } => {
let mut boundary_tracker = BoundaryTracker::new(
- ctxt, body, "r.open_record(None)?;", "_support::B::Item::RecordLabel");
+ ctxt, body, "r.reader.open_record()?;", "_support::B::Item::RecordLabel");
boundary_tracker.emit_boundary(body);
boundary_tracker.item_expr = "_support::B::Item::RecordField";
named_pattern_reader(ctxt, &**label, None, body);
@@ -477,18 +479,18 @@ fn pattern_reader(
},
CompoundPattern::Tuple { patterns } => {
let boundary_tracker = BoundaryTracker::unwrap(
- ctxt, body, "r.open_sequence()?;", boundary_tracker);
+ ctxt, body, "r.reader.open_sequence()?;", boundary_tracker);
for p in patterns {
boundary_tracker.emit_boundary(body);
named_pattern_reader(ctxt, p, None, body);
}
- body.push(item(seq!["r.ensure_complete", parens![
+ body.push(item(seq!["r.reader.ensure_complete", parens![
boundary_tracker.tracker_name.clone(),
seq!["&", boundary_tracker.item_expr]], "?;"]));
},
CompoundPattern::TuplePrefix { fixed, variable } => {
let boundary_tracker = BoundaryTracker::unwrap(
- ctxt, body, "r.open_sequence()?;", boundary_tracker);
+ ctxt, body, "r.reader.open_sequence()?;", boundary_tracker);
for p in fixed {
boundary_tracker.emit_boundary(body);
named_pattern_reader(ctxt, p, None, body);
@@ -497,7 +499,7 @@ fn pattern_reader(
},
CompoundPattern::Dict { entries } => {
let boundary_tracker = BoundaryTracker::new(
- ctxt, body, "r.open_dictionary()?;", "_support::B::Item::DictionaryKey");
+ ctxt, body, "r.reader.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();
diff --git a/implementations/rust/preserves-schema/src/compiler/types.rs b/implementations/rust/preserves-schema/src/compiler/types.rs
index 2c659c2..b6ed6eb 100644
--- a/implementations/rust/preserves-schema/src/compiler/types.rs
+++ b/implementations/rust/preserves-schema/src/compiler/types.rs
@@ -53,7 +53,7 @@ impl compiler::Plugin for TypePlugin {
m.define_type(item(vertical(false, seq![
seq!["pub type _Dom = ", m.render_ref(&*r, RefRenderStyle::Bare), ";"],
seq!["pub type _Ptr = std::sync::Arc<_Dom>;"],
- seq!["pub type _Any = preserves::value::ArcValue<_Ptr>;"]
+ seq!["pub type _Any = _support::preserves::value::ArcValue<_Ptr>;"]
])));
}
}
@@ -63,7 +63,7 @@ impl compiler::Plugin for TypePlugin {
let ty = definition_type(&m.module_path, n, d);
m.define_type(item(ty.render(m, n)));
m.define_type(item(seq![
- "impl", ty.generic_decl(m), " preserves::value::Domain for ",
+ "impl", ty.generic_decl(m), " _support::preserves::value::Domain for ",
names::render_constructor(n), ty.generic_arg(m), " {}"]));
}
}
@@ -174,9 +174,9 @@ pub fn field_type(p: &SimplePattern) -> TField {
SimplePattern::Atom { atom_kind: k } =>
match **k {
AtomKind::Boolean => TField::Base("bool".to_owned()),
- AtomKind::Float => TField::Base("preserves::value::Float".to_owned()),
- AtomKind::Double => TField::Base("preserves::value::Double".to_owned()),
- AtomKind::SignedInteger => TField::Base("preserves::value::signed_integer::SignedInteger".to_owned()),
+ AtomKind::Float => TField::Base("_support::preserves::value::Float".to_owned()),
+ AtomKind::Double => TField::Base("_support::preserves::value::Double".to_owned()),
+ AtomKind::SignedInteger => TField::Base("_support::preserves::value::signed_integer::SignedInteger".to_owned()),
AtomKind::String => TField::Base("std::string::String".to_owned()),
AtomKind::ByteString => TField::Base("std::vec::Vec".to_owned()),
AtomKind::Symbol => TField::Base("std::string::String".to_owned()),
@@ -200,8 +200,8 @@ impl TField {
TField::Any => seq![ctxt.any_type()],
TField::Embedded => seq![ctxt.any_type(), "::Embedded"],
TField::Array(t) => seq!["std::vec::Vec<", t.render(ctxt, false), ">"],
- TField::Set(t) => seq!["preserves::value::Set<", t.render(ctxt, false), ">"],
- TField::Map(k, v) => seq!["preserves::value::Map",
+ TField::Set(t) => seq!["_support::preserves::value::Set<", t.render(ctxt, false), ">"],
+ TField::Map(k, v) => seq!["_support::preserves::value::Map",
anglebrackets![k.render(ctxt, false),
v.render(ctxt, false)]],
TField::Ref(r) =>
@@ -294,7 +294,7 @@ impl TDefinition {
pub fn generic_decl(&self, ctxt: &ModuleContext) -> Item {
if self.has_embedded(ctxt.bundle) {
item(anglebrackets![
- seq![ctxt.any_type(), ": preserves::value::NestedValue"]])
+ seq![ctxt.any_type(), ": _support::preserves::value::NestedValue"]])
} else {
item("")
}
@@ -303,9 +303,9 @@ impl TDefinition {
pub fn generic_decl_with_defaults(&self, ctxt: &ModuleContext) -> Item {
if self.has_embedded(ctxt.bundle) {
item(anglebrackets![
- seq![ctxt.any_type(), ": preserves::value::NestedValue = ",
+ seq![ctxt.any_type(), ": _support::preserves::value::NestedValue = ",
match ctxt.schema.embedded_type {
- EmbeddedTypeName::False => "preserves::value::IOValue",
+ EmbeddedTypeName::False => "_support::preserves::value::IOValue",
EmbeddedTypeName::Ref(_) => "_Any",
}]])
} else {
diff --git a/implementations/rust/preserves-schema/src/compiler/unparsers.rs b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
index eec1cb9..8f323e9 100644
--- a/implementations/rust/preserves-schema/src/compiler/unparsers.rs
+++ b/implementations/rust/preserves-schema/src/compiler/unparsers.rs
@@ -85,7 +85,7 @@ pub fn gen_definition_unparser(m: &mut ModuleContext, n: &str, d: &Definition) {
let (patpat, vc) = destruct(&mut ctxt, item(names::render_constructor(n)), true, &record_type(&ps));
body.push(item(seq!["let ", patpat, " = self;"]));
body.push(item(seq![
- "preserves::value::merge(vec!", brackets(ps.iter().map(
+ "_support::preserves::value::merge(vec!", brackets(ps.iter().map(
|p| named_pattern_unparser(&mut ctxt, p, &vc)).collect()
), ").expect", parens![escape_string(&(
"merge of ".to_owned() + &ctxt.fully_qualified_error_context()))]]));
@@ -144,15 +144,15 @@ fn simple_pattern_unparser(
SimplePattern::Atom { atom_kind: k } => {
match &**k {
AtomKind::Symbol =>
- item(seq!["preserves::value::Value::symbol(", src.as_ref().unwrap().to_owned(), ").wrap()"]),
+ item(seq!["_support::preserves::value::Value::symbol(", src.as_ref().unwrap().to_owned(), ").wrap()"]),
AtomKind::ByteString =>
- item(seq!["preserves::value::Value::ByteString(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]),
+ item(seq!["_support::preserves::value::Value::ByteString(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]),
_ =>
- item(seq!["preserves::value::Value::from(", src.as_ref().unwrap().to_owned(), ").wrap()"])
+ item(seq!["_support::preserves::value::Value::from(", src.as_ref().unwrap().to_owned(), ").wrap()"])
}
}
SimplePattern::Embedded { .. } =>
- item(seq!["preserves::value::Value::Embedded(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]),
+ item(seq!["_support::preserves::value::Value::Embedded(", src.as_ref().unwrap().to_owned(), ".clone()).wrap()"]),
SimplePattern::Lit { value } =>
item(seq![parens![ctxt.m.define_literal(value)], ".clone()"]),
SimplePattern::Seqof { pattern } => {
@@ -169,7 +169,7 @@ fn simple_pattern_unparser(
}
SimplePattern::Setof { pattern } => {
let tmp = ctxt.gentempname();
- item(seq!["preserves::value::Value::Set(",
+ item(seq!["_support::preserves::value::Value::Set(",
src.as_ref().unwrap().to_owned(), ".iter().map(|", tmp.to_owned(), "| ",
simple_pattern_unparser(ctxt, pattern, &normal_src(tmp, true)),
").collect()).wrap()"])
@@ -177,7 +177,7 @@ fn simple_pattern_unparser(
SimplePattern::Dictof { key, value } => {
let tmp_key = ctxt.gentempname();
let tmp_value = ctxt.gentempname();
- item(seq!["preserves::value::Value::Dictionary(",
+ item(seq!["_support::preserves::value::Value::Dictionary(",
src.as_ref().unwrap().to_owned(),
".iter().map(|(", tmp_key.to_owned(), ", ", tmp_value.to_owned(), ")| ",
parens![simple_pattern_unparser(ctxt, key, &normal_src(tmp_key, true)),
@@ -225,7 +225,7 @@ fn pattern_unparser(
let rtmp = ctxt.gentempname();
let mut body = Vec::new();
let init_expr = item(seq![
- "preserves::value::Record(vec![",
+ "_support::preserves::value::Record(vec![",
named_pattern_unparser(ctxt, label, &normal_none(vc.is_struct)),
"])"]);
ctxt.declare_compound(&mut body, &rtmp, init_expr);
@@ -256,13 +256,13 @@ fn pattern_unparser(
CompoundPattern::Dict { entries } => {
let dtmp = ctxt.gentempname();
let mut body = Vec::new();
- ctxt.declare_compound(&mut body, &dtmp, item("preserves::value::Map::new()"));
+ ctxt.declare_compound(&mut body, &dtmp, item("_support::preserves::value::Map::new()"));
for (key_lit, value_pat) in entries.0.iter() {
body.push(item(seq![dtmp.clone(), ".insert", parens![
seq![parens![ctxt.m.define_literal(key_lit)], ".clone()"],
named_pattern_unparser(ctxt, &promote(value_pat), &normal_none(vc.is_struct))], ";"]));
}
- body.push(item(seq!["preserves::value::Value::Dictionary(", dtmp, ").wrap()"]));
+ body.push(item(seq!["_support::preserves::value::Value::Dictionary(", dtmp, ").wrap()"]));
item(codeblock(body))
}
}
@@ -283,7 +283,7 @@ fn sequenceify<'a>(
ctxt.declare_compound(&mut body, &rtmp, item("std::vec::Vec::new()"));
FieldsSink {
finish: item(seq![
- "preserves::value::Value::Sequence", parens![rtmp.clone()], ".wrap()"]),
+ "_support::preserves::value::Value::Sequence", parens![rtmp.clone()], ".wrap()"]),
vec_expr: item(rtmp),
body: body,
}
diff --git a/implementations/rust/preserves-schema/src/gen/mod.rs b/implementations/rust/preserves-schema/src/gen/mod.rs
index d96afaa..4c7d82e 100644
--- a/implementations/rust/preserves-schema/src/gen/mod.rs
+++ b/implementations/rust/preserves-schema/src/gen/mod.rs
@@ -1,10 +1,9 @@
pub mod schema;
use crate::support as _support;
-use _support::preserves;
#[allow(non_snake_case)]
-pub struct Language {
+pub struct Language {
pub LIT_15_FALSE: N /* #f */,
pub LIT_28_1: N /* 1 */,
pub LIT_0_BOOLEAN: N /* Boolean */,
@@ -36,7 +35,7 @@ pub struct Language {
pub LIT_20_VERSION: N /* version */
}
-impl Default for Language {
+impl Default for Language {
fn default() -> Self {
Language {
LIT_15_FALSE: /* #f */ _support::decode_lit(&vec![128]).unwrap(),
diff --git a/implementations/rust/preserves-schema/src/gen/schema.rs b/implementations/rust/preserves-schema/src/gen/schema.rs
index 86306d1..d9ff777 100644
--- a/implementations/rust/preserves-schema/src/gen/schema.rs
+++ b/implementations/rust/preserves-schema/src/gen/schema.rs
@@ -6,9 +6,8 @@ use crate::support as _support;
use _support::Deserialize;
use _support::Parse;
use _support::Unparse;
-use _support::preserves;
-use preserves::value::Domain;
-use preserves::value::NestedValue;
+use _support::preserves::value::Domain;
+use _support::preserves::value::NestedValue;
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
pub enum AtomKind {
@@ -21,12 +20,20 @@ pub enum AtomKind {
Symbol
}
-impl preserves::value::Domain for AtomKind {}
+impl _support::preserves::value::Domain for AtomKind {
+ type Decode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue>;
+ type Encode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue>;
+}
-fn read_atom_kind_boolean<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Symbol(w) if w == "Boolean" => {}
+fn read_atom_kind_boolean<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "Boolean" => {}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean"))?,
@@ -35,10 +42,15 @@ fn read_atom_kind_boolean<'de, _Value: preserves::value::NestedValue, R: _suppor
Ok(AtomKind::Boolean)
}
-fn read_atom_kind_float<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Symbol(w) if w == "Float" => {}
+fn read_atom_kind_float<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "Float" => {}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Float"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Float"))?,
@@ -47,10 +59,15 @@ fn read_atom_kind_float<'de, _Value: preserves::value::NestedValue, R: _support:
Ok(AtomKind::Float)
}
-fn read_atom_kind_double<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Symbol(w) if w == "Double" => {}
+fn read_atom_kind_double<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "Double" => {}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Double"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Double"))?,
@@ -59,10 +76,15 @@ fn read_atom_kind_double<'de, _Value: preserves::value::NestedValue, R: _support
Ok(AtomKind::Double)
}
-fn read_atom_kind_signed_integer<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Symbol(w) if w == "SignedInteger" => {}
+fn read_atom_kind_signed_integer<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "SignedInteger" => {}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger"))?,
@@ -71,10 +93,15 @@ fn read_atom_kind_signed_integer<'de, _Value: preserves::value::NestedValue, R:
Ok(AtomKind::SignedInteger)
}
-fn read_atom_kind_string<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Symbol(w) if w == "String" => {}
+fn read_atom_kind_string<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "String" => {}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::String"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::String"))?,
@@ -83,10 +110,15 @@ fn read_atom_kind_string<'de, _Value: preserves::value::NestedValue, R: _support
Ok(AtomKind::String)
}
-fn read_atom_kind_byte_string<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Symbol(w) if w == "ByteString" => {}
+fn read_atom_kind_byte_string<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "ByteString" => {}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString"))?,
@@ -95,10 +127,15 @@ fn read_atom_kind_byte_string<'de, _Value: preserves::value::NestedValue, R: _su
Ok(AtomKind::ByteString)
}
-fn read_atom_kind_symbol<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Symbol(w) if w == "Symbol" => {}
+fn read_atom_kind_symbol<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "Symbol" => {}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol"))?,
@@ -107,16 +144,20 @@ fn read_atom_kind_symbol<'de, _Value: preserves::value::NestedValue, R: _support
Ok(AtomKind::Symbol)
}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for AtomKind {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- let _mark = r.mark()?;
- 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 }
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for AtomKind {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ let _mark = r.reader.mark()?;
+ match read_atom_kind_boolean(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_atom_kind_float(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_atom_kind_double(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_atom_kind_signed_integer(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_atom_kind_string(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_atom_kind_byte_string(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_atom_kind_symbol(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.AtomKind"))
}
}
@@ -124,7 +165,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for At
fn parse_atom_kind_boolean<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_0_BOOLEAN { return Err(_support::ParseError::conformance_error("schema.AtomKind::Boolean")); }
let _tmp0 = ();
@@ -134,7 +175,7 @@ fn parse_atom_kind_boolean<
fn parse_atom_kind_float<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_1_FLOAT { return Err(_support::ParseError::conformance_error("schema.AtomKind::Float")); }
let _tmp0 = ();
@@ -144,7 +185,7 @@ fn parse_atom_kind_float<
fn parse_atom_kind_double<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_2_DOUBLE { return Err(_support::ParseError::conformance_error("schema.AtomKind::Double")); }
let _tmp0 = ();
@@ -154,7 +195,7 @@ fn parse_atom_kind_double<
fn parse_atom_kind_signed_integer<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_3_SIGNED_INTEGER { return Err(_support::ParseError::conformance_error("schema.AtomKind::SignedInteger")); }
let _tmp0 = ();
@@ -164,7 +205,7 @@ fn parse_atom_kind_signed_integer<
fn parse_atom_kind_string<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_4_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::String")); }
let _tmp0 = ();
@@ -174,7 +215,7 @@ fn parse_atom_kind_string<
fn parse_atom_kind_byte_string<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_5_BYTE_STRING { return Err(_support::ParseError::conformance_error("schema.AtomKind::ByteString")); }
let _tmp0 = ();
@@ -184,7 +225,7 @@ fn parse_atom_kind_byte_string<
fn parse_atom_kind_symbol<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_6_SYMBOL { return Err(_support::ParseError::conformance_error("schema.AtomKind::Symbol")); }
let _tmp0 = ();
@@ -194,7 +235,7 @@ fn parse_atom_kind_symbol<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for AtomKind {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if let Ok(r) = parse_atom_kind_boolean(_ctxt, value) { return Ok(r); }
@@ -211,7 +252,7 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for AtomKind {
fn unparse(&self, _ctxt: _L) -> _Value {
match self {
@@ -229,34 +270,46 @@ impl<
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Binding<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub struct Binding<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
pub name: std::string::String,
pub pattern: SimplePattern<_Value>
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Binding<_Value> {}
+impl<_Value> _support::preserves::value::Domain for Binding<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Binding<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_record(None)?;
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Binding<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
- let _tmp2 = r.next_symbol()?.into_owned();
+ r.reader.boundary(&_tmp0)?;
+ let _tmp2 = r.reader.next_symbol()?.into_owned();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp3 = SimplePattern::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(Binding {name: _tmp2, pattern: _tmp3})
}
}
@@ -264,7 +317,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Bi
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Binding<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
let _tmp0 = value.value().to_record(None)?;
@@ -280,13 +333,13 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Binding<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
let Binding {name: _tmp0, pattern: _tmp1} = self;
{
- let mut _tmp2 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_7_NAMED).clone()]);
- _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp0).wrap());
+ let mut _tmp2 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_7_NAMED).clone()]);
+ _tmp2.fields_vec_mut().push(_support::preserves::value::Value::symbol(_tmp0).wrap());
_tmp2.fields_vec_mut().push(_tmp1.unparse(_ctxt));
_tmp2.finish().wrap()
}
@@ -294,30 +347,43 @@ impl<
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Bundle<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub struct Bundle<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
pub modules: Modules<_Value>
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Bundle<_Value> {}
+impl<_Value> _support::preserves::value::Domain for Bundle<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Bundle<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_record(None)?;
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for Bundle<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = Modules::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(Bundle {modules: _tmp2})
}
}
@@ -325,7 +391,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Bu
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Bundle<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
let _tmp0 = value.value().to_record(None)?;
@@ -340,12 +406,12 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Bundle<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
let Bundle {modules: _tmp0} = self;
{
- let mut _tmp1 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_8_BUNDLE).clone()]);
+ let mut _tmp1 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_8_BUNDLE).clone()]);
_tmp1.fields_vec_mut().push(_tmp0.unparse(_ctxt));
_tmp1.finish().wrap()
}
@@ -353,7 +419,9 @@ impl<
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum CompoundPattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum CompoundPattern<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
Rec {
label: std::boxed::Box>,
fields: std::boxed::Box>
@@ -370,119 +438,150 @@ pub enum CompoundPattern<_Value: preserves::value::NestedValue = preserves::valu
}
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for CompoundPattern<_Value> {}
+impl<_Value> _support::preserves::value::Domain for CompoundPattern<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-fn read_compound_pattern_rec<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_compound_pattern_rec<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = NamedPattern::deserialize(r)?;
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp3 = NamedPattern::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.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, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_compound_pattern_tuple<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
- r.open_sequence()?;
+ r.reader.boundary(&_tmp0)?;
+ r.reader.open_sequence()?;
let mut _tmp4 = _support::B::Type::default();
let mut _tmp3 = std::vec::Vec::new();
- while !r.close_compound(&mut _tmp4, &_support::B::Item::SequenceValue)? {
+ while !r.reader.close_compound(&mut _tmp4, &_support::B::Item::SequenceValue)? {
_tmp4.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp4)?;
+ r.reader.boundary(&_tmp4)?;
let _tmp5 = NamedPattern::deserialize(r)?;
_tmp3.push(_tmp5);
}
let _tmp2 = _tmp3;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(CompoundPattern::Tuple {patterns: _tmp2})
}
-fn read_compound_pattern_tuple_prefix<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_compound_pattern_tuple_prefix<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
- r.open_sequence()?;
+ r.reader.boundary(&_tmp0)?;
+ r.reader.open_sequence()?;
let mut _tmp4 = _support::B::Type::default();
let mut _tmp3 = std::vec::Vec::new();
- while !r.close_compound(&mut _tmp4, &_support::B::Item::SequenceValue)? {
+ while !r.reader.close_compound(&mut _tmp4, &_support::B::Item::SequenceValue)? {
_tmp4.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp4)?;
+ r.reader.boundary(&_tmp4)?;
let _tmp5 = NamedPattern::deserialize(r)?;
_tmp3.push(_tmp5);
}
let _tmp2 = _tmp3;
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp6 = NamedSimplePattern::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(CompoundPattern::TuplePrefix {fixed: _tmp2, variable: std::boxed::Box::new(_tmp6)})
}
-fn read_compound_pattern_dict<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_compound_pattern_dict<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = DictionaryEntries::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(CompoundPattern::Dict {entries: std::boxed::Box::new(_tmp2)})
}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for CompoundPattern<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- let _mark = r.mark()?;
- 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 }
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for CompoundPattern<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ let _mark = r.reader.mark()?;
+ match read_compound_pattern_rec(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_compound_pattern_tuple(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_compound_pattern_tuple_prefix(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_compound_pattern_dict(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.CompoundPattern"))
}
}
@@ -490,7 +589,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Co
fn parse_compound_pattern_rec<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_9_REC { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::rec")); }
@@ -504,7 +603,7 @@ fn parse_compound_pattern_rec<
fn parse_compound_pattern_tuple<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_10_TUPLE { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuple")); }
@@ -522,7 +621,7 @@ fn parse_compound_pattern_tuple<
fn parse_compound_pattern_tuple_prefix<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_11_TUPLE_PREFIX { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::tuplePrefix")); }
@@ -541,7 +640,7 @@ fn parse_compound_pattern_tuple_prefix<
fn parse_compound_pattern_dict<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_12_DICT { return Err(_support::ParseError::conformance_error("schema.CompoundPattern::dict")); }
@@ -554,7 +653,7 @@ fn parse_compound_pattern_dict<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for CompoundPattern<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if let Ok(r) = parse_compound_pattern_rec(_ctxt, value) { return Ok(r); }
@@ -568,31 +667,31 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for CompoundPattern<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
match self {
CompoundPattern::Rec {label: _tmp0, fields: _tmp1} => {
- let mut _tmp2 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_9_REC).clone()]);
+ let mut _tmp2 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_9_REC).clone()]);
_tmp2.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
_tmp2.fields_vec_mut().push(_tmp1.as_ref().unparse(_ctxt));
_tmp2.finish().wrap()
},
CompoundPattern::Tuple {patterns: _tmp0} => {
- let mut _tmp1 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_10_TUPLE).clone()]);
+ let mut _tmp1 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_10_TUPLE).clone()]);
_tmp1.fields_vec_mut().push(
{
let mut _tmp2 = std::vec::Vec::new();
for _tmp3 in _tmp0 {
_tmp2.push(_tmp3.unparse(_ctxt));
}
- preserves::value::Value::Sequence(_tmp2).wrap()
+ _support::preserves::value::Value::Sequence(_tmp2).wrap()
}
);
_tmp1.finish().wrap()
},
CompoundPattern::TuplePrefix {fixed: _tmp0, variable: _tmp1} => {
- let mut _tmp2 = preserves::value::Record(vec![(
+ let mut _tmp2 = _support::preserves::value::Record(vec![(
&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_11_TUPLE_PREFIX
).clone()]);
_tmp2.fields_vec_mut().push(
@@ -601,14 +700,14 @@ impl<
for _tmp4 in _tmp0 {
_tmp3.push(_tmp4.unparse(_ctxt));
}
- preserves::value::Value::Sequence(_tmp3).wrap()
+ _support::preserves::value::Value::Sequence(_tmp3).wrap()
}
);
_tmp2.fields_vec_mut().push(_tmp1.as_ref().unparse(_ctxt));
_tmp2.finish().wrap()
},
CompoundPattern::Dict {entries: _tmp0} => {
- let mut _tmp1 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_12_DICT).clone()]);
+ let mut _tmp1 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_12_DICT).clone()]);
_tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
_tmp1.finish().wrap()
},
@@ -617,7 +716,9 @@ impl<
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum Definition<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum Definition<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
Or {
pattern_0: std::boxed::Box>,
pattern_1: std::boxed::Box>,
@@ -631,40 +732,51 @@ pub enum Definition<_Value: preserves::value::NestedValue = preserves::value::IO
Pattern(std::boxed::Box>)
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Definition<_Value> {}
+impl<_Value> _support::preserves::value::Domain for Definition<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-fn read_definition_or<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_definition_or<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
- r.open_sequence()?;
+ r.reader.boundary(&_tmp0)?;
+ r.reader.open_sequence()?;
let mut _tmp2 = _support::B::Type::default();
_tmp2.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp3 = NamedAlternative::deserialize(r)?;
_tmp2.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp4 = NamedAlternative::deserialize(r)?;
let mut _tmp6 = std::vec::Vec::new();
- while !r.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? {
+ while !r.reader.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? {
_tmp2.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp7 = NamedAlternative::deserialize(r)?;
_tmp6.push(_tmp7);
}
let _tmp5 = _tmp6;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(Definition::Or {
pattern_0: std::boxed::Box::new(_tmp3),
pattern_1: std::boxed::Box::new(_tmp4),
@@ -672,38 +784,43 @@ fn read_definition_or<'de, _Value: preserves::value::NestedValue, R: _support::R
})
}
-fn read_definition_and<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_definition_and<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
- r.open_sequence()?;
+ r.reader.boundary(&_tmp0)?;
+ r.reader.open_sequence()?;
let mut _tmp2 = _support::B::Type::default();
_tmp2.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp3 = NamedPattern::deserialize(r)?;
_tmp2.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp4 = NamedPattern::deserialize(r)?;
let mut _tmp6 = std::vec::Vec::new();
- while !r.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? {
+ while !r.reader.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? {
_tmp2.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp7 = NamedPattern::deserialize(r)?;
_tmp6.push(_tmp7);
}
let _tmp5 = _tmp6;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(Definition::And {
pattern_0: std::boxed::Box::new(_tmp3),
pattern_1: std::boxed::Box::new(_tmp4),
@@ -711,17 +828,27 @@ fn read_definition_and<'de, _Value: preserves::value::NestedValue, R: _support::
})
}
-fn read_definition_pattern<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
+fn read_definition_pattern<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
let _tmp0 = Pattern::deserialize(r)?;
Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Definition<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- let _mark = r.mark()?;
- 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 }
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for Definition<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ let _mark = r.reader.mark()?;
+ match read_definition_or(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_definition_and(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_definition_pattern(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.Definition"))
}
}
@@ -729,7 +856,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for De
fn parse_definition_or<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_13_OR { return Err(_support::ParseError::conformance_error("schema.Definition::or")); }
@@ -754,7 +881,7 @@ fn parse_definition_or<
fn parse_definition_and<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_14_AND { return Err(_support::ParseError::conformance_error("schema.Definition::and")); }
@@ -779,7 +906,7 @@ fn parse_definition_and<
fn parse_definition_pattern<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = Pattern::parse(_ctxt, value)?;
Ok(Definition::Pattern(std::boxed::Box::new(_tmp0)))
@@ -788,7 +915,7 @@ fn parse_definition_pattern<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Definition<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if let Ok(r) = parse_definition_or(_ctxt, value) { return Ok(r); }
@@ -801,12 +928,12 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Definition<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
match self {
Definition::Or {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => {
- let mut _tmp3 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_13_OR).clone()]);
+ let mut _tmp3 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_13_OR).clone()]);
_tmp3.fields_vec_mut().push(
{
let mut _tmp4 = std::vec::Vec::new();
@@ -815,13 +942,13 @@ impl<
for _tmp5 in _tmp2 {
_tmp4.push(_tmp5.unparse(_ctxt));
}
- preserves::value::Value::Sequence(_tmp4).wrap()
+ _support::preserves::value::Value::Sequence(_tmp4).wrap()
}
);
_tmp3.finish().wrap()
},
Definition::And {pattern_0: _tmp0, pattern_1: _tmp1, pattern_n: _tmp2} => {
- let mut _tmp3 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_14_AND).clone()]);
+ let mut _tmp3 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_14_AND).clone()]);
_tmp3.fields_vec_mut().push(
{
let mut _tmp4 = std::vec::Vec::new();
@@ -830,7 +957,7 @@ impl<
for _tmp5 in _tmp2 {
_tmp4.push(_tmp5.unparse(_ctxt));
}
- preserves::value::Value::Sequence(_tmp4).wrap()
+ _support::preserves::value::Value::Sequence(_tmp4).wrap()
}
);
_tmp3.finish().wrap()
@@ -841,21 +968,34 @@ impl<
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Definitions<_Value: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map>);
+pub struct Definitions<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+>(pub _support::preserves::value::Map>);
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Definitions<_Value> {}
+impl<_Value> _support::preserves::value::Domain for Definitions<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Definitions<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_dictionary()?;
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for Definitions<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_dictionary()?;
let mut _tmp2 = _support::B::Type::default();
- let mut _tmp1 = preserves::value::Map::new();
- while !r.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? {
+ let mut _tmp1 = _support::preserves::value::Map::new();
+ while !r.reader.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? {
_tmp2.shift(Some(_support::B::Item::DictionaryKey));
- r.boundary(&_tmp2)?;
- let _tmp3 = r.next_symbol()?.into_owned();
+ r.reader.boundary(&_tmp2)?;
+ let _tmp3 = r.reader.next_symbol()?.into_owned();
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp4 = Definition::deserialize(r)?;
_tmp1.insert(_tmp3, _tmp4);
}
@@ -867,10 +1007,10 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for De
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Definitions<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
- let mut _tmp0 = preserves::value::Map::new();
+ let mut _tmp0 = _support::preserves::value::Map::new();
for (_tmp1, _tmp2) in value.value().to_dictionary()? {
let _tmp3 = _tmp1.value().to_symbol()?;
let _tmp4 = Definition::parse(_ctxt, _tmp2)?;
@@ -883,30 +1023,43 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Definitions<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
let Definitions(_tmp0) = self;
- preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (preserves::value::Value::symbol(_tmp1).wrap(), _tmp2.unparse(_ctxt))).collect()).wrap()
+ _support::preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_support::preserves::value::Value::symbol(_tmp1).wrap(), _tmp2.unparse(_ctxt))).collect()).wrap()
}
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct DictionaryEntries<_Value: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map<_Value, NamedSimplePattern<_Value>>);
+pub struct DictionaryEntries<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+>(pub _support::preserves::value::Map<_Value, NamedSimplePattern<_Value>>);
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for DictionaryEntries<_Value> {}
+impl<_Value> _support::preserves::value::Domain for DictionaryEntries<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for DictionaryEntries<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_dictionary()?;
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for DictionaryEntries<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_dictionary()?;
let mut _tmp2 = _support::B::Type::default();
- let mut _tmp1 = preserves::value::Map::new();
- while !r.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? {
+ let mut _tmp1 = _support::preserves::value::Map::new();
+ while !r.reader.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? {
_tmp2.shift(Some(_support::B::Item::DictionaryKey));
- r.boundary(&_tmp2)?;
- let _tmp3 = r.demand_next(true)?;
+ r.reader.boundary(&_tmp2)?;
+ let _tmp3 = r.demand_next()?;
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp4 = NamedSimplePattern::deserialize(r)?;
_tmp1.insert(_tmp3, _tmp4);
}
@@ -918,10 +1071,10 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Di
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for DictionaryEntries<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
- let mut _tmp0 = preserves::value::Map::new();
+ let mut _tmp0 = _support::preserves::value::Map::new();
for (_tmp1, _tmp2) in value.value().to_dictionary()? {
let _tmp3 = _tmp1;
let _tmp4 = NamedSimplePattern::parse(_ctxt, _tmp2)?;
@@ -934,11 +1087,11 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for DictionaryEntries<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
let DictionaryEntries(_tmp0) = self;
- preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _tmp2.unparse(_ctxt))).collect()).wrap()
+ _support::preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.clone(), _tmp2.unparse(_ctxt))).collect()).wrap()
}
}
@@ -948,17 +1101,30 @@ pub enum EmbeddedTypeName {
False
}
-impl preserves::value::Domain for EmbeddedTypeName {}
+impl _support::preserves::value::Domain for EmbeddedTypeName {
+ type Decode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue>;
+ type Encode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue>;
+}
-fn read_embedded_type_name_ref<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
+fn read_embedded_type_name_ref<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
let _tmp0 = Ref::deserialize(r)?;
Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
}
-fn read_embedded_type_name_false<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Boolean(w) if !*w => {}
+fn read_embedded_type_name_false<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Boolean(w) if !*w => {}
_ => return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false"))?,
@@ -967,11 +1133,15 @@ fn read_embedded_type_name_false<'de, _Value: preserves::value::NestedValue, R:
Ok(EmbeddedTypeName::False)
}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for EmbeddedTypeName {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- let _mark = r.mark()?;
- 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 }
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for EmbeddedTypeName {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ let _mark = r.reader.mark()?;
+ match read_embedded_type_name_ref(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_embedded_type_name_false(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName"))
}
}
@@ -979,7 +1149,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Em
fn parse_embedded_type_name_ref<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
let _tmp0 = Ref::parse(_ctxt, value)?;
Ok(EmbeddedTypeName::Ref(std::boxed::Box::new(_tmp0)))
@@ -988,7 +1158,7 @@ fn parse_embedded_type_name_ref<
fn parse_embedded_type_name_false<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_15_FALSE { return Err(_support::ParseError::conformance_error("schema.EmbeddedTypeName::false")); }
let _tmp0 = ();
@@ -998,7 +1168,7 @@ fn parse_embedded_type_name_false<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for EmbeddedTypeName {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if let Ok(r) = parse_embedded_type_name_ref(_ctxt, value) { return Ok(r); }
@@ -1010,7 +1180,7 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for EmbeddedTypeName {
fn unparse(&self, _ctxt: _L) -> _Value {
match self {
@@ -1023,17 +1193,24 @@ impl<
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
pub struct ModulePath(pub std::vec::Vec);
-impl preserves::value::Domain for ModulePath {}
+impl _support::preserves::value::Domain for ModulePath {
+ type Decode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue>;
+ type Encode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for ModulePath {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_sequence()?;
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for ModulePath {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_sequence()?;
let mut _tmp2 = _support::B::Type::default();
let mut _tmp1 = std::vec::Vec::new();
- while !r.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? {
+ while !r.reader.close_compound(&mut _tmp2, &_support::B::Item::SequenceValue)? {
_tmp2.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp2)?;
- let _tmp3 = r.next_symbol()?.into_owned();
+ r.reader.boundary(&_tmp2)?;
+ let _tmp3 = r.reader.next_symbol()?.into_owned();
_tmp1.push(_tmp3);
}
let _tmp0 = _tmp1;
@@ -1044,7 +1221,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Mo
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for ModulePath {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
let _tmp1 = value.value().to_sequence()?;
@@ -1060,36 +1237,49 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for ModulePath {
fn unparse(&self, _ctxt: _L) -> _Value {
let ModulePath(_tmp0) = self;
{
let mut _tmp1 = std::vec::Vec::new();
for _tmp2 in _tmp0 {
- _tmp1.push(preserves::value::Value::symbol(_tmp2).wrap());
+ _tmp1.push(_support::preserves::value::Value::symbol(_tmp2).wrap());
}
- preserves::value::Value::Sequence(_tmp1).wrap()
+ _support::preserves::value::Value::Sequence(_tmp1).wrap()
}
}
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Modules<_Value: preserves::value::NestedValue = preserves::value::IOValue>(pub preserves::value::Map>);
+pub struct Modules<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+>(pub _support::preserves::value::Map>);
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Modules<_Value> {}
+impl<_Value> _support::preserves::value::Domain for Modules<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Modules<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_dictionary()?;
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for Modules<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_dictionary()?;
let mut _tmp2 = _support::B::Type::default();
- let mut _tmp1 = preserves::value::Map::new();
- while !r.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? {
+ let mut _tmp1 = _support::preserves::value::Map::new();
+ while !r.reader.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? {
_tmp2.shift(Some(_support::B::Item::DictionaryKey));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp3 = ModulePath::deserialize(r)?;
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
let _tmp4 = Schema::deserialize(r)?;
_tmp1.insert(_tmp3, _tmp4);
}
@@ -1101,10 +1291,10 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Mo
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Modules<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
- let mut _tmp0 = preserves::value::Map::new();
+ let mut _tmp0 = _support::preserves::value::Map::new();
for (_tmp1, _tmp2) in value.value().to_dictionary()? {
let _tmp3 = ModulePath::parse(_ctxt, _tmp1)?;
let _tmp4 = Schema::parse(_ctxt, _tmp2)?;
@@ -1117,33 +1307,46 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Modules<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
let Modules(_tmp0) = self;
- preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.unparse(_ctxt), _tmp2.unparse(_ctxt))).collect()).wrap()
+ _support::preserves::value::Value::Dictionary(_tmp0.iter().map(|(_tmp1, _tmp2)| (_tmp1.unparse(_ctxt), _tmp2.unparse(_ctxt))).collect()).wrap()
}
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct NamedAlternative<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub struct NamedAlternative<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
pub variant_label: std::string::String,
pub pattern: Pattern<_Value>
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for NamedAlternative<_Value> {}
+impl<_Value> _support::preserves::value::Domain for NamedAlternative<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for NamedAlternative<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_sequence()?;
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for NamedAlternative<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_sequence()?;
let mut _tmp0 = _support::B::Type::default();
_tmp0.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp0)?;
- let _tmp1 = r.next_str()?.into_owned();
+ r.reader.boundary(&_tmp0)?;
+ let _tmp1 = r.reader.next_str()?.into_owned();
_tmp0.shift(Some(_support::B::Item::SequenceValue));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = Pattern::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::SequenceValue)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::SequenceValue)?;
Ok(NamedAlternative {variant_label: _tmp1, pattern: _tmp2})
}
}
@@ -1151,7 +1354,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Na
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for NamedAlternative<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
let _tmp0 = value.value().to_sequence()?;
@@ -1165,42 +1368,65 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for NamedAlternative<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
let NamedAlternative {variant_label: _tmp0, pattern: _tmp1} = self;
{
let mut _tmp2 = std::vec::Vec::new();
- _tmp2.push(preserves::value::Value::from(_tmp0).wrap());
+ _tmp2.push(_support::preserves::value::Value::from(_tmp0).wrap());
_tmp2.push(_tmp1.unparse(_ctxt));
- preserves::value::Value::Sequence(_tmp2).wrap()
+ _support::preserves::value::Value::Sequence(_tmp2).wrap()
}
}
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum NamedPattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum NamedPattern<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
Named(std::boxed::Box>),
Anonymous(std::boxed::Box>)
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for NamedPattern<_Value> {}
+impl<_Value> _support::preserves::value::Domain for NamedPattern<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-fn read_named_pattern_named<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
+fn read_named_pattern_named<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
let _tmp0 = Binding::deserialize(r)?;
Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
}
-fn read_named_pattern_anonymous<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
+fn read_named_pattern_anonymous<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
let _tmp0 = Pattern::deserialize(r)?;
Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for NamedPattern<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- let _mark = r.mark()?;
- 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 }
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for NamedPattern<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ let _mark = r.reader.mark()?;
+ match read_named_pattern_named(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_named_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.NamedPattern"))
}
}
@@ -1208,7 +1434,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Na
fn parse_named_pattern_named<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = Binding::parse(_ctxt, value)?;
Ok(NamedPattern::Named(std::boxed::Box::new(_tmp0)))
@@ -1217,7 +1443,7 @@ fn parse_named_pattern_named<
fn parse_named_pattern_anonymous<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = Pattern::parse(_ctxt, value)?;
Ok(NamedPattern::Anonymous(std::boxed::Box::new(_tmp0)))
@@ -1226,7 +1452,7 @@ fn parse_named_pattern_anonymous<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for NamedPattern<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if let Ok(r) = parse_named_pattern_named(_ctxt, value) { return Ok(r); }
@@ -1238,7 +1464,7 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for NamedPattern<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
match self {
@@ -1249,28 +1475,51 @@ impl<
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum NamedSimplePattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum NamedSimplePattern<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
Named(std::boxed::Box>),
Anonymous(std::boxed::Box>)
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for NamedSimplePattern<_Value> {}
+impl<_Value> _support::preserves::value::Domain for NamedSimplePattern<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-fn read_named_simple_pattern_named<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
+fn read_named_simple_pattern_named<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
let _tmp0 = Binding::deserialize(r)?;
Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
}
-fn read_named_simple_pattern_anonymous<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
+fn read_named_simple_pattern_anonymous<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
let _tmp0 = SimplePattern::deserialize(r)?;
Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for NamedSimplePattern<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- let _mark = r.mark()?;
- 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 }
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for NamedSimplePattern<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ let _mark = r.reader.mark()?;
+ match read_named_simple_pattern_named(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_named_simple_pattern_anonymous(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.NamedSimplePattern"))
}
}
@@ -1278,7 +1527,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Na
fn parse_named_simple_pattern_named<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = Binding::parse(_ctxt, value)?;
Ok(NamedSimplePattern::Named(std::boxed::Box::new(_tmp0)))
@@ -1287,7 +1536,7 @@ fn parse_named_simple_pattern_named<
fn parse_named_simple_pattern_anonymous<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = SimplePattern::parse(_ctxt, value)?;
Ok(NamedSimplePattern::Anonymous(std::boxed::Box::new(_tmp0)))
@@ -1296,7 +1545,7 @@ fn parse_named_simple_pattern_anonymous<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for NamedSimplePattern<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if let Ok(r) = parse_named_simple_pattern_named(_ctxt, value) { return Ok(r); }
@@ -1308,7 +1557,7 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for NamedSimplePattern<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
match self {
@@ -1319,28 +1568,51 @@ impl<
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum Pattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum Pattern<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
SimplePattern(std::boxed::Box>),
CompoundPattern(std::boxed::Box>)
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Pattern<_Value> {}
+impl<_Value> _support::preserves::value::Domain for Pattern<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-fn read_pattern_simple_pattern<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
+fn read_pattern_simple_pattern<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
let _tmp0 = SimplePattern::deserialize(r)?;
Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
}
-fn read_pattern_compound_pattern<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
+fn read_pattern_compound_pattern<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
let _tmp0 = CompoundPattern::deserialize(r)?;
Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Pattern<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- let _mark = r.mark()?;
- 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 }
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for Pattern<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ let _mark = r.reader.mark()?;
+ match read_pattern_simple_pattern(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_pattern_compound_pattern(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.Pattern"))
}
}
@@ -1348,7 +1620,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Pa
fn parse_pattern_simple_pattern<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = SimplePattern::parse(_ctxt, value)?;
Ok(Pattern::SimplePattern(std::boxed::Box::new(_tmp0)))
@@ -1357,7 +1629,7 @@ fn parse_pattern_simple_pattern<
fn parse_pattern_compound_pattern<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = CompoundPattern::parse(_ctxt, value)?;
Ok(Pattern::CompoundPattern(std::boxed::Box::new(_tmp0)))
@@ -1366,7 +1638,7 @@ fn parse_pattern_compound_pattern<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Pattern<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if let Ok(r) = parse_pattern_simple_pattern(_ctxt, value) { return Ok(r); }
@@ -1378,7 +1650,7 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Pattern<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
match self {
@@ -1394,29 +1666,36 @@ pub struct Ref {
pub name: std::string::String
}
-impl preserves::value::Domain for Ref {}
+impl _support::preserves::value::Domain for Ref {
+ type Decode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue
[>;
+ type Encode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue][>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Ref {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_record(None)?;
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Ref {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.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)?;
+ r.reader.boundary(&_tmp0)?;
+ let _tmp3 = r.reader.next_symbol()?.into_owned();
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(Ref {module: _tmp2, name: _tmp3})
}
}
@@ -1424,7 +1703,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Re
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Ref {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
let _tmp0 = value.value().to_record(None)?;
@@ -1440,69 +1719,82 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Ref {
fn unparse(&self, _ctxt: _L) -> _Value {
let Ref {module: _tmp0, name: _tmp1} = self;
{
- let mut _tmp2 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_16_REF).clone()]);
+ let mut _tmp2 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_16_REF).clone()]);
_tmp2.fields_vec_mut().push(_tmp0.unparse(_ctxt));
- _tmp2.fields_vec_mut().push(preserves::value::Value::symbol(_tmp1).wrap());
+ _tmp2.fields_vec_mut().push(_support::preserves::value::Value::symbol(_tmp1).wrap());
_tmp2.finish().wrap()
}
}
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub struct Schema<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub struct Schema<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
pub definitions: Definitions<_Value>,
pub embedded_type: EmbeddedTypeName,
pub version: Version
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for Schema<_Value> {}
+impl<_Value> _support::preserves::value::Domain for Schema<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Schema<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- r.open_record(None)?;
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for Schema<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
- r.open_dictionary()?;
+ r.reader.boundary(&_tmp0)?;
+ r.reader.open_dictionary()?;
let mut _tmp2 = _support::B::Type::default();
let mut _tmp3 = None;
let mut _tmp4 = None;
let mut _tmp5 = None;
- while !r.close_compound(&mut _tmp2, &_support::B::Item::DictionaryKey)? {
+ while !r.reader.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" => {
+ r.reader.boundary(&_tmp2)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "definitions" => {
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
_tmp3 = Some(Definitions::deserialize(r)?);
continue;
}
- preserves::value::Value::Symbol(w) if w == "embeddedType" => {
+ _support::preserves::value::Value::Symbol(w) if w == "embeddedType" => {
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
_tmp4 = Some(EmbeddedTypeName::deserialize(r)?);
continue;
}
- preserves::value::Value::Symbol(w) if w == "version" => {
+ _support::preserves::value::Value::Symbol(w) if w == "version" => {
_tmp2.shift(Some(_support::B::Item::DictionaryValue));
- r.boundary(&_tmp2)?;
+ r.reader.boundary(&_tmp2)?;
_tmp5 = Some(Version::deserialize(r)?);
continue;
}
@@ -1511,7 +1803,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Sc
_ => return Err(_support::ParseError::conformance_error("schema.Schema"))?,
}
}
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(Schema {
definitions: _tmp3.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
embedded_type: _tmp4.ok_or_else(|| _support::ParseError::conformance_error("schema.Schema"))?,
@@ -1523,7 +1815,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Sc
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Schema<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
let _tmp0 = value.value().to_record(None)?;
@@ -1548,15 +1840,15 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Schema<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
let Schema {definitions: _tmp0, embedded_type: _tmp1, version: _tmp2} = self;
{
- let mut _tmp3 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_17_SCHEMA).clone()]);
+ let mut _tmp3 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_17_SCHEMA).clone()]);
_tmp3.fields_vec_mut().push(
{
- let mut _tmp4 = preserves::value::Map::new();
+ let mut _tmp4 = _support::preserves::value::Map::new();
_tmp4.insert(
(
&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_18_DEFINITIONS
@@ -1573,7 +1865,7 @@ impl<
(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_20_VERSION).clone(),
_tmp2.unparse(_ctxt)
);
- preserves::value::Value::Dictionary(_tmp4).wrap()
+ _support::preserves::value::Value::Dictionary(_tmp4).wrap()
}
);
_tmp3.finish().wrap()
@@ -1582,7 +1874,9 @@ impl<
}
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
-pub enum SimplePattern<_Value: preserves::value::NestedValue = preserves::value::IOValue> {
+pub enum SimplePattern<
+ _Value: _support::preserves::value::NestedValue = _support::preserves::value::IOValue
+> {
Any,
Atom {
atom_kind: std::boxed::Box
@@ -1606,12 +1900,23 @@ pub enum SimplePattern<_Value: preserves::value::NestedValue = preserves::value:
Ref(std::boxed::Box][)
}
-impl<_Value: preserves::value::NestedValue> preserves::value::Domain for SimplePattern<_Value> {}
+impl<_Value> _support::preserves::value::Domain for SimplePattern<_Value>
+where
+ for<'value> _Value: _support::preserves::value::NestedValue> + 'value
+{
+ type Decode = _support::SchemaDomainCodec<_Value>;
+ type Encode = _support::SchemaDomainCodec<_Value>;
+}
-fn read_simple_pattern_any<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::Symbol(w) if w == "any" => {}
+fn read_simple_pattern_any<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::Symbol(w) if w == "any" => {}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::any"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.SimplePattern::any"))?,
@@ -1620,145 +1925,185 @@ fn read_simple_pattern_any<'de, _Value: preserves::value::NestedValue, R: _suppo
Ok(SimplePattern::Any)
}
-fn read_simple_pattern_atom<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_simple_pattern_atom<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = AtomKind::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(SimplePattern::Atom {atom_kind: std::boxed::Box::new(_tmp2)})
}
-fn read_simple_pattern_embedded<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_simple_pattern_embedded<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = SimplePattern::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(SimplePattern::Embedded {interface: std::boxed::Box::new(_tmp2)})
}
-fn read_simple_pattern_lit<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_simple_pattern_lit<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _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)?;
+ r.reader.boundary(&_tmp0)?;
+ let _tmp2 = r.demand_next()?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(SimplePattern::Lit {value: _tmp2})
}
-fn read_simple_pattern_seqof<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_simple_pattern_seqof<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = SimplePattern::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(SimplePattern::Seqof {pattern: std::boxed::Box::new(_tmp2)})
}
-fn read_simple_pattern_setof<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_simple_pattern_setof<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = SimplePattern::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
Ok(SimplePattern::Setof {pattern: std::boxed::Box::new(_tmp2)})
}
-fn read_simple_pattern_dictof<'de, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
- r.open_record(None)?;
+fn read_simple_pattern_dictof<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
+ r.reader.open_record()?;
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" => {}
+ r.reader.boundary(&_tmp0)?;
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::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 _tmp1 = ();
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp2 = SimplePattern::deserialize(r)?;
_tmp0.shift(Some(_support::B::Item::RecordField));
- r.boundary(&_tmp0)?;
+ r.reader.boundary(&_tmp0)?;
let _tmp3 = SimplePattern::deserialize(r)?;
- r.ensure_complete(_tmp0, &_support::B::Item::RecordField)?;
+ r.reader.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, _Value: preserves::value::NestedValue, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result, _support::ParseError> {
+fn read_simple_pattern_ref<
+ 'de,
+ _Value: _support::preserves::value::NestedValue,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result, _support::ParseError> {
let _tmp0 = Ref::deserialize(r)?;
Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for SimplePattern<_Value> {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- let _mark = r.mark()?;
- 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 }
+impl< _Value: _support::preserves::value::NestedValue,
+> _support::Deserialize<_Value> for SimplePattern<_Value> {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ let _mark = r.reader.mark()?;
+ match read_simple_pattern_any(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_simple_pattern_atom(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_simple_pattern_embedded(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_simple_pattern_lit(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_simple_pattern_seqof(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_simple_pattern_setof(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_simple_pattern_dictof(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
+ match read_simple_pattern_ref(r) { Err(e) if e.is_conformance_error() => r.reader.restore(&_mark)?, result => return result }
Err(_support::ParseError::conformance_error("schema.SimplePattern"))
}
}
@@ -1766,7 +2111,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Si
fn parse_simple_pattern_any<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_21_ANY { return Err(_support::ParseError::conformance_error("schema.SimplePattern::any")); }
let _tmp0 = ();
@@ -1776,7 +2121,7 @@ fn parse_simple_pattern_any<
fn parse_simple_pattern_atom<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_22_ATOM { return Err(_support::ParseError::conformance_error("schema.SimplePattern::atom")); }
@@ -1789,7 +2134,7 @@ fn parse_simple_pattern_atom<
fn parse_simple_pattern_embedded<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_23_EMBEDDED { return Err(_support::ParseError::conformance_error("schema.SimplePattern::embedded")); }
@@ -1802,7 +2147,7 @@ fn parse_simple_pattern_embedded<
fn parse_simple_pattern_lit<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_24_LIT { return Err(_support::ParseError::conformance_error("schema.SimplePattern::lit")); }
@@ -1815,7 +2160,7 @@ fn parse_simple_pattern_lit<
fn parse_simple_pattern_seqof<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_25_SEQOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::seqof")); }
@@ -1828,7 +2173,7 @@ fn parse_simple_pattern_seqof<
fn parse_simple_pattern_setof<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_26_SETOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::setof")); }
@@ -1841,7 +2186,7 @@ fn parse_simple_pattern_setof<
fn parse_simple_pattern_dictof<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = value.value().to_record(None)?;
if _tmp0.label() != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_27_DICTOF { return Err(_support::ParseError::conformance_error("schema.SimplePattern::dictof")); }
@@ -1855,7 +2200,7 @@ fn parse_simple_pattern_dictof<
fn parse_simple_pattern_ref<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
>(_ctxt: _L, value: &_Value) -> std::result::Result, _support::ParseError> {
let _tmp0 = Ref::parse(_ctxt, value)?;
Ok(SimplePattern::Ref(std::boxed::Box::new(_tmp0)))
@@ -1864,7 +2209,7 @@ fn parse_simple_pattern_ref<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for SimplePattern<_Value> {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if let Ok(r) = parse_simple_pattern_any(_ctxt, value) { return Ok(r); }
@@ -1882,38 +2227,38 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for SimplePattern<_Value> {
fn unparse(&self, _ctxt: _L) -> _Value {
match self {
SimplePattern::Any => (&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_21_ANY).clone(),
SimplePattern::Atom {atom_kind: _tmp0} => {
- let mut _tmp1 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_22_ATOM).clone()]);
+ let mut _tmp1 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_22_ATOM).clone()]);
_tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
_tmp1.finish().wrap()
},
SimplePattern::Embedded {interface: _tmp0} => {
- let mut _tmp1 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_23_EMBEDDED).clone()]);
+ let mut _tmp1 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_23_EMBEDDED).clone()]);
_tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
_tmp1.finish().wrap()
},
SimplePattern::Lit {value: _tmp0} => {
- let mut _tmp1 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_24_LIT).clone()]);
+ let mut _tmp1 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_24_LIT).clone()]);
_tmp1.fields_vec_mut().push(_tmp0.clone());
_tmp1.finish().wrap()
},
SimplePattern::Seqof {pattern: _tmp0} => {
- let mut _tmp1 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_25_SEQOF).clone()]);
+ let mut _tmp1 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_25_SEQOF).clone()]);
_tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
_tmp1.finish().wrap()
},
SimplePattern::Setof {pattern: _tmp0} => {
- let mut _tmp1 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_26_SETOF).clone()]);
+ let mut _tmp1 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_26_SETOF).clone()]);
_tmp1.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
_tmp1.finish().wrap()
},
SimplePattern::Dictof {key: _tmp0, value: _tmp1} => {
- let mut _tmp2 = preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_27_DICTOF).clone()]);
+ let mut _tmp2 = _support::preserves::value::Record(vec![(&<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_27_DICTOF).clone()]);
_tmp2.fields_vec_mut().push(_tmp0.as_ref().unparse(_ctxt));
_tmp2.fields_vec_mut().push(_tmp1.as_ref().unparse(_ctxt));
_tmp2.finish().wrap()
@@ -1926,13 +2271,20 @@ impl<
#[derive(Debug, PartialOrd, Ord, PartialEq, Eq, Clone, Hash)]
pub struct Version;
-impl preserves::value::Domain for Version {}
+impl _support::preserves::value::Domain for Version {
+ type Decode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue>;
+ type Encode = _support::SchemaDomainCodec<_support::preserves::value::PlainValue>;
+}
-impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Version {
- fn deserialize<'de, R: _support::Reader<'de, _Value>>(r: &mut R) -> std::result::Result {
- match r.next_token(true)? {
- preserves::value::Token::Atom(v) => match v.value() {
- preserves::value::Value::SignedInteger(w) if *w == (1).into() => {}
+impl<_Value: _support::preserves::value::NestedValue> _support::Deserialize<_Value> for Version {
+ fn deserialize<
+ 'de,
+ _Dec: _support::DomainDecode<_Value::Embedded>,
+ _R: _support::Reader<'de>
+>(r: &mut _support::preserves::value::ConfiguredReader<'de, _Value, _R, _Dec>) -> std::result::Result {
+ match r.next_token()? {
+ _support::preserves::value::Token::Atom(v) => match v.value() {
+ _support::preserves::value::Value::SignedInteger(w) if *w == (1).into() => {}
_ => return Err(_support::ParseError::conformance_error("schema.Version"))?,
}
_ => return Err(_support::ParseError::conformance_error("schema.Version"))?,
@@ -1945,7 +2297,7 @@ impl<_Value: preserves::value::NestedValue> _support::Deserialize<_Value> for Ve
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Parse<_L, _Value> for Version {
fn parse(_ctxt: _L, value: &_Value) -> std::result::Result {
if value != &<_L as Into<&'a crate::gen::Language<_Value>>>::into(_ctxt).LIT_28_1 { return Err(_support::ParseError::conformance_error("schema.Version")); }
@@ -1957,7 +2309,7 @@ impl<
impl<
'a,
_L: Copy + Into<&'a crate::gen::Language<_Value>>,
- _Value: preserves::value::NestedValue + 'a
+ _Value: _support::preserves::value::NestedValue + 'a
> _support::Unparse<_L, _Value> for Version {
fn unparse(&self, _ctxt: _L) -> _Value {
let Version = self;
diff --git a/implementations/rust/preserves-schema/src/lib.rs b/implementations/rust/preserves-schema/src/lib.rs
index 39be38c..5f8f583 100644
--- a/implementations/rust/preserves-schema/src/lib.rs
+++ b/implementations/rust/preserves-schema/src/lib.rs
@@ -42,8 +42,8 @@ mod tests {
let mut f = std::fs::File::open("../../../schema/schema.bin")?;
let mut src = IOBinarySource::new(&mut f);
- let mut reader = src.packed_iovalues();
- let schema = reader.demand_next(false)?;
+ let mut reader = src.packed().iovalues();
+ let schema = reader.demand_next()?;
let language = crate::gen::Language::default();
let parsed = Schema::parse(&language, &schema).expect("successful parse");
assert_eq!(schema, parsed.unparse(&language));
diff --git a/implementations/rust/preserves-schema/src/support/interpret.rs b/implementations/rust/preserves-schema/src/support/interpret.rs
index b517452..29e8d90 100644
--- a/implementations/rust/preserves-schema/src/support/interpret.rs
+++ b/implementations/rust/preserves-schema/src/support/interpret.rs
@@ -39,7 +39,7 @@ impl<'a, V: NestedValue> Context<'a, V> {
}
pub fn dynamic_unparse(&mut self, _module: &Vec, _name: &str, _w: &V) -> Option {
- panic!("Not yet implemented");
+ todo!("Not yet implemented");
}
}
diff --git a/implementations/rust/preserves-schema/src/support/mod.rs b/implementations/rust/preserves-schema/src/support/mod.rs
index 16bddd0..27e84ee 100644
--- a/implementations/rust/preserves-schema/src/support/mod.rs
+++ b/implementations/rust/preserves-schema/src/support/mod.rs
@@ -1,23 +1,23 @@
pub use lazy_static::lazy_static;
pub use preserves;
+pub use preserves::value::DomainDecode;
pub use preserves::value::Reader;
pub use preserves::value::boundary as B;
pub mod interpret;
-use preserves::value::ArcValue;
+use preserves::value::ConfiguredReader;
use preserves::value::Domain;
-use preserves::value::IOValue;
+use preserves::value::DomainEncode;
use preserves::value::NestedValue;
use preserves::value::NoEmbeddedDomainCodec;
-use preserves::value::Value;
+use preserves::value::Writer;
use std::convert::From;
use std::convert::Into;
-use std::convert::TryFrom;
use std::io;
-use std::sync::Arc;
+use std::marker::PhantomData;
use thiserror::Error;
@@ -63,30 +63,50 @@ pub trait Deserialize
where
Self: Sized
{
- fn deserialize<'de, R: Reader<'de, N>>(r: &mut R) -> Result;
+ fn deserialize<'de, Dec: DomainDecode, R: Reader<'de>>(
+ r: &mut ConfiguredReader<'de, N, R, Dec>,
+ ) -> Result;
+}
+
+pub trait Serialize
+{
+ fn serialize(&self, w: &mut W) -> io::Result<()>;
+}
+
+pub struct SchemaDomainCodec(PhantomData);
+
+impl Default for SchemaDomainCodec {
+ fn default() -> Self {
+ SchemaDomainCodec(PhantomData)
+ }
+}
+
+impl + Domain> DomainDecode for SchemaDomainCodec
+where
+ for<'value> N: NestedValue + 'value
+{
+ fn decode_embedded<'de, R: Reader<'de>>(
+ &mut self,
+ r: &mut R,
+ read_annotations: bool,
+ ) -> io::Result {
+ Ok(T::deserialize(&mut r.configured::(read_annotations, T::Decode::default()))?)
+ }
+}
+
+impl, T: /* Serialize + */ Domain> DomainEncode for SchemaDomainCodec {
+ fn encode_embedded(
+ &mut self,
+ w: &mut W,
+ d: &T,
+ ) -> io::Result<()> {
+ todo!()
+ // d.serialize(w)
+ }
}
pub fn decode_lit(bs: &[u8]) -> io::Result {
- preserves::value::packed::from_bytes(bs, NoEmbeddedDomainCodec)
-}
-
-pub fn decode_embedded(
- v: &IOValue,
-) -> Result>, ParseError>
-where
- for<'a> D: TryFrom<&'a IOValue, Error = ParseError>
-{
- v.copy_via(&mut |d| Ok(Value::Embedded(Arc::new(D::try_from(d)?))))
-}
-
-pub fn encode_embedded(
- v: &ArcValue>,
-) -> IOValue
-where
- for<'a> IOValue: From<&'a D>
-{
- v.copy_via::<_, _, std::convert::Infallible>(
- &mut |d| Ok(Value::Embedded(IOValue::from(d)))).unwrap()
+ preserves::value::packed::from_bytes(bs, &mut NoEmbeddedDomainCodec)
}
#[derive(Error, Debug)]
@@ -100,7 +120,7 @@ pub enum ParseError {
impl From for ParseError {
fn from(v: preserves::error::Error) -> Self {
match v {
- preserves::error::Error::Expected(_, _) =>
+ preserves::error::Error::Expected(_) =>
ParseError::ConformanceError("preserves::error::Error::Expected"),
_ =>
ParseError::Preserves(v),
diff --git a/implementations/rust/preserves/benches/codec.rs b/implementations/rust/preserves/benches/codec.rs
index 521b954..6ceac5f 100644
--- a/implementations/rust/preserves/benches/codec.rs
+++ b/implementations/rust/preserves/benches/codec.rs
@@ -4,6 +4,7 @@ use preserves::ser;
use preserves::value::BinarySource;
use preserves::value::BytesBinarySource;
use preserves::value::IOBinarySource;
+use preserves::value::IOValue;
use preserves::value::IOValueDomainCodec;
use preserves::value::PackedWriter;
use preserves::value::Reader;
@@ -31,7 +32,7 @@ pub fn bench_decoder_file(c: &mut Criterion) {
let mut fh = File::open("../../../tests/samples.bin").unwrap();
c.bench_function("decode samples.bin via file", |b| b.iter_with_large_drop(|| {
fh.seek(io::SeekFrom::Start(0)).ok();
- IOBinarySource::new(&mut fh).packed_iovalues().demand_next(true).unwrap()
+ IOBinarySource::new(&mut fh).packed().next_iovalue(true).unwrap()
}));
}
@@ -39,13 +40,13 @@ pub fn bench_decoder_buffered_file(c: &mut Criterion) {
let mut fh = io::BufReader::new(File::open("../../../tests/samples.bin").unwrap());
c.bench_function("decode samples.bin via buffered file", |b| b.iter_with_large_drop(|| {
fh.seek(io::SeekFrom::Start(0)).ok();
- IOBinarySource::new(&mut fh).packed_iovalues().demand_next(true).unwrap()
+ IOBinarySource::new(&mut fh).packed().next_iovalue(true).unwrap()
}));
}
pub fn bench_encoder(c: &mut Criterion) {
let mut fh = File::open("../../../tests/samples.bin").unwrap();
- let v = IOBinarySource::new(&mut fh).packed_iovalues().demand_next(true).unwrap();
+ let v = IOBinarySource::new(&mut fh).packed().next_iovalue(true).unwrap();
c.bench_function("encode samples.bin", |b| b.iter_with_large_drop(
|| PackedWriter::encode_iovalue(&v).unwrap()));
}
@@ -90,8 +91,8 @@ pub fn large_testdata_decoder_with_ann(c: &mut Criterion) {
fh.read_to_end(&mut bs).ok();
b.iter(|| {
let mut src = BytesBinarySource::new(&bs[..]);
- let mut r = src.packed_iovalues();
- while let Some(_) = r.next(true).unwrap() {}
+ let mut r = src.packed();
+ while let Some(_) = r.next::(true).unwrap() {}
})
});
}
@@ -103,8 +104,8 @@ pub fn large_testdata_decoder_without_ann(c: &mut Criterion) {
fh.read_to_end(&mut bs).ok();
b.iter(|| {
let mut src = BytesBinarySource::new(&bs[..]);
- let mut r = src.packed_iovalues();
- while let Some(_) = r.next(false).unwrap() {}
+ let mut r = src.packed();
+ while let Some(_) = r.next::(false).unwrap() {}
})
});
}
@@ -114,8 +115,8 @@ pub fn large_testdata_encoder(c: &mut Criterion) {
let mut fh = io::BufReader::new(File::open("benches/testdata.bin").unwrap());
let mut vs = vec![];
let mut src = IOBinarySource::new(&mut fh);
- let mut r = src.packed_iovalues();
- while let Some(v) = r.next(true).unwrap() {
+ let mut r = src.packed();
+ while let Some(v) = r.next::(true).unwrap() {
vs.push(v);
}
b.iter_with_large_drop(|| {
diff --git a/implementations/rust/preserves/examples/extensibility.rs b/implementations/rust/preserves/examples/extensibility.rs
index 6df3376..ed92ac1 100644
--- a/implementations/rust/preserves/examples/extensibility.rs
+++ b/implementations/rust/preserves/examples/extensibility.rs
@@ -33,7 +33,7 @@ enum Variety {
}
fn try_file(kind: &str, path: &str) -> io::Result<()> {
- let fruits_value = IOBinarySource::new(&mut File::open(path)?).packed_iovalues().demand_next(true)?;
+ let fruits_value = IOBinarySource::new(&mut File::open(path)?).packed().next_iovalue(true)?;
println!("{:#?}", fruits_value);
let fruits1: Vec = value::de::from_value(&fruits_value)?;
diff --git a/implementations/rust/preserves/src/de.rs b/implementations/rust/preserves/src/de.rs
index b6abd83..d8f5a36 100644
--- a/implementations/rust/preserves/src/de.rs
+++ b/implementations/rust/preserves/src/de.rs
@@ -6,14 +6,16 @@ use std::io;
use std::marker::PhantomData;
use super::value::boundary as B;
-use super::value::{IOValue, IOValueDomainCodec, PackedReader, TextReader, ViaCodec};
-use super::value::reader::{Reader, IOBinarySource, BytesBinarySource};
+use super::value::{PackedReader, TextReader};
+use super::value::reader::Reader;
+use super::value::source::BytesBinarySource;
+use super::value::source::IOBinarySource;
-pub use super::error::Error;
+pub use super::error::{Error, ExpectedKind};
pub type Result = std::result::Result;
-pub struct Deserializer<'de, 'r, R: Reader<'de, IOValue>> {
+pub struct Deserializer<'de, 'r, R: Reader<'de>> {
pub read: &'r mut R,
phantom: PhantomData<&'de ()>,
}
@@ -23,12 +25,11 @@ pub fn from_bytes<'de, T>(bytes: &'de [u8]) ->
where
T: Deserialize<'de>
{
- from_reader(&mut PackedReader::new(&mut BytesBinarySource::new(bytes), IOValueDomainCodec))
+ from_reader(&mut PackedReader::new(&mut BytesBinarySource::new(bytes)))
}
pub fn from_text<'de, T>(text: &'de str) -> Result where T: Deserialize<'de> {
- from_reader(&mut TextReader::new(&mut BytesBinarySource::new(text.as_bytes()),
- ViaCodec::new(IOValueDomainCodec)))
+ from_reader(&mut TextReader::new(&mut BytesBinarySource::new(text.as_bytes())))
}
pub fn from_read<'de, 'r, IOR: io::Read + io::Seek, T>(read: &'r mut IOR) ->
@@ -36,10 +37,10 @@ pub fn from_read<'de, 'r, IOR: io::Read + io::Seek, T>(read: &'r mut IOR) ->
where
T: Deserialize<'de>
{
- from_reader(&mut PackedReader::new(&mut IOBinarySource::new(read), IOValueDomainCodec))
+ from_reader(&mut PackedReader::new(&mut IOBinarySource::new(read)))
}
-pub fn from_reader<'r, 'de, R: Reader<'de, IOValue>, T>(read: &'r mut R) ->
+pub fn from_reader<'r, 'de, R: Reader<'de>, T>(read: &'r mut R) ->
Result
where
T: Deserialize<'de>
@@ -49,13 +50,29 @@ where
Ok(t)
}
-impl<'r, 'de, R: Reader<'de, IOValue>> Deserializer<'de, 'r, R> {
+impl<'r, 'de, R: Reader<'de>> Deserializer<'de, 'r, R> {
pub fn from_reader(read: &'r mut R) -> Self {
Deserializer { read, phantom: PhantomData }
}
+
+ fn new_record_boundary(&mut self) -> Result {
+ let b = B::start(B::Item::RecordLabel);
+ self.read.boundary(&b)?;
+ Ok(b)
+ }
+
+ fn open_simple_record(&mut self, label: &str) -> Result {
+ self.read.open_simple_record(label)?;
+ self.new_record_boundary()
+ }
+
+ fn open_record(&mut self) -> Result {
+ self.read.open_record()?;
+ self.new_record_boundary()
+ }
}
-impl<'r, 'de, 'a, R: Reader<'de, IOValue>>
+impl<'r, 'de, 'a, R: Reader<'de>>
serde::de::Deserializer<'de>
for &'a mut Deserializer<'de, 'r, R>
{
@@ -155,19 +172,25 @@ impl<'r, 'de, 'a, R: Reader<'de, IOValue>>
fn deserialize_option(self, visitor: V) -> Result where V: Visitor<'de>
{
- if let Some(mut b) = self.read.open_option()? {
- self.read.ensure_more_expected(&mut b, &B::Item::RecordField)?;
- let result = visitor.visit_some(&mut *self)?;
- self.read.ensure_complete(b, &B::Item::RecordField)?;
- Ok(result)
- } else {
- Ok(visitor.visit_none::()?)
+ let mut b = self.open_record()?;
+ match self.read.next_symbol()?.as_ref() {
+ "None" => {
+ self.read.ensure_complete(b, &B::Item::RecordField)?;
+ visitor.visit_none::()
+ },
+ "Some" => {
+ self.read.ensure_more_expected(&mut b, &B::Item::RecordField)?;
+ let result = visitor.visit_some(&mut *self)?;
+ self.read.ensure_complete(b, &B::Item::RecordField)?;
+ Ok(result)
+ }
+ _ => Err(Error::Expected(ExpectedKind::Option)),
}
}
fn deserialize_unit(self, visitor: V) -> Result where V: Visitor<'de>
{
- let b = self.read.open_simple_record("tuple", Some(0))?;
+ let b = self.open_simple_record("tuple")?;
let result = visitor.visit_unit::]