diff --git a/pdl-compiler/scripts/generate_cxx_backend_tests.py b/pdl-compiler/scripts/generate_cxx_backend_tests.py index 42e8bfd..e746830 100755 --- a/pdl-compiler/scripts/generate_cxx_backend_tests.py +++ b/pdl-compiler/scripts/generate_cxx_backend_tests.py @@ -83,7 +83,8 @@ def check_members(decl: ast.Declaration, var: str, expected: object) -> List[str checks.append(f"ASSERT_TRUE(!{get_field(decl, var, id)}.has_value());") elif isinstance(field, ast.TypedefField) and field.cond and value is not None: - checks.append(f"{field.type_id} const& {field_var} = {get_field(decl, var, id)}.value();") + checks.append(f"auto opt_{field_var} = {get_field(decl, var, id)};") + checks.append(f"{field.type_id} const& {field_var} = opt_{field_var}.value();") checks.extend(check_members(field.type, field_var, value)) elif isinstance(field, ast.TypedefField): diff --git a/pdl-compiler/src/analyzer.rs b/pdl-compiler/src/analyzer.rs index e1aa37e..0c20ad1 100644 --- a/pdl-compiler/src/analyzer.rs +++ b/pdl-compiler/src/analyzer.rs @@ -1934,7 +1934,7 @@ mod test { let mut db = ast::SourceDatabase::new(); let file = parse_inline(&mut db, "stdin", $text.to_owned()).expect("parsing failure"); let result = analyzer::analyze(&file); - assert!(matches!(result, Err(_))); + assert!(result.is_err()); let diagnostics = result.err().unwrap(); let mut buffer = termcolor::Buffer::no_color(); let _ = diagnostics.emit(&db, &mut buffer); diff --git a/pdl-compiler/src/backends.rs b/pdl-compiler/src/backends.rs index acb4ac4..816576c 100644 --- a/pdl-compiler/src/backends.rs +++ b/pdl-compiler/src/backends.rs @@ -14,6 +14,7 @@ //! Compiler backends. +pub mod cxx; #[cfg(feature = "java")] pub mod java; pub mod json; diff --git a/pdl-compiler/src/backends/cxx.rs b/pdl-compiler/src/backends/cxx.rs new file mode 100644 index 0000000..916f368 --- /dev/null +++ b/pdl-compiler/src/backends/cxx.rs @@ -0,0 +1,2503 @@ +// Copyright 2023 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! C++ compiler backend. + +use crate::{analyzer, ast}; +use heck::ToUpperCamelCase; +use std::collections::HashSet; + +fn indent(s: &str, level: usize) -> String { + let prefix = " ".repeat(level); + s.lines() + .map(|line| if line.is_empty() { line.to_string() } else { format!("{}{}", prefix, line) }) + .collect::>() + .join("\n") +} + +fn to_pascal_case(s: &str) -> String { + s.to_upper_camel_case() +} + +fn mask(width: usize) -> String { + format!("{:#x}", (1u128 << width) - 1) +} + +fn deref(var: Option<&str>, id: &str) -> String { + match var { + Some(v) => format!("{}.{}", v, id), + None => id.to_string(), + } +} + +fn get_cxx_scalar_type(width: usize) -> String { + for n in [8, 16, 32, 64] { + if width <= n { + return format!("uint{}_t", n); + } + } + panic!("PDL type does not fit on non-extended scalar types: width = {}", width); +} + +pub fn generate( + sources: &ast::SourceDatabase, + file: &ast::File, + namespace: Option<&str>, + include_headers: &[String], + using_namespaces: &[String], + exclude_declarations: &[String], +) -> String { + let mut code = String::new(); + let source = sources.get(file.file).expect("could not read source"); + let scope = analyzer::Scope::new(file).unwrap(); + let schema = analyzer::Schema::new(file); + + code.push_str(&format!("// File generated from {}, with the command:\n", source.name())); + code.push_str("// pdlc ...\n"); + code.push_str("// /!\\ Do not edit by hand\n\n"); + + code.push_str("#pragma once\n\n"); + code.push_str("#include \n"); + code.push_str("#include \n"); + code.push_str("#include \n"); + code.push_str("#include \n"); + code.push_str("#include \n"); + code.push_str("#include \n"); + code.push_str("#include \n\n"); + code.push_str("#include \n\n"); + + for header in include_headers { + code.push_str(&format!("#include <{}>\n", header)); + } + if !include_headers.is_empty() { + code.push('\n'); + } + + for ns in using_namespaces { + code.push_str(&format!("using namespace {};\n", ns)); + } + if !using_namespaces.is_empty() { + code.push('\n'); + } + + code.push_str("#ifndef _ASSERT_VALID\n"); + code.push_str("#ifdef ASSERT\n"); + code.push_str("#define _ASSERT_VALID ASSERT\n"); + code.push_str("#else\n"); + code.push_str("#include \n"); + code.push_str("#define _ASSERT_VALID assert\n"); + code.push_str("#endif // ASSERT\n"); + code.push_str("#endif // !_ASSERT_VALID\n\n"); + + if let Some(ns) = namespace { + code.push_str(&format!("namespace {} {{\n", ns)); + } + + // Forward declarations + for decl in &file.declarations { + if let Some(id) = decl.id() { + if exclude_declarations.contains(&id.to_string()) { + continue; + } + if matches!(decl.desc, ast::DeclDesc::Packet { .. }) { + code.push_str(&format!("class {}View;\n", id)); + } + } + } + + for decl in &file.declarations { + if let Some(id) = decl.id() { + if exclude_declarations.contains(&id.to_string()) { + continue; + } + } + + match &decl.desc { + ast::DeclDesc::Enum { id, tags, width } => { + code.push_str(&generate_enum_declaration(id, tags, *width)); + code.push_str(&generate_enum_to_text(id, tags)); + code.push_str(&generate_enum_is_valid(id, tags)); + } + ast::DeclDesc::Packet { .. } => { + code.push_str(&generate_packet_view(&scope, &schema, decl)); + code.push_str(&generate_packet_builder(&scope, &schema, decl)); + } + ast::DeclDesc::Struct { .. } => { + code.push_str(&generate_struct_declaration(&scope, &schema, decl)); + } + _ => {} + } + } + + if let Some(ns) = namespace { + code.push_str(&format!("}} // {}\n", ns)); + } + + code +} + +fn generate_enum_declaration(id: &str, tags: &[ast::Tag], width: usize) -> String { + let enum_type = get_cxx_scalar_type(width); + let mut tag_decls = Vec::new(); + for tag in tags { + match tag { + ast::Tag::Value(t) => { + tag_decls.push(format!("{} = {:#x},", t.id, t.value)); + } + ast::Tag::Range(t) => { + for subtag in &t.tags { + tag_decls.push(format!("{} = {:#x},", subtag.id, subtag.value)); + } + } + _ => {} + } + } + + format!("\nenum class {} : {} {{\n{}\n}};\n", id, enum_type, indent(&tag_decls.join("\n"), 1)) +} + +fn generate_enum_to_text(id: &str, tags: &[ast::Tag]) -> String { + let mut tag_cases = Vec::new(); + for tag in tags { + match tag { + ast::Tag::Value(t) => { + tag_cases.push(format!("case {}::{}: return \"{}\";", id, t.id, t.id)); + } + ast::Tag::Range(t) => { + for subtag in &t.tags { + tag_cases + .push(format!("case {}::{}: return \"{}\";", id, subtag.id, subtag.id)); + } + } + _ => {} + } + } + + format!( + r#" +inline std::string {id}Text({id} tag) {{ + switch (tag) {{ +{tag_cases} + default: + return std::string("Unknown {id}: " + + std::to_string(static_cast(tag))); + }} +}} +"#, + id = id, + tag_cases = indent(&tag_cases.join("\n"), 2) + ) +} + +fn generate_enum_is_valid(id: &str, tags: &[ast::Tag]) -> String { + let mut check_exprs = Vec::new(); + let mut has_other = false; + for tag in tags { + match tag { + ast::Tag::Value(t) => { + check_exprs.push(format!("tag == {}::{}", id, t.id)); + } + ast::Tag::Range(t) => { + check_exprs.push(format!( + "(static_cast(tag) >= {:#x} && static_cast(tag) <= {:#x})", + t.range.start(), + t.range.end() + )); + } + ast::Tag::Other(_) => { + has_other = true; + } + } + } + + if has_other || check_exprs.is_empty() { + return format!("\ninline bool Is{id}Valid({id} /* tag */) {{ return true; }}\n", id = id); + } + + format!( + r#" +inline bool Is{id}Valid({id} tag) {{ + return {check_exprs}; +}} +"#, + id = id, + check_exprs = check_exprs.join(" || ") + ) +} + +fn get_unconstrained_parent_fields<'a>( + scope: &analyzer::Scope<'a>, + decl: &'a ast::Decl, +) -> Vec<&'a ast::Field> { + let mut constraints = HashSet::new(); + for parent in scope.iter_parents_and_self(decl) { + for constraint in parent.constraints() { + constraints.insert(constraint.id.clone()); + } + } + + let mut fields = Vec::new(); + let parents: Vec<_> = scope.iter_parents(decl).collect(); + for parent in parents.into_iter().rev() { + for field in parent.fields() { + if let Some(id) = field.id() { + if !constraints.contains(id) { + match &field.desc { + ast::FieldDesc::Scalar { .. } + | ast::FieldDesc::Array { .. } + | ast::FieldDesc::Typedef { .. } + | ast::FieldDesc::Payload { .. } + | ast::FieldDesc::Body => { + fields.push(field); + } + _ => {} + } + } + } + } + } + fields +} + +fn get_all_parent_fields<'a>( + scope: &analyzer::Scope<'a>, + decl: &'a ast::Decl, +) -> Vec<&'a ast::Field> { + let mut fields = Vec::new(); + let parents: Vec<_> = scope.iter_parents(decl).collect(); + for parent in parents.into_iter().rev() { + for field in parent.fields() { + match &field.desc { + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => {} + _ => { + fields.push(field); + } + } + } + } + fields +} + +struct FieldParser<'a> { + scope: &'a analyzer::Scope<'a>, + schema: &'a analyzer::Schema, + endianness: ast::EndiannessValue, + offset: usize, + shift: usize, + chunk: Vec<(usize, usize, &'a ast::Field)>, + chunk_nr: usize, + unchecked_code: Vec, + code: Vec, + is_cond_for: HashSet, + target_prefix: String, + extract_arrays: bool, + decl: &'a ast::Decl, +} + +impl<'a> FieldParser<'a> { + fn new( + scope: &'a analyzer::Scope<'a>, + schema: &'a analyzer::Schema, + endianness: ast::EndiannessValue, + target_prefix: &str, + extract_arrays: bool, + decl: &'a ast::Decl, + ) -> Self { + Self { + scope, + schema, + endianness, + offset: 0, + shift: 0, + chunk: Vec::new(), + chunk_nr: 0, + unchecked_code: Vec::new(), + code: Vec::new(), + is_cond_for: HashSet::new(), + target_prefix: target_prefix.to_string(), + extract_arrays, + decl, + } + } + + fn unchecked_append(&mut self, line: String) { + self.unchecked_code.push(line); + } + + fn append(&mut self, line: String) { + assert!(self.unchecked_code.is_empty()); + self.code.push(line); + } + + fn check_size(&mut self, size: &str) { + self.append(format!("if (span.size() < {}) {{", size)); + self.append(" return false;".to_string()); + self.append("}".to_string()); + } + + fn check_code(&mut self) { + if !self.unchecked_code.is_empty() { + assert!(self.chunk.is_empty()); + let unchecked_code = std::mem::take(&mut self.unchecked_code); + let offset = self.offset; + self.check_size(&offset.to_string()); + self.code.extend(unchecked_code); + self.offset = 0; + } + } + + fn parse_bit_field(&mut self, field: &'a ast::Field) { + let width = self.schema.field_size(field.key).static_().unwrap(); + self.chunk.push((self.shift, width, field)); + self.shift += width; + + if !self.shift.is_multiple_of(8) { + return; + } + + let size = self.shift / 8; + let backing_type = get_cxx_scalar_type(self.shift); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + + let should_skip_value = + self.chunk.iter().all(|(_, _, f)| matches!(f.desc, ast::FieldDesc::Reserved { .. })); + if should_skip_value { + self.unchecked_append(format!("span.skip({}); // skip reserved fields", size)); + self.offset += size; + self.shift = 0; + self.chunk.clear(); + return; + } + + let value = if self.chunk.len() > 1 { + let v = format!("chunk{}", self.chunk_nr); + self.unchecked_append(format!( + "{} {} = span.read_{}<{}, {}>();", + backing_type, v, byteorder, backing_type, size + )); + self.chunk_nr += 1; + v + } else { + format!("span.read_{}<{}, {}>()", byteorder, backing_type, size) + }; + + let chunk = std::mem::take(&mut self.chunk); + for (shift, width, field) in chunk.iter() { + let v = if chunk.len() == 1 && *shift == 0 { + value.clone() + } else { + format!("({} >> {}) & {}", value, shift, mask(*width)) + }; + + let is_cond = field.id().map(|id| self.is_cond_for.contains(id)).unwrap_or(false); + + match &field.desc { + ast::FieldDesc::Scalar { id, .. } => { + if is_cond { + self.unchecked_append(format!("uint8_t {} = {};", id, v)); + } else { + self.unchecked_append(format!("{}{}_ = {};", self.target_prefix, id, v)); + } + } + ast::FieldDesc::FixedScalar { value: fixed_value, .. } => { + self.unchecked_append(format!( + "if (static_cast({}) != {:#x}) {{", + v, fixed_value + )); + self.unchecked_append(" return false;".to_string()); + self.unchecked_append("}".to_string()); + } + ast::FieldDesc::FixedEnum { enum_id, tag_id, .. } => { + self.unchecked_append(format!( + "if ({}({}) != {}::{}) {{", + enum_id, v, enum_id, tag_id + )); + self.unchecked_append(" return false;".to_string()); + self.unchecked_append("}".to_string()); + } + ast::FieldDesc::Typedef { id, type_id, .. } => { + let type_decl = self.scope.typedef.get(type_id).unwrap(); + if matches!(type_decl.desc, ast::DeclDesc::Enum { .. }) { + self.unchecked_append(format!( + "{}{}_ = static_cast<{}>( {} );", + self.target_prefix, id, type_id, v + )); + self.unchecked_append(format!( + "if (!Is{}Valid({}{}_)) return false;", + type_id, self.target_prefix, id + )); + } else { + self.unchecked_append(format!("{}{}_ = {};", self.target_prefix, id, v)); + } + } + ast::FieldDesc::Size { field_id, .. } => { + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + self.unchecked_append(format!( + "{}{}_size_ = {};", + self.target_prefix, field_name, v + )); + } + ast::FieldDesc::Count { field_id, .. } => { + self.unchecked_append(format!( + "{}{}_count_ = {};", + self.target_prefix, field_id, v + )); + } + ast::FieldDesc::ElementSize { field_id, .. } => { + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + self.unchecked_append(format!( + "{}{}_element_size_ = {};", + self.target_prefix, field_name, v + )); + } + ast::FieldDesc::Flag { id, .. } => { + self.unchecked_append(format!("uint8_t {} = {};", id, v)); + } + ast::FieldDesc::Reserved { .. } => {} + _ => panic!("Unsupported bit field type: {:?}", field.desc), + } + } + + self.offset += size; + self.shift = 0; + } + + fn parse_typedef_field(&mut self, field: &'a ast::Field, id: &str, type_id: &str) { + if self.shift != 0 { + panic!("Typedef field does not start on an octet boundary"); + } + self.check_code(); + + let type_decl = self.scope.typedef.get(type_id).unwrap(); + if let ast::DeclDesc::Enum { width, .. } = &type_decl.desc { + let ty = get_cxx_scalar_type(*width); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + self.append(format!("if (span.size() < {}) return false;", width / 8)); + self.append(format!( + "{}{}_ = static_cast<{}>(span.read_{}<{}, {}>());", + self.target_prefix, + id, + type_id, + byteorder, + ty, + width / 8 + )); + self.append(format!( + "if (!Is{}Valid({}{}_)) return false;", + type_id, self.target_prefix, id + )); + return; + } + + let field_size = self.schema.field_size(field.key); + if let analyzer::Size::Unknown = field_size { + let trailing_size = self.get_trailing_size(field); + if trailing_size > 0 { + self.append(format!("if (span.size() < {}) return false;", trailing_size / 8)); + let size = format!("span.size() - {}", trailing_size / 8); + self.append(format!( + "pdl::packet::slice {0}_span = span.subrange(0, {1});", + id, size + )); + self.append(format!( + "if (!{0}::Parse({1}_span, &{2}{1}_)) return false;", + type_id, id, self.target_prefix + )); + self.append(format!("span.skip({0}_span.size());", id)); + } else { + self.append(format!( + "if (!{}::Parse(span, &{}{}_)) return false;", + type_id, self.target_prefix, id + )); + } + } else { + self.append(format!( + "if (!{}::Parse(span, &{}{}_)) return false;", + type_id, self.target_prefix, id + )); + } + } + + fn parse_optional_field(&mut self, field: &'a ast::Field) { + self.check_code(); + let cond = field.cond.as_ref().unwrap(); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + + match &field.desc { + ast::FieldDesc::Scalar { id, width } => { + let backing_type = get_cxx_scalar_type(*width); + let size = width / 8; + let cond_value = cond.value.unwrap(); + self.append(format!("if ({} == {}) {{", cond.id, cond_value)); + self.append(format!(" if (span.size() < {}) {{", size)); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append(format!( + " {}{}_ = span.read_{}<{}, {}>();", + self.target_prefix, id, byteorder, backing_type, size + )); + self.append("}".to_string()); + } + ast::FieldDesc::Typedef { id, type_id, .. } => { + let type_decl = self.scope.typedef.get(type_id).unwrap(); + let cond_value = cond.value.unwrap(); + if let ast::DeclDesc::Enum { width, .. } = &type_decl.desc { + let backing_type = get_cxx_scalar_type(*width); + let size = width / 8; + self.append(format!("if ({} == {}) {{", cond.id, cond_value)); + self.append(format!(" if (span.size() < {}) {{", size)); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append(format!( + " {}{}_ = static_cast<{}>(span.read_{}<{}, {}>());", + self.target_prefix, id, type_id, byteorder, backing_type, size + )); + self.append(format!( + " if (!Is{}Valid({}{}_.value())) return false;", + type_id, self.target_prefix, id + )); + self.append("}".to_string()); + } else { + self.append(format!("if ({} == {}) {{", cond.id, cond_value)); + self.append(format!( + " auto& opt_output = {}{}_.emplace();", + self.target_prefix, id + )); + self.append(format!(" if (!{}::Parse(span, &opt_output)) {{", type_id)); + self.append(" return false;".to_string()); + self.append(" }".to_string()); + self.append("}".to_string()); + } + } + _ => panic!("Unsupported optional field type"), + } + } + + fn parse_array_field_lite( + &mut self, + field: &'a ast::Field, + id: &str, + _type_id: Option<&str>, + _width: Option, + _size: Option, + ) { + self.check_code(); + match self.schema.field_size(field.key) { + analyzer::Size::Static(bits) => { + let size = bits / 8; + self.check_size(&size.to_string()); + self.append(format!("{}{}_ = span.subrange(0, {});", self.target_prefix, id, size)); + self.append(format!("span.skip({});", size)); + } + _ => { + let mut size_expr = "".to_string(); + let mut count_expr = "".to_string(); + + for f in self.decl.fields() { + match &f.desc { + ast::FieldDesc::Size { field_id, .. } if field_id == id => { + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + size_expr = format!("{}{}_size_", self.target_prefix, field_name); + } + ast::FieldDesc::Count { field_id, .. } if field_id == id => { + count_expr = format!("{}{}_count_", self.target_prefix, field_id); + } + _ => {} + } + } + + if !size_expr.is_empty() { + let inverted_modifier = match &field.desc { + ast::FieldDesc::Array { size_modifier: Some(m), .. } => { + if let Some(stripped) = m.strip_prefix('+') { + format!("- {}", stripped) + } else if let Some(stripped) = m.strip_prefix('-') { + format!("+ {}", stripped) + } else { + m.clone() + } + } + _ => String::new(), + }; + let actual_size = if inverted_modifier.is_empty() { + size_expr + } else { + format!("({} {})", size_expr, inverted_modifier) + }; + self.append(format!("if (span.size() < {}) return false;", actual_size)); + if let ast::FieldDesc::Array { width: Some(w), .. } = &field.desc { + if w % 8 == 0 { + self.append(format!( + "if (({} % {}) != 0) return false;", + actual_size, + w / 8 + )); + } + } + self.append(format!( + "{}{}_ = span.subrange(0, {});", + self.target_prefix, id, actual_size + )); + self.append(format!("span.skip({});", actual_size)); + } else if !count_expr.is_empty() { + if let ast::FieldDesc::Array { width: Some(w), .. } = &field.desc { + let total_size = format!("{} * {}", count_expr, w / 8); + self.append(format!("if (span.size() < {}) return false;", total_size)); + self.append(format!( + "{}{}_ = span.subrange(0, {});", + self.target_prefix, id, total_size + )); + self.append(format!("span.skip({});", total_size)); + } else { + // Full parse needed + self.append(format!("{}{}_ = span;", self.target_prefix, id)); + self.append("span.clear();".to_string()); + } + } else { + let trailing_size = self.get_trailing_size(field); + if trailing_size > 0 { + self.append(format!( + "if (span.size() < {}) return false;", + trailing_size / 8 + )); + let size = format!("span.size() - {}", trailing_size / 8); + self.append(format!( + "{}{}_ = span.subrange(0, {});", + self.target_prefix, id, size + )); + self.append(format!("span.skip({});", size)); + } else { + self.append(format!("{}{}_ = span;", self.target_prefix, id)); + self.append("span.clear();".to_string()); + } + } + } + } + } + + fn get_trailing_size(&self, field: &'a ast::Field) -> usize { + let mut trailing_size = 0; + let mut found = false; + for f in self.decl.fields() { + if found { + match self.schema.field_size(f.key) { + analyzer::Size::Static(bits) => trailing_size += bits, + _ => panic!( + "Multiple unknown size fields in {}", + self.decl.id().unwrap_or("unknown") + ), + } + } + if f.key == field.key { + found = true; + } + } + trailing_size + } + + fn parse_payload_field_lite(&mut self, _field: &'a ast::Field, _is_body: bool) { + if self.shift != 0 { + panic!("Payload field does not start on an octet boundary"); + } + self.check_code(); + let mut size_expr = "".to_string(); + for f in self.decl.fields() { + if let ast::FieldDesc::Size { field_id, .. } = &f.desc { + if field_id == "_payload_" || field_id == "_body_" { + size_expr = format!("{}{}_size_", self.target_prefix, "payload"); + } + } + } + + if !size_expr.is_empty() { + let inverted_modifier = match &_field.desc { + ast::FieldDesc::Payload { size_modifier: Some(m), .. } => { + if let Some(stripped) = m.strip_prefix('+') { + format!("- {}", stripped) + } else if let Some(stripped) = m.strip_prefix('-') { + format!("+ {}", stripped) + } else { + m.clone() + } + } + _ => String::new(), + }; + let actual_size = if inverted_modifier.is_empty() { + size_expr + } else { + format!("({} {})", size_expr, inverted_modifier) + }; + self.append(format!("if (span.size() < {}) return false;", actual_size)); + self.append(format!( + "{}payload_ = span.subrange(0, {});", + self.target_prefix, actual_size + )); + self.append(format!("span.skip({});", actual_size)); + } else { + let trailing_size = self.get_trailing_size(_field); + if trailing_size > 0 { + self.append(format!("if (span.size() < {}) return false;", trailing_size / 8)); + let size = format!("span.size() - {}", trailing_size / 8); + self.append(format!( + "{}payload_ = span.subrange(0, {});", + self.target_prefix, size + )); + self.append(format!("span.skip({});", size)); + } else { + self.append(format!("{}payload_ = span;", self.target_prefix)); + self.append("span.clear();".to_string()); + } + } + } + + fn parse_array_field_full( + &mut self, + _field: &'a ast::Field, + id: &str, + type_id: Option<&str>, + width: Option, + size: Option, + ) { + self.check_code(); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + + if let Some(s) = size { + self.append(format!("for (int n = 0; n < {}; n++) {{", s)); + if let Some(tid) = type_id { + let td = self.scope.typedef.get(tid).unwrap(); + match &td.desc { + ast::DeclDesc::Enum { width, .. } => { + let backing_type = get_cxx_scalar_type(*width); + self.append(format!(" if (span.size() < {}) return false;", width / 8)); + self.append(format!( + " {0}{1}_[n] = {2}(span.read_{3}<{4}, {5}>());", + self.target_prefix, + id, + tid, + byteorder, + backing_type, + width / 8 + )); + } + _ => { + self.append(format!( + " if (!{}::Parse(span, &{}{}_[n])) return false;", + tid, self.target_prefix, id + )); + } + } + } else { + let element_width = width.unwrap(); + let backing_type = get_cxx_scalar_type(element_width); + self.append(format!(" if (span.size() < {}) return false;", element_width / 8)); + self.append(format!( + " {0}{1}_[n] = span.read_{2}<{3}, {4}>();", + self.target_prefix, + id, + byteorder, + backing_type, + element_width / 8 + )); + } + self.append("}".to_string()); + } else { + let mut count_expr = "".to_string(); + let mut size_expr = "".to_string(); + for f in self.decl.fields() { + match &f.desc { + ast::FieldDesc::Size { field_id, .. } if field_id == id => { + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + size_expr = format!("{}{}_size_", self.target_prefix, field_name); + } + ast::FieldDesc::Count { field_id, .. } if field_id == id => { + count_expr = format!("{}{}_count_", self.target_prefix, field_id); + } + _ => {} + } + } + + if !count_expr.is_empty() { + self.append(format!("for (size_t n = 0; n < {}; n++) {{", count_expr)); + } else if !size_expr.is_empty() { + let inverted_modifier = match &_field.desc { + ast::FieldDesc::Array { size_modifier: Some(m), .. } => { + if let Some(stripped) = m.strip_prefix('+') { + format!("- {}", stripped) + } else if let Some(stripped) = m.strip_prefix('-') { + format!("+ {}", stripped) + } else { + m.clone() + } + } + _ => String::new(), + }; + let actual_size = if inverted_modifier.is_empty() { + size_expr + } else { + format!("({} {})", size_expr, inverted_modifier) + }; + self.append(format!("if (span.size() < {}) return false;", actual_size)); + + if let Some(w) = width { + self.append(format!("if (({} % {}) != 0) return false;", actual_size, w / 8)); + } else if let Some(tid) = type_id { + let decl = self.scope.typedef.get(tid).unwrap(); + let element_size = self.schema.decl_size(decl.key); + if let analyzer::Size::Static(bits) = element_size { + self.append(format!( + "if (({} % {}) != 0) return false;", + actual_size, + bits / 8 + )); + } + } + + self.append(format!("size_t limit = span.size() - {};", actual_size)); + self.append("while (span.size() > limit) {".to_string()); + } else { + self.append("while (span.size() > 0) {".to_string()); + } + + if let Some(tid) = type_id { + let td = self.scope.typedef.get(tid).unwrap(); + match &td.desc { + ast::DeclDesc::Enum { width, .. } => { + let backing_type = get_cxx_scalar_type(*width); + self.append(format!(" if (span.size() < {}) return false;", width / 8)); + self.append(format!( + " {}{}_.push_back({}(span.read_{}<{}, {}>()));", + self.target_prefix, + id, + tid, + byteorder, + backing_type, + width / 8 + )); + } + _ => { + self.append(format!(" {} element;", tid)); + self.append(format!( + " if (!{}::Parse(span, &element)) return false;", + tid + )); + self.append(format!( + " {}{}_.emplace_back(std::move(element));", + self.target_prefix, id + )); + } + } + } else { + let element_width = width.unwrap(); + let backing_type = get_cxx_scalar_type(element_width); + self.append(format!(" if (span.size() < {}) return false;", element_width / 8)); + self.append(format!( + " {}{}_.push_back(span.read_{}<{}, {}>());", + self.target_prefix, + id, + byteorder, + backing_type, + element_width / 8 + )); + } + self.append("}".to_string()); + } + } + + fn parse(&mut self, field: &'a ast::Field) { + if field.cond.is_some() { + self.parse_optional_field(field); + } else if self.scope.is_bitfield(field) { + self.parse_bit_field(field); + } else { + self.check_code(); + match &field.desc { + ast::FieldDesc::Padding { .. } => {} + ast::FieldDesc::Array { id, type_id, width, size, .. } => { + let padded_size = self.schema.padded_size(field.key); + if padded_size.is_some() { + self.append(format!("size_t {0}_start_size = span.size();", id)); + } + if !self.extract_arrays { + self.parse_array_field_lite(field, id, type_id.as_deref(), *width, *size); + } else { + self.parse_array_field_full(field, id, type_id.as_deref(), *width, *size); + } + if let Some(ps) = padded_size { + let ps_bytes = ps / 8; + self.append(format!( + "if ({0}_start_size - span.size() < {1}) {{", + id, ps_bytes + )); + self.append(format!(" if (span.size() < {1} - ({0}_start_size - span.size())) return false;", id, ps_bytes)); + self.append(format!( + " span.skip({1} - ({0}_start_size - span.size()));", + id, ps_bytes + )); + self.append("}".to_string()); + } + } + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { + self.parse_payload_field_lite( + field, + matches!(field.desc, ast::FieldDesc::Body), + ); + } + ast::FieldDesc::Scalar { id, width } => { + let ty = get_cxx_scalar_type(*width); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + self.append(format!("if (span.size() < {}) return false;", width / 8)); + self.append(format!( + "{}{}_ = span.read_{}<{}, {}>();", + self.target_prefix, + id, + byteorder, + ty, + width / 8 + )); + } + ast::FieldDesc::Size { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + self.append(format!("if (span.size() < {}) return false;", width / 8)); + self.append(format!( + "{}{}_size_ = span.read_{}<{}, {}>();", + self.target_prefix, + field_name, + byteorder, + ty, + width / 8 + )); + } + ast::FieldDesc::Count { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + self.append(format!("if (span.size() < {}) return false;", width / 8)); + self.append(format!( + "{}{}_count_ = span.read_{}<{}, {}>();", + self.target_prefix, + field_id, + byteorder, + ty, + width / 8 + )); + } + ast::FieldDesc::ElementSize { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + self.append(format!("if (span.size() < {}) return false;", width / 8)); + self.append(format!( + "{}{}_element_size_ = span.read_{}<{}, {}>();", + self.target_prefix, + field_name, + byteorder, + ty, + width / 8 + )); + } + ast::FieldDesc::FixedScalar { width, value } => { + let ty = get_cxx_scalar_type(*width); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + self.append(format!("if (span.size() < {}) return false;", width / 8)); + self.append(format!( + "if (span.read_{}<{}, {}>() != {:#x}) return false;", + byteorder, + ty, + width / 8, + value + )); + } + ast::FieldDesc::FixedEnum { enum_id, tag_id, .. } => { + let width = match &self.scope.typedef[enum_id].desc { + ast::DeclDesc::Enum { width, .. } => *width, + _ => unreachable!(), + }; + let ty = get_cxx_scalar_type(width); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + self.append(format!("if (span.size() < {}) return false;", width / 8)); + self.append(format!( + "if (span.read_{}<{}, {}>() != static_cast<{}>( {}::{} )) return false;", + byteorder, + ty, + width / 8, + ty, + enum_id, + tag_id + )); + } + ast::FieldDesc::Typedef { id, type_id, .. } => { + self.parse_typedef_field(field, id, type_id); + } + _ => {} + } + } + } + + fn done(&mut self) { + self.check_code(); + } +} + +struct FieldSerializer<'a> { + scope: &'a analyzer::Scope<'a>, + schema: &'a analyzer::Schema, + endianness: ast::EndiannessValue, + shift: usize, + values: Vec<(String, usize)>, + code: Vec, + indent_level: usize, +} + +impl<'a> FieldSerializer<'a> { + fn new( + scope: &'a analyzer::Scope<'a>, + schema: &'a analyzer::Schema, + endianness: ast::EndiannessValue, + ) -> Self { + Self { + scope, + schema, + endianness, + shift: 0, + values: Vec::new(), + code: Vec::new(), + indent_level: 0, + } + } + + fn indent(&mut self) { + self.indent_level += 1; + } + + fn unindent(&mut self) { + self.indent_level -= 1; + } + + fn append(&mut self, line: &str) { + let prefix = " ".repeat(self.indent_level); + for l in line.lines() { + self.code.push(format!("{}{}", prefix, l)); + } + } + + fn get_payload_field_size( + &self, + var: Option<&str>, + field_id: &str, + decl: &'a ast::Decl, + ) -> String { + let parent_constraints = self + .scope + .iter_parents_and_self(decl) + .flat_map(|d| d.constraints()) + .collect::>(); + let get_field_size_expr = |f: &ast::Field| -> String { + let fid = f.id(); + let is_constrained = + fid.map(|fid| parent_constraints.iter().any(|c| c.id == fid)).unwrap_or(false); + if is_constrained { + return format!("{}", self.schema.field_size(f.key).static_().unwrap() / 8); + } + + match &f.desc { + ast::FieldDesc::Scalar { width, .. } => { + if let Some(cond) = &f.cond { + let cond_field = self + .scope + .iter_fields(decl) + .find(|f| f.id() == Some(&cond.id)) + .expect("Cond field not found"); + let _cond_field_var = + format!("{0}.has_value() ? ...", cond_field.id().unwrap()); // This is getting complex + // Actually, I'll just use a simpler approach for now. + format!("(({}_.has_value()) ? {} : 0)", f.id().unwrap(), width / 8) + } else { + format!("{}", width / 8) + } + } + ast::FieldDesc::Typedef { id, type_id, .. } => { + let type_decl = self.scope.typedef.get(type_id).unwrap(); + let width = match &type_decl.desc { + ast::DeclDesc::Enum { width, .. } => *width, + _ => 0, + }; + if f.cond.is_some() { + if width > 0 { + format!("(({}_.has_value()) ? {} : 0)", id, width / 8) + } else { + format!("(({0}_.has_value()) ? {0}_->GetSize() : 0)", id) + } + } else if width > 0 { + format!("{}", width / 8) + } else { + format!("{}_.GetSize()", id) + } + } + ast::FieldDesc::Array { id, width, type_id, .. } => { + let element_size = if let Some(w) = width { + format!("{}", w / 8) + } else { + let tid = type_id.as_ref().unwrap(); + let td = self.scope.typedef.get(tid).unwrap(); + match &td.desc { + ast::DeclDesc::Enum { width, .. } => format!("{}", width / 8), + _ => "element.GetSize()".to_string(), + } + }; + + if element_size.contains("GetSize") { + format!( + "std::accumulate({0}_.begin(), {0}_.end(), static_cast(0), [](size_t s, auto const& element) {{ return s + {1}; }})", + id, element_size + ) + } else { + format!("({0}_.size() * {1})", id, element_size) + } + } + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { + format!("{}.size()", deref(var, "payload_")) + } + _ => format!("{}", self.schema.field_size(f.key).static_().unwrap_or(0) / 8), + } + }; + + if field_id == "_payload_" || field_id == "_body_" { + let size_modifier = self.scope.iter_fields(decl).find_map(|f| match &f.desc { + ast::FieldDesc::Payload { size_modifier, .. } => size_modifier.as_ref(), + _ => None, + }); + + let has_local_payload = decl + .fields() + .any(|f| matches!(f.desc, ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body)); + let size_expr = if has_local_payload { + format!("{}.size()", deref(var, "payload_")) + } else { + let local_fields = decl.fields().map(get_field_size_expr).collect::>(); + if local_fields.is_empty() { "0".to_string() } else { local_fields.join(" + ") } + }; + + if let Some(m) = size_modifier { + return format!("({} {})", size_expr, m); + } + return size_expr; + } + let f = + self.scope.iter_fields(decl).find(|f| f.id() == Some(field_id)).unwrap_or_else(|| { + panic!("Field {} not found in {}", field_id, decl.id().unwrap_or("unknown")) + }); + match &f.desc { + ast::FieldDesc::Array { .. } => { + let size_expr = get_field_size_expr(f); + let size_modifier = match &f.desc { + ast::FieldDesc::Array { size_modifier, .. } => size_modifier.as_ref(), + _ => None, + }; + if let Some(m) = size_modifier { + return format!("({} {})", size_expr, m); + } + size_expr + } + _ => format!("{}.GetSize()", deref(var, &format!("{}_", f.id().unwrap()))), + } + } + + fn pack_bit_fields(&mut self) { + assert_eq!(self.shift % 8, 0); + let size = self.shift / 8; + let backing_type = get_cxx_scalar_type(self.shift); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + + if self.values.is_empty() { + self.append(&format!( + "pdl::packet::Builder::write_{}<{}, {}>(output, 0);", + byteorder, backing_type, size + )); + } else { + let packed_val = self + .values + .iter() + .map(|(v, s)| { + if *s == 0 { + format!("(static_cast<{}>({}))", backing_type, v) + } else { + format!("(static_cast<{}>({}) << {})", backing_type, v, s) + } + }) + .collect::>() + .join(" | "); + self.append(&format!( + "pdl::packet::Builder::write_{}<{}, {}>(output, {});", + byteorder, backing_type, size, packed_val + )); + } + + self.shift = 0; + self.values.clear(); + } + + fn serialize(&mut self, field: &'a ast::Field, decl: &'a ast::Decl, var: Option<&str>) { + let parent_constraints = self + .scope + .iter_parents_and_self(decl) + .flat_map(|d| d.constraints()) + .collect::>(); + let get_field_expr = |f: &ast::Field| -> String { + if let Some(fid) = f.id() { + if let Some(constraint) = parent_constraints.iter().find(|c| c.id == fid) { + if let Some(tag_id) = &constraint.tag_id { + let type_id = match &f.desc { + ast::FieldDesc::Typedef { type_id, .. } => Some(type_id.as_str()), + ast::FieldDesc::Array { type_id, .. } => type_id.as_deref(), + _ => None, + }; + if let Some(type_id) = type_id { + return format!("{}::{}", type_id, tag_id); + } + } + return format!("{:#x}", constraint.value.unwrap()); + } + } + match &f.desc { + ast::FieldDesc::Flag { optional_field_ids, .. } => { + let (opt_id, val_present) = &optional_field_ids[0]; + let val_absent = if *val_present == 0 { 1 } else { 0 }; + format!( + "({0}.has_value() ? {1} : {2})", + deref(var, &format!("{}_", opt_id)), + val_present, + val_absent + ) + } + _ => deref(var, &format!("{}_", f.id().unwrap())), + } + }; + + let field_var = field.id().map(|_| get_field_expr(field)); + let byteorder = match self.endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + + if let Some(cond) = &field.cond { + let cond_field = self + .scope + .iter_fields(decl) + .find(|f| f.id() == Some(&cond.id)) + .expect("Cond field not found"); + let cond_field_var = get_field_expr(cond_field); + let cond_val = cond.value.unwrap(); + self.append(&format!("if ({} == {}) {{", cond_field_var, cond_val)); + self.indent(); + match &field.desc { + ast::FieldDesc::Scalar { width, .. } => { + let ty = get_cxx_scalar_type(*width); + self.append(&format!( + "pdl::packet::Builder::write_{}<{}, {}>(output, *{});", + byteorder, + ty, + width / 8, + field_var.as_ref().unwrap() + )); + } + ast::FieldDesc::Typedef { type_id, .. } => { + let td = self.scope.typedef.get(type_id).unwrap(); + if let ast::DeclDesc::Enum { width, .. } = &td.desc { + let ty = get_cxx_scalar_type(*width); + self.append(&format!( + "pdl::packet::Builder::write_{}<{}, {}>(output, static_cast<{}>(*{}));", + byteorder, + ty, + width / 8, + ty, + field_var.as_ref().unwrap() + )); + } else { + self.append(&format!( + "{0}->Serialize(output);", + field_var.as_ref().unwrap() + )); + } + } + _ => {} + } + self.unindent(); + self.append("}"); + } else if self.scope.is_bitfield(field) { + let width = self.schema.field_size(field.key).static_().unwrap(); + let shift = self.shift; + match &field.desc { + ast::FieldDesc::Scalar { .. } => { + self.values.push((format!("{} & {}", field_var.unwrap(), mask(width)), shift)); + } + ast::FieldDesc::FixedScalar { value, .. } => { + self.values.push((format!("{:#x}", value), shift)); + } + ast::FieldDesc::FixedEnum { enum_id, tag_id, .. } => { + self.values.push((format!("{}::{}", enum_id, tag_id), shift)); + } + ast::FieldDesc::Typedef { id: _, type_id, .. } => { + let type_decl = self.scope.typedef.get(type_id).unwrap(); + if matches!(type_decl.desc, ast::DeclDesc::Enum { .. }) { + self.values.push(( + format!( + "static_cast<{}>({})", + get_cxx_scalar_type(width), + field_var.unwrap() + ), + shift, + )); + } else { + self.values.push((field_var.unwrap(), shift)); + } + } + ast::FieldDesc::Size { field_id, .. } => { + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + let size_expr = self.get_payload_field_size(var, field_id, decl); + self.append(&format!("size_t {field_name}_size = {size_expr};")); + self.values.push((format!("{}_size", field_name), shift)); + } + ast::FieldDesc::Count { field_id, .. } => { + let f = self + .scope + .iter_fields(decl) + .find(|f| f.id() == Some(field_id)) + .expect("Field not found"); + self.values.push((format!("{}.size()", get_field_expr(f)), shift)); + } + ast::FieldDesc::ElementSize { field_id, .. } => { + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + self.append(&format!("size_t {field_name}_element_size = 0; // TODO")); + self.values.push((format!("{}_element_size", field_name), shift)); + } + ast::FieldDesc::Flag { .. } => { + self.values.push((field_var.unwrap(), shift)); + } + _ => {} + } + self.shift += width; + if self.shift.is_multiple_of(8) { + self.pack_bit_fields(); + } + } else { + match &field.desc { + ast::FieldDesc::Padding { .. } => {} + ast::FieldDesc::Array { id, type_id, width, .. } => { + let padded_size = self.schema.padded_size(field.key); + if padded_size.is_some() { + self.append(&format!("size_t {0}_start = output.size();", id)); + } + if let Some(v) = field_var { + self.append(&format!("for (auto const& element : {}) {{", v)); + self.indent(); + if let Some(tid) = type_id { + let td = self.scope.typedef.get(tid).unwrap(); + match &td.desc { + ast::DeclDesc::Enum { width, .. } => { + let backing_type = get_cxx_scalar_type(*width); + self.append(&format!("pdl::packet::Builder::write_{}<{}, {}>(output, static_cast<{}>(element));", byteorder, backing_type, width / 8, backing_type)); + } + _ => self.append("element.Serialize(output);"), + } + } else { + let element_width = width.unwrap(); + let backing_type = get_cxx_scalar_type(element_width); + self.append(&format!("pdl::packet::Builder::write_{}<{}, {}>(output, static_cast<{}>(element));", byteorder, backing_type, element_width / 8, backing_type)); + } + self.unindent(); + self.append("}"); + } + if let Some(ps) = padded_size { + let ps_bytes = ps / 8; + self.append(&format!( + "if (output.size() - {0}_start < {1}) {{", + id, ps_bytes + )); + self.append(&format!( + " output.resize({0}_start + {1}, 0);", + id, ps_bytes + )); + self.append("}"); + } + } + ast::FieldDesc::Scalar { width, .. } => { + let ty = get_cxx_scalar_type(*width); + self.append(&format!( + "pdl::packet::Builder::write_{}<{}, {}>(output, {});", + byteorder, + ty, + width / 8, + field_var.unwrap() + )); + } + ast::FieldDesc::Typedef { type_id, .. } => { + let td = self.scope.typedef.get(type_id).unwrap(); + if let ast::DeclDesc::Enum { width, .. } = &td.desc { + let ty = get_cxx_scalar_type(*width); + self.append(&format!( + "pdl::packet::Builder::write_{}<{}, {}>(output, static_cast<{}>( {}));", + byteorder, + ty, + width / 8, + ty, + field_var.unwrap() + )); + } else { + self.append(&format!("{}.Serialize(output);", field_var.unwrap())); + } + } + ast::FieldDesc::Size { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let size_expr = self.get_payload_field_size(var, field_id, decl); + self.append(&format!( + "pdl::packet::Builder::write_{}<{}, {}>(output, static_cast<{}>( {}));", + byteorder, + ty, + width / 8, + ty, + size_expr + )); + } + ast::FieldDesc::Count { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let f = self + .scope + .iter_fields(decl) + .find(|f| f.id() == Some(field_id)) + .expect("Field not found"); + self.append(&format!("pdl::packet::Builder::write_{}<{}, {}>(output, static_cast<{}>( {}.size() ));", byteorder, ty, width / 8, ty, get_field_expr(f))); + } + ast::FieldDesc::ElementSize { width, .. } => { + let ty = get_cxx_scalar_type(*width); + self.append(&format!("pdl::packet::Builder::write_{}<{}, {}>(output, static_cast<{}>( 0 )); // TODO", byteorder, ty, width / 8, ty)); + } + ast::FieldDesc::FixedScalar { width, value } => { + let ty = get_cxx_scalar_type(*width); + self.append(&format!( + "pdl::packet::Builder::write_{}<{}, {}>(output, {:#x});", + byteorder, + ty, + width / 8, + value + )); + } + ast::FieldDesc::FixedEnum { enum_id, tag_id, .. } => { + let td = self.scope.typedef.get(enum_id).unwrap(); + if let ast::DeclDesc::Enum { width, .. } = &td.desc { + let ty = get_cxx_scalar_type(*width); + self.append(&format!("pdl::packet::Builder::write_{}<{}, {}>(output, static_cast<{}>( {}::{} ));", byteorder, ty, width / 8, ty, enum_id, tag_id)); + } + } + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { + self.append(&format!( + "output.insert(output.end(), {0}.begin(), {0}.end());", + deref(var, "payload_") + )); + } + _ => {} + } + } + } +} + +fn generate_packet_view( + scope: &analyzer::Scope, + schema: &analyzer::Schema, + decl: &ast::Decl, +) -> String { + let id = decl.id().unwrap(); + let parent_id = decl.parent_id(); + let parent_class = + parent_id.map(|p| format!("{}View", p)).unwrap_or_else(|| "pdl::packet::slice".to_string()); + let bytes_initializer = if parent_id.is_some() { "parent.bytes_" } else { "parent" }; + let endianness = scope.file.endianness.value; + let byteorder = match endianness { + ast::EndiannessValue::LittleEndian => "le", + ast::EndiannessValue::BigEndian => "be", + }; + + let mut is_cond_for = HashSet::new(); + for field in decl.fields() { + if let Some(cond) = &field.cond { + is_cond_for.insert(cond.id.clone()); + } + } + + let mut field_members = Vec::new(); + let mut field_accessors = Vec::new(); + let all_fields = + get_all_parent_fields(scope, decl).into_iter().chain(decl.fields()).collect::>(); + + let parent_constraints = + scope.iter_parents_and_self(decl).flat_map(|d| d.constraints()).collect::>(); + for field in &all_fields { + let fid = field.id(); + let constraint = fid.and_then(|fid| parent_constraints.iter().find(|c| c.id == fid)); + let is_constrained = constraint.is_some(); + + if is_constrained { + // Constrained fields still get accessors returning their constant values. + let fid = field.id().unwrap(); + let accessor_name = to_pascal_case(fid); + let constraint = constraint.unwrap(); + match &field.desc { + ast::FieldDesc::Typedef { type_id, .. } => { + let type_decl = scope.typedef.get(type_id).unwrap(); + if let ast::DeclDesc::Enum { .. } = &type_decl.desc { + field_accessors.push(format!( + " {} Get{}() const {{ return {}::{}; }}\n", + type_id, + accessor_name, + type_id, + constraint.tag_id.as_ref().unwrap() + )); + } else { + field_accessors.push(format!( + " {} Get{}() const {{ return {}; }}\n", + type_id, + accessor_name, + constraint.value.unwrap() + )); + } + } + ast::FieldDesc::Scalar { width, .. } => { + let ty = get_cxx_scalar_type(*width); + field_accessors.push(format!( + " {} Get{}() const {{ return {}; }}\n", + ty, + accessor_name, + constraint.value.unwrap() + )); + } + _ => {} + } + continue; + } + + if let Some(fid) = field.id() { + if is_cond_for.contains(fid) { + continue; + } + } + + match &field.desc { + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { + field_members.push("pdl::packet::slice payload_;".to_string()); + field_accessors.push(indent("std::vector GetPayload() const {\n _ASSERT_VALID(valid_);\n return payload_.bytes();\n}\n", 1)); + } + ast::FieldDesc::Array { id, type_id, width, size, .. } => { + field_members.push(format!("pdl::packet::slice {}_;", id)); + let accessor_name = to_pascal_case(id); + let element_type = type_id + .as_deref() + .map(|t| t.to_string()) + .unwrap_or_else(|| get_cxx_scalar_type(width.unwrap())); + let array_type = if let Some(s) = size { + format!("std::array<{}, {}>", element_type, s) + } else { + format!("std::vector<{}>", element_type) + }; + + let mut accessor_code = Vec::new(); + accessor_code.push(format!("pdl::packet::slice span = {}_;", id)); + if let Some(s) = size { + accessor_code.push(format!("{} elements;", array_type)); + accessor_code.push(format!("for (int n = 0; n < {}; n++) {{", s)); + if let Some(tid) = type_id { + let td = scope.typedef.get(tid).unwrap(); + match &td.desc { + ast::DeclDesc::Enum { width, .. } => { + let backing_type = get_cxx_scalar_type(*width); + accessor_code.push(format!( + " elements[n] = {}(span.read_{}<{}, {}>());", + tid, + byteorder, + backing_type, + width / 8 + )); + } + _ => { + accessor_code + .push(format!(" {}::Parse(span, &elements[n]);", tid)); + } + } + } else { + let element_width = width.unwrap(); + let backing_type = get_cxx_scalar_type(element_width); + accessor_code.push(format!( + " elements[n] = span.read_{}<{}, {}>();", + byteorder, + backing_type, + element_width / 8 + )); + } + accessor_code.push("}".to_string()); + } else { + accessor_code.push(format!("{} elements;", array_type)); + let mut count_limit = "span.size() > 0".to_string(); + for f in &all_fields { + if let ast::FieldDesc::Count { field_id, .. } = &f.desc { + if field_id == id { + count_limit = format!("elements.size() < {}_count_", id); + break; + } + } + } + + if let Some(tid) = type_id { + let td = scope.typedef.get(tid).unwrap(); + match &td.desc { + ast::DeclDesc::Enum { width, .. } => { + let backing_type = get_cxx_scalar_type(*width); + accessor_code.push(format!( + "while ({} && span.size() >= {}) {{", + count_limit, + width / 8 + )); + accessor_code.push(format!( + " elements.push_back({}(span.read_{}<{}, {}>()));", + tid, + byteorder, + backing_type, + width / 8 + )); + accessor_code.push("}".to_string()); + } + _ => { + accessor_code.push(format!("while ({}) {{", count_limit)); + accessor_code.push(format!(" {} element;", tid)); + accessor_code.push(format!( + " if (!{}::Parse(span, &element)) break;", + tid + )); + accessor_code.push( + " elements.emplace_back(std::move(element));".to_string(), + ); + accessor_code.push("}".to_string()); + } + } + } else { + let element_width = width.unwrap(); + let backing_type = get_cxx_scalar_type(element_width); + accessor_code.push(format!( + "while ({} && span.size() >= {}) {{", + count_limit, + element_width / 8 + )); + accessor_code.push(format!( + " elements.push_back(span.read_{}<{}, {}>());", + byteorder, + backing_type, + element_width / 8 + )); + accessor_code.push("}".to_string()); + } + } + accessor_code.push("return elements;".to_string()); + + field_accessors.push(format!( + " {} Get{}() const {{\n _ASSERT_VALID(valid_);\n{}\n }}\n", + array_type, + accessor_name, + indent(&accessor_code.join("\n"), 2) + )); + } + ast::FieldDesc::Scalar { id, width } => { + let ty = get_cxx_scalar_type(*width); + let accessor_name = to_pascal_case(id); + if field.cond.is_some() { + field_members.push(format!("std::optional<{}> {}_;", ty, id)); + field_accessors.push(format!(" std::optional<{}> Get{}() const {{ _ASSERT_VALID(valid_); return {}_; }}\n", ty, accessor_name, id)); + } else { + field_members.push(format!("{} {}_;", ty, id)); + field_accessors.push(format!( + " {} Get{}() const {{ _ASSERT_VALID(valid_); return {}_; }}\n", + ty, accessor_name, id + )); + } + } + ast::FieldDesc::Typedef { id, type_id, .. } => { + let ty = type_id; + let accessor_name = to_pascal_case(id); + if field.cond.is_some() { + field_members.push(format!("std::optional<{}> {}_;", ty, id)); + field_accessors.push(format!(" std::optional<{}> Get{}() const {{ _ASSERT_VALID(valid_); return {}_; }}\n", ty, accessor_name, id)); + } else { + let type_decl = scope.typedef.get(type_id).unwrap(); + if let ast::DeclDesc::Enum { tags, .. } = &type_decl.desc { + field_members.push(format!("{} {}_{{{}::{}}};", ty, id, ty, tags[0].id())); + field_accessors.push(format!( + " {} Get{}() const {{ _ASSERT_VALID(valid_); return {}_; }}\n", + ty, accessor_name, id + )); + } else { + field_members.push(format!("{} {}_;", ty, id)); + field_accessors.push(format!(" {} const& Get{}() const {{ _ASSERT_VALID(valid_); return {}_; }}\n", ty, accessor_name, id)); + } + } + } + ast::FieldDesc::Size { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + field_members.push(format!("{} {}_size_ {{0}};", ty, field_name)); + } + ast::FieldDesc::Count { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + field_members.push(format!("{} {}_count_ {{0}};", ty, field_id)); + } + ast::FieldDesc::ElementSize { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + field_members.push(format!("{} {}_element_size_ {{0}};", ty, field_name)); + } + _ => {} + } + } + + let mut field_parsers = Vec::new(); + if parent_id.is_some() { + field_parsers.push("// Check validity of parent packet.".to_string()); + field_parsers.push("if (!parent.IsValid()) { return false; }".to_string()); + let unconstrained_parent_fields = get_unconstrained_parent_fields(scope, decl); + if !unconstrained_parent_fields.is_empty() { + field_parsers.push("// Copy parent field values.".to_string()); + for f in unconstrained_parent_fields { + if let Some(id) = f.id() { + field_parsers.push(format!("{}_ = parent.{}_;", id, id)); + } + } + } + } + + if decl.fields().next().is_some() { + field_parsers.push("// Parse packet field values.".to_string()); + let span = if parent_id.is_some() { "parent.payload_" } else { "parent" }; + field_parsers.push(format!("pdl::packet::slice span = {};", span)); + + let mut parser = FieldParser::new(scope, schema, endianness, "", false, decl); + parser.is_cond_for = is_cond_for; + for f in decl.fields() { + parser.parse(f); + } + parser.done(); + field_parsers.extend(parser.code); + + let has_payload = decl + .fields() + .any(|f| matches!(f.desc, ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body)); + if !has_payload { + field_parsers.push("if (span.size() != 0) { return false; }".to_string()); + } + } + field_parsers.push("return true;".to_string()); + + let friend_classes = scope + .iter_children(decl) + .filter_map(|child| child.id().map(|id| format!("friend class {}View;", id))) + .collect::>(); + + format!( + r#" +class {id}View {{ +public: + static {id}View Create({parent_class} const& parent) {{ + return {id}View(parent); + }} + +{field_accessors} + std::string ToString() const {{ return ""; }} + + bool IsValid() const {{ + return valid_; + }} + + pdl::packet::slice bytes() const {{ + return bytes_; + }} + +protected: + explicit {id}View({parent_class} const& parent) + : bytes_({bytes_initializer}) {{ + valid_ = Parse(parent); + }} + + bool Parse({parent_class} const& parent) {{ +{field_parsers} + }} + + bool valid_{{false}}; + pdl::packet::slice bytes_; +{field_members} + +{friend_classes} +}}; +"#, + id = id, + parent_class = parent_class, + bytes_initializer = bytes_initializer, + field_parsers = indent(&field_parsers.join("\n"), 2), + field_members = indent(&field_members.join("\n"), 1), + field_accessors = field_accessors.join("\n"), + friend_classes = indent(&friend_classes.join("\n"), 1) + ) +} +fn generate_packet_builder( + scope: &analyzer::Scope, + schema: &analyzer::Schema, + decl: &ast::Decl, +) -> String { + let id = decl.id().unwrap(); + let class_name = format!("{}Builder", id); + let endianness = scope.file.endianness.value; + + let mut field_members = Vec::new(); + let mut constructor_params: Vec = Vec::new(); + let mut constructor_inits = Vec::new(); + + let parent_constraints = + scope.iter_parents_and_self(decl).flat_map(|d| d.constraints()).collect::>(); + let all_fields = + get_all_parent_fields(scope, decl).into_iter().chain(decl.fields()).collect::>(); + + for field in &all_fields { + let fid = field.id(); + let is_constrained = + fid.map(|fid| parent_constraints.iter().any(|c| c.id == fid)).unwrap_or(false); + if is_constrained { + continue; + } + + match &field.desc { + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { + field_members.push("std::vector payload_;".to_string()); + constructor_params.push("std::vector payload".to_string()); + constructor_inits.push("payload_(std::move(payload))".to_string()); + } + ast::FieldDesc::Array { id, width, type_id, size, .. } => { + let element_type = type_id + .as_deref() + .map(|t| t.to_string()) + .unwrap_or_else(|| get_cxx_scalar_type(width.unwrap())); + if let Some(s) = size { + field_members.push(format!("std::array<{}, {}> {}_;", element_type, s, id)); + constructor_params.push(format!("std::array<{}, {}> {}", element_type, s, id)); + } else { + field_members.push(format!("std::vector<{}> {}_;", element_type, id)); + constructor_params.push(format!("std::vector<{}> {}", element_type, id)); + } + constructor_inits.push(format!("{0}_(std::move({0}))", id)); + } + ast::FieldDesc::Scalar { id, width } => { + let ty = get_cxx_scalar_type(*width); + if field.cond.is_some() { + field_members.push(format!("std::optional<{}> {}_;", ty, id)); + constructor_params.push(format!("std::optional<{}> {}", ty, id)); + } else { + field_members.push(format!("{} {}_{{0}};", ty, id)); + constructor_params.push(format!("{} {}", ty, id)); + } + constructor_inits.push(format!("{0}_(std::move({0}))", id)); + } + ast::FieldDesc::Typedef { id, type_id, .. } => { + let ty = type_id; + if field.cond.is_some() { + field_members.push(format!("std::optional<{}> {}_;", ty, id)); + constructor_params.push(format!("std::optional<{}> {}", ty, id)); + } else { + let type_decl = scope.typedef.get(type_id).unwrap(); + if let ast::DeclDesc::Enum { tags, .. } = &type_decl.desc { + field_members.push(format!("{} {}_{{{}::{}}};", ty, id, ty, tags[0].id())); + } else { + field_members.push(format!("{} {}_;", ty, id)); + } + constructor_params.push(format!("{} {}", ty, id)); + } + constructor_inits.push(format!("{0}_(std::move({0}))", id)); + } + ast::FieldDesc::Size { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + field_members.push(format!("{} {}_size_ {{0}};", ty, field_name)); + } + ast::FieldDesc::Count { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + field_members.push(format!("{} {}_count_ {{0}};", ty, field_id)); + } + ast::FieldDesc::ElementSize { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + field_members.push(format!("{} {}_element_size_ {{0}};", ty, field_name)); + } + _ => {} + } + } + + let mut serializer = FieldSerializer::new(scope, schema, endianness); + for f in &all_fields { + serializer.serialize(f, decl, None); + } + let field_serializers = serializer.code; + + let mut variable_widths = Vec::new(); + let mut static_bits = 0; + + let get_field_expr = |f: &ast::Field| -> String { + if let Some(fid) = f.id() { + if let Some(constraint) = parent_constraints.iter().find(|c| c.id == fid) { + return format!("{:#x}", constraint.value.unwrap()); + } + } + match &f.desc { + ast::FieldDesc::Flag { optional_field_ids, .. } => { + let (opt_id, val_present) = &optional_field_ids[0]; + let val_absent = if *val_present == 0 { 1 } else { 0 }; + format!("({0}_.has_value() ? {1} : {2})", opt_id, val_present, val_absent) + } + _ => format!("{}_", f.id().unwrap()), + } + }; + + for f in &all_fields { + let field_size = schema.field_size(f.key); + match &f.desc { + ast::FieldDesc::Scalar { width, .. } => { + if let Some(cond) = &f.cond { + let cond_field = scope + .iter_fields(decl) + .find(|f| f.id() == Some(&cond.id)) + .expect("Cond field not found"); + let cond_field_var = get_field_expr(cond_field); + variable_widths.push(format!( + "(({} == {}) ? {} : 0)", + cond_field_var, + cond.value.unwrap(), + width / 8 + )); + } else { + static_bits += width; + } + } + ast::FieldDesc::Typedef { id: _, type_id, .. } => { + let type_decl = scope.typedef.get(type_id).unwrap(); + let width = match &type_decl.desc { + ast::DeclDesc::Enum { width, .. } => *width, + _ => 0, + }; + if let Some(cond) = &f.cond { + let cond_field = scope + .iter_fields(decl) + .find(|f| f.id() == Some(&cond.id)) + .expect("Cond field not found"); + let cond_field_var = get_field_expr(cond_field); + if width > 0 { + variable_widths.push(format!( + "(({} == {}) ? {} : 0)", + cond_field_var, + cond.value.unwrap(), + width / 8 + )); + } else { + variable_widths.push(format!( + "(({} == {}) ? {}_->GetSize() : 0)", + cond_field_var, + cond.value.unwrap(), + f.id().unwrap() + )); + } + } else if width > 0 { + static_bits += width; + } else { + variable_widths.push(format!("{}_.GetSize()", f.id().unwrap())); + } + } + ast::FieldDesc::Array { id, width, type_id, .. } => { + let padded_size = schema.padded_size(f.key); + let array_size = if let Some(w) = width { + format!("({0}_.size() * {1})", id, w / 8) + } else if let Some(tid) = type_id { + let td = scope.typedef.get(tid).unwrap(); + match &td.desc { + ast::DeclDesc::Enum { width, .. } => { + format!("({0}_.size() * {1})", id, width / 8) + } + _ => format!( + "std::accumulate({0}_.begin(), {0}_.end(), static_cast(0), [](size_t s, auto const& e) {{ return s + e.GetSize(); }})", + id + ), + } + } else { + format!( + "std::accumulate({0}_.begin(), {0}_.end(), static_cast(0), [](size_t s, auto const& e) {{ return s + e.GetSize(); }})", + id + ) + }; + + if let Some(ps) = padded_size { + variable_widths.push(format!("std::max({}, {})", array_size, ps / 8)); + } else { + variable_widths.push(array_size); + } + } + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { + variable_widths.push("payload_.size()".to_string()); + } + _ => { + if let analyzer::Size::Static(bits) = field_size { + static_bits += bits; + } + } + } + } + + let size_expr = if variable_widths.is_empty() { + format!("return {};", static_bits / 8) + } else if static_bits > 0 { + format!("return {} + ({});", static_bits / 8, variable_widths.join(" + ")) + } else { + format!("return {};", variable_widths.join(" + ")) + }; + + let constructor = if constructor_params.is_empty() { + format!(" {0}() = default;", class_name) + } else { + format!( + " {0}() = default;\n explicit {0}({1}) : {2} {{}}", + class_name, + constructor_params.join(", "), + constructor_inits.join(", ") + ) + }; + + format!( + r#" +class {class_name} : public pdl::packet::Builder {{ +public: + ~{class_name}() override = default; +{constructor} + {class_name}({class_name} const&) = default; + {class_name}({class_name}&&) = default; + {class_name}& operator=({class_name} const&) = default; + + void Serialize(std::vector& output) const override {{ +{field_serializers} + }} + + size_t GetSize() const override {{ + {size_expr} + }} + + std::string ToString() const {{ return ""; }} + +{field_members} +}}; +"#, + class_name = class_name, + constructor = constructor, + field_serializers = indent(&field_serializers.join("\n"), 2), + size_expr = size_expr, + field_members = indent(&field_members.join("\n"), 1) + ) +} +fn generate_struct_declaration( + scope: &analyzer::Scope, + schema: &analyzer::Schema, + decl: &ast::Decl, +) -> String { + let id = decl.id().unwrap(); + let mut field_members = Vec::new(); + let mut constructor_params: Vec = Vec::new(); + let mut constructor_inits = Vec::new(); + let endianness = scope.file.endianness.value; + + for field in decl.fields() { + match &field.desc { + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { + field_members.push("std::vector payload_;".to_string()); + constructor_params.push("std::vector payload".to_string()); + constructor_inits.push("payload_(std::move(payload))".to_string()); + } + ast::FieldDesc::Array { id, width, type_id, size, .. } => { + let element_type = type_id + .as_deref() + .map(|t| t.to_string()) + .unwrap_or_else(|| get_cxx_scalar_type(width.unwrap())); + if let Some(s) = size { + field_members.push(format!("std::array<{}, {}> {}_;", element_type, s, id)); + constructor_params.push(format!("std::array<{}, {}> {}", element_type, s, id)); + } else { + field_members.push(format!("std::vector<{}> {}_;", element_type, id)); + constructor_params.push(format!("std::vector<{}> {}", element_type, id)); + } + constructor_inits.push(format!("{0}_(std::move({0}))", id)); + } + ast::FieldDesc::Scalar { id, width } => { + let ty = get_cxx_scalar_type(*width); + if field.cond.is_some() { + field_members.push(format!("std::optional<{}> {}_;", ty, id)); + constructor_params.push(format!("std::optional<{}> {}", ty, id)); + } else { + field_members.push(format!("{} {}_{{0}};", ty, id)); + constructor_params.push(format!("{} {}", ty, id)); + } + constructor_inits.push(format!("{0}_(std::move({0}))", id)); + } + ast::FieldDesc::Typedef { id, type_id, .. } => { + let ty = type_id; + if field.cond.is_some() { + field_members.push(format!("std::optional<{}> {}_;", ty, id)); + constructor_params.push(format!("std::optional<{}> {}", ty, id)); + } else { + let type_decl = scope.typedef.get(type_id).unwrap(); + if let ast::DeclDesc::Enum { tags, .. } = &type_decl.desc { + field_members.push(format!("{} {}_{{{}::{}}};", ty, id, ty, tags[0].id())); + } else { + field_members.push(format!("{} {}_;", ty, id)); + } + constructor_params.push(format!("{} {}", ty, id)); + } + constructor_inits.push(format!("{0}_(std::move({0}))", id)); + } + ast::FieldDesc::Size { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + field_members.push(format!("{} {}_size_ {{0}};", ty, field_name)); + } + ast::FieldDesc::Count { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + field_members.push(format!("{} {}_count_ {{0}};", ty, field_id)); + } + ast::FieldDesc::ElementSize { field_id, width, .. } => { + let ty = get_cxx_scalar_type(*width); + let field_name = if field_id == "_payload_" || field_id == "_body_" { + "payload" + } else { + field_id + }; + field_members.push(format!("{} {}_element_size_ {{0}};", ty, field_name)); + } + _ => {} + } + } + + let mut field_parsers = Vec::new(); + field_parsers.push("pdl::packet::slice span = parent_span;".to_string()); + + let mut parser = FieldParser::new(scope, schema, endianness, "output->", true, decl); + for f in decl.fields() { + parser.parse(f); + } + parser.done(); + field_parsers.extend(parser.code); + field_parsers.push("parent_span = span;".to_string()); + field_parsers.push("return true;".to_string()); + + let mut serializer = FieldSerializer::new(scope, schema, endianness); + for f in decl.fields() { + serializer.serialize(f, decl, None); + } + let field_serializers = serializer.code; + + let mut variable_widths = Vec::new(); + let mut static_bits = 0; + + let get_field_expr = |f: &ast::Field| -> String { + match &f.desc { + ast::FieldDesc::Flag { optional_field_ids, .. } => { + let (opt_id, val_present) = &optional_field_ids[0]; + let val_absent = if *val_present == 0 { 1 } else { 0 }; + format!("({0}_.has_value() ? {1} : {2})", opt_id, val_present, val_absent) + } + _ => format!("{}_", f.id().unwrap()), + } + }; + + for f in decl.fields() { + let field_size = schema.field_size(f.key); + match &f.desc { + ast::FieldDesc::Scalar { width, .. } => { + if let Some(cond) = &f.cond { + let cond_field = scope + .iter_fields(decl) + .find(|f| f.id() == Some(&cond.id)) + .expect("Cond field not found"); + let cond_field_var = get_field_expr(cond_field); + variable_widths.push(format!( + "(({} == {}) ? {} : 0)", + cond_field_var, + cond.value.unwrap(), + width / 8 + )); + } else { + static_bits += width; + } + } + ast::FieldDesc::Typedef { id: _, type_id, .. } => { + let type_decl = scope.typedef.get(type_id).unwrap(); + let width = match &type_decl.desc { + ast::DeclDesc::Enum { width, .. } => *width, + _ => 0, + }; + if let Some(cond) = &f.cond { + let cond_field = scope + .iter_fields(decl) + .find(|f| f.id() == Some(&cond.id)) + .expect("Cond field not found"); + let cond_field_var = get_field_expr(cond_field); + if width > 0 { + variable_widths.push(format!( + "(({} == {}) ? {} : 0)", + cond_field_var, + cond.value.unwrap(), + width / 8 + )); + } else { + variable_widths.push(format!( + "(({} == {}) ? {}_->GetSize() : 0)", + cond_field_var, + cond.value.unwrap(), + f.id().unwrap() + )); + } + } else if width > 0 { + static_bits += width; + } else { + variable_widths.push(format!("{}_.GetSize()", f.id().unwrap())); + } + } + ast::FieldDesc::Array { id, width, type_id, .. } => { + let padded_size = schema.padded_size(f.key); + let array_size = if let Some(w) = width { + format!("({0}_.size() * {1})", id, w / 8) + } else if let Some(tid) = type_id { + let td = scope.typedef.get(tid).unwrap(); + match &td.desc { + ast::DeclDesc::Enum { width, .. } => { + format!("({0}_.size() * {1})", id, width / 8) + } + _ => format!( + "std::accumulate({0}_.begin(), {0}_.end(), static_cast(0), [](size_t s, auto const& e) {{ return s + e.GetSize(); }})", + id + ), + } + } else { + format!( + "std::accumulate({0}_.begin(), {0}_.end(), static_cast(0), [](size_t s, auto const& e) {{ return s + e.GetSize(); }})", + id + ) + }; + + if let Some(ps) = padded_size { + variable_widths.push(format!("std::max({}, {})", array_size, ps / 8)); + } else { + variable_widths.push(array_size); + } + } + ast::FieldDesc::Payload { .. } | ast::FieldDesc::Body => { + variable_widths.push("payload_.size()".to_string()); + } + _ => { + if let analyzer::Size::Static(bits) = field_size { + static_bits += bits; + } + } + } + } + + let size_expr = if variable_widths.is_empty() { + format!("return {};", static_bits / 8) + } else if static_bits > 0 { + format!("return {} + ({});", static_bits / 8, variable_widths.join(" + ")) + } else { + format!("return {};", variable_widths.join(" + ")) + }; + + let constructor = if constructor_params.is_empty() { + format!(" {0}() = default;", id) + } else { + format!( + " {0}() = default;\n explicit {0}({1}) : {2} {{}}", + id, + constructor_params.join(", "), + constructor_inits.join(", ") + ) + }; + + format!( + r#" +class {id} : public pdl::packet::Builder {{ +public: + ~{id}() override = default; +{constructor} + {id}({id} const&) = default; + {id}({id}&&) = default; + {id}& operator=({id} const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, {id}* output) {{ +{struct_parse_code} + }} + + void Serialize(std::vector& output) const override {{ +{field_serializers} + }} + + size_t GetSize() const override {{ + {size_expr} + }} + + std::string ToString() const {{ return ""; }} + +{field_members} +}}; +"#, + id = id, + constructor = constructor, + struct_parse_code = indent(&field_parsers.join("\n"), 2), + field_serializers = indent(&field_serializers.join("\n"), 2), + size_expr = size_expr, + field_members = indent(&field_members.join("\n"), 1) + ) +} + +#[cfg(test)] +mod test { + use super::*; + use crate::test_utils::assert_snapshot_eq; + use crate::{analyzer, ast, parser}; + + #[test] + fn test_canonical() { + let mut db = ast::SourceDatabase::new(); + let input_file = "tests/canonical/le_test_file.pdl"; + let file = parser::parse_file(&mut db, input_file).unwrap(); + let file = analyzer::analyze(&file).unwrap(); + let actual_code = generate( + &db, + &file, + Some("le_backend"), + &[], + &[], + &[ + "Packet_Custom_Field_ConstantSize".to_string(), + "Packet_Custom_Field_VariableSize".to_string(), + "Packet_Checksum_Field_FromStart".to_string(), + "Packet_Checksum_Field_FromEnd".to_string(), + "Packet_Array_Field_VariableElementSize_ConstantSize".to_string(), + "Packet_Array_Field_VariableElementSize_VariableSize".to_string(), + "Packet_Array_Field_VariableElementSize_VariableCount".to_string(), + "Packet_Array_Field_VariableElementSize_UnknownSize".to_string(), + "Struct_Custom_Field_ConstantSize".to_string(), + "Struct_Custom_Field_VariableSize".to_string(), + "Struct_Checksum_Field_FromStart".to_string(), + "Struct_Checksum_Field_FromEnd".to_string(), + "Struct_Custom_Field_ConstantSize_".to_string(), + "Struct_Custom_Field_VariableSize_".to_string(), + "Struct_Checksum_Field_FromStart_".to_string(), + "Struct_Checksum_Field_FromEnd_".to_string(), + "PartialParent5".to_string(), + "PartialChild5_A".to_string(), + "PartialChild5_B".to_string(), + "PartialParent12".to_string(), + "PartialChild12_A".to_string(), + "PartialChild12_B".to_string(), + ], + ); + assert_snapshot_eq("tests/generated/cxx/le_backend.h", &actual_code); + } +} diff --git a/pdl-compiler/src/main.rs b/pdl-compiler/src/main.rs index 968b531..7d588da 100644 --- a/pdl-compiler/src/main.rs +++ b/pdl-compiler/src/main.rs @@ -22,6 +22,7 @@ use pdl_compiler::{analyzer, ast, backends, parser}; #[allow(clippy::upper_case_acronyms)] #[derive(Copy, Clone, Debug, Eq, PartialEq)] enum OutputFormat { + Cxx, Java, JSON, Python, @@ -33,6 +34,7 @@ impl std::str::FromStr for OutputFormat { fn from_str(input: &str) -> Result { match input.to_lowercase().as_str() { + "cxx" => Ok(Self::Cxx), "json" => Ok(Self::JSON), "python" => Ok(Self::Python), "rust" => Ok(Self::Rust), @@ -41,7 +43,7 @@ impl std::str::FromStr for OutputFormat { Err("'rust_legacy' is now deprecated. Use 'rust' format instead.".to_string()) } _ => Err(format!( - "could not parse {input:?}, valid option are 'json', 'python', 'rust'." + "could not parse {input:?}, valid option are 'cxx', 'json', 'python', 'rust'." )), } } @@ -98,6 +100,18 @@ struct Opt { #[argh(option)] /// java package to contain the generated classes. java_package: Option, + + #[argh(option)] + /// generated module namespace. Valid for the output format "cxx". + namespace: Option, + + #[argh(option)] + /// added include directives. Valid for the output format "cxx". + include_header: Vec, + + #[argh(option)] + /// added using namespace statements. Valid for the output format "cxx". + using_namespace: Vec, } /// Remove declarations listed in the input filter. @@ -151,6 +165,20 @@ fn generate_backend(opt: &Opt, input_file: &str) -> Result<(), String> { println!("{}", backends::json::generate(&file).unwrap()); Ok(()) } + OutputFormat::Cxx => { + println!( + "{}", + backends::cxx::generate( + &sources, + &analyzed_file, + opt.namespace.as_deref(), + &opt.include_header, + &opt.using_namespace, + &opt.exclude_declaration, + ) + ); + Ok(()) + } OutputFormat::Python => { println!( "{}", diff --git a/pdl-compiler/tests/generated/cxx/le_backend.h b/pdl-compiler/tests/generated/cxx/le_backend.h new file mode 100644 index 0000000..aa586be --- /dev/null +++ b/pdl-compiler/tests/generated/cxx/le_backend.h @@ -0,0 +1,8426 @@ +// File generated from tests/canonical/le_test_file.pdl, with the command: +// pdlc ... +// /!\ Do not edit by hand + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifndef _ASSERT_VALID +#ifdef ASSERT +#define _ASSERT_VALID ASSERT +#else +#include +#define _ASSERT_VALID assert +#endif // ASSERT +#endif // !_ASSERT_VALID + +namespace le_backend { +class ScalarParentView; +class EnumParentView; +class EmptyParentView; +class Packet_Scalar_FieldView; +class Packet_Enum_FieldView; +class Packet_Reserved_FieldView; +class Packet_Size_FieldView; +class Packet_Count_FieldView; +class Packet_FixedScalar_FieldView; +class Packet_FixedEnum_FieldView; +class Packet_Payload_Field_VariableSizeView; +class Packet_Payload_Field_SizeModifierView; +class Packet_Payload_Field_UnknownSizeView; +class Packet_Payload_Field_UnknownSize_TerminalView; +class Packet_Body_Field_VariableSizeView; +class Packet_Body_Field_UnknownSizeView; +class Packet_Body_Field_UnknownSize_TerminalView; +class Packet_ScalarGroup_FieldView; +class Packet_EnumGroup_FieldView; +class Packet_Struct_FieldView; +class Packet_Array_Field_ByteElement_ConstantSizeView; +class Packet_Array_Field_ByteElement_VariableSizeView; +class Packet_Array_Field_ByteElement_VariableCountView; +class Packet_Array_Field_ByteElement_UnknownSizeView; +class Packet_Array_Field_ScalarElement_ConstantSizeView; +class Packet_Array_Field_ScalarElement_VariableSizeView; +class Packet_Array_Field_ScalarElement_VariableCountView; +class Packet_Array_Field_ScalarElement_UnknownSizeView; +class Packet_Array_Field_EnumElement_ConstantSizeView; +class Packet_Array_Field_EnumElement_VariableSizeView; +class Packet_Array_Field_EnumElement_VariableCountView; +class Packet_Array_Field_EnumElement_UnknownSizeView; +class Packet_Array_Field_SizedElement_ConstantSizeView; +class Packet_Array_Field_SizedElement_VariableSizeView; +class Packet_Array_Field_SizedElement_VariableCountView; +class Packet_Array_Field_SizedElement_UnknownSizeView; +class Packet_Array_Field_UnsizedElement_ConstantSizeView; +class Packet_Array_Field_UnsizedElement_VariableSizeView; +class Packet_Array_Field_UnsizedElement_VariableCountView; +class Packet_Array_Field_UnsizedElement_UnknownSizeView; +class Packet_Array_Field_UnsizedElement_SizeModifierView; +class Packet_Array_Field_SizedElement_VariableSize_PaddedView; +class Packet_Array_Field_UnsizedElement_VariableCount_PaddedView; +class Packet_Optional_Scalar_FieldView; +class Packet_Optional_Enum_FieldView; +class Packet_Optional_Struct_FieldView; +class ScalarChild_AView; +class ScalarChild_BView; +class EnumChild_AView; +class EnumChild_BView; +class AliasedChild_AView; +class AliasedChild_BView; +class Struct_Enum_FieldView; +class Struct_Reserved_FieldView; +class Struct_Size_FieldView; +class Struct_Count_FieldView; +class Struct_FixedScalar_FieldView; +class Struct_FixedEnum_FieldView; +class Struct_ScalarGroup_FieldView; +class Struct_EnumGroup_FieldView; +class Struct_Struct_FieldView; +class Struct_Array_Field_ByteElement_ConstantSizeView; +class Struct_Array_Field_ByteElement_VariableSizeView; +class Struct_Array_Field_ByteElement_VariableCountView; +class Struct_Array_Field_ByteElement_UnknownSizeView; +class Struct_Array_Field_ScalarElement_ConstantSizeView; +class Struct_Array_Field_ScalarElement_VariableSizeView; +class Struct_Array_Field_ScalarElement_VariableCountView; +class Struct_Array_Field_ScalarElement_UnknownSizeView; +class Struct_Array_Field_EnumElement_ConstantSizeView; +class Struct_Array_Field_EnumElement_VariableSizeView; +class Struct_Array_Field_EnumElement_VariableCountView; +class Struct_Array_Field_EnumElement_UnknownSizeView; +class Struct_Array_Field_SizedElement_ConstantSizeView; +class Struct_Array_Field_SizedElement_VariableSizeView; +class Struct_Array_Field_SizedElement_VariableCountView; +class Struct_Array_Field_SizedElement_UnknownSizeView; +class Struct_Array_Field_UnsizedElement_ConstantSizeView; +class Struct_Array_Field_UnsizedElement_VariableSizeView; +class Struct_Array_Field_UnsizedElement_VariableCountView; +class Struct_Array_Field_UnsizedElement_UnknownSizeView; +class Struct_Array_Field_UnsizedElement_SizeModifierView; +class Struct_Array_Field_SizedElement_VariableSize_PaddedView; +class Struct_Array_Field_UnsizedElement_VariableCount_PaddedView; +class Struct_Optional_Scalar_FieldView; +class Struct_Optional_Enum_FieldView; +class Struct_Optional_Struct_FieldView; +class Enum_Incomplete_Truncated_ClosedView; +class Enum_Incomplete_Truncated_OpenView; +class Enum_Incomplete_Truncated_Closed_WithRangeView; +class Enum_Incomplete_Truncated_Open_WithRangeView; +class Enum_Complete_TruncatedView; +class Enum_Complete_Truncated_WithRangeView; +class Enum_Complete_WithRangeView; + +enum class Enum7 : uint8_t { + A = 0x1, + B = 0x2, +}; + +inline std::string Enum7Text(Enum7 tag) { + switch (tag) { + case Enum7::A: return "A"; + case Enum7::B: return "B"; + default: + return std::string("Unknown Enum7: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum7Valid(Enum7 tag) { + return tag == Enum7::A || tag == Enum7::B; +} + +enum class Enum16 : uint16_t { + A = 0xaabb, + B = 0xccdd, +}; + +inline std::string Enum16Text(Enum16 tag) { + switch (tag) { + case Enum16::A: return "A"; + case Enum16::B: return "B"; + default: + return std::string("Unknown Enum16: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum16Valid(Enum16 tag) { + return tag == Enum16::A || tag == Enum16::B; +} + +class SizedStruct : public pdl::packet::Builder { +public: + ~SizedStruct() override = default; + SizedStruct() = default; + explicit SizedStruct(uint8_t a) : a_(std::move(a)) {} + SizedStruct(SizedStruct const&) = default; + SizedStruct(SizedStruct&&) = default; + SizedStruct& operator=(SizedStruct const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, SizedStruct* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + output->a_ = span.read_le(); + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0xff))); + } + + size_t GetSize() const override { + return 1; + } + + std::string ToString() const { return ""; } + + uint8_t a_{0}; +}; + +class UnsizedStruct : public pdl::packet::Builder { +public: + ~UnsizedStruct() override = default; + UnsizedStruct() = default; + explicit UnsizedStruct(std::vector array) : array_(std::move(array)) {} + UnsizedStruct(UnsizedStruct const&) = default; + UnsizedStruct(UnsizedStruct&&) = default; + UnsizedStruct& operator=(UnsizedStruct const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, UnsizedStruct* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_size_ = (chunk0 >> 0) & 0x3; + if (span.size() < output->array_size_) return false; + if ((output->array_size_ % 1) != 0) return false; + size_t limit = span.size() - output->array_size_; + while (span.size() > limit) { + if (span.size() < 1) return false; + output->array_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 1); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class UnknownSizeStruct : public pdl::packet::Builder { +public: + ~UnknownSizeStruct() override = default; + UnknownSizeStruct() = default; + explicit UnknownSizeStruct(std::vector array) : array_(std::move(array)) {} + UnknownSizeStruct(UnknownSizeStruct const&) = default; + UnknownSizeStruct(UnknownSizeStruct&&) = default; + UnknownSizeStruct& operator=(UnknownSizeStruct const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, UnknownSizeStruct* output) { + pdl::packet::slice span = parent_span; + while (span.size() > 0) { + if (span.size() < 1) return false; + output->array_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 1); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class ScalarParentView { +public: + static ScalarParentView Create(pdl::packet::slice const& parent) { + return ScalarParentView(parent); + } + + uint8_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit ScalarParentView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) { + return false; + } + a_ = span.read_le(); + payload_size_ = span.read_le(); + if (span.size() < payload_size_) return false; + payload_ = span.subrange(0, payload_size_); + span.skip(payload_size_); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t a_; + uint8_t payload_size_ {0}; + pdl::packet::slice payload_; + + friend class EmptyParentView; + friend class ScalarChild_AView; + friend class ScalarChild_BView; +}; + +class ScalarParentBuilder : public pdl::packet::Builder { +public: + ~ScalarParentBuilder() override = default; + ScalarParentBuilder() = default; + explicit ScalarParentBuilder(uint8_t a, std::vector payload) : a_(std::move(a)), payload_(std::move(payload)) {} + ScalarParentBuilder(ScalarParentBuilder const&) = default; + ScalarParentBuilder(ScalarParentBuilder&&) = default; + ScalarParentBuilder& operator=(ScalarParentBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0xff))); + size_t payload_size = payload_.size(); + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + output.insert(output.end(), payload_.begin(), payload_.end()); + } + + size_t GetSize() const override { + return 2 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + uint8_t a_{0}; + uint8_t payload_size_ {0}; + std::vector payload_; +}; + +class EnumParentView { +public: + static EnumParentView Create(pdl::packet::slice const& parent) { + return EnumParentView(parent); + } + + Enum16 GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit EnumParentView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 3) { + return false; + } + a_ = static_cast( span.read_le() ); + if (!IsEnum16Valid(a_)) return false; + payload_size_ = span.read_le(); + if (span.size() < payload_size_) return false; + payload_ = span.subrange(0, payload_size_); + span.skip(payload_size_); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum16 a_{Enum16::A}; + uint8_t payload_size_ {0}; + pdl::packet::slice payload_; + + friend class EnumChild_AView; + friend class EnumChild_BView; +}; + +class EnumParentBuilder : public pdl::packet::Builder { +public: + ~EnumParentBuilder() override = default; + EnumParentBuilder() = default; + explicit EnumParentBuilder(Enum16 a, std::vector payload) : a_(std::move(a)), payload_(std::move(payload)) {} + EnumParentBuilder(EnumParentBuilder const&) = default; + EnumParentBuilder(EnumParentBuilder&&) = default; + EnumParentBuilder& operator=(EnumParentBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(a_)))); + size_t payload_size = payload_.size(); + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + output.insert(output.end(), payload_.begin(), payload_.end()); + } + + size_t GetSize() const override { + return 3 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + Enum16 a_{Enum16::A}; + uint8_t payload_size_ {0}; + std::vector payload_; +}; + +class EmptyParentView { +public: + static EmptyParentView Create(ScalarParentView const& parent) { + return EmptyParentView(parent); + } + + uint8_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit EmptyParentView(ScalarParentView const& parent) + : bytes_(parent.bytes_) { + valid_ = Parse(parent); + } + + bool Parse(ScalarParentView const& parent) { + // Check validity of parent packet. + if (!parent.IsValid()) { return false; } + // Copy parent field values. + a_ = parent.a_; + // Parse packet field values. + pdl::packet::slice span = parent.payload_; + payload_ = span; + span.clear(); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t a_; + uint8_t payload_size_ {0}; + pdl::packet::slice payload_; + + friend class AliasedChild_AView; + friend class AliasedChild_BView; +}; + +class EmptyParentBuilder : public pdl::packet::Builder { +public: + ~EmptyParentBuilder() override = default; + EmptyParentBuilder() = default; + explicit EmptyParentBuilder(uint8_t a, std::vector payload) : a_(std::move(a)), payload_(std::move(payload)) {} + EmptyParentBuilder(EmptyParentBuilder const&) = default; + EmptyParentBuilder(EmptyParentBuilder&&) = default; + EmptyParentBuilder& operator=(EmptyParentBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0xff))); + size_t payload_size = payload_.size(); + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + output.insert(output.end(), payload_.begin(), payload_.end()); + } + + size_t GetSize() const override { + return 2 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + uint8_t a_{0}; + uint8_t payload_size_ {0}; + std::vector payload_; +}; + +class Packet_Scalar_FieldView { +public: + static Packet_Scalar_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Scalar_FieldView(parent); + } + + uint8_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + uint64_t GetC() const { _ASSERT_VALID(valid_); return c_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Scalar_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + a_ = (chunk0 >> 0) & 0x7f; + c_ = (chunk0 >> 7) & 0x1ffffffffffffff; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t a_; + uint64_t c_; + + +}; + +class Packet_Scalar_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Scalar_FieldBuilder() override = default; + Packet_Scalar_FieldBuilder() = default; + explicit Packet_Scalar_FieldBuilder(uint8_t a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} + Packet_Scalar_FieldBuilder(Packet_Scalar_FieldBuilder const&) = default; + Packet_Scalar_FieldBuilder(Packet_Scalar_FieldBuilder&&) = default; + Packet_Scalar_FieldBuilder& operator=(Packet_Scalar_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0x7f)) | (static_cast(c_ & 0x1ffffffffffffff) << 7)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + uint8_t a_{0}; + uint64_t c_{0}; +}; + +class Packet_Enum_FieldView { +public: + static Packet_Enum_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Enum_FieldView(parent); + } + + Enum7 GetA() const { _ASSERT_VALID(valid_); return a_; } + + uint64_t GetC() const { _ASSERT_VALID(valid_); return c_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Enum_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + a_ = static_cast( (chunk0 >> 0) & 0x7f ); + if (!IsEnum7Valid(a_)) return false; + c_ = (chunk0 >> 7) & 0x1ffffffffffffff; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum7 a_{Enum7::A}; + uint64_t c_; + + +}; + +class Packet_Enum_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Enum_FieldBuilder() override = default; + Packet_Enum_FieldBuilder() = default; + explicit Packet_Enum_FieldBuilder(Enum7 a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} + Packet_Enum_FieldBuilder(Packet_Enum_FieldBuilder const&) = default; + Packet_Enum_FieldBuilder(Packet_Enum_FieldBuilder&&) = default; + Packet_Enum_FieldBuilder& operator=(Packet_Enum_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(a_))) | (static_cast(c_ & 0x1ffffffffffffff) << 7)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + Enum7 a_{Enum7::A}; + uint64_t c_{0}; +}; + +class Packet_Reserved_FieldView { +public: + static Packet_Reserved_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Reserved_FieldView(parent); + } + + uint8_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + uint64_t GetC() const { _ASSERT_VALID(valid_); return c_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Reserved_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + a_ = (chunk0 >> 0) & 0x7f; + c_ = (chunk0 >> 9) & 0x7fffffffffffff; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t a_; + uint64_t c_; + + +}; + +class Packet_Reserved_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Reserved_FieldBuilder() override = default; + Packet_Reserved_FieldBuilder() = default; + explicit Packet_Reserved_FieldBuilder(uint8_t a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} + Packet_Reserved_FieldBuilder(Packet_Reserved_FieldBuilder const&) = default; + Packet_Reserved_FieldBuilder(Packet_Reserved_FieldBuilder&&) = default; + Packet_Reserved_FieldBuilder& operator=(Packet_Reserved_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0x7f)) | (static_cast(c_ & 0x7fffffffffffff) << 9)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + uint8_t a_{0}; + uint64_t c_{0}; +}; + +class Packet_Size_FieldView { +public: + static Packet_Size_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Size_FieldView(parent); + } + + uint64_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::vector GetB() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = b_; + std::vector elements; + while (span.size() > 0 && span.size() >= 1) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Size_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + b_size_ = (chunk0 >> 0) & 0x7; + a_ = (chunk0 >> 3) & 0x1fffffffffffffff; + if (span.size() < b_size_) return false; + if ((b_size_ % 1) != 0) return false; + b_ = span.subrange(0, b_size_); + span.skip(b_size_); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t b_size_ {0}; + uint64_t a_; + pdl::packet::slice b_; + + +}; + +class Packet_Size_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Size_FieldBuilder() override = default; + Packet_Size_FieldBuilder() = default; + explicit Packet_Size_FieldBuilder(uint64_t a, std::vector b) : a_(std::move(a)), b_(std::move(b)) {} + Packet_Size_FieldBuilder(Packet_Size_FieldBuilder const&) = default; + Packet_Size_FieldBuilder(Packet_Size_FieldBuilder&&) = default; + Packet_Size_FieldBuilder& operator=(Packet_Size_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t b_size = (b_.size() * 1); + pdl::packet::Builder::write_le(output, (static_cast(b_size)) | (static_cast(a_ & 0x1fffffffffffffff) << 3)); + for (auto const& element : b_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 8 + ((b_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t b_size_ {0}; + uint64_t a_{0}; + std::vector b_; +}; + +class Packet_Count_FieldView { +public: + static Packet_Count_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Count_FieldView(parent); + } + + uint64_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::vector GetB() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = b_; + std::vector elements; + while (elements.size() < b_count_ && span.size() >= 1) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Count_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + b_count_ = (chunk0 >> 0) & 0x7; + a_ = (chunk0 >> 3) & 0x1fffffffffffffff; + if (span.size() < b_count_ * 1) return false; + b_ = span.subrange(0, b_count_ * 1); + span.skip(b_count_ * 1); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t b_count_ {0}; + uint64_t a_; + pdl::packet::slice b_; + + +}; + +class Packet_Count_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Count_FieldBuilder() override = default; + Packet_Count_FieldBuilder() = default; + explicit Packet_Count_FieldBuilder(uint64_t a, std::vector b) : a_(std::move(a)), b_(std::move(b)) {} + Packet_Count_FieldBuilder(Packet_Count_FieldBuilder const&) = default; + Packet_Count_FieldBuilder(Packet_Count_FieldBuilder&&) = default; + Packet_Count_FieldBuilder& operator=(Packet_Count_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(b_.size())) | (static_cast(a_ & 0x1fffffffffffffff) << 3)); + for (auto const& element : b_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 8 + ((b_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t b_count_ {0}; + uint64_t a_{0}; + std::vector b_; +}; + +class Packet_FixedScalar_FieldView { +public: + static Packet_FixedScalar_FieldView Create(pdl::packet::slice const& parent) { + return Packet_FixedScalar_FieldView(parent); + } + + uint64_t GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_FixedScalar_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + if (static_cast((chunk0 >> 0) & 0x7f) != 0x7) { + return false; + } + b_ = (chunk0 >> 7) & 0x1ffffffffffffff; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint64_t b_; + + +}; + +class Packet_FixedScalar_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_FixedScalar_FieldBuilder() override = default; + Packet_FixedScalar_FieldBuilder() = default; + explicit Packet_FixedScalar_FieldBuilder(uint64_t b) : b_(std::move(b)) {} + Packet_FixedScalar_FieldBuilder(Packet_FixedScalar_FieldBuilder const&) = default; + Packet_FixedScalar_FieldBuilder(Packet_FixedScalar_FieldBuilder&&) = default; + Packet_FixedScalar_FieldBuilder& operator=(Packet_FixedScalar_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(0x7)) | (static_cast(b_ & 0x1ffffffffffffff) << 7)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + uint64_t b_{0}; +}; + +class Packet_FixedEnum_FieldView { +public: + static Packet_FixedEnum_FieldView Create(pdl::packet::slice const& parent) { + return Packet_FixedEnum_FieldView(parent); + } + + uint64_t GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_FixedEnum_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + if (Enum7((chunk0 >> 0) & 0x7f) != Enum7::A) { + return false; + } + b_ = (chunk0 >> 7) & 0x1ffffffffffffff; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint64_t b_; + + +}; + +class Packet_FixedEnum_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_FixedEnum_FieldBuilder() override = default; + Packet_FixedEnum_FieldBuilder() = default; + explicit Packet_FixedEnum_FieldBuilder(uint64_t b) : b_(std::move(b)) {} + Packet_FixedEnum_FieldBuilder(Packet_FixedEnum_FieldBuilder const&) = default; + Packet_FixedEnum_FieldBuilder(Packet_FixedEnum_FieldBuilder&&) = default; + Packet_FixedEnum_FieldBuilder& operator=(Packet_FixedEnum_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(Enum7::A)) | (static_cast(b_ & 0x1ffffffffffffff) << 7)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + uint64_t b_{0}; +}; + +class Packet_Payload_Field_VariableSizeView { +public: + static Packet_Payload_Field_VariableSizeView Create(pdl::packet::slice const& parent) { + return Packet_Payload_Field_VariableSizeView(parent); + } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Payload_Field_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + payload_size_ = (chunk0 >> 0) & 0x7; + if (span.size() < payload_size_) return false; + payload_ = span.subrange(0, payload_size_); + span.skip(payload_size_); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + pdl::packet::slice payload_; + + +}; + +class Packet_Payload_Field_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Payload_Field_VariableSizeBuilder() override = default; + Packet_Payload_Field_VariableSizeBuilder() = default; + explicit Packet_Payload_Field_VariableSizeBuilder(std::vector payload) : payload_(std::move(payload)) {} + Packet_Payload_Field_VariableSizeBuilder(Packet_Payload_Field_VariableSizeBuilder const&) = default; + Packet_Payload_Field_VariableSizeBuilder(Packet_Payload_Field_VariableSizeBuilder&&) = default; + Packet_Payload_Field_VariableSizeBuilder& operator=(Packet_Payload_Field_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t payload_size = payload_.size(); + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + output.insert(output.end(), payload_.begin(), payload_.end()); + } + + size_t GetSize() const override { + return 1 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + std::vector payload_; +}; + +class Packet_Payload_Field_SizeModifierView { +public: + static Packet_Payload_Field_SizeModifierView Create(pdl::packet::slice const& parent) { + return Packet_Payload_Field_SizeModifierView(parent); + } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Payload_Field_SizeModifierView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + payload_size_ = (chunk0 >> 0) & 0x7; + if (span.size() < (payload_size_ - 2)) return false; + payload_ = span.subrange(0, (payload_size_ - 2)); + span.skip((payload_size_ - 2)); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + pdl::packet::slice payload_; + + +}; + +class Packet_Payload_Field_SizeModifierBuilder : public pdl::packet::Builder { +public: + ~Packet_Payload_Field_SizeModifierBuilder() override = default; + Packet_Payload_Field_SizeModifierBuilder() = default; + explicit Packet_Payload_Field_SizeModifierBuilder(std::vector payload) : payload_(std::move(payload)) {} + Packet_Payload_Field_SizeModifierBuilder(Packet_Payload_Field_SizeModifierBuilder const&) = default; + Packet_Payload_Field_SizeModifierBuilder(Packet_Payload_Field_SizeModifierBuilder&&) = default; + Packet_Payload_Field_SizeModifierBuilder& operator=(Packet_Payload_Field_SizeModifierBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t payload_size = (payload_.size() +2); + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + output.insert(output.end(), payload_.begin(), payload_.end()); + } + + size_t GetSize() const override { + return 1 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + std::vector payload_; +}; + +class Packet_Payload_Field_UnknownSizeView { +public: + static Packet_Payload_Field_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Packet_Payload_Field_UnknownSizeView(parent); + } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + uint16_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Payload_Field_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) return false; + payload_ = span.subrange(0, span.size() - 2); + span.skip(span.size() - 2); + if (span.size() < 2) { + return false; + } + a_ = span.read_le(); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice payload_; + uint16_t a_; + + +}; + +class Packet_Payload_Field_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Payload_Field_UnknownSizeBuilder() override = default; + Packet_Payload_Field_UnknownSizeBuilder() = default; + explicit Packet_Payload_Field_UnknownSizeBuilder(std::vector payload, uint16_t a) : payload_(std::move(payload)), a_(std::move(a)) {} + Packet_Payload_Field_UnknownSizeBuilder(Packet_Payload_Field_UnknownSizeBuilder const&) = default; + Packet_Payload_Field_UnknownSizeBuilder(Packet_Payload_Field_UnknownSizeBuilder&&) = default; + Packet_Payload_Field_UnknownSizeBuilder& operator=(Packet_Payload_Field_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + output.insert(output.end(), payload_.begin(), payload_.end()); + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0xffff))); + } + + size_t GetSize() const override { + return 2 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + std::vector payload_; + uint16_t a_{0}; +}; + +class Packet_Payload_Field_UnknownSize_TerminalView { +public: + static Packet_Payload_Field_UnknownSize_TerminalView Create(pdl::packet::slice const& parent) { + return Packet_Payload_Field_UnknownSize_TerminalView(parent); + } + + uint16_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Payload_Field_UnknownSize_TerminalView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) { + return false; + } + a_ = span.read_le(); + payload_ = span; + span.clear(); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint16_t a_; + pdl::packet::slice payload_; + + +}; + +class Packet_Payload_Field_UnknownSize_TerminalBuilder : public pdl::packet::Builder { +public: + ~Packet_Payload_Field_UnknownSize_TerminalBuilder() override = default; + Packet_Payload_Field_UnknownSize_TerminalBuilder() = default; + explicit Packet_Payload_Field_UnknownSize_TerminalBuilder(uint16_t a, std::vector payload) : a_(std::move(a)), payload_(std::move(payload)) {} + Packet_Payload_Field_UnknownSize_TerminalBuilder(Packet_Payload_Field_UnknownSize_TerminalBuilder const&) = default; + Packet_Payload_Field_UnknownSize_TerminalBuilder(Packet_Payload_Field_UnknownSize_TerminalBuilder&&) = default; + Packet_Payload_Field_UnknownSize_TerminalBuilder& operator=(Packet_Payload_Field_UnknownSize_TerminalBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0xffff))); + output.insert(output.end(), payload_.begin(), payload_.end()); + } + + size_t GetSize() const override { + return 2 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + uint16_t a_{0}; + std::vector payload_; +}; + +class Packet_Body_Field_VariableSizeView { +public: + static Packet_Body_Field_VariableSizeView Create(pdl::packet::slice const& parent) { + return Packet_Body_Field_VariableSizeView(parent); + } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Body_Field_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + payload_size_ = (chunk0 >> 0) & 0x7; + if (span.size() < payload_size_) return false; + payload_ = span.subrange(0, payload_size_); + span.skip(payload_size_); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + pdl::packet::slice payload_; + + +}; + +class Packet_Body_Field_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Body_Field_VariableSizeBuilder() override = default; + Packet_Body_Field_VariableSizeBuilder() = default; + explicit Packet_Body_Field_VariableSizeBuilder(std::vector payload) : payload_(std::move(payload)) {} + Packet_Body_Field_VariableSizeBuilder(Packet_Body_Field_VariableSizeBuilder const&) = default; + Packet_Body_Field_VariableSizeBuilder(Packet_Body_Field_VariableSizeBuilder&&) = default; + Packet_Body_Field_VariableSizeBuilder& operator=(Packet_Body_Field_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t payload_size = payload_.size(); + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + output.insert(output.end(), payload_.begin(), payload_.end()); + } + + size_t GetSize() const override { + return 1 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + std::vector payload_; +}; + +class Packet_Body_Field_UnknownSizeView { +public: + static Packet_Body_Field_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Packet_Body_Field_UnknownSizeView(parent); + } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + uint16_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Body_Field_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) return false; + payload_ = span.subrange(0, span.size() - 2); + span.skip(span.size() - 2); + if (span.size() < 2) { + return false; + } + a_ = span.read_le(); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice payload_; + uint16_t a_; + + +}; + +class Packet_Body_Field_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Body_Field_UnknownSizeBuilder() override = default; + Packet_Body_Field_UnknownSizeBuilder() = default; + explicit Packet_Body_Field_UnknownSizeBuilder(std::vector payload, uint16_t a) : payload_(std::move(payload)), a_(std::move(a)) {} + Packet_Body_Field_UnknownSizeBuilder(Packet_Body_Field_UnknownSizeBuilder const&) = default; + Packet_Body_Field_UnknownSizeBuilder(Packet_Body_Field_UnknownSizeBuilder&&) = default; + Packet_Body_Field_UnknownSizeBuilder& operator=(Packet_Body_Field_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + output.insert(output.end(), payload_.begin(), payload_.end()); + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0xffff))); + } + + size_t GetSize() const override { + return 2 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + std::vector payload_; + uint16_t a_{0}; +}; + +class Packet_Body_Field_UnknownSize_TerminalView { +public: + static Packet_Body_Field_UnknownSize_TerminalView Create(pdl::packet::slice const& parent) { + return Packet_Body_Field_UnknownSize_TerminalView(parent); + } + + uint16_t GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::vector GetPayload() const { + _ASSERT_VALID(valid_); + return payload_.bytes(); + } + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Body_Field_UnknownSize_TerminalView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) { + return false; + } + a_ = span.read_le(); + payload_ = span; + span.clear(); + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint16_t a_; + pdl::packet::slice payload_; + + +}; + +class Packet_Body_Field_UnknownSize_TerminalBuilder : public pdl::packet::Builder { +public: + ~Packet_Body_Field_UnknownSize_TerminalBuilder() override = default; + Packet_Body_Field_UnknownSize_TerminalBuilder() = default; + explicit Packet_Body_Field_UnknownSize_TerminalBuilder(uint16_t a, std::vector payload) : a_(std::move(a)), payload_(std::move(payload)) {} + Packet_Body_Field_UnknownSize_TerminalBuilder(Packet_Body_Field_UnknownSize_TerminalBuilder const&) = default; + Packet_Body_Field_UnknownSize_TerminalBuilder(Packet_Body_Field_UnknownSize_TerminalBuilder&&) = default; + Packet_Body_Field_UnknownSize_TerminalBuilder& operator=(Packet_Body_Field_UnknownSize_TerminalBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0xffff))); + output.insert(output.end(), payload_.begin(), payload_.end()); + } + + size_t GetSize() const override { + return 2 + (payload_.size()); + } + + std::string ToString() const { return ""; } + + uint16_t a_{0}; + std::vector payload_; +}; + +class Packet_ScalarGroup_FieldView { +public: + static Packet_ScalarGroup_FieldView Create(pdl::packet::slice const& parent) { + return Packet_ScalarGroup_FieldView(parent); + } + + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_ScalarGroup_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) { + return false; + } + if (static_cast(span.read_le()) != 0x2a) { + return false; + } + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + + + +}; + +class Packet_ScalarGroup_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_ScalarGroup_FieldBuilder() override = default; + Packet_ScalarGroup_FieldBuilder() = default; + Packet_ScalarGroup_FieldBuilder(Packet_ScalarGroup_FieldBuilder const&) = default; + Packet_ScalarGroup_FieldBuilder(Packet_ScalarGroup_FieldBuilder&&) = default; + Packet_ScalarGroup_FieldBuilder& operator=(Packet_ScalarGroup_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(0x2a))); + } + + size_t GetSize() const override { + return 2; + } + + std::string ToString() const { return ""; } + + +}; + +class Packet_EnumGroup_FieldView { +public: + static Packet_EnumGroup_FieldView Create(pdl::packet::slice const& parent) { + return Packet_EnumGroup_FieldView(parent); + } + + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_EnumGroup_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 2) { + return false; + } + if (Enum16(span.read_le()) != Enum16::A) { + return false; + } + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + + + +}; + +class Packet_EnumGroup_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_EnumGroup_FieldBuilder() override = default; + Packet_EnumGroup_FieldBuilder() = default; + Packet_EnumGroup_FieldBuilder(Packet_EnumGroup_FieldBuilder const&) = default; + Packet_EnumGroup_FieldBuilder(Packet_EnumGroup_FieldBuilder&&) = default; + Packet_EnumGroup_FieldBuilder& operator=(Packet_EnumGroup_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(Enum16::A))); + } + + size_t GetSize() const override { + return 2; + } + + std::string ToString() const { return ""; } + + +}; + +class Packet_Struct_FieldView { +public: + static Packet_Struct_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Struct_FieldView(parent); + } + + SizedStruct const& GetA() const { _ASSERT_VALID(valid_); return a_; } + + UnsizedStruct const& GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Struct_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!SizedStruct::Parse(span, &a_)) return false; + if (!UnsizedStruct::Parse(span, &b_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + SizedStruct a_; + UnsizedStruct b_; + + +}; + +class Packet_Struct_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Struct_FieldBuilder() override = default; + Packet_Struct_FieldBuilder() = default; + explicit Packet_Struct_FieldBuilder(SizedStruct a, UnsizedStruct b) : a_(std::move(a)), b_(std::move(b)) {} + Packet_Struct_FieldBuilder(Packet_Struct_FieldBuilder const&) = default; + Packet_Struct_FieldBuilder(Packet_Struct_FieldBuilder&&) = default; + Packet_Struct_FieldBuilder& operator=(Packet_Struct_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + a_.Serialize(output); + b_.Serialize(output); + } + + size_t GetSize() const override { + return a_.GetSize() + b_.GetSize(); + } + + std::string ToString() const { return ""; } + + SizedStruct a_; + UnsizedStruct b_; +}; + +class Packet_Array_Field_ByteElement_ConstantSizeView { +public: + static Packet_Array_Field_ByteElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_ByteElement_ConstantSizeView(parent); + } + + std::array GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::array elements; + for (int n = 0; n < 4; n++) { + elements[n] = span.read_le(); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_ByteElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 4) { + return false; + } + array_ = span.subrange(0, 4); + span.skip(4); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_ByteElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_ByteElement_ConstantSizeBuilder() override = default; + Packet_Array_Field_ByteElement_ConstantSizeBuilder() = default; + explicit Packet_Array_Field_ByteElement_ConstantSizeBuilder(std::array array) : array_(std::move(array)) {} + Packet_Array_Field_ByteElement_ConstantSizeBuilder(Packet_Array_Field_ByteElement_ConstantSizeBuilder const&) = default; + Packet_Array_Field_ByteElement_ConstantSizeBuilder(Packet_Array_Field_ByteElement_ConstantSizeBuilder&&) = default; + Packet_Array_Field_ByteElement_ConstantSizeBuilder& operator=(Packet_Array_Field_ByteElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 1); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Packet_Array_Field_ByteElement_VariableSizeView { +public: + static Packet_Array_Field_ByteElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_ByteElement_VariableSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0 && span.size() >= 1) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_ByteElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < array_size_) return false; + if ((array_size_ % 1) != 0) return false; + array_ = span.subrange(0, array_size_); + span.skip(array_size_); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_ByteElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_ByteElement_VariableSizeBuilder() override = default; + Packet_Array_Field_ByteElement_VariableSizeBuilder() = default; + explicit Packet_Array_Field_ByteElement_VariableSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_ByteElement_VariableSizeBuilder(Packet_Array_Field_ByteElement_VariableSizeBuilder const&) = default; + Packet_Array_Field_ByteElement_VariableSizeBuilder(Packet_Array_Field_ByteElement_VariableSizeBuilder&&) = default; + Packet_Array_Field_ByteElement_VariableSizeBuilder& operator=(Packet_Array_Field_ByteElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 1); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_ByteElement_VariableCountView { +public: + static Packet_Array_Field_ByteElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_ByteElement_VariableCountView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (elements.size() < array_count_ && span.size() >= 1) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_ByteElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_count_ = (chunk0 >> 0) & 0xf; + if (span.size() < array_count_ * 1) return false; + array_ = span.subrange(0, array_count_ * 1); + span.skip(array_count_ * 1); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_count_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_ByteElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_ByteElement_VariableCountBuilder() override = default; + Packet_Array_Field_ByteElement_VariableCountBuilder() = default; + explicit Packet_Array_Field_ByteElement_VariableCountBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_ByteElement_VariableCountBuilder(Packet_Array_Field_ByteElement_VariableCountBuilder const&) = default; + Packet_Array_Field_ByteElement_VariableCountBuilder(Packet_Array_Field_ByteElement_VariableCountBuilder&&) = default; + Packet_Array_Field_ByteElement_VariableCountBuilder& operator=(Packet_Array_Field_ByteElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_ByteElement_UnknownSizeView { +public: + static Packet_Array_Field_ByteElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_ByteElement_UnknownSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0 && span.size() >= 1) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_ByteElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_ByteElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_ByteElement_UnknownSizeBuilder() override = default; + Packet_Array_Field_ByteElement_UnknownSizeBuilder() = default; + explicit Packet_Array_Field_ByteElement_UnknownSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_ByteElement_UnknownSizeBuilder(Packet_Array_Field_ByteElement_UnknownSizeBuilder const&) = default; + Packet_Array_Field_ByteElement_UnknownSizeBuilder(Packet_Array_Field_ByteElement_UnknownSizeBuilder&&) = default; + Packet_Array_Field_ByteElement_UnknownSizeBuilder& operator=(Packet_Array_Field_ByteElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 1); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Packet_Array_Field_ScalarElement_ConstantSizeView { +public: + static Packet_Array_Field_ScalarElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_ScalarElement_ConstantSizeView(parent); + } + + std::array GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::array elements; + for (int n = 0; n < 4; n++) { + elements[n] = span.read_le(); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_ScalarElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + array_ = span.subrange(0, 8); + span.skip(8); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_ScalarElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_ScalarElement_ConstantSizeBuilder() override = default; + Packet_Array_Field_ScalarElement_ConstantSizeBuilder() = default; + explicit Packet_Array_Field_ScalarElement_ConstantSizeBuilder(std::array array) : array_(std::move(array)) {} + Packet_Array_Field_ScalarElement_ConstantSizeBuilder(Packet_Array_Field_ScalarElement_ConstantSizeBuilder const&) = default; + Packet_Array_Field_ScalarElement_ConstantSizeBuilder(Packet_Array_Field_ScalarElement_ConstantSizeBuilder&&) = default; + Packet_Array_Field_ScalarElement_ConstantSizeBuilder& operator=(Packet_Array_Field_ScalarElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 2); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Packet_Array_Field_ScalarElement_VariableSizeView { +public: + static Packet_Array_Field_ScalarElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_ScalarElement_VariableSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0 && span.size() >= 2) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_ScalarElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < array_size_) return false; + if ((array_size_ % 2) != 0) return false; + array_ = span.subrange(0, array_size_); + span.skip(array_size_); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_ScalarElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_ScalarElement_VariableSizeBuilder() override = default; + Packet_Array_Field_ScalarElement_VariableSizeBuilder() = default; + explicit Packet_Array_Field_ScalarElement_VariableSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_ScalarElement_VariableSizeBuilder(Packet_Array_Field_ScalarElement_VariableSizeBuilder const&) = default; + Packet_Array_Field_ScalarElement_VariableSizeBuilder(Packet_Array_Field_ScalarElement_VariableSizeBuilder&&) = default; + Packet_Array_Field_ScalarElement_VariableSizeBuilder& operator=(Packet_Array_Field_ScalarElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 2); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 2)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_ScalarElement_VariableCountView { +public: + static Packet_Array_Field_ScalarElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_ScalarElement_VariableCountView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (elements.size() < array_count_ && span.size() >= 2) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_ScalarElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_count_ = (chunk0 >> 0) & 0xf; + if (span.size() < array_count_ * 2) return false; + array_ = span.subrange(0, array_count_ * 2); + span.skip(array_count_ * 2); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_count_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_ScalarElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_ScalarElement_VariableCountBuilder() override = default; + Packet_Array_Field_ScalarElement_VariableCountBuilder() = default; + explicit Packet_Array_Field_ScalarElement_VariableCountBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_ScalarElement_VariableCountBuilder(Packet_Array_Field_ScalarElement_VariableCountBuilder const&) = default; + Packet_Array_Field_ScalarElement_VariableCountBuilder(Packet_Array_Field_ScalarElement_VariableCountBuilder&&) = default; + Packet_Array_Field_ScalarElement_VariableCountBuilder& operator=(Packet_Array_Field_ScalarElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 2)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_ScalarElement_UnknownSizeView { +public: + static Packet_Array_Field_ScalarElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_ScalarElement_UnknownSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0 && span.size() >= 2) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_ScalarElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_ScalarElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_ScalarElement_UnknownSizeBuilder() override = default; + Packet_Array_Field_ScalarElement_UnknownSizeBuilder() = default; + explicit Packet_Array_Field_ScalarElement_UnknownSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_ScalarElement_UnknownSizeBuilder(Packet_Array_Field_ScalarElement_UnknownSizeBuilder const&) = default; + Packet_Array_Field_ScalarElement_UnknownSizeBuilder(Packet_Array_Field_ScalarElement_UnknownSizeBuilder&&) = default; + Packet_Array_Field_ScalarElement_UnknownSizeBuilder& operator=(Packet_Array_Field_ScalarElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 2); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Packet_Array_Field_EnumElement_ConstantSizeView { +public: + static Packet_Array_Field_EnumElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_EnumElement_ConstantSizeView(parent); + } + + std::array GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::array elements; + for (int n = 0; n < 4; n++) { + elements[n] = Enum16(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_EnumElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 8) { + return false; + } + array_ = span.subrange(0, 8); + span.skip(8); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_EnumElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_EnumElement_ConstantSizeBuilder() override = default; + Packet_Array_Field_EnumElement_ConstantSizeBuilder() = default; + explicit Packet_Array_Field_EnumElement_ConstantSizeBuilder(std::array array) : array_(std::move(array)) {} + Packet_Array_Field_EnumElement_ConstantSizeBuilder(Packet_Array_Field_EnumElement_ConstantSizeBuilder const&) = default; + Packet_Array_Field_EnumElement_ConstantSizeBuilder(Packet_Array_Field_EnumElement_ConstantSizeBuilder&&) = default; + Packet_Array_Field_EnumElement_ConstantSizeBuilder& operator=(Packet_Array_Field_EnumElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 2); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Packet_Array_Field_EnumElement_VariableSizeView { +public: + static Packet_Array_Field_EnumElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_EnumElement_VariableSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0 && span.size() >= 2) { + elements.push_back(Enum16(span.read_le())); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_EnumElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < array_size_) return false; + array_ = span.subrange(0, array_size_); + span.skip(array_size_); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_EnumElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_EnumElement_VariableSizeBuilder() override = default; + Packet_Array_Field_EnumElement_VariableSizeBuilder() = default; + explicit Packet_Array_Field_EnumElement_VariableSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_EnumElement_VariableSizeBuilder(Packet_Array_Field_EnumElement_VariableSizeBuilder const&) = default; + Packet_Array_Field_EnumElement_VariableSizeBuilder(Packet_Array_Field_EnumElement_VariableSizeBuilder&&) = default; + Packet_Array_Field_EnumElement_VariableSizeBuilder& operator=(Packet_Array_Field_EnumElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 2); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 2)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_EnumElement_VariableCountView { +public: + static Packet_Array_Field_EnumElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_EnumElement_VariableCountView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (elements.size() < array_count_ && span.size() >= 2) { + elements.push_back(Enum16(span.read_le())); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_EnumElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_count_ = (chunk0 >> 0) & 0xf; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_count_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_EnumElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_EnumElement_VariableCountBuilder() override = default; + Packet_Array_Field_EnumElement_VariableCountBuilder() = default; + explicit Packet_Array_Field_EnumElement_VariableCountBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_EnumElement_VariableCountBuilder(Packet_Array_Field_EnumElement_VariableCountBuilder const&) = default; + Packet_Array_Field_EnumElement_VariableCountBuilder(Packet_Array_Field_EnumElement_VariableCountBuilder&&) = default; + Packet_Array_Field_EnumElement_VariableCountBuilder& operator=(Packet_Array_Field_EnumElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 2)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_EnumElement_UnknownSizeView { +public: + static Packet_Array_Field_EnumElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_EnumElement_UnknownSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0 && span.size() >= 2) { + elements.push_back(Enum16(span.read_le())); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_EnumElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_EnumElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_EnumElement_UnknownSizeBuilder() override = default; + Packet_Array_Field_EnumElement_UnknownSizeBuilder() = default; + explicit Packet_Array_Field_EnumElement_UnknownSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_EnumElement_UnknownSizeBuilder(Packet_Array_Field_EnumElement_UnknownSizeBuilder const&) = default; + Packet_Array_Field_EnumElement_UnknownSizeBuilder(Packet_Array_Field_EnumElement_UnknownSizeBuilder&&) = default; + Packet_Array_Field_EnumElement_UnknownSizeBuilder& operator=(Packet_Array_Field_EnumElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 2); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Packet_Array_Field_SizedElement_ConstantSizeView { +public: + static Packet_Array_Field_SizedElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_SizedElement_ConstantSizeView(parent); + } + + std::array GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::array elements; + for (int n = 0; n < 4; n++) { + SizedStruct::Parse(span, &elements[n]); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_SizedElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 4) { + return false; + } + array_ = span.subrange(0, 4); + span.skip(4); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_SizedElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_SizedElement_ConstantSizeBuilder() override = default; + Packet_Array_Field_SizedElement_ConstantSizeBuilder() = default; + explicit Packet_Array_Field_SizedElement_ConstantSizeBuilder(std::array array) : array_(std::move(array)) {} + Packet_Array_Field_SizedElement_ConstantSizeBuilder(Packet_Array_Field_SizedElement_ConstantSizeBuilder const&) = default; + Packet_Array_Field_SizedElement_ConstantSizeBuilder(Packet_Array_Field_SizedElement_ConstantSizeBuilder&&) = default; + Packet_Array_Field_SizedElement_ConstantSizeBuilder& operator=(Packet_Array_Field_SizedElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Packet_Array_Field_SizedElement_VariableSizeView { +public: + static Packet_Array_Field_SizedElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_SizedElement_VariableSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0) { + SizedStruct element; + if (!SizedStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_SizedElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < array_size_) return false; + array_ = span.subrange(0, array_size_); + span.skip(array_size_); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_SizedElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_SizedElement_VariableSizeBuilder() override = default; + Packet_Array_Field_SizedElement_VariableSizeBuilder() = default; + explicit Packet_Array_Field_SizedElement_VariableSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_SizedElement_VariableSizeBuilder(Packet_Array_Field_SizedElement_VariableSizeBuilder const&) = default; + Packet_Array_Field_SizedElement_VariableSizeBuilder(Packet_Array_Field_SizedElement_VariableSizeBuilder&&) = default; + Packet_Array_Field_SizedElement_VariableSizeBuilder& operator=(Packet_Array_Field_SizedElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_size = std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& element) { return s + element.GetSize(); }); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_SizedElement_VariableCountView { +public: + static Packet_Array_Field_SizedElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_SizedElement_VariableCountView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (elements.size() < array_count_) { + SizedStruct element; + if (!SizedStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_SizedElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_count_ = (chunk0 >> 0) & 0xf; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_count_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_SizedElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_SizedElement_VariableCountBuilder() override = default; + Packet_Array_Field_SizedElement_VariableCountBuilder() = default; + explicit Packet_Array_Field_SizedElement_VariableCountBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_SizedElement_VariableCountBuilder(Packet_Array_Field_SizedElement_VariableCountBuilder const&) = default; + Packet_Array_Field_SizedElement_VariableCountBuilder(Packet_Array_Field_SizedElement_VariableCountBuilder&&) = default; + Packet_Array_Field_SizedElement_VariableCountBuilder& operator=(Packet_Array_Field_SizedElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_SizedElement_UnknownSizeView { +public: + static Packet_Array_Field_SizedElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_SizedElement_UnknownSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0) { + SizedStruct element; + if (!SizedStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_SizedElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_SizedElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_SizedElement_UnknownSizeBuilder() override = default; + Packet_Array_Field_SizedElement_UnknownSizeBuilder() = default; + explicit Packet_Array_Field_SizedElement_UnknownSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_SizedElement_UnknownSizeBuilder(Packet_Array_Field_SizedElement_UnknownSizeBuilder const&) = default; + Packet_Array_Field_SizedElement_UnknownSizeBuilder(Packet_Array_Field_SizedElement_UnknownSizeBuilder&&) = default; + Packet_Array_Field_SizedElement_UnknownSizeBuilder& operator=(Packet_Array_Field_SizedElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Packet_Array_Field_UnsizedElement_ConstantSizeView { +public: + static Packet_Array_Field_UnsizedElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_UnsizedElement_ConstantSizeView(parent); + } + + std::array GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::array elements; + for (int n = 0; n < 4; n++) { + UnsizedStruct::Parse(span, &elements[n]); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_UnsizedElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_UnsizedElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_UnsizedElement_ConstantSizeBuilder() override = default; + Packet_Array_Field_UnsizedElement_ConstantSizeBuilder() = default; + explicit Packet_Array_Field_UnsizedElement_ConstantSizeBuilder(std::array array) : array_(std::move(array)) {} + Packet_Array_Field_UnsizedElement_ConstantSizeBuilder(Packet_Array_Field_UnsizedElement_ConstantSizeBuilder const&) = default; + Packet_Array_Field_UnsizedElement_ConstantSizeBuilder(Packet_Array_Field_UnsizedElement_ConstantSizeBuilder&&) = default; + Packet_Array_Field_UnsizedElement_ConstantSizeBuilder& operator=(Packet_Array_Field_UnsizedElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Packet_Array_Field_UnsizedElement_VariableSizeView { +public: + static Packet_Array_Field_UnsizedElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_UnsizedElement_VariableSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_UnsizedElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < array_size_) return false; + array_ = span.subrange(0, array_size_); + span.skip(array_size_); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_UnsizedElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_UnsizedElement_VariableSizeBuilder() override = default; + Packet_Array_Field_UnsizedElement_VariableSizeBuilder() = default; + explicit Packet_Array_Field_UnsizedElement_VariableSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_UnsizedElement_VariableSizeBuilder(Packet_Array_Field_UnsizedElement_VariableSizeBuilder const&) = default; + Packet_Array_Field_UnsizedElement_VariableSizeBuilder(Packet_Array_Field_UnsizedElement_VariableSizeBuilder&&) = default; + Packet_Array_Field_UnsizedElement_VariableSizeBuilder& operator=(Packet_Array_Field_UnsizedElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_size = std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& element) { return s + element.GetSize(); }); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_UnsizedElement_VariableCountView { +public: + static Packet_Array_Field_UnsizedElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_UnsizedElement_VariableCountView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (elements.size() < array_count_) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_UnsizedElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_count_ = (chunk0 >> 0) & 0xf; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_count_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_UnsizedElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_UnsizedElement_VariableCountBuilder() override = default; + Packet_Array_Field_UnsizedElement_VariableCountBuilder() = default; + explicit Packet_Array_Field_UnsizedElement_VariableCountBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_UnsizedElement_VariableCountBuilder(Packet_Array_Field_UnsizedElement_VariableCountBuilder const&) = default; + Packet_Array_Field_UnsizedElement_VariableCountBuilder(Packet_Array_Field_UnsizedElement_VariableCountBuilder&&) = default; + Packet_Array_Field_UnsizedElement_VariableCountBuilder& operator=(Packet_Array_Field_UnsizedElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_UnsizedElement_UnknownSizeView { +public: + static Packet_Array_Field_UnsizedElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_UnsizedElement_UnknownSizeView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_UnsizedElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + array_ = span; + span.clear(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_UnsizedElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_UnsizedElement_UnknownSizeBuilder() override = default; + Packet_Array_Field_UnsizedElement_UnknownSizeBuilder() = default; + explicit Packet_Array_Field_UnsizedElement_UnknownSizeBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_UnsizedElement_UnknownSizeBuilder(Packet_Array_Field_UnsizedElement_UnknownSizeBuilder const&) = default; + Packet_Array_Field_UnsizedElement_UnknownSizeBuilder(Packet_Array_Field_UnsizedElement_UnknownSizeBuilder&&) = default; + Packet_Array_Field_UnsizedElement_UnknownSizeBuilder& operator=(Packet_Array_Field_UnsizedElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Packet_Array_Field_UnsizedElement_SizeModifierView { +public: + static Packet_Array_Field_UnsizedElement_SizeModifierView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_UnsizedElement_SizeModifierView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_UnsizedElement_SizeModifierView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < (array_size_ - 2)) return false; + array_ = span.subrange(0, (array_size_ - 2)); + span.skip((array_size_ - 2)); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_UnsizedElement_SizeModifierBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_UnsizedElement_SizeModifierBuilder() override = default; + Packet_Array_Field_UnsizedElement_SizeModifierBuilder() = default; + explicit Packet_Array_Field_UnsizedElement_SizeModifierBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_UnsizedElement_SizeModifierBuilder(Packet_Array_Field_UnsizedElement_SizeModifierBuilder const&) = default; + Packet_Array_Field_UnsizedElement_SizeModifierBuilder(Packet_Array_Field_UnsizedElement_SizeModifierBuilder&&) = default; + Packet_Array_Field_UnsizedElement_SizeModifierBuilder& operator=(Packet_Array_Field_UnsizedElement_SizeModifierBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_size = (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& element) { return s + element.GetSize(); }) +2); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_SizedElement_VariableSize_PaddedView { +public: + static Packet_Array_Field_SizedElement_VariableSize_PaddedView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_SizedElement_VariableSize_PaddedView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (span.size() > 0 && span.size() >= 2) { + elements.push_back(span.read_le()); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_SizedElement_VariableSize_PaddedView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + array_size_ = (chunk0 >> 0) & 0xf; + size_t array_start_size = span.size(); + if (span.size() < array_size_) return false; + if ((array_size_ % 2) != 0) return false; + array_ = span.subrange(0, array_size_); + span.skip(array_size_); + if (array_start_size - span.size() < 16) { + if (span.size() < 16 - (array_start_size - span.size())) return false; + span.skip(16 - (array_start_size - span.size())); + } + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_size_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder() override = default; + Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder() = default; + explicit Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder(Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder const&) = default; + Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder(Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder&&) = default; + Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder& operator=(Packet_Array_Field_SizedElement_VariableSize_PaddedBuilder const&) = default; + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 2); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + size_t array_start = output.size(); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + if (output.size() - array_start < 16) { + output.resize(array_start + 16, 0); + } + } + + size_t GetSize() const override { + return 1 + (std::max((array_.size() * 2), 16)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Packet_Array_Field_UnsizedElement_VariableCount_PaddedView { +public: + static Packet_Array_Field_UnsizedElement_VariableCount_PaddedView Create(pdl::packet::slice const& parent) { + return Packet_Array_Field_UnsizedElement_VariableCount_PaddedView(parent); + } + + std::vector GetArray() const { + _ASSERT_VALID(valid_); + pdl::packet::slice span = array_; + std::vector elements; + while (elements.size() < array_count_) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) break; + elements.emplace_back(std::move(element)); + } + return elements; + } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Array_Field_UnsizedElement_VariableCount_PaddedView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + array_count_ = span.read_le(); + size_t array_start_size = span.size(); + array_ = span; + span.clear(); + if (array_start_size - span.size() < 16) { + if (span.size() < 16 - (array_start_size - span.size())) return false; + span.skip(16 - (array_start_size - span.size())); + } + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t array_count_ {0}; + pdl::packet::slice array_; + + +}; + +class Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder : public pdl::packet::Builder { +public: + ~Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder() override = default; + Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder() = default; + explicit Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder(std::vector array) : array_(std::move(array)) {} + Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder(Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder const&) = default; + Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder(Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder&&) = default; + Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder& operator=(Packet_Array_Field_UnsizedElement_VariableCount_PaddedBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + size_t array_start = output.size(); + for (auto const& element : array_) { + element.Serialize(output); + } + if (output.size() - array_start < 16) { + output.resize(array_start + 16, 0); + } + } + + size_t GetSize() const override { + return 1 + (std::max(std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }), 16)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Packet_Optional_Scalar_FieldView { +public: + static Packet_Optional_Scalar_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Optional_Scalar_FieldView(parent); + } + + std::optional GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::optional GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Optional_Scalar_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + uint8_t c0 = (chunk0 >> 0) & 0x1; + uint8_t c1 = (chunk0 >> 1) & 0x1; + if (c0 == 0) { + if (span.size() < 3) { + return false; + } + a_ = span.read_le(); + } + if (c1 == 1) { + if (span.size() < 4) { + return false; + } + b_ = span.read_le(); + } + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + std::optional a_; + std::optional b_; + + +}; + +class Packet_Optional_Scalar_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Optional_Scalar_FieldBuilder() override = default; + Packet_Optional_Scalar_FieldBuilder() = default; + explicit Packet_Optional_Scalar_FieldBuilder(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} + Packet_Optional_Scalar_FieldBuilder(Packet_Optional_Scalar_FieldBuilder const&) = default; + Packet_Optional_Scalar_FieldBuilder(Packet_Optional_Scalar_FieldBuilder&&) = default; + Packet_Optional_Scalar_FieldBuilder& operator=(Packet_Optional_Scalar_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast((a_.has_value() ? 0 : 1))) | (static_cast((b_.has_value() ? 1 : 0)) << 1)); + if ((a_.has_value() ? 0 : 1) == 0) { + pdl::packet::Builder::write_le(output, *a_); + } + if ((b_.has_value() ? 1 : 0) == 1) { + pdl::packet::Builder::write_le(output, *b_); + } + } + + size_t GetSize() const override { + return 1 + ((((a_.has_value() ? 0 : 1) == 0) ? 3 : 0) + (((b_.has_value() ? 1 : 0) == 1) ? 4 : 0)); + } + + std::string ToString() const { return ""; } + + std::optional a_; + std::optional b_; +}; + +class Packet_Optional_Enum_FieldView { +public: + static Packet_Optional_Enum_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Optional_Enum_FieldView(parent); + } + + std::optional GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::optional GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Optional_Enum_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + uint8_t c0 = (chunk0 >> 0) & 0x1; + uint8_t c1 = (chunk0 >> 1) & 0x1; + if (c0 == 0) { + if (span.size() < 2) { + return false; + } + a_ = static_cast(span.read_le()); + if (!IsEnum16Valid(a_.value())) return false; + } + if (c1 == 1) { + if (span.size() < 2) { + return false; + } + b_ = static_cast(span.read_le()); + if (!IsEnum16Valid(b_.value())) return false; + } + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + std::optional a_; + std::optional b_; + + +}; + +class Packet_Optional_Enum_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Optional_Enum_FieldBuilder() override = default; + Packet_Optional_Enum_FieldBuilder() = default; + explicit Packet_Optional_Enum_FieldBuilder(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} + Packet_Optional_Enum_FieldBuilder(Packet_Optional_Enum_FieldBuilder const&) = default; + Packet_Optional_Enum_FieldBuilder(Packet_Optional_Enum_FieldBuilder&&) = default; + Packet_Optional_Enum_FieldBuilder& operator=(Packet_Optional_Enum_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast((a_.has_value() ? 0 : 1))) | (static_cast((b_.has_value() ? 1 : 0)) << 1)); + if ((a_.has_value() ? 0 : 1) == 0) { + pdl::packet::Builder::write_le(output, static_cast(*a_)); + } + if ((b_.has_value() ? 1 : 0) == 1) { + pdl::packet::Builder::write_le(output, static_cast(*b_)); + } + } + + size_t GetSize() const override { + return 1 + ((((a_.has_value() ? 0 : 1) == 0) ? 2 : 0) + (((b_.has_value() ? 1 : 0) == 1) ? 2 : 0)); + } + + std::string ToString() const { return ""; } + + std::optional a_; + std::optional b_; +}; + +class Packet_Optional_Struct_FieldView { +public: + static Packet_Optional_Struct_FieldView Create(pdl::packet::slice const& parent) { + return Packet_Optional_Struct_FieldView(parent); + } + + std::optional GetA() const { _ASSERT_VALID(valid_); return a_; } + + std::optional GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Packet_Optional_Struct_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + uint8_t c0 = (chunk0 >> 0) & 0x1; + uint8_t c1 = (chunk0 >> 1) & 0x1; + if (c0 == 0) { + auto& opt_output = a_.emplace(); + if (!SizedStruct::Parse(span, &opt_output)) { + return false; + } + } + if (c1 == 1) { + auto& opt_output = b_.emplace(); + if (!UnsizedStruct::Parse(span, &opt_output)) { + return false; + } + } + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + std::optional a_; + std::optional b_; + + +}; + +class Packet_Optional_Struct_FieldBuilder : public pdl::packet::Builder { +public: + ~Packet_Optional_Struct_FieldBuilder() override = default; + Packet_Optional_Struct_FieldBuilder() = default; + explicit Packet_Optional_Struct_FieldBuilder(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} + Packet_Optional_Struct_FieldBuilder(Packet_Optional_Struct_FieldBuilder const&) = default; + Packet_Optional_Struct_FieldBuilder(Packet_Optional_Struct_FieldBuilder&&) = default; + Packet_Optional_Struct_FieldBuilder& operator=(Packet_Optional_Struct_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast((a_.has_value() ? 0 : 1))) | (static_cast((b_.has_value() ? 1 : 0)) << 1)); + if ((a_.has_value() ? 0 : 1) == 0) { + a_->Serialize(output); + } + if ((b_.has_value() ? 1 : 0) == 1) { + b_->Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + ((((a_.has_value() ? 0 : 1) == 0) ? a_->GetSize() : 0) + (((b_.has_value() ? 1 : 0) == 1) ? b_->GetSize() : 0)); + } + + std::string ToString() const { return ""; } + + std::optional a_; + std::optional b_; +}; + +class ScalarChild_AView { +public: + static ScalarChild_AView Create(ScalarParentView const& parent) { + return ScalarChild_AView(parent); + } + + uint8_t GetA() const { return 0; } + + uint8_t GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit ScalarChild_AView(ScalarParentView const& parent) + : bytes_(parent.bytes_) { + valid_ = Parse(parent); + } + + bool Parse(ScalarParentView const& parent) { + // Check validity of parent packet. + if (!parent.IsValid()) { return false; } + // Parse packet field values. + pdl::packet::slice span = parent.payload_; + if (span.size() < 1) { + return false; + } + b_ = span.read_le(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + uint8_t b_; + + +}; + +class ScalarChild_ABuilder : public pdl::packet::Builder { +public: + ~ScalarChild_ABuilder() override = default; + ScalarChild_ABuilder() = default; + explicit ScalarChild_ABuilder(uint8_t b) : b_(std::move(b)) {} + ScalarChild_ABuilder(ScalarChild_ABuilder const&) = default; + ScalarChild_ABuilder(ScalarChild_ABuilder&&) = default; + ScalarChild_ABuilder& operator=(ScalarChild_ABuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(0x0 & 0xff))); + size_t payload_size = 1; + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + pdl::packet::Builder::write_le(output, (static_cast(b_ & 0xff))); + } + + size_t GetSize() const override { + return 3; + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + uint8_t b_{0}; +}; + +class ScalarChild_BView { +public: + static ScalarChild_BView Create(ScalarParentView const& parent) { + return ScalarChild_BView(parent); + } + + uint8_t GetA() const { return 1; } + + uint16_t GetC() const { _ASSERT_VALID(valid_); return c_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit ScalarChild_BView(ScalarParentView const& parent) + : bytes_(parent.bytes_) { + valid_ = Parse(parent); + } + + bool Parse(ScalarParentView const& parent) { + // Check validity of parent packet. + if (!parent.IsValid()) { return false; } + // Parse packet field values. + pdl::packet::slice span = parent.payload_; + if (span.size() < 2) { + return false; + } + c_ = span.read_le(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + uint16_t c_; + + +}; + +class ScalarChild_BBuilder : public pdl::packet::Builder { +public: + ~ScalarChild_BBuilder() override = default; + ScalarChild_BBuilder() = default; + explicit ScalarChild_BBuilder(uint16_t c) : c_(std::move(c)) {} + ScalarChild_BBuilder(ScalarChild_BBuilder const&) = default; + ScalarChild_BBuilder(ScalarChild_BBuilder&&) = default; + ScalarChild_BBuilder& operator=(ScalarChild_BBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(0x1 & 0xff))); + size_t payload_size = 2; + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + pdl::packet::Builder::write_le(output, (static_cast(c_ & 0xffff))); + } + + size_t GetSize() const override { + return 4; + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + uint16_t c_{0}; +}; + +class EnumChild_AView { +public: + static EnumChild_AView Create(EnumParentView const& parent) { + return EnumChild_AView(parent); + } + + Enum16 GetA() const { return Enum16::A; } + + uint8_t GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit EnumChild_AView(EnumParentView const& parent) + : bytes_(parent.bytes_) { + valid_ = Parse(parent); + } + + bool Parse(EnumParentView const& parent) { + // Check validity of parent packet. + if (!parent.IsValid()) { return false; } + // Parse packet field values. + pdl::packet::slice span = parent.payload_; + if (span.size() < 1) { + return false; + } + b_ = span.read_le(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + uint8_t b_; + + +}; + +class EnumChild_ABuilder : public pdl::packet::Builder { +public: + ~EnumChild_ABuilder() override = default; + EnumChild_ABuilder() = default; + explicit EnumChild_ABuilder(uint8_t b) : b_(std::move(b)) {} + EnumChild_ABuilder(EnumChild_ABuilder const&) = default; + EnumChild_ABuilder(EnumChild_ABuilder&&) = default; + EnumChild_ABuilder& operator=(EnumChild_ABuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(Enum16::A)))); + size_t payload_size = 1; + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + pdl::packet::Builder::write_le(output, (static_cast(b_ & 0xff))); + } + + size_t GetSize() const override { + return 4; + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + uint8_t b_{0}; +}; + +class EnumChild_BView { +public: + static EnumChild_BView Create(EnumParentView const& parent) { + return EnumChild_BView(parent); + } + + Enum16 GetA() const { return Enum16::B; } + + uint16_t GetC() const { _ASSERT_VALID(valid_); return c_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit EnumChild_BView(EnumParentView const& parent) + : bytes_(parent.bytes_) { + valid_ = Parse(parent); + } + + bool Parse(EnumParentView const& parent) { + // Check validity of parent packet. + if (!parent.IsValid()) { return false; } + // Parse packet field values. + pdl::packet::slice span = parent.payload_; + if (span.size() < 2) { + return false; + } + c_ = span.read_le(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + uint16_t c_; + + +}; + +class EnumChild_BBuilder : public pdl::packet::Builder { +public: + ~EnumChild_BBuilder() override = default; + EnumChild_BBuilder() = default; + explicit EnumChild_BBuilder(uint16_t c) : c_(std::move(c)) {} + EnumChild_BBuilder(EnumChild_BBuilder const&) = default; + EnumChild_BBuilder(EnumChild_BBuilder&&) = default; + EnumChild_BBuilder& operator=(EnumChild_BBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(Enum16::B)))); + size_t payload_size = 2; + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + pdl::packet::Builder::write_le(output, (static_cast(c_ & 0xffff))); + } + + size_t GetSize() const override { + return 5; + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + uint16_t c_{0}; +}; + +class AliasedChild_AView { +public: + static AliasedChild_AView Create(EmptyParentView const& parent) { + return AliasedChild_AView(parent); + } + + uint8_t GetA() const { return 2; } + + uint8_t GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit AliasedChild_AView(EmptyParentView const& parent) + : bytes_(parent.bytes_) { + valid_ = Parse(parent); + } + + bool Parse(EmptyParentView const& parent) { + // Check validity of parent packet. + if (!parent.IsValid()) { return false; } + // Parse packet field values. + pdl::packet::slice span = parent.payload_; + if (span.size() < 1) { + return false; + } + b_ = span.read_le(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + uint8_t b_; + + +}; + +class AliasedChild_ABuilder : public pdl::packet::Builder { +public: + ~AliasedChild_ABuilder() override = default; + AliasedChild_ABuilder() = default; + explicit AliasedChild_ABuilder(uint8_t b) : b_(std::move(b)) {} + AliasedChild_ABuilder(AliasedChild_ABuilder const&) = default; + AliasedChild_ABuilder(AliasedChild_ABuilder&&) = default; + AliasedChild_ABuilder& operator=(AliasedChild_ABuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(0x2 & 0xff))); + size_t payload_size = 1; + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + pdl::packet::Builder::write_le(output, (static_cast(b_ & 0xff))); + } + + size_t GetSize() const override { + return 3; + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + uint8_t b_{0}; +}; + +class AliasedChild_BView { +public: + static AliasedChild_BView Create(EmptyParentView const& parent) { + return AliasedChild_BView(parent); + } + + uint8_t GetA() const { return 3; } + + uint16_t GetC() const { _ASSERT_VALID(valid_); return c_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit AliasedChild_BView(EmptyParentView const& parent) + : bytes_(parent.bytes_) { + valid_ = Parse(parent); + } + + bool Parse(EmptyParentView const& parent) { + // Check validity of parent packet. + if (!parent.IsValid()) { return false; } + // Parse packet field values. + pdl::packet::slice span = parent.payload_; + if (span.size() < 2) { + return false; + } + c_ = span.read_le(); + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + uint8_t payload_size_ {0}; + uint16_t c_; + + +}; + +class AliasedChild_BBuilder : public pdl::packet::Builder { +public: + ~AliasedChild_BBuilder() override = default; + AliasedChild_BBuilder() = default; + explicit AliasedChild_BBuilder(uint16_t c) : c_(std::move(c)) {} + AliasedChild_BBuilder(AliasedChild_BBuilder const&) = default; + AliasedChild_BBuilder(AliasedChild_BBuilder&&) = default; + AliasedChild_BBuilder& operator=(AliasedChild_BBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(0x3 & 0xff))); + size_t payload_size = 2; + pdl::packet::Builder::write_le(output, (static_cast(payload_size))); + pdl::packet::Builder::write_le(output, (static_cast(c_ & 0xffff))); + } + + size_t GetSize() const override { + return 4; + } + + std::string ToString() const { return ""; } + + uint8_t payload_size_ {0}; + uint16_t c_{0}; +}; + +class Struct_Scalar_Field : public pdl::packet::Builder { +public: + ~Struct_Scalar_Field() override = default; + Struct_Scalar_Field() = default; + explicit Struct_Scalar_Field(uint8_t a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} + Struct_Scalar_Field(Struct_Scalar_Field const&) = default; + Struct_Scalar_Field(Struct_Scalar_Field&&) = default; + Struct_Scalar_Field& operator=(Struct_Scalar_Field const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Scalar_Field* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + output->a_ = (chunk0 >> 0) & 0x7f; + output->c_ = (chunk0 >> 7) & 0x1ffffffffffffff; + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0x7f)) | (static_cast(c_ & 0x1ffffffffffffff) << 7)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + uint8_t a_{0}; + uint64_t c_{0}; +}; + +class Struct_Enum_Field_ : public pdl::packet::Builder { +public: + ~Struct_Enum_Field_() override = default; + Struct_Enum_Field_() = default; + explicit Struct_Enum_Field_(Enum7 a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} + Struct_Enum_Field_(Struct_Enum_Field_ const&) = default; + Struct_Enum_Field_(Struct_Enum_Field_&&) = default; + Struct_Enum_Field_& operator=(Struct_Enum_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Enum_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + output->a_ = static_cast( (chunk0 >> 0) & 0x7f ); + if (!IsEnum7Valid(output->a_)) return false; + output->c_ = (chunk0 >> 7) & 0x1ffffffffffffff; + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(a_))) | (static_cast(c_ & 0x1ffffffffffffff) << 7)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + Enum7 a_{Enum7::A}; + uint64_t c_{0}; +}; + +class Struct_Enum_FieldView { +public: + static Struct_Enum_FieldView Create(pdl::packet::slice const& parent) { + return Struct_Enum_FieldView(parent); + } + + Struct_Enum_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Enum_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Enum_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Enum_Field_ s_; + + +}; + +class Struct_Enum_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_Enum_FieldBuilder() override = default; + Struct_Enum_FieldBuilder() = default; + explicit Struct_Enum_FieldBuilder(Struct_Enum_Field_ s) : s_(std::move(s)) {} + Struct_Enum_FieldBuilder(Struct_Enum_FieldBuilder const&) = default; + Struct_Enum_FieldBuilder(Struct_Enum_FieldBuilder&&) = default; + Struct_Enum_FieldBuilder& operator=(Struct_Enum_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Enum_Field_ s_; +}; + +class Struct_Reserved_Field_ : public pdl::packet::Builder { +public: + ~Struct_Reserved_Field_() override = default; + Struct_Reserved_Field_() = default; + explicit Struct_Reserved_Field_(uint8_t a, uint64_t c) : a_(std::move(a)), c_(std::move(c)) {} + Struct_Reserved_Field_(Struct_Reserved_Field_ const&) = default; + Struct_Reserved_Field_(Struct_Reserved_Field_&&) = default; + Struct_Reserved_Field_& operator=(Struct_Reserved_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Reserved_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + output->a_ = (chunk0 >> 0) & 0x7f; + output->c_ = (chunk0 >> 9) & 0x7fffffffffffff; + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(a_ & 0x7f)) | (static_cast(c_ & 0x7fffffffffffff) << 9)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + uint8_t a_{0}; + uint64_t c_{0}; +}; + +class Struct_Reserved_FieldView { +public: + static Struct_Reserved_FieldView Create(pdl::packet::slice const& parent) { + return Struct_Reserved_FieldView(parent); + } + + Struct_Reserved_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Reserved_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Reserved_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Reserved_Field_ s_; + + +}; + +class Struct_Reserved_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_Reserved_FieldBuilder() override = default; + Struct_Reserved_FieldBuilder() = default; + explicit Struct_Reserved_FieldBuilder(Struct_Reserved_Field_ s) : s_(std::move(s)) {} + Struct_Reserved_FieldBuilder(Struct_Reserved_FieldBuilder const&) = default; + Struct_Reserved_FieldBuilder(Struct_Reserved_FieldBuilder&&) = default; + Struct_Reserved_FieldBuilder& operator=(Struct_Reserved_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Reserved_Field_ s_; +}; + +class Struct_Size_Field_ : public pdl::packet::Builder { +public: + ~Struct_Size_Field_() override = default; + Struct_Size_Field_() = default; + explicit Struct_Size_Field_(uint64_t a, std::vector b) : a_(std::move(a)), b_(std::move(b)) {} + Struct_Size_Field_(Struct_Size_Field_ const&) = default; + Struct_Size_Field_(Struct_Size_Field_&&) = default; + Struct_Size_Field_& operator=(Struct_Size_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Size_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + output->b_size_ = (chunk0 >> 0) & 0x7; + output->a_ = (chunk0 >> 3) & 0x1fffffffffffffff; + if (span.size() < output->b_size_) return false; + if ((output->b_size_ % 1) != 0) return false; + size_t limit = span.size() - output->b_size_; + while (span.size() > limit) { + if (span.size() < 1) return false; + output->b_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t b_size = (b_.size() * 1); + pdl::packet::Builder::write_le(output, (static_cast(b_size)) | (static_cast(a_ & 0x1fffffffffffffff) << 3)); + for (auto const& element : b_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 8 + ((b_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t b_size_ {0}; + uint64_t a_{0}; + std::vector b_; +}; + +class Struct_Size_FieldView { +public: + static Struct_Size_FieldView Create(pdl::packet::slice const& parent) { + return Struct_Size_FieldView(parent); + } + + Struct_Size_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Size_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Size_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Size_Field_ s_; + + +}; + +class Struct_Size_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_Size_FieldBuilder() override = default; + Struct_Size_FieldBuilder() = default; + explicit Struct_Size_FieldBuilder(Struct_Size_Field_ s) : s_(std::move(s)) {} + Struct_Size_FieldBuilder(Struct_Size_FieldBuilder const&) = default; + Struct_Size_FieldBuilder(Struct_Size_FieldBuilder&&) = default; + Struct_Size_FieldBuilder& operator=(Struct_Size_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Size_Field_ s_; +}; + +class Struct_Count_Field_ : public pdl::packet::Builder { +public: + ~Struct_Count_Field_() override = default; + Struct_Count_Field_() = default; + explicit Struct_Count_Field_(uint64_t a, std::vector b) : a_(std::move(a)), b_(std::move(b)) {} + Struct_Count_Field_(Struct_Count_Field_ const&) = default; + Struct_Count_Field_(Struct_Count_Field_&&) = default; + Struct_Count_Field_& operator=(Struct_Count_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Count_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + output->b_count_ = (chunk0 >> 0) & 0x7; + output->a_ = (chunk0 >> 3) & 0x1fffffffffffffff; + for (size_t n = 0; n < output->b_count_; n++) { + if (span.size() < 1) return false; + output->b_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(b_.size())) | (static_cast(a_ & 0x1fffffffffffffff) << 3)); + for (auto const& element : b_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 8 + ((b_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t b_count_ {0}; + uint64_t a_{0}; + std::vector b_; +}; + +class Struct_Count_FieldView { +public: + static Struct_Count_FieldView Create(pdl::packet::slice const& parent) { + return Struct_Count_FieldView(parent); + } + + Struct_Count_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Count_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Count_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Count_Field_ s_; + + +}; + +class Struct_Count_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_Count_FieldBuilder() override = default; + Struct_Count_FieldBuilder() = default; + explicit Struct_Count_FieldBuilder(Struct_Count_Field_ s) : s_(std::move(s)) {} + Struct_Count_FieldBuilder(Struct_Count_FieldBuilder const&) = default; + Struct_Count_FieldBuilder(Struct_Count_FieldBuilder&&) = default; + Struct_Count_FieldBuilder& operator=(Struct_Count_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Count_Field_ s_; +}; + +class Struct_FixedScalar_Field_ : public pdl::packet::Builder { +public: + ~Struct_FixedScalar_Field_() override = default; + Struct_FixedScalar_Field_() = default; + explicit Struct_FixedScalar_Field_(uint64_t b) : b_(std::move(b)) {} + Struct_FixedScalar_Field_(Struct_FixedScalar_Field_ const&) = default; + Struct_FixedScalar_Field_(Struct_FixedScalar_Field_&&) = default; + Struct_FixedScalar_Field_& operator=(Struct_FixedScalar_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_FixedScalar_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + if (static_cast((chunk0 >> 0) & 0x7f) != 0x7) { + return false; + } + output->b_ = (chunk0 >> 7) & 0x1ffffffffffffff; + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(0x7)) | (static_cast(b_ & 0x1ffffffffffffff) << 7)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + uint64_t b_{0}; +}; + +class Struct_FixedScalar_FieldView { +public: + static Struct_FixedScalar_FieldView Create(pdl::packet::slice const& parent) { + return Struct_FixedScalar_FieldView(parent); + } + + Struct_FixedScalar_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_FixedScalar_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_FixedScalar_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_FixedScalar_Field_ s_; + + +}; + +class Struct_FixedScalar_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_FixedScalar_FieldBuilder() override = default; + Struct_FixedScalar_FieldBuilder() = default; + explicit Struct_FixedScalar_FieldBuilder(Struct_FixedScalar_Field_ s) : s_(std::move(s)) {} + Struct_FixedScalar_FieldBuilder(Struct_FixedScalar_FieldBuilder const&) = default; + Struct_FixedScalar_FieldBuilder(Struct_FixedScalar_FieldBuilder&&) = default; + Struct_FixedScalar_FieldBuilder& operator=(Struct_FixedScalar_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_FixedScalar_Field_ s_; +}; + +class Struct_FixedEnum_Field_ : public pdl::packet::Builder { +public: + ~Struct_FixedEnum_Field_() override = default; + Struct_FixedEnum_Field_() = default; + explicit Struct_FixedEnum_Field_(uint64_t b) : b_(std::move(b)) {} + Struct_FixedEnum_Field_(Struct_FixedEnum_Field_ const&) = default; + Struct_FixedEnum_Field_(Struct_FixedEnum_Field_&&) = default; + Struct_FixedEnum_Field_& operator=(Struct_FixedEnum_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_FixedEnum_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 8) { + return false; + } + uint64_t chunk0 = span.read_le(); + if (Enum7((chunk0 >> 0) & 0x7f) != Enum7::A) { + return false; + } + output->b_ = (chunk0 >> 7) & 0x1ffffffffffffff; + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(Enum7::A)) | (static_cast(b_ & 0x1ffffffffffffff) << 7)); + } + + size_t GetSize() const override { + return 8; + } + + std::string ToString() const { return ""; } + + uint64_t b_{0}; +}; + +class Struct_FixedEnum_FieldView { +public: + static Struct_FixedEnum_FieldView Create(pdl::packet::slice const& parent) { + return Struct_FixedEnum_FieldView(parent); + } + + Struct_FixedEnum_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_FixedEnum_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_FixedEnum_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_FixedEnum_Field_ s_; + + +}; + +class Struct_FixedEnum_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_FixedEnum_FieldBuilder() override = default; + Struct_FixedEnum_FieldBuilder() = default; + explicit Struct_FixedEnum_FieldBuilder(Struct_FixedEnum_Field_ s) : s_(std::move(s)) {} + Struct_FixedEnum_FieldBuilder(Struct_FixedEnum_FieldBuilder const&) = default; + Struct_FixedEnum_FieldBuilder(Struct_FixedEnum_FieldBuilder&&) = default; + Struct_FixedEnum_FieldBuilder& operator=(Struct_FixedEnum_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_FixedEnum_Field_ s_; +}; + +class Struct_ScalarGroup_Field_ : public pdl::packet::Builder { +public: + ~Struct_ScalarGroup_Field_() override = default; + Struct_ScalarGroup_Field_() = default; + Struct_ScalarGroup_Field_(Struct_ScalarGroup_Field_ const&) = default; + Struct_ScalarGroup_Field_(Struct_ScalarGroup_Field_&&) = default; + Struct_ScalarGroup_Field_& operator=(Struct_ScalarGroup_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_ScalarGroup_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 2) { + return false; + } + if (static_cast(span.read_le()) != 0x2a) { + return false; + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(0x2a))); + } + + size_t GetSize() const override { + return 2; + } + + std::string ToString() const { return ""; } + + +}; + +class Struct_ScalarGroup_FieldView { +public: + static Struct_ScalarGroup_FieldView Create(pdl::packet::slice const& parent) { + return Struct_ScalarGroup_FieldView(parent); + } + + Struct_ScalarGroup_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_ScalarGroup_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_ScalarGroup_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_ScalarGroup_Field_ s_; + + +}; + +class Struct_ScalarGroup_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_ScalarGroup_FieldBuilder() override = default; + Struct_ScalarGroup_FieldBuilder() = default; + explicit Struct_ScalarGroup_FieldBuilder(Struct_ScalarGroup_Field_ s) : s_(std::move(s)) {} + Struct_ScalarGroup_FieldBuilder(Struct_ScalarGroup_FieldBuilder const&) = default; + Struct_ScalarGroup_FieldBuilder(Struct_ScalarGroup_FieldBuilder&&) = default; + Struct_ScalarGroup_FieldBuilder& operator=(Struct_ScalarGroup_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_ScalarGroup_Field_ s_; +}; + +class Struct_EnumGroup_Field_ : public pdl::packet::Builder { +public: + ~Struct_EnumGroup_Field_() override = default; + Struct_EnumGroup_Field_() = default; + Struct_EnumGroup_Field_(Struct_EnumGroup_Field_ const&) = default; + Struct_EnumGroup_Field_(Struct_EnumGroup_Field_&&) = default; + Struct_EnumGroup_Field_& operator=(Struct_EnumGroup_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_EnumGroup_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 2) { + return false; + } + if (Enum16(span.read_le()) != Enum16::A) { + return false; + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(Enum16::A))); + } + + size_t GetSize() const override { + return 2; + } + + std::string ToString() const { return ""; } + + +}; + +class Struct_EnumGroup_FieldView { +public: + static Struct_EnumGroup_FieldView Create(pdl::packet::slice const& parent) { + return Struct_EnumGroup_FieldView(parent); + } + + Struct_EnumGroup_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_EnumGroup_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_EnumGroup_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_EnumGroup_Field_ s_; + + +}; + +class Struct_EnumGroup_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_EnumGroup_FieldBuilder() override = default; + Struct_EnumGroup_FieldBuilder() = default; + explicit Struct_EnumGroup_FieldBuilder(Struct_EnumGroup_Field_ s) : s_(std::move(s)) {} + Struct_EnumGroup_FieldBuilder(Struct_EnumGroup_FieldBuilder const&) = default; + Struct_EnumGroup_FieldBuilder(Struct_EnumGroup_FieldBuilder&&) = default; + Struct_EnumGroup_FieldBuilder& operator=(Struct_EnumGroup_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_EnumGroup_Field_ s_; +}; + +class Struct_Struct_FieldView { +public: + static Struct_Struct_FieldView Create(pdl::packet::slice const& parent) { + return Struct_Struct_FieldView(parent); + } + + SizedStruct const& GetA() const { _ASSERT_VALID(valid_); return a_; } + + UnsizedStruct const& GetB() const { _ASSERT_VALID(valid_); return b_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Struct_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!SizedStruct::Parse(span, &a_)) return false; + if (!UnsizedStruct::Parse(span, &b_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + SizedStruct a_; + UnsizedStruct b_; + + +}; + +class Struct_Struct_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_Struct_FieldBuilder() override = default; + Struct_Struct_FieldBuilder() = default; + explicit Struct_Struct_FieldBuilder(SizedStruct a, UnsizedStruct b) : a_(std::move(a)), b_(std::move(b)) {} + Struct_Struct_FieldBuilder(Struct_Struct_FieldBuilder const&) = default; + Struct_Struct_FieldBuilder(Struct_Struct_FieldBuilder&&) = default; + Struct_Struct_FieldBuilder& operator=(Struct_Struct_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + a_.Serialize(output); + b_.Serialize(output); + } + + size_t GetSize() const override { + return a_.GetSize() + b_.GetSize(); + } + + std::string ToString() const { return ""; } + + SizedStruct a_; + UnsizedStruct b_; +}; + +class Struct_Array_Field_ByteElement_ConstantSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ByteElement_ConstantSize_() override = default; + Struct_Array_Field_ByteElement_ConstantSize_() = default; + explicit Struct_Array_Field_ByteElement_ConstantSize_(std::array array) : array_(std::move(array)) {} + Struct_Array_Field_ByteElement_ConstantSize_(Struct_Array_Field_ByteElement_ConstantSize_ const&) = default; + Struct_Array_Field_ByteElement_ConstantSize_(Struct_Array_Field_ByteElement_ConstantSize_&&) = default; + Struct_Array_Field_ByteElement_ConstantSize_& operator=(Struct_Array_Field_ByteElement_ConstantSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ByteElement_ConstantSize_* output) { + pdl::packet::slice span = parent_span; + for (int n = 0; n < 4; n++) { + if (span.size() < 1) return false; + output->array_[n] = span.read_le(); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 1); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Struct_Array_Field_ByteElement_ConstantSizeView { +public: + static Struct_Array_Field_ByteElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_ByteElement_ConstantSizeView(parent); + } + + Struct_Array_Field_ByteElement_ConstantSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_ByteElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_ByteElement_ConstantSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_ByteElement_ConstantSize_ s_; + + +}; + +class Struct_Array_Field_ByteElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ByteElement_ConstantSizeBuilder() override = default; + Struct_Array_Field_ByteElement_ConstantSizeBuilder() = default; + explicit Struct_Array_Field_ByteElement_ConstantSizeBuilder(Struct_Array_Field_ByteElement_ConstantSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_ByteElement_ConstantSizeBuilder(Struct_Array_Field_ByteElement_ConstantSizeBuilder const&) = default; + Struct_Array_Field_ByteElement_ConstantSizeBuilder(Struct_Array_Field_ByteElement_ConstantSizeBuilder&&) = default; + Struct_Array_Field_ByteElement_ConstantSizeBuilder& operator=(Struct_Array_Field_ByteElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_ByteElement_ConstantSize_ s_; +}; + +class Struct_Array_Field_ByteElement_VariableSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ByteElement_VariableSize_() override = default; + Struct_Array_Field_ByteElement_VariableSize_() = default; + explicit Struct_Array_Field_ByteElement_VariableSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_ByteElement_VariableSize_(Struct_Array_Field_ByteElement_VariableSize_ const&) = default; + Struct_Array_Field_ByteElement_VariableSize_(Struct_Array_Field_ByteElement_VariableSize_&&) = default; + Struct_Array_Field_ByteElement_VariableSize_& operator=(Struct_Array_Field_ByteElement_VariableSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ByteElement_VariableSize_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < output->array_size_) return false; + if ((output->array_size_ % 1) != 0) return false; + size_t limit = span.size() - output->array_size_; + while (span.size() > limit) { + if (span.size() < 1) return false; + output->array_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 1); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_ByteElement_VariableSizeView { +public: + static Struct_Array_Field_ByteElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_ByteElement_VariableSizeView(parent); + } + + Struct_Array_Field_ByteElement_VariableSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_ByteElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_ByteElement_VariableSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_ByteElement_VariableSize_ s_; + + +}; + +class Struct_Array_Field_ByteElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ByteElement_VariableSizeBuilder() override = default; + Struct_Array_Field_ByteElement_VariableSizeBuilder() = default; + explicit Struct_Array_Field_ByteElement_VariableSizeBuilder(Struct_Array_Field_ByteElement_VariableSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_ByteElement_VariableSizeBuilder(Struct_Array_Field_ByteElement_VariableSizeBuilder const&) = default; + Struct_Array_Field_ByteElement_VariableSizeBuilder(Struct_Array_Field_ByteElement_VariableSizeBuilder&&) = default; + Struct_Array_Field_ByteElement_VariableSizeBuilder& operator=(Struct_Array_Field_ByteElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_ByteElement_VariableSize_ s_; +}; + +class Struct_Array_Field_ByteElement_VariableCount_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ByteElement_VariableCount_() override = default; + Struct_Array_Field_ByteElement_VariableCount_() = default; + explicit Struct_Array_Field_ByteElement_VariableCount_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_ByteElement_VariableCount_(Struct_Array_Field_ByteElement_VariableCount_ const&) = default; + Struct_Array_Field_ByteElement_VariableCount_(Struct_Array_Field_ByteElement_VariableCount_&&) = default; + Struct_Array_Field_ByteElement_VariableCount_& operator=(Struct_Array_Field_ByteElement_VariableCount_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ByteElement_VariableCount_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_count_ = (chunk0 >> 0) & 0xf; + for (size_t n = 0; n < output->array_count_; n++) { + if (span.size() < 1) return false; + output->array_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 1)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_ByteElement_VariableCountView { +public: + static Struct_Array_Field_ByteElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_ByteElement_VariableCountView(parent); + } + + Struct_Array_Field_ByteElement_VariableCount_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_ByteElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_ByteElement_VariableCount_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_ByteElement_VariableCount_ s_; + + +}; + +class Struct_Array_Field_ByteElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ByteElement_VariableCountBuilder() override = default; + Struct_Array_Field_ByteElement_VariableCountBuilder() = default; + explicit Struct_Array_Field_ByteElement_VariableCountBuilder(Struct_Array_Field_ByteElement_VariableCount_ s) : s_(std::move(s)) {} + Struct_Array_Field_ByteElement_VariableCountBuilder(Struct_Array_Field_ByteElement_VariableCountBuilder const&) = default; + Struct_Array_Field_ByteElement_VariableCountBuilder(Struct_Array_Field_ByteElement_VariableCountBuilder&&) = default; + Struct_Array_Field_ByteElement_VariableCountBuilder& operator=(Struct_Array_Field_ByteElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_ByteElement_VariableCount_ s_; +}; + +class Struct_Array_Field_ByteElement_UnknownSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ByteElement_UnknownSize_() override = default; + Struct_Array_Field_ByteElement_UnknownSize_() = default; + explicit Struct_Array_Field_ByteElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_ByteElement_UnknownSize_(Struct_Array_Field_ByteElement_UnknownSize_ const&) = default; + Struct_Array_Field_ByteElement_UnknownSize_(Struct_Array_Field_ByteElement_UnknownSize_&&) = default; + Struct_Array_Field_ByteElement_UnknownSize_& operator=(Struct_Array_Field_ByteElement_UnknownSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ByteElement_UnknownSize_* output) { + pdl::packet::slice span = parent_span; + while (span.size() > 0) { + if (span.size() < 1) return false; + output->array_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 1); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Struct_Array_Field_ByteElement_UnknownSizeView { +public: + static Struct_Array_Field_ByteElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_ByteElement_UnknownSizeView(parent); + } + + Struct_Array_Field_ByteElement_UnknownSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_ByteElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_ByteElement_UnknownSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_ByteElement_UnknownSize_ s_; + + +}; + +class Struct_Array_Field_ByteElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ByteElement_UnknownSizeBuilder() override = default; + Struct_Array_Field_ByteElement_UnknownSizeBuilder() = default; + explicit Struct_Array_Field_ByteElement_UnknownSizeBuilder(Struct_Array_Field_ByteElement_UnknownSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_ByteElement_UnknownSizeBuilder(Struct_Array_Field_ByteElement_UnknownSizeBuilder const&) = default; + Struct_Array_Field_ByteElement_UnknownSizeBuilder(Struct_Array_Field_ByteElement_UnknownSizeBuilder&&) = default; + Struct_Array_Field_ByteElement_UnknownSizeBuilder& operator=(Struct_Array_Field_ByteElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_ByteElement_UnknownSize_ s_; +}; + +class Struct_Array_Field_ScalarElement_ConstantSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ScalarElement_ConstantSize_() override = default; + Struct_Array_Field_ScalarElement_ConstantSize_() = default; + explicit Struct_Array_Field_ScalarElement_ConstantSize_(std::array array) : array_(std::move(array)) {} + Struct_Array_Field_ScalarElement_ConstantSize_(Struct_Array_Field_ScalarElement_ConstantSize_ const&) = default; + Struct_Array_Field_ScalarElement_ConstantSize_(Struct_Array_Field_ScalarElement_ConstantSize_&&) = default; + Struct_Array_Field_ScalarElement_ConstantSize_& operator=(Struct_Array_Field_ScalarElement_ConstantSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ScalarElement_ConstantSize_* output) { + pdl::packet::slice span = parent_span; + for (int n = 0; n < 4; n++) { + if (span.size() < 2) return false; + output->array_[n] = span.read_le(); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 2); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Struct_Array_Field_ScalarElement_ConstantSizeView { +public: + static Struct_Array_Field_ScalarElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_ScalarElement_ConstantSizeView(parent); + } + + Struct_Array_Field_ScalarElement_ConstantSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_ScalarElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_ScalarElement_ConstantSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_ScalarElement_ConstantSize_ s_; + + +}; + +class Struct_Array_Field_ScalarElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ScalarElement_ConstantSizeBuilder() override = default; + Struct_Array_Field_ScalarElement_ConstantSizeBuilder() = default; + explicit Struct_Array_Field_ScalarElement_ConstantSizeBuilder(Struct_Array_Field_ScalarElement_ConstantSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_ScalarElement_ConstantSizeBuilder(Struct_Array_Field_ScalarElement_ConstantSizeBuilder const&) = default; + Struct_Array_Field_ScalarElement_ConstantSizeBuilder(Struct_Array_Field_ScalarElement_ConstantSizeBuilder&&) = default; + Struct_Array_Field_ScalarElement_ConstantSizeBuilder& operator=(Struct_Array_Field_ScalarElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_ScalarElement_ConstantSize_ s_; +}; + +class Struct_Array_Field_ScalarElement_VariableSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ScalarElement_VariableSize_() override = default; + Struct_Array_Field_ScalarElement_VariableSize_() = default; + explicit Struct_Array_Field_ScalarElement_VariableSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_ScalarElement_VariableSize_(Struct_Array_Field_ScalarElement_VariableSize_ const&) = default; + Struct_Array_Field_ScalarElement_VariableSize_(Struct_Array_Field_ScalarElement_VariableSize_&&) = default; + Struct_Array_Field_ScalarElement_VariableSize_& operator=(Struct_Array_Field_ScalarElement_VariableSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ScalarElement_VariableSize_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < output->array_size_) return false; + if ((output->array_size_ % 2) != 0) return false; + size_t limit = span.size() - output->array_size_; + while (span.size() > limit) { + if (span.size() < 2) return false; + output->array_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 2); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 2)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_ScalarElement_VariableSizeView { +public: + static Struct_Array_Field_ScalarElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_ScalarElement_VariableSizeView(parent); + } + + Struct_Array_Field_ScalarElement_VariableSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_ScalarElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_ScalarElement_VariableSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_ScalarElement_VariableSize_ s_; + + +}; + +class Struct_Array_Field_ScalarElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ScalarElement_VariableSizeBuilder() override = default; + Struct_Array_Field_ScalarElement_VariableSizeBuilder() = default; + explicit Struct_Array_Field_ScalarElement_VariableSizeBuilder(Struct_Array_Field_ScalarElement_VariableSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_ScalarElement_VariableSizeBuilder(Struct_Array_Field_ScalarElement_VariableSizeBuilder const&) = default; + Struct_Array_Field_ScalarElement_VariableSizeBuilder(Struct_Array_Field_ScalarElement_VariableSizeBuilder&&) = default; + Struct_Array_Field_ScalarElement_VariableSizeBuilder& operator=(Struct_Array_Field_ScalarElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_ScalarElement_VariableSize_ s_; +}; + +class Struct_Array_Field_ScalarElement_VariableCount_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ScalarElement_VariableCount_() override = default; + Struct_Array_Field_ScalarElement_VariableCount_() = default; + explicit Struct_Array_Field_ScalarElement_VariableCount_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_ScalarElement_VariableCount_(Struct_Array_Field_ScalarElement_VariableCount_ const&) = default; + Struct_Array_Field_ScalarElement_VariableCount_(Struct_Array_Field_ScalarElement_VariableCount_&&) = default; + Struct_Array_Field_ScalarElement_VariableCount_& operator=(Struct_Array_Field_ScalarElement_VariableCount_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ScalarElement_VariableCount_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_count_ = (chunk0 >> 0) & 0xf; + for (size_t n = 0; n < output->array_count_; n++) { + if (span.size() < 2) return false; + output->array_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 2)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_ScalarElement_VariableCountView { +public: + static Struct_Array_Field_ScalarElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_ScalarElement_VariableCountView(parent); + } + + Struct_Array_Field_ScalarElement_VariableCount_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_ScalarElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_ScalarElement_VariableCount_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_ScalarElement_VariableCount_ s_; + + +}; + +class Struct_Array_Field_ScalarElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ScalarElement_VariableCountBuilder() override = default; + Struct_Array_Field_ScalarElement_VariableCountBuilder() = default; + explicit Struct_Array_Field_ScalarElement_VariableCountBuilder(Struct_Array_Field_ScalarElement_VariableCount_ s) : s_(std::move(s)) {} + Struct_Array_Field_ScalarElement_VariableCountBuilder(Struct_Array_Field_ScalarElement_VariableCountBuilder const&) = default; + Struct_Array_Field_ScalarElement_VariableCountBuilder(Struct_Array_Field_ScalarElement_VariableCountBuilder&&) = default; + Struct_Array_Field_ScalarElement_VariableCountBuilder& operator=(Struct_Array_Field_ScalarElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_ScalarElement_VariableCount_ s_; +}; + +class Struct_Array_Field_ScalarElement_UnknownSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ScalarElement_UnknownSize_() override = default; + Struct_Array_Field_ScalarElement_UnknownSize_() = default; + explicit Struct_Array_Field_ScalarElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_ScalarElement_UnknownSize_(Struct_Array_Field_ScalarElement_UnknownSize_ const&) = default; + Struct_Array_Field_ScalarElement_UnknownSize_(Struct_Array_Field_ScalarElement_UnknownSize_&&) = default; + Struct_Array_Field_ScalarElement_UnknownSize_& operator=(Struct_Array_Field_ScalarElement_UnknownSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_ScalarElement_UnknownSize_* output) { + pdl::packet::slice span = parent_span; + while (span.size() > 0) { + if (span.size() < 2) return false; + output->array_.push_back(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 2); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Struct_Array_Field_ScalarElement_UnknownSizeView { +public: + static Struct_Array_Field_ScalarElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_ScalarElement_UnknownSizeView(parent); + } + + Struct_Array_Field_ScalarElement_UnknownSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_ScalarElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_ScalarElement_UnknownSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_ScalarElement_UnknownSize_ s_; + + +}; + +class Struct_Array_Field_ScalarElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_ScalarElement_UnknownSizeBuilder() override = default; + Struct_Array_Field_ScalarElement_UnknownSizeBuilder() = default; + explicit Struct_Array_Field_ScalarElement_UnknownSizeBuilder(Struct_Array_Field_ScalarElement_UnknownSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_ScalarElement_UnknownSizeBuilder(Struct_Array_Field_ScalarElement_UnknownSizeBuilder const&) = default; + Struct_Array_Field_ScalarElement_UnknownSizeBuilder(Struct_Array_Field_ScalarElement_UnknownSizeBuilder&&) = default; + Struct_Array_Field_ScalarElement_UnknownSizeBuilder& operator=(Struct_Array_Field_ScalarElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_ScalarElement_UnknownSize_ s_; +}; + +class Struct_Array_Field_EnumElement_ConstantSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_EnumElement_ConstantSize_() override = default; + Struct_Array_Field_EnumElement_ConstantSize_() = default; + explicit Struct_Array_Field_EnumElement_ConstantSize_(std::array array) : array_(std::move(array)) {} + Struct_Array_Field_EnumElement_ConstantSize_(Struct_Array_Field_EnumElement_ConstantSize_ const&) = default; + Struct_Array_Field_EnumElement_ConstantSize_(Struct_Array_Field_EnumElement_ConstantSize_&&) = default; + Struct_Array_Field_EnumElement_ConstantSize_& operator=(Struct_Array_Field_EnumElement_ConstantSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_EnumElement_ConstantSize_* output) { + pdl::packet::slice span = parent_span; + for (int n = 0; n < 4; n++) { + if (span.size() < 2) return false; + output->array_[n] = Enum16(span.read_le()); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 2); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Struct_Array_Field_EnumElement_ConstantSizeView { +public: + static Struct_Array_Field_EnumElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_EnumElement_ConstantSizeView(parent); + } + + Struct_Array_Field_EnumElement_ConstantSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_EnumElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_EnumElement_ConstantSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_EnumElement_ConstantSize_ s_; + + +}; + +class Struct_Array_Field_EnumElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_EnumElement_ConstantSizeBuilder() override = default; + Struct_Array_Field_EnumElement_ConstantSizeBuilder() = default; + explicit Struct_Array_Field_EnumElement_ConstantSizeBuilder(Struct_Array_Field_EnumElement_ConstantSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_EnumElement_ConstantSizeBuilder(Struct_Array_Field_EnumElement_ConstantSizeBuilder const&) = default; + Struct_Array_Field_EnumElement_ConstantSizeBuilder(Struct_Array_Field_EnumElement_ConstantSizeBuilder&&) = default; + Struct_Array_Field_EnumElement_ConstantSizeBuilder& operator=(Struct_Array_Field_EnumElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_EnumElement_ConstantSize_ s_; +}; + +class Struct_Array_Field_EnumElement_VariableSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_EnumElement_VariableSize_() override = default; + Struct_Array_Field_EnumElement_VariableSize_() = default; + explicit Struct_Array_Field_EnumElement_VariableSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_EnumElement_VariableSize_(Struct_Array_Field_EnumElement_VariableSize_ const&) = default; + Struct_Array_Field_EnumElement_VariableSize_(Struct_Array_Field_EnumElement_VariableSize_&&) = default; + Struct_Array_Field_EnumElement_VariableSize_& operator=(Struct_Array_Field_EnumElement_VariableSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_EnumElement_VariableSize_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < output->array_size_) return false; + if ((output->array_size_ % 2) != 0) return false; + size_t limit = span.size() - output->array_size_; + while (span.size() > limit) { + if (span.size() < 2) return false; + output->array_.push_back(Enum16(span.read_le())); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 2); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 2)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_EnumElement_VariableSizeView { +public: + static Struct_Array_Field_EnumElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_EnumElement_VariableSizeView(parent); + } + + Struct_Array_Field_EnumElement_VariableSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_EnumElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_EnumElement_VariableSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_EnumElement_VariableSize_ s_; + + +}; + +class Struct_Array_Field_EnumElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_EnumElement_VariableSizeBuilder() override = default; + Struct_Array_Field_EnumElement_VariableSizeBuilder() = default; + explicit Struct_Array_Field_EnumElement_VariableSizeBuilder(Struct_Array_Field_EnumElement_VariableSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_EnumElement_VariableSizeBuilder(Struct_Array_Field_EnumElement_VariableSizeBuilder const&) = default; + Struct_Array_Field_EnumElement_VariableSizeBuilder(Struct_Array_Field_EnumElement_VariableSizeBuilder&&) = default; + Struct_Array_Field_EnumElement_VariableSizeBuilder& operator=(Struct_Array_Field_EnumElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_EnumElement_VariableSize_ s_; +}; + +class Struct_Array_Field_EnumElement_VariableCount_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_EnumElement_VariableCount_() override = default; + Struct_Array_Field_EnumElement_VariableCount_() = default; + explicit Struct_Array_Field_EnumElement_VariableCount_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_EnumElement_VariableCount_(Struct_Array_Field_EnumElement_VariableCount_ const&) = default; + Struct_Array_Field_EnumElement_VariableCount_(Struct_Array_Field_EnumElement_VariableCount_&&) = default; + Struct_Array_Field_EnumElement_VariableCount_& operator=(Struct_Array_Field_EnumElement_VariableCount_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_EnumElement_VariableCount_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_count_ = (chunk0 >> 0) & 0xf; + for (size_t n = 0; n < output->array_count_; n++) { + if (span.size() < 2) return false; + output->array_.push_back(Enum16(span.read_le())); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return 1 + ((array_.size() * 2)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_EnumElement_VariableCountView { +public: + static Struct_Array_Field_EnumElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_EnumElement_VariableCountView(parent); + } + + Struct_Array_Field_EnumElement_VariableCount_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_EnumElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_EnumElement_VariableCount_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_EnumElement_VariableCount_ s_; + + +}; + +class Struct_Array_Field_EnumElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_EnumElement_VariableCountBuilder() override = default; + Struct_Array_Field_EnumElement_VariableCountBuilder() = default; + explicit Struct_Array_Field_EnumElement_VariableCountBuilder(Struct_Array_Field_EnumElement_VariableCount_ s) : s_(std::move(s)) {} + Struct_Array_Field_EnumElement_VariableCountBuilder(Struct_Array_Field_EnumElement_VariableCountBuilder const&) = default; + Struct_Array_Field_EnumElement_VariableCountBuilder(Struct_Array_Field_EnumElement_VariableCountBuilder&&) = default; + Struct_Array_Field_EnumElement_VariableCountBuilder& operator=(Struct_Array_Field_EnumElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_EnumElement_VariableCount_ s_; +}; + +class Struct_Array_Field_EnumElement_UnknownSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_EnumElement_UnknownSize_() override = default; + Struct_Array_Field_EnumElement_UnknownSize_() = default; + explicit Struct_Array_Field_EnumElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_EnumElement_UnknownSize_(Struct_Array_Field_EnumElement_UnknownSize_ const&) = default; + Struct_Array_Field_EnumElement_UnknownSize_(Struct_Array_Field_EnumElement_UnknownSize_&&) = default; + Struct_Array_Field_EnumElement_UnknownSize_& operator=(Struct_Array_Field_EnumElement_UnknownSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_EnumElement_UnknownSize_* output) { + pdl::packet::slice span = parent_span; + while (span.size() > 0) { + if (span.size() < 2) return false; + output->array_.push_back(Enum16(span.read_le())); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + } + + size_t GetSize() const override { + return (array_.size() * 2); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Struct_Array_Field_EnumElement_UnknownSizeView { +public: + static Struct_Array_Field_EnumElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_EnumElement_UnknownSizeView(parent); + } + + Struct_Array_Field_EnumElement_UnknownSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_EnumElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_EnumElement_UnknownSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_EnumElement_UnknownSize_ s_; + + +}; + +class Struct_Array_Field_EnumElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_EnumElement_UnknownSizeBuilder() override = default; + Struct_Array_Field_EnumElement_UnknownSizeBuilder() = default; + explicit Struct_Array_Field_EnumElement_UnknownSizeBuilder(Struct_Array_Field_EnumElement_UnknownSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_EnumElement_UnknownSizeBuilder(Struct_Array_Field_EnumElement_UnknownSizeBuilder const&) = default; + Struct_Array_Field_EnumElement_UnknownSizeBuilder(Struct_Array_Field_EnumElement_UnknownSizeBuilder&&) = default; + Struct_Array_Field_EnumElement_UnknownSizeBuilder& operator=(Struct_Array_Field_EnumElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_EnumElement_UnknownSize_ s_; +}; + +class Struct_Array_Field_SizedElement_ConstantSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_ConstantSize_() override = default; + Struct_Array_Field_SizedElement_ConstantSize_() = default; + explicit Struct_Array_Field_SizedElement_ConstantSize_(std::array array) : array_(std::move(array)) {} + Struct_Array_Field_SizedElement_ConstantSize_(Struct_Array_Field_SizedElement_ConstantSize_ const&) = default; + Struct_Array_Field_SizedElement_ConstantSize_(Struct_Array_Field_SizedElement_ConstantSize_&&) = default; + Struct_Array_Field_SizedElement_ConstantSize_& operator=(Struct_Array_Field_SizedElement_ConstantSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_ConstantSize_* output) { + pdl::packet::slice span = parent_span; + for (int n = 0; n < 4; n++) { + if (!SizedStruct::Parse(span, &output->array_[n])) return false; + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Struct_Array_Field_SizedElement_ConstantSizeView { +public: + static Struct_Array_Field_SizedElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_SizedElement_ConstantSizeView(parent); + } + + Struct_Array_Field_SizedElement_ConstantSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_SizedElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_SizedElement_ConstantSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_SizedElement_ConstantSize_ s_; + + +}; + +class Struct_Array_Field_SizedElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_ConstantSizeBuilder() override = default; + Struct_Array_Field_SizedElement_ConstantSizeBuilder() = default; + explicit Struct_Array_Field_SizedElement_ConstantSizeBuilder(Struct_Array_Field_SizedElement_ConstantSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_SizedElement_ConstantSizeBuilder(Struct_Array_Field_SizedElement_ConstantSizeBuilder const&) = default; + Struct_Array_Field_SizedElement_ConstantSizeBuilder(Struct_Array_Field_SizedElement_ConstantSizeBuilder&&) = default; + Struct_Array_Field_SizedElement_ConstantSizeBuilder& operator=(Struct_Array_Field_SizedElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_SizedElement_ConstantSize_ s_; +}; + +class Struct_Array_Field_SizedElement_VariableSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_VariableSize_() override = default; + Struct_Array_Field_SizedElement_VariableSize_() = default; + explicit Struct_Array_Field_SizedElement_VariableSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_SizedElement_VariableSize_(Struct_Array_Field_SizedElement_VariableSize_ const&) = default; + Struct_Array_Field_SizedElement_VariableSize_(Struct_Array_Field_SizedElement_VariableSize_&&) = default; + Struct_Array_Field_SizedElement_VariableSize_& operator=(Struct_Array_Field_SizedElement_VariableSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_VariableSize_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < output->array_size_) return false; + if ((output->array_size_ % 1) != 0) return false; + size_t limit = span.size() - output->array_size_; + while (span.size() > limit) { + SizedStruct element; + if (!SizedStruct::Parse(span, &element)) return false; + output->array_.emplace_back(std::move(element)); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t array_size = std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& element) { return s + element.GetSize(); }); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_SizedElement_VariableSizeView { +public: + static Struct_Array_Field_SizedElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_SizedElement_VariableSizeView(parent); + } + + Struct_Array_Field_SizedElement_VariableSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_SizedElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_SizedElement_VariableSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_SizedElement_VariableSize_ s_; + + +}; + +class Struct_Array_Field_SizedElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_VariableSizeBuilder() override = default; + Struct_Array_Field_SizedElement_VariableSizeBuilder() = default; + explicit Struct_Array_Field_SizedElement_VariableSizeBuilder(Struct_Array_Field_SizedElement_VariableSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_SizedElement_VariableSizeBuilder(Struct_Array_Field_SizedElement_VariableSizeBuilder const&) = default; + Struct_Array_Field_SizedElement_VariableSizeBuilder(Struct_Array_Field_SizedElement_VariableSizeBuilder&&) = default; + Struct_Array_Field_SizedElement_VariableSizeBuilder& operator=(Struct_Array_Field_SizedElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_SizedElement_VariableSize_ s_; +}; + +class Struct_Array_Field_SizedElement_VariableCount_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_VariableCount_() override = default; + Struct_Array_Field_SizedElement_VariableCount_() = default; + explicit Struct_Array_Field_SizedElement_VariableCount_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_SizedElement_VariableCount_(Struct_Array_Field_SizedElement_VariableCount_ const&) = default; + Struct_Array_Field_SizedElement_VariableCount_(Struct_Array_Field_SizedElement_VariableCount_&&) = default; + Struct_Array_Field_SizedElement_VariableCount_& operator=(Struct_Array_Field_SizedElement_VariableCount_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_VariableCount_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_count_ = (chunk0 >> 0) & 0xf; + for (size_t n = 0; n < output->array_count_; n++) { + SizedStruct element; + if (!SizedStruct::Parse(span, &element)) return false; + output->array_.emplace_back(std::move(element)); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_SizedElement_VariableCountView { +public: + static Struct_Array_Field_SizedElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_SizedElement_VariableCountView(parent); + } + + Struct_Array_Field_SizedElement_VariableCount_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_SizedElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_SizedElement_VariableCount_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_SizedElement_VariableCount_ s_; + + +}; + +class Struct_Array_Field_SizedElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_VariableCountBuilder() override = default; + Struct_Array_Field_SizedElement_VariableCountBuilder() = default; + explicit Struct_Array_Field_SizedElement_VariableCountBuilder(Struct_Array_Field_SizedElement_VariableCount_ s) : s_(std::move(s)) {} + Struct_Array_Field_SizedElement_VariableCountBuilder(Struct_Array_Field_SizedElement_VariableCountBuilder const&) = default; + Struct_Array_Field_SizedElement_VariableCountBuilder(Struct_Array_Field_SizedElement_VariableCountBuilder&&) = default; + Struct_Array_Field_SizedElement_VariableCountBuilder& operator=(Struct_Array_Field_SizedElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_SizedElement_VariableCount_ s_; +}; + +class Struct_Array_Field_SizedElement_UnknownSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_UnknownSize_() override = default; + Struct_Array_Field_SizedElement_UnknownSize_() = default; + explicit Struct_Array_Field_SizedElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_SizedElement_UnknownSize_(Struct_Array_Field_SizedElement_UnknownSize_ const&) = default; + Struct_Array_Field_SizedElement_UnknownSize_(Struct_Array_Field_SizedElement_UnknownSize_&&) = default; + Struct_Array_Field_SizedElement_UnknownSize_& operator=(Struct_Array_Field_SizedElement_UnknownSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_UnknownSize_* output) { + pdl::packet::slice span = parent_span; + while (span.size() > 0) { + SizedStruct element; + if (!SizedStruct::Parse(span, &element)) return false; + output->array_.emplace_back(std::move(element)); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Struct_Array_Field_SizedElement_UnknownSizeView { +public: + static Struct_Array_Field_SizedElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_SizedElement_UnknownSizeView(parent); + } + + Struct_Array_Field_SizedElement_UnknownSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_SizedElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_SizedElement_UnknownSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_SizedElement_UnknownSize_ s_; + + +}; + +class Struct_Array_Field_SizedElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_UnknownSizeBuilder() override = default; + Struct_Array_Field_SizedElement_UnknownSizeBuilder() = default; + explicit Struct_Array_Field_SizedElement_UnknownSizeBuilder(Struct_Array_Field_SizedElement_UnknownSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_SizedElement_UnknownSizeBuilder(Struct_Array_Field_SizedElement_UnknownSizeBuilder const&) = default; + Struct_Array_Field_SizedElement_UnknownSizeBuilder(Struct_Array_Field_SizedElement_UnknownSizeBuilder&&) = default; + Struct_Array_Field_SizedElement_UnknownSizeBuilder& operator=(Struct_Array_Field_SizedElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_SizedElement_UnknownSize_ s_; +}; + +class Struct_Array_Field_UnsizedElement_ConstantSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_ConstantSize_() override = default; + Struct_Array_Field_UnsizedElement_ConstantSize_() = default; + explicit Struct_Array_Field_UnsizedElement_ConstantSize_(std::array array) : array_(std::move(array)) {} + Struct_Array_Field_UnsizedElement_ConstantSize_(Struct_Array_Field_UnsizedElement_ConstantSize_ const&) = default; + Struct_Array_Field_UnsizedElement_ConstantSize_(Struct_Array_Field_UnsizedElement_ConstantSize_&&) = default; + Struct_Array_Field_UnsizedElement_ConstantSize_& operator=(Struct_Array_Field_UnsizedElement_ConstantSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_ConstantSize_* output) { + pdl::packet::slice span = parent_span; + for (int n = 0; n < 4; n++) { + if (!UnsizedStruct::Parse(span, &output->array_[n])) return false; + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }); + } + + std::string ToString() const { return ""; } + + std::array array_; +}; + +class Struct_Array_Field_UnsizedElement_ConstantSizeView { +public: + static Struct_Array_Field_UnsizedElement_ConstantSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_UnsizedElement_ConstantSizeView(parent); + } + + Struct_Array_Field_UnsizedElement_ConstantSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_UnsizedElement_ConstantSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_UnsizedElement_ConstantSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_UnsizedElement_ConstantSize_ s_; + + +}; + +class Struct_Array_Field_UnsizedElement_ConstantSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_ConstantSizeBuilder() override = default; + Struct_Array_Field_UnsizedElement_ConstantSizeBuilder() = default; + explicit Struct_Array_Field_UnsizedElement_ConstantSizeBuilder(Struct_Array_Field_UnsizedElement_ConstantSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_UnsizedElement_ConstantSizeBuilder(Struct_Array_Field_UnsizedElement_ConstantSizeBuilder const&) = default; + Struct_Array_Field_UnsizedElement_ConstantSizeBuilder(Struct_Array_Field_UnsizedElement_ConstantSizeBuilder&&) = default; + Struct_Array_Field_UnsizedElement_ConstantSizeBuilder& operator=(Struct_Array_Field_UnsizedElement_ConstantSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_UnsizedElement_ConstantSize_ s_; +}; + +class Struct_Array_Field_UnsizedElement_VariableSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_VariableSize_() override = default; + Struct_Array_Field_UnsizedElement_VariableSize_() = default; + explicit Struct_Array_Field_UnsizedElement_VariableSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_UnsizedElement_VariableSize_(Struct_Array_Field_UnsizedElement_VariableSize_ const&) = default; + Struct_Array_Field_UnsizedElement_VariableSize_(Struct_Array_Field_UnsizedElement_VariableSize_&&) = default; + Struct_Array_Field_UnsizedElement_VariableSize_& operator=(Struct_Array_Field_UnsizedElement_VariableSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_VariableSize_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < output->array_size_) return false; + size_t limit = span.size() - output->array_size_; + while (span.size() > limit) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) return false; + output->array_.emplace_back(std::move(element)); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t array_size = std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& element) { return s + element.GetSize(); }); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_UnsizedElement_VariableSizeView { +public: + static Struct_Array_Field_UnsizedElement_VariableSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_UnsizedElement_VariableSizeView(parent); + } + + Struct_Array_Field_UnsizedElement_VariableSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_UnsizedElement_VariableSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_UnsizedElement_VariableSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_UnsizedElement_VariableSize_ s_; + + +}; + +class Struct_Array_Field_UnsizedElement_VariableSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_VariableSizeBuilder() override = default; + Struct_Array_Field_UnsizedElement_VariableSizeBuilder() = default; + explicit Struct_Array_Field_UnsizedElement_VariableSizeBuilder(Struct_Array_Field_UnsizedElement_VariableSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_UnsizedElement_VariableSizeBuilder(Struct_Array_Field_UnsizedElement_VariableSizeBuilder const&) = default; + Struct_Array_Field_UnsizedElement_VariableSizeBuilder(Struct_Array_Field_UnsizedElement_VariableSizeBuilder&&) = default; + Struct_Array_Field_UnsizedElement_VariableSizeBuilder& operator=(Struct_Array_Field_UnsizedElement_VariableSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_UnsizedElement_VariableSize_ s_; +}; + +class Struct_Array_Field_UnsizedElement_VariableCount_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_VariableCount_() override = default; + Struct_Array_Field_UnsizedElement_VariableCount_() = default; + explicit Struct_Array_Field_UnsizedElement_VariableCount_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_UnsizedElement_VariableCount_(Struct_Array_Field_UnsizedElement_VariableCount_ const&) = default; + Struct_Array_Field_UnsizedElement_VariableCount_(Struct_Array_Field_UnsizedElement_VariableCount_&&) = default; + Struct_Array_Field_UnsizedElement_VariableCount_& operator=(Struct_Array_Field_UnsizedElement_VariableCount_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_VariableCount_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_count_ = (chunk0 >> 0) & 0xf; + for (size_t n = 0; n < output->array_count_; n++) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) return false; + output->array_.emplace_back(std::move(element)); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_UnsizedElement_VariableCountView { +public: + static Struct_Array_Field_UnsizedElement_VariableCountView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_UnsizedElement_VariableCountView(parent); + } + + Struct_Array_Field_UnsizedElement_VariableCount_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_UnsizedElement_VariableCountView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_UnsizedElement_VariableCount_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_UnsizedElement_VariableCount_ s_; + + +}; + +class Struct_Array_Field_UnsizedElement_VariableCountBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_VariableCountBuilder() override = default; + Struct_Array_Field_UnsizedElement_VariableCountBuilder() = default; + explicit Struct_Array_Field_UnsizedElement_VariableCountBuilder(Struct_Array_Field_UnsizedElement_VariableCount_ s) : s_(std::move(s)) {} + Struct_Array_Field_UnsizedElement_VariableCountBuilder(Struct_Array_Field_UnsizedElement_VariableCountBuilder const&) = default; + Struct_Array_Field_UnsizedElement_VariableCountBuilder(Struct_Array_Field_UnsizedElement_VariableCountBuilder&&) = default; + Struct_Array_Field_UnsizedElement_VariableCountBuilder& operator=(Struct_Array_Field_UnsizedElement_VariableCountBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_UnsizedElement_VariableCount_ s_; +}; + +class Struct_Array_Field_UnsizedElement_UnknownSize_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_UnknownSize_() override = default; + Struct_Array_Field_UnsizedElement_UnknownSize_() = default; + explicit Struct_Array_Field_UnsizedElement_UnknownSize_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_UnsizedElement_UnknownSize_(Struct_Array_Field_UnsizedElement_UnknownSize_ const&) = default; + Struct_Array_Field_UnsizedElement_UnknownSize_(Struct_Array_Field_UnsizedElement_UnknownSize_&&) = default; + Struct_Array_Field_UnsizedElement_UnknownSize_& operator=(Struct_Array_Field_UnsizedElement_UnknownSize_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_UnknownSize_* output) { + pdl::packet::slice span = parent_span; + while (span.size() > 0) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) return false; + output->array_.emplace_back(std::move(element)); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }); + } + + std::string ToString() const { return ""; } + + std::vector array_; +}; + +class Struct_Array_Field_UnsizedElement_UnknownSizeView { +public: + static Struct_Array_Field_UnsizedElement_UnknownSizeView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_UnsizedElement_UnknownSizeView(parent); + } + + Struct_Array_Field_UnsizedElement_UnknownSize_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_UnsizedElement_UnknownSizeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_UnsizedElement_UnknownSize_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_UnsizedElement_UnknownSize_ s_; + + +}; + +class Struct_Array_Field_UnsizedElement_UnknownSizeBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_UnknownSizeBuilder() override = default; + Struct_Array_Field_UnsizedElement_UnknownSizeBuilder() = default; + explicit Struct_Array_Field_UnsizedElement_UnknownSizeBuilder(Struct_Array_Field_UnsizedElement_UnknownSize_ s) : s_(std::move(s)) {} + Struct_Array_Field_UnsizedElement_UnknownSizeBuilder(Struct_Array_Field_UnsizedElement_UnknownSizeBuilder const&) = default; + Struct_Array_Field_UnsizedElement_UnknownSizeBuilder(Struct_Array_Field_UnsizedElement_UnknownSizeBuilder&&) = default; + Struct_Array_Field_UnsizedElement_UnknownSizeBuilder& operator=(Struct_Array_Field_UnsizedElement_UnknownSizeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_UnsizedElement_UnknownSize_ s_; +}; + +class Struct_Array_Field_UnsizedElement_SizeModifier_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_SizeModifier_() override = default; + Struct_Array_Field_UnsizedElement_SizeModifier_() = default; + explicit Struct_Array_Field_UnsizedElement_SizeModifier_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_UnsizedElement_SizeModifier_(Struct_Array_Field_UnsizedElement_SizeModifier_ const&) = default; + Struct_Array_Field_UnsizedElement_SizeModifier_(Struct_Array_Field_UnsizedElement_SizeModifier_&&) = default; + Struct_Array_Field_UnsizedElement_SizeModifier_& operator=(Struct_Array_Field_UnsizedElement_SizeModifier_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_SizeModifier_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_size_ = (chunk0 >> 0) & 0xf; + if (span.size() < (output->array_size_ - 2)) return false; + size_t limit = span.size() - (output->array_size_ - 2); + while (span.size() > limit) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) return false; + output->array_.emplace_back(std::move(element)); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t array_size = (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& element) { return s + element.GetSize(); }) +2); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + for (auto const& element : array_) { + element.Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + (std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); })); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_UnsizedElement_SizeModifierView { +public: + static Struct_Array_Field_UnsizedElement_SizeModifierView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_UnsizedElement_SizeModifierView(parent); + } + + Struct_Array_Field_UnsizedElement_SizeModifier_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_UnsizedElement_SizeModifierView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_UnsizedElement_SizeModifier_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_UnsizedElement_SizeModifier_ s_; + + +}; + +class Struct_Array_Field_UnsizedElement_SizeModifierBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_SizeModifierBuilder() override = default; + Struct_Array_Field_UnsizedElement_SizeModifierBuilder() = default; + explicit Struct_Array_Field_UnsizedElement_SizeModifierBuilder(Struct_Array_Field_UnsizedElement_SizeModifier_ s) : s_(std::move(s)) {} + Struct_Array_Field_UnsizedElement_SizeModifierBuilder(Struct_Array_Field_UnsizedElement_SizeModifierBuilder const&) = default; + Struct_Array_Field_UnsizedElement_SizeModifierBuilder(Struct_Array_Field_UnsizedElement_SizeModifierBuilder&&) = default; + Struct_Array_Field_UnsizedElement_SizeModifierBuilder& operator=(Struct_Array_Field_UnsizedElement_SizeModifierBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_UnsizedElement_SizeModifier_ s_; +}; + +class Struct_Array_Field_SizedElement_VariableSize_Padded_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_VariableSize_Padded_() override = default; + Struct_Array_Field_SizedElement_VariableSize_Padded_() = default; + explicit Struct_Array_Field_SizedElement_VariableSize_Padded_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_SizedElement_VariableSize_Padded_(Struct_Array_Field_SizedElement_VariableSize_Padded_ const&) = default; + Struct_Array_Field_SizedElement_VariableSize_Padded_(Struct_Array_Field_SizedElement_VariableSize_Padded_&&) = default; + Struct_Array_Field_SizedElement_VariableSize_Padded_& operator=(Struct_Array_Field_SizedElement_VariableSize_Padded_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_SizedElement_VariableSize_Padded_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + output->array_size_ = (chunk0 >> 0) & 0xf; + size_t array_start_size = span.size(); + if (span.size() < output->array_size_) return false; + if ((output->array_size_ % 2) != 0) return false; + size_t limit = span.size() - output->array_size_; + while (span.size() > limit) { + if (span.size() < 2) return false; + output->array_.push_back(span.read_le()); + } + if (array_start_size - span.size() < 16) { + if (span.size() < 16 - (array_start_size - span.size())) return false; + span.skip(16 - (array_start_size - span.size())); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + size_t array_size = (array_.size() * 2); + pdl::packet::Builder::write_le(output, (static_cast(array_size))); + size_t array_start = output.size(); + for (auto const& element : array_) { + pdl::packet::Builder::write_le(output, static_cast(element)); + } + if (output.size() - array_start < 16) { + output.resize(array_start + 16, 0); + } + } + + size_t GetSize() const override { + return 1 + (std::max((array_.size() * 2), 16)); + } + + std::string ToString() const { return ""; } + + uint8_t array_size_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_SizedElement_VariableSize_PaddedView { +public: + static Struct_Array_Field_SizedElement_VariableSize_PaddedView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_SizedElement_VariableSize_PaddedView(parent); + } + + Struct_Array_Field_SizedElement_VariableSize_Padded_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_SizedElement_VariableSize_PaddedView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_SizedElement_VariableSize_Padded_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_SizedElement_VariableSize_Padded_ s_; + + +}; + +class Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder() override = default; + Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder() = default; + explicit Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder(Struct_Array_Field_SizedElement_VariableSize_Padded_ s) : s_(std::move(s)) {} + Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder(Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder const&) = default; + Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder(Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder&&) = default; + Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder& operator=(Struct_Array_Field_SizedElement_VariableSize_PaddedBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_SizedElement_VariableSize_Padded_ s_; +}; + +class Struct_Array_Field_UnsizedElement_VariableCount_Padded_ : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_VariableCount_Padded_() override = default; + Struct_Array_Field_UnsizedElement_VariableCount_Padded_() = default; + explicit Struct_Array_Field_UnsizedElement_VariableCount_Padded_(std::vector array) : array_(std::move(array)) {} + Struct_Array_Field_UnsizedElement_VariableCount_Padded_(Struct_Array_Field_UnsizedElement_VariableCount_Padded_ const&) = default; + Struct_Array_Field_UnsizedElement_VariableCount_Padded_(Struct_Array_Field_UnsizedElement_VariableCount_Padded_&&) = default; + Struct_Array_Field_UnsizedElement_VariableCount_Padded_& operator=(Struct_Array_Field_UnsizedElement_VariableCount_Padded_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Array_Field_UnsizedElement_VariableCount_Padded_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + output->array_count_ = span.read_le(); + size_t array_start_size = span.size(); + for (size_t n = 0; n < output->array_count_; n++) { + UnsizedStruct element; + if (!UnsizedStruct::Parse(span, &element)) return false; + output->array_.emplace_back(std::move(element)); + } + if (array_start_size - span.size() < 16) { + if (span.size() < 16 - (array_start_size - span.size())) return false; + span.skip(16 - (array_start_size - span.size())); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(array_.size()))); + size_t array_start = output.size(); + for (auto const& element : array_) { + element.Serialize(output); + } + if (output.size() - array_start < 16) { + output.resize(array_start + 16, 0); + } + } + + size_t GetSize() const override { + return 1 + (std::max(std::accumulate(array_.begin(), array_.end(), static_cast(0), [](size_t s, auto const& e) { return s + e.GetSize(); }), 16)); + } + + std::string ToString() const { return ""; } + + uint8_t array_count_ {0}; + std::vector array_; +}; + +class Struct_Array_Field_UnsizedElement_VariableCount_PaddedView { +public: + static Struct_Array_Field_UnsizedElement_VariableCount_PaddedView Create(pdl::packet::slice const& parent) { + return Struct_Array_Field_UnsizedElement_VariableCount_PaddedView(parent); + } + + Struct_Array_Field_UnsizedElement_VariableCount_Padded_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Array_Field_UnsizedElement_VariableCount_PaddedView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Array_Field_UnsizedElement_VariableCount_Padded_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Array_Field_UnsizedElement_VariableCount_Padded_ s_; + + +}; + +class Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder : public pdl::packet::Builder { +public: + ~Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder() override = default; + Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder() = default; + explicit Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder(Struct_Array_Field_UnsizedElement_VariableCount_Padded_ s) : s_(std::move(s)) {} + Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder(Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder const&) = default; + Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder(Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder&&) = default; + Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder& operator=(Struct_Array_Field_UnsizedElement_VariableCount_PaddedBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Array_Field_UnsizedElement_VariableCount_Padded_ s_; +}; + +class Struct_Optional_Scalar_Field_ : public pdl::packet::Builder { +public: + ~Struct_Optional_Scalar_Field_() override = default; + Struct_Optional_Scalar_Field_() = default; + explicit Struct_Optional_Scalar_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} + Struct_Optional_Scalar_Field_(Struct_Optional_Scalar_Field_ const&) = default; + Struct_Optional_Scalar_Field_(Struct_Optional_Scalar_Field_&&) = default; + Struct_Optional_Scalar_Field_& operator=(Struct_Optional_Scalar_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Optional_Scalar_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + uint8_t c0 = (chunk0 >> 0) & 0x1; + uint8_t c1 = (chunk0 >> 1) & 0x1; + if (c0 == 0) { + if (span.size() < 3) { + return false; + } + output->a_ = span.read_le(); + } + if (c1 == 1) { + if (span.size() < 4) { + return false; + } + output->b_ = span.read_le(); + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast((a_.has_value() ? 0 : 1))) | (static_cast((b_.has_value() ? 1 : 0)) << 1)); + if ((a_.has_value() ? 0 : 1) == 0) { + pdl::packet::Builder::write_le(output, *a_); + } + if ((b_.has_value() ? 1 : 0) == 1) { + pdl::packet::Builder::write_le(output, *b_); + } + } + + size_t GetSize() const override { + return 1 + ((((a_.has_value() ? 0 : 1) == 0) ? 3 : 0) + (((b_.has_value() ? 1 : 0) == 1) ? 4 : 0)); + } + + std::string ToString() const { return ""; } + + std::optional a_; + std::optional b_; +}; + +class Struct_Optional_Scalar_FieldView { +public: + static Struct_Optional_Scalar_FieldView Create(pdl::packet::slice const& parent) { + return Struct_Optional_Scalar_FieldView(parent); + } + + Struct_Optional_Scalar_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Optional_Scalar_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Optional_Scalar_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Optional_Scalar_Field_ s_; + + +}; + +class Struct_Optional_Scalar_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_Optional_Scalar_FieldBuilder() override = default; + Struct_Optional_Scalar_FieldBuilder() = default; + explicit Struct_Optional_Scalar_FieldBuilder(Struct_Optional_Scalar_Field_ s) : s_(std::move(s)) {} + Struct_Optional_Scalar_FieldBuilder(Struct_Optional_Scalar_FieldBuilder const&) = default; + Struct_Optional_Scalar_FieldBuilder(Struct_Optional_Scalar_FieldBuilder&&) = default; + Struct_Optional_Scalar_FieldBuilder& operator=(Struct_Optional_Scalar_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Optional_Scalar_Field_ s_; +}; + +class Struct_Optional_Enum_Field_ : public pdl::packet::Builder { +public: + ~Struct_Optional_Enum_Field_() override = default; + Struct_Optional_Enum_Field_() = default; + explicit Struct_Optional_Enum_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} + Struct_Optional_Enum_Field_(Struct_Optional_Enum_Field_ const&) = default; + Struct_Optional_Enum_Field_(Struct_Optional_Enum_Field_&&) = default; + Struct_Optional_Enum_Field_& operator=(Struct_Optional_Enum_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Optional_Enum_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + uint8_t c0 = (chunk0 >> 0) & 0x1; + uint8_t c1 = (chunk0 >> 1) & 0x1; + if (c0 == 0) { + if (span.size() < 2) { + return false; + } + output->a_ = static_cast(span.read_le()); + if (!IsEnum16Valid(output->a_.value())) return false; + } + if (c1 == 1) { + if (span.size() < 2) { + return false; + } + output->b_ = static_cast(span.read_le()); + if (!IsEnum16Valid(output->b_.value())) return false; + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast((a_.has_value() ? 0 : 1))) | (static_cast((b_.has_value() ? 1 : 0)) << 1)); + if ((a_.has_value() ? 0 : 1) == 0) { + pdl::packet::Builder::write_le(output, static_cast(*a_)); + } + if ((b_.has_value() ? 1 : 0) == 1) { + pdl::packet::Builder::write_le(output, static_cast(*b_)); + } + } + + size_t GetSize() const override { + return 1 + ((((a_.has_value() ? 0 : 1) == 0) ? 2 : 0) + (((b_.has_value() ? 1 : 0) == 1) ? 2 : 0)); + } + + std::string ToString() const { return ""; } + + std::optional a_; + std::optional b_; +}; + +class Struct_Optional_Enum_FieldView { +public: + static Struct_Optional_Enum_FieldView Create(pdl::packet::slice const& parent) { + return Struct_Optional_Enum_FieldView(parent); + } + + Struct_Optional_Enum_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Optional_Enum_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Optional_Enum_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Optional_Enum_Field_ s_; + + +}; + +class Struct_Optional_Enum_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_Optional_Enum_FieldBuilder() override = default; + Struct_Optional_Enum_FieldBuilder() = default; + explicit Struct_Optional_Enum_FieldBuilder(Struct_Optional_Enum_Field_ s) : s_(std::move(s)) {} + Struct_Optional_Enum_FieldBuilder(Struct_Optional_Enum_FieldBuilder const&) = default; + Struct_Optional_Enum_FieldBuilder(Struct_Optional_Enum_FieldBuilder&&) = default; + Struct_Optional_Enum_FieldBuilder& operator=(Struct_Optional_Enum_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Optional_Enum_Field_ s_; +}; + +class Struct_Optional_Struct_Field_ : public pdl::packet::Builder { +public: + ~Struct_Optional_Struct_Field_() override = default; + Struct_Optional_Struct_Field_() = default; + explicit Struct_Optional_Struct_Field_(std::optional a, std::optional b) : a_(std::move(a)), b_(std::move(b)) {} + Struct_Optional_Struct_Field_(Struct_Optional_Struct_Field_ const&) = default; + Struct_Optional_Struct_Field_(Struct_Optional_Struct_Field_&&) = default; + Struct_Optional_Struct_Field_& operator=(Struct_Optional_Struct_Field_ const&) = default; + + static bool Parse(pdl::packet::slice& parent_span, Struct_Optional_Struct_Field_* output) { + pdl::packet::slice span = parent_span; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + uint8_t c0 = (chunk0 >> 0) & 0x1; + uint8_t c1 = (chunk0 >> 1) & 0x1; + if (c0 == 0) { + auto& opt_output = output->a_.emplace(); + if (!SizedStruct::Parse(span, &opt_output)) { + return false; + } + } + if (c1 == 1) { + auto& opt_output = output->b_.emplace(); + if (!UnsizedStruct::Parse(span, &opt_output)) { + return false; + } + } + parent_span = span; + return true; + } + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast((a_.has_value() ? 0 : 1))) | (static_cast((b_.has_value() ? 1 : 0)) << 1)); + if ((a_.has_value() ? 0 : 1) == 0) { + a_->Serialize(output); + } + if ((b_.has_value() ? 1 : 0) == 1) { + b_->Serialize(output); + } + } + + size_t GetSize() const override { + return 1 + ((((a_.has_value() ? 0 : 1) == 0) ? a_->GetSize() : 0) + (((b_.has_value() ? 1 : 0) == 1) ? b_->GetSize() : 0)); + } + + std::string ToString() const { return ""; } + + std::optional a_; + std::optional b_; +}; + +class Struct_Optional_Struct_FieldView { +public: + static Struct_Optional_Struct_FieldView Create(pdl::packet::slice const& parent) { + return Struct_Optional_Struct_FieldView(parent); + } + + Struct_Optional_Struct_Field_ const& GetS() const { _ASSERT_VALID(valid_); return s_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Struct_Optional_Struct_FieldView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (!Struct_Optional_Struct_Field_::Parse(span, &s_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Struct_Optional_Struct_Field_ s_; + + +}; + +class Struct_Optional_Struct_FieldBuilder : public pdl::packet::Builder { +public: + ~Struct_Optional_Struct_FieldBuilder() override = default; + Struct_Optional_Struct_FieldBuilder() = default; + explicit Struct_Optional_Struct_FieldBuilder(Struct_Optional_Struct_Field_ s) : s_(std::move(s)) {} + Struct_Optional_Struct_FieldBuilder(Struct_Optional_Struct_FieldBuilder const&) = default; + Struct_Optional_Struct_FieldBuilder(Struct_Optional_Struct_FieldBuilder&&) = default; + Struct_Optional_Struct_FieldBuilder& operator=(Struct_Optional_Struct_FieldBuilder const&) = default; + + void Serialize(std::vector& output) const override { + s_.Serialize(output); + } + + size_t GetSize() const override { + return s_.GetSize(); + } + + std::string ToString() const { return ""; } + + Struct_Optional_Struct_Field_ s_; +}; + +enum class Enum_Incomplete_Truncated_Closed_ : uint8_t { + A = 0x0, + B = 0x1, +}; + +inline std::string Enum_Incomplete_Truncated_Closed_Text(Enum_Incomplete_Truncated_Closed_ tag) { + switch (tag) { + case Enum_Incomplete_Truncated_Closed_::A: return "A"; + case Enum_Incomplete_Truncated_Closed_::B: return "B"; + default: + return std::string("Unknown Enum_Incomplete_Truncated_Closed_: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum_Incomplete_Truncated_Closed_Valid(Enum_Incomplete_Truncated_Closed_ tag) { + return tag == Enum_Incomplete_Truncated_Closed_::A || tag == Enum_Incomplete_Truncated_Closed_::B; +} + +class Enum_Incomplete_Truncated_ClosedView { +public: + static Enum_Incomplete_Truncated_ClosedView Create(pdl::packet::slice const& parent) { + return Enum_Incomplete_Truncated_ClosedView(parent); + } + + Enum_Incomplete_Truncated_Closed_ GetE() const { _ASSERT_VALID(valid_); return e_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Enum_Incomplete_Truncated_ClosedView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + e_ = static_cast( (chunk0 >> 0) & 0x7 ); + if (!IsEnum_Incomplete_Truncated_Closed_Valid(e_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum_Incomplete_Truncated_Closed_ e_{Enum_Incomplete_Truncated_Closed_::A}; + + +}; + +class Enum_Incomplete_Truncated_ClosedBuilder : public pdl::packet::Builder { +public: + ~Enum_Incomplete_Truncated_ClosedBuilder() override = default; + Enum_Incomplete_Truncated_ClosedBuilder() = default; + explicit Enum_Incomplete_Truncated_ClosedBuilder(Enum_Incomplete_Truncated_Closed_ e) : e_(std::move(e)) {} + Enum_Incomplete_Truncated_ClosedBuilder(Enum_Incomplete_Truncated_ClosedBuilder const&) = default; + Enum_Incomplete_Truncated_ClosedBuilder(Enum_Incomplete_Truncated_ClosedBuilder&&) = default; + Enum_Incomplete_Truncated_ClosedBuilder& operator=(Enum_Incomplete_Truncated_ClosedBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(e_)))); + } + + size_t GetSize() const override { + return 1; + } + + std::string ToString() const { return ""; } + + Enum_Incomplete_Truncated_Closed_ e_{Enum_Incomplete_Truncated_Closed_::A}; +}; + +enum class Enum_Incomplete_Truncated_Open_ : uint8_t { + A = 0x0, + B = 0x1, +}; + +inline std::string Enum_Incomplete_Truncated_Open_Text(Enum_Incomplete_Truncated_Open_ tag) { + switch (tag) { + case Enum_Incomplete_Truncated_Open_::A: return "A"; + case Enum_Incomplete_Truncated_Open_::B: return "B"; + default: + return std::string("Unknown Enum_Incomplete_Truncated_Open_: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum_Incomplete_Truncated_Open_Valid(Enum_Incomplete_Truncated_Open_ /* tag */) { return true; } + +class Enum_Incomplete_Truncated_OpenView { +public: + static Enum_Incomplete_Truncated_OpenView Create(pdl::packet::slice const& parent) { + return Enum_Incomplete_Truncated_OpenView(parent); + } + + Enum_Incomplete_Truncated_Open_ GetE() const { _ASSERT_VALID(valid_); return e_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Enum_Incomplete_Truncated_OpenView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + e_ = static_cast( (chunk0 >> 0) & 0x7 ); + if (!IsEnum_Incomplete_Truncated_Open_Valid(e_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum_Incomplete_Truncated_Open_ e_{Enum_Incomplete_Truncated_Open_::A}; + + +}; + +class Enum_Incomplete_Truncated_OpenBuilder : public pdl::packet::Builder { +public: + ~Enum_Incomplete_Truncated_OpenBuilder() override = default; + Enum_Incomplete_Truncated_OpenBuilder() = default; + explicit Enum_Incomplete_Truncated_OpenBuilder(Enum_Incomplete_Truncated_Open_ e) : e_(std::move(e)) {} + Enum_Incomplete_Truncated_OpenBuilder(Enum_Incomplete_Truncated_OpenBuilder const&) = default; + Enum_Incomplete_Truncated_OpenBuilder(Enum_Incomplete_Truncated_OpenBuilder&&) = default; + Enum_Incomplete_Truncated_OpenBuilder& operator=(Enum_Incomplete_Truncated_OpenBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(e_)))); + } + + size_t GetSize() const override { + return 1; + } + + std::string ToString() const { return ""; } + + Enum_Incomplete_Truncated_Open_ e_{Enum_Incomplete_Truncated_Open_::A}; +}; + +enum class Enum_Incomplete_Truncated_Closed_WithRange_ : uint8_t { + A = 0x0, + X = 0x1, + Y = 0x2, +}; + +inline std::string Enum_Incomplete_Truncated_Closed_WithRange_Text(Enum_Incomplete_Truncated_Closed_WithRange_ tag) { + switch (tag) { + case Enum_Incomplete_Truncated_Closed_WithRange_::A: return "A"; + case Enum_Incomplete_Truncated_Closed_WithRange_::X: return "X"; + case Enum_Incomplete_Truncated_Closed_WithRange_::Y: return "Y"; + default: + return std::string("Unknown Enum_Incomplete_Truncated_Closed_WithRange_: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum_Incomplete_Truncated_Closed_WithRange_Valid(Enum_Incomplete_Truncated_Closed_WithRange_ tag) { + return tag == Enum_Incomplete_Truncated_Closed_WithRange_::A || (static_cast(tag) >= 0x1 && static_cast(tag) <= 0x6); +} + +class Enum_Incomplete_Truncated_Closed_WithRangeView { +public: + static Enum_Incomplete_Truncated_Closed_WithRangeView Create(pdl::packet::slice const& parent) { + return Enum_Incomplete_Truncated_Closed_WithRangeView(parent); + } + + Enum_Incomplete_Truncated_Closed_WithRange_ GetE() const { _ASSERT_VALID(valid_); return e_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Enum_Incomplete_Truncated_Closed_WithRangeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + e_ = static_cast( (chunk0 >> 0) & 0x7 ); + if (!IsEnum_Incomplete_Truncated_Closed_WithRange_Valid(e_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum_Incomplete_Truncated_Closed_WithRange_ e_{Enum_Incomplete_Truncated_Closed_WithRange_::A}; + + +}; + +class Enum_Incomplete_Truncated_Closed_WithRangeBuilder : public pdl::packet::Builder { +public: + ~Enum_Incomplete_Truncated_Closed_WithRangeBuilder() override = default; + Enum_Incomplete_Truncated_Closed_WithRangeBuilder() = default; + explicit Enum_Incomplete_Truncated_Closed_WithRangeBuilder(Enum_Incomplete_Truncated_Closed_WithRange_ e) : e_(std::move(e)) {} + Enum_Incomplete_Truncated_Closed_WithRangeBuilder(Enum_Incomplete_Truncated_Closed_WithRangeBuilder const&) = default; + Enum_Incomplete_Truncated_Closed_WithRangeBuilder(Enum_Incomplete_Truncated_Closed_WithRangeBuilder&&) = default; + Enum_Incomplete_Truncated_Closed_WithRangeBuilder& operator=(Enum_Incomplete_Truncated_Closed_WithRangeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(e_)))); + } + + size_t GetSize() const override { + return 1; + } + + std::string ToString() const { return ""; } + + Enum_Incomplete_Truncated_Closed_WithRange_ e_{Enum_Incomplete_Truncated_Closed_WithRange_::A}; +}; + +enum class Enum_Incomplete_Truncated_Open_WithRange_ : uint8_t { + A = 0x0, + X = 0x1, + Y = 0x2, +}; + +inline std::string Enum_Incomplete_Truncated_Open_WithRange_Text(Enum_Incomplete_Truncated_Open_WithRange_ tag) { + switch (tag) { + case Enum_Incomplete_Truncated_Open_WithRange_::A: return "A"; + case Enum_Incomplete_Truncated_Open_WithRange_::X: return "X"; + case Enum_Incomplete_Truncated_Open_WithRange_::Y: return "Y"; + default: + return std::string("Unknown Enum_Incomplete_Truncated_Open_WithRange_: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum_Incomplete_Truncated_Open_WithRange_Valid(Enum_Incomplete_Truncated_Open_WithRange_ /* tag */) { return true; } + +class Enum_Incomplete_Truncated_Open_WithRangeView { +public: + static Enum_Incomplete_Truncated_Open_WithRangeView Create(pdl::packet::slice const& parent) { + return Enum_Incomplete_Truncated_Open_WithRangeView(parent); + } + + Enum_Incomplete_Truncated_Open_WithRange_ GetE() const { _ASSERT_VALID(valid_); return e_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Enum_Incomplete_Truncated_Open_WithRangeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + e_ = static_cast( (chunk0 >> 0) & 0x7 ); + if (!IsEnum_Incomplete_Truncated_Open_WithRange_Valid(e_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum_Incomplete_Truncated_Open_WithRange_ e_{Enum_Incomplete_Truncated_Open_WithRange_::A}; + + +}; + +class Enum_Incomplete_Truncated_Open_WithRangeBuilder : public pdl::packet::Builder { +public: + ~Enum_Incomplete_Truncated_Open_WithRangeBuilder() override = default; + Enum_Incomplete_Truncated_Open_WithRangeBuilder() = default; + explicit Enum_Incomplete_Truncated_Open_WithRangeBuilder(Enum_Incomplete_Truncated_Open_WithRange_ e) : e_(std::move(e)) {} + Enum_Incomplete_Truncated_Open_WithRangeBuilder(Enum_Incomplete_Truncated_Open_WithRangeBuilder const&) = default; + Enum_Incomplete_Truncated_Open_WithRangeBuilder(Enum_Incomplete_Truncated_Open_WithRangeBuilder&&) = default; + Enum_Incomplete_Truncated_Open_WithRangeBuilder& operator=(Enum_Incomplete_Truncated_Open_WithRangeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(e_)))); + } + + size_t GetSize() const override { + return 1; + } + + std::string ToString() const { return ""; } + + Enum_Incomplete_Truncated_Open_WithRange_ e_{Enum_Incomplete_Truncated_Open_WithRange_::A}; +}; + +enum class Enum_Complete_Truncated_ : uint8_t { + A = 0x0, + B = 0x1, + C = 0x2, + D = 0x3, + E = 0x4, + F = 0x5, + G = 0x6, + H = 0x7, +}; + +inline std::string Enum_Complete_Truncated_Text(Enum_Complete_Truncated_ tag) { + switch (tag) { + case Enum_Complete_Truncated_::A: return "A"; + case Enum_Complete_Truncated_::B: return "B"; + case Enum_Complete_Truncated_::C: return "C"; + case Enum_Complete_Truncated_::D: return "D"; + case Enum_Complete_Truncated_::E: return "E"; + case Enum_Complete_Truncated_::F: return "F"; + case Enum_Complete_Truncated_::G: return "G"; + case Enum_Complete_Truncated_::H: return "H"; + default: + return std::string("Unknown Enum_Complete_Truncated_: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum_Complete_Truncated_Valid(Enum_Complete_Truncated_ tag) { + return tag == Enum_Complete_Truncated_::A || tag == Enum_Complete_Truncated_::B || tag == Enum_Complete_Truncated_::C || tag == Enum_Complete_Truncated_::D || tag == Enum_Complete_Truncated_::E || tag == Enum_Complete_Truncated_::F || tag == Enum_Complete_Truncated_::G || tag == Enum_Complete_Truncated_::H; +} + +class Enum_Complete_TruncatedView { +public: + static Enum_Complete_TruncatedView Create(pdl::packet::slice const& parent) { + return Enum_Complete_TruncatedView(parent); + } + + Enum_Complete_Truncated_ GetE() const { _ASSERT_VALID(valid_); return e_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Enum_Complete_TruncatedView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + e_ = static_cast( (chunk0 >> 0) & 0x7 ); + if (!IsEnum_Complete_Truncated_Valid(e_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum_Complete_Truncated_ e_{Enum_Complete_Truncated_::A}; + + +}; + +class Enum_Complete_TruncatedBuilder : public pdl::packet::Builder { +public: + ~Enum_Complete_TruncatedBuilder() override = default; + Enum_Complete_TruncatedBuilder() = default; + explicit Enum_Complete_TruncatedBuilder(Enum_Complete_Truncated_ e) : e_(std::move(e)) {} + Enum_Complete_TruncatedBuilder(Enum_Complete_TruncatedBuilder const&) = default; + Enum_Complete_TruncatedBuilder(Enum_Complete_TruncatedBuilder&&) = default; + Enum_Complete_TruncatedBuilder& operator=(Enum_Complete_TruncatedBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(e_)))); + } + + size_t GetSize() const override { + return 1; + } + + std::string ToString() const { return ""; } + + Enum_Complete_Truncated_ e_{Enum_Complete_Truncated_::A}; +}; + +enum class Enum_Complete_Truncated_WithRange_ : uint8_t { + A = 0x0, + X = 0x1, + Y = 0x2, +}; + +inline std::string Enum_Complete_Truncated_WithRange_Text(Enum_Complete_Truncated_WithRange_ tag) { + switch (tag) { + case Enum_Complete_Truncated_WithRange_::A: return "A"; + case Enum_Complete_Truncated_WithRange_::X: return "X"; + case Enum_Complete_Truncated_WithRange_::Y: return "Y"; + default: + return std::string("Unknown Enum_Complete_Truncated_WithRange_: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum_Complete_Truncated_WithRange_Valid(Enum_Complete_Truncated_WithRange_ tag) { + return tag == Enum_Complete_Truncated_WithRange_::A || (static_cast(tag) >= 0x1 && static_cast(tag) <= 0x7); +} + +class Enum_Complete_Truncated_WithRangeView { +public: + static Enum_Complete_Truncated_WithRangeView Create(pdl::packet::slice const& parent) { + return Enum_Complete_Truncated_WithRangeView(parent); + } + + Enum_Complete_Truncated_WithRange_ GetE() const { _ASSERT_VALID(valid_); return e_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Enum_Complete_Truncated_WithRangeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + uint8_t chunk0 = span.read_le(); + e_ = static_cast( (chunk0 >> 0) & 0x7 ); + if (!IsEnum_Complete_Truncated_WithRange_Valid(e_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum_Complete_Truncated_WithRange_ e_{Enum_Complete_Truncated_WithRange_::A}; + + +}; + +class Enum_Complete_Truncated_WithRangeBuilder : public pdl::packet::Builder { +public: + ~Enum_Complete_Truncated_WithRangeBuilder() override = default; + Enum_Complete_Truncated_WithRangeBuilder() = default; + explicit Enum_Complete_Truncated_WithRangeBuilder(Enum_Complete_Truncated_WithRange_ e) : e_(std::move(e)) {} + Enum_Complete_Truncated_WithRangeBuilder(Enum_Complete_Truncated_WithRangeBuilder const&) = default; + Enum_Complete_Truncated_WithRangeBuilder(Enum_Complete_Truncated_WithRangeBuilder&&) = default; + Enum_Complete_Truncated_WithRangeBuilder& operator=(Enum_Complete_Truncated_WithRangeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(e_)))); + } + + size_t GetSize() const override { + return 1; + } + + std::string ToString() const { return ""; } + + Enum_Complete_Truncated_WithRange_ e_{Enum_Complete_Truncated_WithRange_::A}; +}; + +enum class Enum_Complete_WithRange_ : uint8_t { + A = 0x0, + B = 0x1, +}; + +inline std::string Enum_Complete_WithRange_Text(Enum_Complete_WithRange_ tag) { + switch (tag) { + case Enum_Complete_WithRange_::A: return "A"; + case Enum_Complete_WithRange_::B: return "B"; + default: + return std::string("Unknown Enum_Complete_WithRange_: " + + std::to_string(static_cast(tag))); + } +} + +inline bool IsEnum_Complete_WithRange_Valid(Enum_Complete_WithRange_ tag) { + return tag == Enum_Complete_WithRange_::A || tag == Enum_Complete_WithRange_::B || (static_cast(tag) >= 0x2 && static_cast(tag) <= 0xff); +} + +class Enum_Complete_WithRangeView { +public: + static Enum_Complete_WithRangeView Create(pdl::packet::slice const& parent) { + return Enum_Complete_WithRangeView(parent); + } + + Enum_Complete_WithRange_ GetE() const { _ASSERT_VALID(valid_); return e_; } + + std::string ToString() const { return ""; } + + bool IsValid() const { + return valid_; + } + + pdl::packet::slice bytes() const { + return bytes_; + } + +protected: + explicit Enum_Complete_WithRangeView(pdl::packet::slice const& parent) + : bytes_(parent) { + valid_ = Parse(parent); + } + + bool Parse(pdl::packet::slice const& parent) { + // Parse packet field values. + pdl::packet::slice span = parent; + if (span.size() < 1) { + return false; + } + e_ = static_cast( span.read_le() ); + if (!IsEnum_Complete_WithRange_Valid(e_)) return false; + if (span.size() != 0) { return false; } + return true; + } + + bool valid_{false}; + pdl::packet::slice bytes_; + Enum_Complete_WithRange_ e_{Enum_Complete_WithRange_::A}; + + +}; + +class Enum_Complete_WithRangeBuilder : public pdl::packet::Builder { +public: + ~Enum_Complete_WithRangeBuilder() override = default; + Enum_Complete_WithRangeBuilder() = default; + explicit Enum_Complete_WithRangeBuilder(Enum_Complete_WithRange_ e) : e_(std::move(e)) {} + Enum_Complete_WithRangeBuilder(Enum_Complete_WithRangeBuilder const&) = default; + Enum_Complete_WithRangeBuilder(Enum_Complete_WithRangeBuilder&&) = default; + Enum_Complete_WithRangeBuilder& operator=(Enum_Complete_WithRangeBuilder const&) = default; + + void Serialize(std::vector& output) const override { + pdl::packet::Builder::write_le(output, (static_cast(static_cast(e_)))); + } + + size_t GetSize() const override { + return 1; + } + + std::string ToString() const { return ""; } + + Enum_Complete_WithRange_ e_{Enum_Complete_WithRange_::A}; +}; +} // le_backend diff --git a/pdl-compiler/tests/run_cxx_generator_tests.sh b/pdl-compiler/tests/run_cxx_generator_tests.sh index 862bd0a..9f9d7d4 100755 --- a/pdl-compiler/tests/run_cxx_generator_tests.sh +++ b/pdl-compiler/tests/run_cxx_generator_tests.sh @@ -12,20 +12,15 @@ sed -e 's/little_endian_packets/big_endian_packets/' \ -e '/Start: little_endian_only/,/End: little_endian_only/d' \ < tests/canonical/le_test_file.pdl > "$OUT_DIR"/be_test_file.pdl -pdlc tests/canonical/le_test_file.pdl > "$OUT_DIR"/le_test_file.json -pdlc "$OUT_DIR"/be_test_file.pdl > "$OUT_DIR"/be_test_file.json +cargo run --quiet -- tests/canonical/le_test_file.pdl > "$OUT_DIR"/le_test_file.json +cargo run --quiet -- "$OUT_DIR"/be_test_file.pdl > "$OUT_DIR"/be_test_file.json -python3 scripts/generate_cxx_backend.py \ - --input "$OUT_DIR"/le_test_file.json \ - --output "$OUT_DIR"/le_backend.h \ +cargo run --quiet -- --output-format cxx \ + tests/canonical/le_test_file.pdl \ --exclude-declaration Packet_Custom_Field_ConstantSize \ --exclude-declaration Packet_Custom_Field_VariableSize \ --exclude-declaration Packet_Checksum_Field_FromStart \ --exclude-declaration Packet_Checksum_Field_FromEnd \ - --exclude-declaration Packet_Array_Field_VariableElementSize_ConstantSize \ - --exclude-declaration Packet_Array_Field_VariableElementSize_VariableSize \ - --exclude-declaration Packet_Array_Field_VariableElementSize_VariableCount \ - --exclude-declaration Packet_Array_Field_VariableElementSize_UnknownSize \ --exclude-declaration Struct_Custom_Field_ConstantSize \ --exclude-declaration Struct_Custom_Field_VariableSize \ --exclude-declaration Struct_Checksum_Field_FromStart \ @@ -40,18 +35,13 @@ python3 scripts/generate_cxx_backend.py \ --exclude-declaration PartialParent12 \ --exclude-declaration PartialChild12_A \ --exclude-declaration PartialChild12_B \ - --namespace le_backend -python3 scripts/generate_cxx_backend.py \ - --input "$OUT_DIR"/be_test_file.json \ - --output "$OUT_DIR"/be_backend.h \ + --namespace le_backend > "$OUT_DIR"/le_backend.h +cargo run --quiet -- --output-format cxx \ + "$OUT_DIR"/be_test_file.pdl \ --exclude-declaration Packet_Custom_Field_ConstantSize \ --exclude-declaration Packet_Custom_Field_VariableSize \ --exclude-declaration Packet_Checksum_Field_FromStart \ --exclude-declaration Packet_Checksum_Field_FromEnd \ - --exclude-declaration Packet_Array_Field_VariableElementSize_ConstantSize \ - --exclude-declaration Packet_Array_Field_VariableElementSize_VariableSize \ - --exclude-declaration Packet_Array_Field_VariableElementSize_VariableCount \ - --exclude-declaration Packet_Array_Field_VariableElementSize_UnknownSize \ --exclude-declaration Struct_Custom_Field_ConstantSize \ --exclude-declaration Struct_Custom_Field_VariableSize \ --exclude-declaration Struct_Checksum_Field_FromStart \ @@ -66,7 +56,7 @@ python3 scripts/generate_cxx_backend.py \ --exclude-declaration PartialParent12 \ --exclude-declaration PartialChild12_A \ --exclude-declaration PartialChild12_B \ - --namespace be_backend + --namespace be_backend > "$OUT_DIR"/be_backend.h python3 scripts/generate_cxx_backend_tests.py \ --input "$OUT_DIR"/le_test_file.json \ @@ -85,7 +75,7 @@ python3 scripts/generate_cxx_backend_tests.py \ --serializer-test-suite be_backend_serializer_test \ --include-header be_backend.h -g++ -Iscripts -I"$OUT_DIR" \ +g++ -fsanitize=address,undefined,leak -Iscripts -I"$OUT_DIR" \ "$OUT_DIR"/le_backend_tests.cc \ "$OUT_DIR"/be_backend_tests.cc \ -lgtest -lgtest_main -o "$OUT_DIR"/cxx_backend_tests