diff --git a/compiler/back_end/cpp/generated_code_templates b/compiler/back_end/cpp/generated_code_templates index 9e2c7818..3fbc8592 100644 --- a/compiler/back_end/cpp/generated_code_templates +++ b/compiler/back_end/cpp/generated_code_templates @@ -411,6 +411,26 @@ ${switch_cases} } +// ** ok_method_switch_block_guarded ** //////////////////////////////////////// + // Check fields that share a conditionally-present discriminant. Every arm + // carries a residual, so when the discriminant is out of bounds the message + // is still valid for any arm whose residual is statically false. Dispatch + // only when the discriminant can be read; otherwise fall back to per-field + // existence checks. (An Unknown discriminant can never make has_X() + // Known-true, so only the Known() test is needed in the fallback.) + { + const auto emboss_reserved_switch_discrim = ${discriminant}; + if (emboss_reserved_switch_discrim.Known()) { + switch (emboss_reserved_switch_discrim.ValueOrDefault()) { +${switch_cases} + + default: break; + } + } else { +${fallback_checks} } + } + + // ** ok_method_switch_arm ** ////////////////////////////////////////////////// ${case_labels}${case_body} break; diff --git a/compiler/back_end/cpp/header_generator.py b/compiler/back_end/cpp/header_generator.py index 0342f92a..45b91f7e 100644 --- a/compiler/back_end/cpp/header_generator.py +++ b/compiler/back_end/cpp/header_generator.py @@ -1801,18 +1801,56 @@ def _emit_switch_block(group): ) ) - if group.get("known_check_required", True): - known_check = ( - " if (!emboss_reserved_switch_discrim.Known()) return false;\n" + if not group.get("known_check_required", True): + # Provably-present discriminant: the per-field validation loop has + # already proven the discriminant readable, so dispatch is always safe. + return code_template.format_template( + _TEMPLATES.ok_method_switch_block, + discriminant=group["discrim_rendered"], + known_check="", + switch_cases="".join(rendered_arms), ) - else: - known_check = "" + # A "bare" arm is one whose existence condition is exactly `discrim == K`, + # with no residual conjuncts. When the group has at least one bare arm, an + # Unknown discriminant leaves that field's has_X() Unknown, so the simple + # `if (!discrim.Known()) return false;` guard faithfully reproduces the + # unoptimized Ok() (which bails for the same reason). This covers ordinary + # tagged unions and always-present-but-virtual discriminants (e.g. a `let` + # alias of a parameter). + has_bare_arm = any( + not has_residual + for case_entry in group["cases_by_label"].values() + for (_field, has_residual) in case_entry["entries"] + ) + if has_bare_arm: + return code_template.format_template( + _TEMPLATES.ok_method_switch_block, + discriminant=group["discrim_rendered"], + known_check=( + " if (!emboss_reserved_switch_discrim.Known()) return false;\n" + ), + switch_cases="".join(rendered_arms), + ) + + # Every arm carries a residual and the discriminant is not provably present. + # The `Known()` guard would be unsound here: a valid message can have an + # out-of-bounds (Unknown) discriminant while every arm's residual is + # statically false, making every has_X() Known-false (absent). Dispatch + # only when the discriminant is in bounds; otherwise fall back to per-field + # existence checks. (With the discriminant Unknown, has_X() can never be + # Known-true, so the fallback needs only the Known() test.) + fallback_checks = "".join( + " if (!has_{}().Known()) return false;\n".format( + _cpp_field_name(field.name.name.text) + ) + for field in group["encounter_order"] + ) return code_template.format_template( - _TEMPLATES.ok_method_switch_block, + _TEMPLATES.ok_method_switch_block_guarded, discriminant=group["discrim_rendered"], - known_check=known_check, switch_cases="".join(rendered_arms), + fallback_checks=fallback_checks, ) diff --git a/compiler/back_end/cpp/testcode/condition_test.cc b/compiler/back_end/cpp/testcode/condition_test.cc index 1645f484..850fbadb 100644 --- a/compiler/back_end/cpp/testcode/condition_test.cc +++ b/compiler/back_end/cpp/testcode/condition_test.cc @@ -300,6 +300,217 @@ TEST(Conditional, StructWithNestedConditionIsOkWhenOuterConditionExists) { EXPECT_EQ(2U, writer.SizeInBytes()); } +// Regression tests for the optimized Ok() switch when the discriminant (`tag`) +// is itself a conditionally-present field. In ResidualConditionalDiscriminant +// every arm carries a residual (`outer == 1`), so when `outer != 1` the message +// is valid even though `tag` is absent -- and the optimized Ok() must not +// reject it just because the (out-of-bounds) discriminant reads as Unknown. +TEST(Conditional, + ResidualConditionalDiscriminantOkWhenDiscriminantFieldIsAbsent) { + // outer == 0, so `tag` is absent and `a`/`b` cannot exist. The 1-byte + // buffer is too short to read `tag`, but the message is still valid. + ::std::uint8_t buffer[1] = {0}; + auto writer = ResidualConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_TRUE(writer.has_tag().Known()); + EXPECT_FALSE(writer.has_tag().Value()); + EXPECT_TRUE(writer.has_a().Known()); + EXPECT_FALSE(writer.has_a().Value()); + EXPECT_TRUE(writer.has_b().Known()); + EXPECT_FALSE(writer.has_b().Value()); +} + +TEST(Conditional, + ResidualConditionalDiscriminantNotOkWhenDiscriminantPresentButTruncated) { + // outer == 1, so `tag` is present, but the buffer is too short to read it: + // whether `a`/`b` exist is indeterminate, so the message is invalid. + ::std::uint8_t buffer[1] = {1}; + auto writer = ResidualConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_FALSE(writer.Ok()); + EXPECT_TRUE(writer.has_tag().Known()); + EXPECT_TRUE(writer.has_tag().Value()); + EXPECT_FALSE(writer.has_a().Known()); +} + +TEST(Conditional, ResidualConditionalDiscriminantOkWhenGatedFieldIsPresent) { + // outer == 1, tag == 0, so `a` exists and is in bounds; `b` is absent. + ::std::uint8_t buffer[3] = {1, 0, 7}; + auto writer = ResidualConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_TRUE(writer.has_a().Known()); + EXPECT_TRUE(writer.has_a().Value()); + EXPECT_TRUE(writer.has_b().Known()); + EXPECT_FALSE(writer.has_b().Value()); + EXPECT_EQ(7, writer.a().Read()); +} + +TEST(Conditional, ResidualConditionalDiscriminantNotOkWhenGatedFieldTruncated) { + // outer == 1, tag == 0, so `a` exists, but the buffer is too short for it. + ::std::uint8_t buffer[2] = {1, 0}; + auto writer = ResidualConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.has_a().Known()); + EXPECT_TRUE(writer.has_a().Value()); + EXPECT_FALSE(writer.a().Ok()); + EXPECT_FALSE(writer.Ok()); +} + +TEST(Conditional, ResidualConditionalDiscriminantOkWhenDiscriminantMatchesNoArm) { + // outer == 1, tag == 5: neither `a` nor `b` exists, so the message is valid. + ::std::uint8_t buffer[2] = {1, 5}; + auto writer = ResidualConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_FALSE(writer.has_a().Value()); + EXPECT_FALSE(writer.has_b().Value()); +} + +// BareConditionalDiscriminant keeps the simple discriminant Known() guard: +// the arms are bare (`if tag == K:`), so an Unknown `tag` leaves has_a()/ +// has_b() Unknown and Ok() must report the message as invalid. +TEST(Conditional, BareConditionalDiscriminantNotOkWhenDiscriminantTruncated) { + // 1-byte buffer: `tag` (offset 1) is out of bounds, so has_a()/has_b() are + // Unknown and the message's validity cannot be determined. + ::std::uint8_t buffer[1] = {0}; + auto writer = BareConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_FALSE(writer.Ok()); + EXPECT_FALSE(writer.has_a().Known()); + EXPECT_FALSE(writer.has_b().Known()); +} + +TEST(Conditional, BareConditionalDiscriminantOkWhenGatedFieldIsPresent) { + // outer == 1 (so `tag` is present) and tag == 0, so `a` exists and is in + // bounds. + ::std::uint8_t buffer[3] = {1, 0, 7}; + auto writer = BareConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_TRUE(writer.has_a().Known()); + EXPECT_TRUE(writer.has_a().Value()); + EXPECT_EQ(7, writer.a().Read()); +} + +TEST(Conditional, BareConditionalDiscriminantNotOkWhenGatedFieldTruncated) { + // outer == 1, tag == 0, so `a` exists, but the buffer is too short for it. + ::std::uint8_t buffer[2] = {1, 0}; + auto writer = BareConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.has_a().Known()); + EXPECT_TRUE(writer.has_a().Value()); + EXPECT_FALSE(writer.Ok()); +} + +// Distinguishing test: a bare arm on a conditional discriminant whose field is +// size-dominated by an always-present field. IsComplete() stays true, so only +// the discriminant Known() guard can reject the message. This is the case +// where a `if (has_tag().ValueOrDefault())` wrapper diverges (it would accept). +TEST(Conditional, DominatedBareDiscriminantNotOkWhenDiscriminantAbsent) { + ::std::uint8_t buffer[4] = {0, 0, 0, 9}; + auto writer = DominatedBareDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.IsComplete()); + EXPECT_FALSE(writer.has_a().Known()); + EXPECT_FALSE(writer.has_b().Known()); + EXPECT_FALSE(writer.Ok()); +} + +TEST(Conditional, DominatedBareDiscriminantOkWhenDiscriminantPresent) { + // outer == 1, tag == 0: `a` present and readable; `tail` present. + ::std::uint8_t buffer[4] = {1, 0, 5, 9}; + auto writer = DominatedBareDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_TRUE(writer.has_a().Value()); + EXPECT_EQ(5, writer.a().Read()); + EXPECT_EQ(9, writer.tail().Read()); +} + +// Disjunction arms (#256 matcher) on a conditional discriminant, all carrying a +// residual -> the residual-only guarded switch with coalesced case labels. +TEST(Conditional, DisjunctionConditionalDiscriminantOkWhenDiscriminantAbsent) { + ::std::uint8_t buffer[1] = {0}; + auto writer = DisjunctionConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_FALSE(writer.has_a().Value()); + EXPECT_FALSE(writer.has_b().Value()); +} + +TEST(Conditional, DisjunctionConditionalDiscriminantBothDisjunctsSelectField) { + // tag == 0 and tag == 1 both make `a` present. + ::std::uint8_t buffer0[3] = {1, 0, 7}; + auto w0 = DisjunctionConditionalDiscriminantWriter(buffer0, sizeof buffer0); + EXPECT_TRUE(w0.Ok()); + EXPECT_TRUE(w0.has_a().Value()); + EXPECT_EQ(7, w0.a().Read()); + + ::std::uint8_t buffer1[3] = {1, 1, 8}; + auto w1 = DisjunctionConditionalDiscriminantWriter(buffer1, sizeof buffer1); + EXPECT_TRUE(w1.Ok()); + EXPECT_TRUE(w1.has_a().Value()); + EXPECT_EQ(8, w1.a().Read()); +} + +TEST(Conditional, DisjunctionConditionalDiscriminantSecondArmAndNoMatch) { + // tag == 2 selects `b` (which overlaps `a` at offset 2); tag == 9 selects + // neither (still valid). + ::std::uint8_t buffer2[3] = {1, 2, 6}; + auto w2 = DisjunctionConditionalDiscriminantWriter(buffer2, sizeof buffer2); + EXPECT_TRUE(w2.Ok()); + EXPECT_TRUE(w2.has_b().Value()); + EXPECT_EQ(6, w2.b().Read()); + + ::std::uint8_t buffer9[2] = {1, 9}; + auto w9 = DisjunctionConditionalDiscriminantWriter(buffer9, sizeof buffer9); + EXPECT_TRUE(w9.Ok()); + EXPECT_FALSE(w9.has_a().Value()); + EXPECT_FALSE(w9.has_b().Value()); +} + +// Single-entry group on a conditional discriminant: demoted to a has_X() check +// (#256), so no discriminant guard is emitted and the bug cannot arise. +TEST(Conditional, SingleEntryConditionalDiscriminantOkWhenDiscriminantAbsent) { + ::std::uint8_t buffer[1] = {0}; + auto writer = SingleEntryConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_TRUE(writer.has_a().Known()); + EXPECT_FALSE(writer.has_a().Value()); +} + +TEST(Conditional, SingleEntryConditionalDiscriminantOkWhenPresent) { + ::std::uint8_t buffer[3] = {1, 0, 4}; + auto writer = SingleEntryConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_TRUE(writer.has_a().Value()); + EXPECT_EQ(4, writer.a().Read()); +} + +TEST(Conditional, + SingleEntryConditionalDiscriminantNotOkWhenDiscriminantTruncated) { + // outer == 1 but the buffer is too short for tag: a's existence is Unknown. + ::std::uint8_t buffer[1] = {1}; + auto writer = SingleEntryConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_FALSE(writer.has_a().Known()); + EXPECT_FALSE(writer.Ok()); +} + +// Enum-typed conditional discriminant with residual arms (static_cast case +// labels in the guarded switch). +TEST(Conditional, EnumConditionalDiscriminantOkWhenDiscriminantAbsent) { + ::std::uint8_t buffer[1] = {0}; // outer == OFF + auto writer = EnumConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_FALSE(writer.has_a().Value()); + EXPECT_FALSE(writer.has_b().Value()); +} + +TEST(Conditional, EnumConditionalDiscriminantOkWhenPresent) { + ::std::uint8_t buffer[3] = {1, 0, 7}; // outer == ON, tag == OFF -> a present + auto writer = EnumConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_TRUE(writer.Ok()); + EXPECT_TRUE(writer.has_a().Value()); + EXPECT_EQ(7, writer.a().Read()); +} + +TEST(Conditional, EnumConditionalDiscriminantNotOkWhenDiscriminantTruncated) { + ::std::uint8_t buffer[1] = {1}; // outer == ON, tag truncated + auto writer = EnumConditionalDiscriminantWriter(buffer, sizeof buffer); + EXPECT_FALSE(writer.Ok()); +} + TEST(Conditional, AlwaysMissingFieldDoesNotContributeToStaticSize) { EXPECT_EQ(0U, OnlyAlwaysFalseConditionWriter::SizeInBytes()); EXPECT_EQ(1U, AlwaysFalseConditionWriter::SizeInBytes()); diff --git a/testdata/condition.emb b/testdata/condition.emb index 4d9f2a57..e93dcce5 100644 --- a/testdata/condition.emb +++ b/testdata/condition.emb @@ -229,3 +229,99 @@ struct ConditionalOnFlag: 0 [+1] Flag enabled if enabled: 1 [+1] UInt value + + +struct ResidualConditionalDiscriminant: + # `tag` is itself conditional, and is the switch discriminant for `a`/`b` + # (it is the first conjunct of their existence conditions). Every arm + # carries a residual (`outer == 1`), so when `outer != 1` the message is + # valid even though `tag` is absent -- and on a buffer too short to hold + # `tag`, reading the discriminant is Unknown. The optimized Ok() must not + # reject such a message. + 0 [+1] UInt outer + if outer == 1: + 1 [+1] UInt tag + + if tag == 0 && outer == 1: + 2 [+1] UInt a + + if tag == 1 && outer == 1: + 2 [+1] UInt b + + +struct BareConditionalDiscriminant: + # Like above, but `a`/`b` reference the conditional discriminant `tag` + # without re-guarding `outer == 1`, so the switch arms are bare. Here the + # discriminant Known() guard is sound: an Unknown `tag` leaves has_a()/ + # has_b() Unknown, so Ok() correctly reports the message as invalid. + 0 [+1] UInt outer + if outer == 1: + 1 [+1] UInt tag + + if tag == 0: + 2 [+1] UInt a + + if tag == 1: + 2 [+1] UInt b + + +struct DominatedBareDiscriminant: + # Bare arms on a conditional discriminant, plus an always-present `tail` + # field that dominates the structure size. When `outer != 1`, `tag` is + # absent and has_a()/has_b() are Unknown, but `tail` keeps the size Known so + # IsComplete() is true. Ok() must still be false: a/b's existence is + # indeterminate, and the discriminant Known() guard -- not IsComplete() -- + # is what enforces that. (A `if (has_tag().ValueOrDefault())` wrapper would + # wrongly accept this message.) + 0 [+1] UInt outer + if outer == 1: + 1 [+1] UInt tag + + if tag == 0: + 2 [+1] UInt a + + if tag == 1: + 2 [+1] UInt b + + 3 [+1] UInt tail + + +struct DisjunctionConditionalDiscriminant: + # Disjunction arms (`tag == 0 || tag == 1`) on a conditional discriminant, + # each carrying a residual. Exercises the disjunction matcher and case-label + # coalescing together with the residual-only guarded switch. + 0 [+1] UInt outer + if outer == 1: + 1 [+1] UInt tag + + if (tag == 0 || tag == 1) && outer == 1: + 2 [+1] UInt a + + if (tag == 2 || tag == 3) && outer == 1: + 2 [+1] UInt b + + +struct SingleEntryConditionalDiscriminant: + # A single residual arm on a conditional discriminant. The switch group has + # one entry, so it is demoted to a has_X() check instead of a switch; no + # discriminant guard is emitted, so the bug cannot arise here. + 0 [+1] UInt outer + if outer == 1: + 1 [+1] UInt tag + + if tag == 0 && outer == 1: + 2 [+1] UInt a + + +struct EnumConditionalDiscriminant: + # Conditional discriminant of enum type, with residual arms. Exercises the + # enum-typed case labels in the guarded switch. + 0 [+1] OnOff outer + if outer == OnOff.ON: + 1 [+1] OnOff tag + + if tag == OnOff.OFF && outer == OnOff.ON: + 2 [+1] UInt a + + if tag == OnOff.ON && outer == OnOff.ON: + 2 [+1] UInt b diff --git a/testdata/golden_cpp/condition.emb.h b/testdata/golden_cpp/condition.emb.h index 725fe824..be99df26 100644 --- a/testdata/golden_cpp/condition.emb.h +++ b/testdata/golden_cpp/condition.emb.h @@ -215,6 +215,46 @@ class GenericEmbossReservedAnonymousField1View; template class GenericConditionalOnFlagView; +namespace ResidualConditionalDiscriminant { + +} // namespace ResidualConditionalDiscriminant + +template +class GenericResidualConditionalDiscriminantView; + +namespace BareConditionalDiscriminant { + +} // namespace BareConditionalDiscriminant + +template +class GenericBareConditionalDiscriminantView; + +namespace DominatedBareDiscriminant {} // namespace DominatedBareDiscriminant + +template +class GenericDominatedBareDiscriminantView; + +namespace DisjunctionConditionalDiscriminant { + +} // namespace DisjunctionConditionalDiscriminant + +template +class GenericDisjunctionConditionalDiscriminantView; + +namespace SingleEntryConditionalDiscriminant { + +} // namespace SingleEntryConditionalDiscriminant + +template +class GenericSingleEntryConditionalDiscriminantView; + +namespace EnumConditionalDiscriminant { + +} // namespace EnumConditionalDiscriminant + +template +class GenericEnumConditionalDiscriminantView; + namespace BasicConditional {} // namespace BasicConditional template @@ -19445,188 +19485,6141 @@ MakeAlignedConditionalOnFlagView(T* emboss_reserved_local_data, emboss_reserved_local_data, emboss_reserved_local_size); } -namespace BasicConditional {} // namespace BasicConditional +namespace ResidualConditionalDiscriminant { + +} // namespace ResidualConditionalDiscriminant + +template +struct EmbossReservedInternalIsGenericResidualConditionalDiscriminantView; template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +class GenericResidualConditionalDiscriminantView final { + public: + GenericResidualConditionalDiscriminantView() : backing_() {} + explicit GenericResidualConditionalDiscriminantView( + Storage emboss_reserved_local_bytes) + : backing_(emboss_reserved_local_bytes) {} -GenericBasicConditionalView::x() const { - if (has_x().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(1LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(0LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + template + GenericResidualConditionalDiscriminantView( + const GenericResidualConditionalDiscriminantView& + emboss_reserved_local_other) + : backing_{emboss_reserved_local_other.BackingStorage()} {} - (backing_.template GetOffsetStorage<0, 0>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } + template < + typename Arg, + typename = typename ::std::enable_if< + !EmbossReservedInternalIsGenericResidualConditionalDiscriminantView< + typename ::std::remove_cv::type>::type>::value>::type> + explicit GenericResidualConditionalDiscriminantView( + Arg&& emboss_reserved_local_arg) + : backing_(::std::forward(emboss_reserved_local_arg)) {} + template + explicit GenericResidualConditionalDiscriminantView( + Arg0&& emboss_reserved_local_arg0, Arg1&& emboss_reserved_local_arg1, + Args&&... emboss_reserved_local_args) + : backing_(::std::forward(emboss_reserved_local_arg0), + ::std::forward(emboss_reserved_local_arg1), + ::std::forward(emboss_reserved_local_args)...) {} + + template + GenericResidualConditionalDiscriminantView& operator=( + const GenericResidualConditionalDiscriminantView& + emboss_reserved_local_other) { + backing_ = emboss_reserved_local_other.BackingStorage(); + return *this; } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - (); -} + bool Ok() const { + if (!IsComplete()) return false; -template -inline ::emboss::support::Maybe -GenericBasicConditionalView::has_x() const { - return ::emboss::support::Maybe(true); -} + const auto emboss_reserved_local_ok_subexpr_1 = tag(); + const auto emboss_reserved_local_ok_subexpr_2 = + (emboss_reserved_local_ok_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_ok_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); -template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + if (!has_outer().Known()) return false; + if (has_outer().ValueOrDefault() && !outer().Ok()) return false; -GenericBasicConditionalView::xc() const { - if (has_xc().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(1LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(1LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + if (!has_IntrinsicSizeInBytes().Known()) return false; + if (has_IntrinsicSizeInBytes().ValueOrDefault() && + !IntrinsicSizeInBytes().Ok()) + return false; - (backing_.template GetOffsetStorage<0, 1>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); + if (!has_MaxSizeInBytes().Known()) return false; + if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) + return false; + + if (!has_MinSizeInBytes().Known()) return false; + if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) + return false; + + if (!has_tag().Known()) return false; + if (has_tag().ValueOrDefault() && !tag().Ok()) return false; + + { + const auto emboss_reserved_switch_discrim = + emboss_reserved_local_ok_subexpr_2; + if (emboss_reserved_switch_discrim.Known()) { + switch (emboss_reserved_switch_discrim.ValueOrDefault()) { + case static_cast(0LL): + if (!has_a().Known()) return false; + if (has_a().ValueOrDefault() && !a().Ok()) return false; + break; + + case static_cast(1LL): + if (!has_b().Known()) return false; + if (has_b().ValueOrDefault() && !b().Ok()) return false; + break; + + default: + break; + } + } else { + if (!has_a().Known()) return false; + if (!has_b().Known()) return false; + } } + + return true; } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + Storage BackingStorage() const { return backing_; } + bool IsComplete() const { + return backing_.Ok() && IntrinsicSizeInBytes().Ok() && + backing_.SizeInBytes() >= + static_cast( + IntrinsicSizeInBytes().UncheckedRead()); + } + ::std::size_t SizeInBytes() const { + return static_cast(IntrinsicSizeInBytes().Read()); + } + bool SizeIsKnown() const { return IntrinsicSizeInBytes().Ok(); } - (); -} + template + bool Equals(GenericResidualConditionalDiscriminantView + emboss_reserved_local_other) const { + if (!has_outer().Known()) return false; + if (!emboss_reserved_local_other.has_outer().Known()) return false; -template -inline ::emboss::support::Maybe -GenericBasicConditionalView::has_xc() const { - return ::emboss::support::Equal( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL))); -} + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + !has_outer().ValueOrDefault()) + return false; + if (has_outer().ValueOrDefault() && + !emboss_reserved_local_other.has_outer().ValueOrDefault()) + return false; -template -inline typename GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericBasicConditionalView::IntrinsicSizeInBytes() const { - return typename GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); -} + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + has_outer().ValueOrDefault() && + !outer().Equals(emboss_reserved_local_other.outer())) + return false; -template -inline ::emboss::support::Maybe -GenericBasicConditionalView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); -} + if (!has_tag().Known()) return false; + if (!emboss_reserved_local_other.has_tag().Known()) return false; -namespace BasicConditional { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(2LL)) - .ValueOrDefault(); -} -} // namespace BasicConditional + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + !has_tag().ValueOrDefault()) + return false; + if (has_tag().ValueOrDefault() && + !emboss_reserved_local_other.has_tag().ValueOrDefault()) + return false; -template -inline constexpr ::std::int32_t GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return BasicConditional::MaxSizeInBytes(); -} + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + has_tag().ValueOrDefault() && + !tag().Equals(emboss_reserved_local_other.tag())) + return false; -template -inline constexpr ::std::int32_t GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return BasicConditional::MaxSizeInBytes(); -} + if (!has_a().Known()) return false; + if (!emboss_reserved_local_other.has_a().Known()) return false; -namespace BasicConditional { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace BasicConditional + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + !has_a().ValueOrDefault()) + return false; + if (has_a().ValueOrDefault() && + !emboss_reserved_local_other.has_a().ValueOrDefault()) + return false; -template -inline constexpr ::std::int32_t GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return BasicConditional::MinSizeInBytes(); -} + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + has_a().ValueOrDefault() && + !a().Equals(emboss_reserved_local_other.a())) + return false; -template -inline constexpr ::std::int32_t GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return BasicConditional::MinSizeInBytes(); -} -namespace NegativeConditional {} // namespace NegativeConditional + if (!has_b().Known()) return false; + if (!emboss_reserved_local_other.has_b().Known()) return false; -template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + !has_b().ValueOrDefault()) + return false; + if (has_b().ValueOrDefault() && + !emboss_reserved_local_other.has_b().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + has_b().ValueOrDefault() && + !b().Equals(emboss_reserved_local_other.b())) + return false; + + return true; + } + template + bool UncheckedEquals(GenericResidualConditionalDiscriminantView + emboss_reserved_local_other) const { + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + !has_outer().ValueOr(false)) + return false; + if (has_outer().ValueOr(false) && + !emboss_reserved_local_other.has_outer().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + has_outer().ValueOr(false) && + !outer().UncheckedEquals(emboss_reserved_local_other.outer())) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + !has_tag().ValueOr(false)) + return false; + if (has_tag().ValueOr(false) && + !emboss_reserved_local_other.has_tag().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + has_tag().ValueOr(false) && + !tag().UncheckedEquals(emboss_reserved_local_other.tag())) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + !has_a().ValueOr(false)) + return false; + if (has_a().ValueOr(false) && + !emboss_reserved_local_other.has_a().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + has_a().ValueOr(false) && + !a().UncheckedEquals(emboss_reserved_local_other.a())) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + !has_b().ValueOr(false)) + return false; + if (has_b().ValueOr(false) && + !emboss_reserved_local_other.has_b().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + has_b().ValueOr(false) && + !b().UncheckedEquals(emboss_reserved_local_other.b())) + return false; + + return true; + } + template + void UncheckedCopyFrom( + GenericResidualConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.UncheckedCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().UncheckedRead()); + } + + template + void CopyFrom(GenericResidualConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.CopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + template + bool TryToCopyFrom(GenericResidualConditionalDiscriminantView + emboss_reserved_local_other) const { + return emboss_reserved_local_other.Ok() && + backing_.TryToCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + + template + bool UpdateFromTextStream(Stream* emboss_reserved_local_stream) const { + ::std::string emboss_reserved_local_brace; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_brace)) + return false; + if (emboss_reserved_local_brace != "{") return false; + for (;;) { + ::std::string emboss_reserved_local_name; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == ",") + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == "}") return true; + ::std::string emboss_reserved_local_colon; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_colon)) + return false; + if (emboss_reserved_local_colon != ":") return false; + if (emboss_reserved_local_name == "outer") { + if (!outer().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "tag") { + if (!tag().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "a") { + if (!a().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "b") { + if (!b().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + return false; + } + } + + template + void WriteToTextStream( + Stream* emboss_reserved_local_stream, + ::emboss::TextOutputOptions emboss_reserved_local_options) const { + ::emboss::TextOutputOptions emboss_reserved_local_field_options = + emboss_reserved_local_options.PlusOneIndent(); + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write("{\n"); + } else { + emboss_reserved_local_stream->Write("{"); + } + bool emboss_reserved_local_wrote_field = false; + if (has_outer().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + outer().IsAggregate() || outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("outer: "); + outer().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !outer().IsAggregate() && !outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# outer: UNREADABLE\n"); + } + } + + if (has_tag().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + tag().IsAggregate() || tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("tag: "); + tag().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !tag().IsAggregate() && !tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# tag: UNREADABLE\n"); + } + } + + if (has_a().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + a().IsAggregate() || a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("a: "); + a().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !a().IsAggregate() && !a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# a: UNREADABLE\n"); + } + } + + if (has_b().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + b().IsAggregate() || b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("b: "); + b().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !b().IsAggregate() && !b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# b: UNREADABLE\n"); + } + } + + (void)emboss_reserved_local_wrote_field; + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_options.current_indent()); + emboss_reserved_local_stream->Write("}"); + } else { + emboss_reserved_local_stream->Write(" }"); + } + } + + static constexpr bool IsAggregate() { return true; } + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + outer() const; + ::emboss::support::Maybe has_outer() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + tag() const; + ::emboss::support::Maybe has_tag() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + a() const; + ::emboss::support::Maybe has_a() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + b() const; + ::emboss::support::Maybe has_b() const; + + public: + class EmbossReservedDollarVirtualIntrinsicSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + explicit EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const GenericResidualConditionalDiscriminantView& + emboss_reserved_local_view) + : view_(emboss_reserved_local_view) {} + EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = delete; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = default; + + ::std::int32_t Read() const { + EMBOSS_CHECK(view_.has_IntrinsicSizeInBytes().ValueOr(false)); + auto emboss_reserved_local_value = MaybeRead(); + EMBOSS_CHECK(emboss_reserved_local_value.Known()); + EMBOSS_CHECK(ValueIsOk(emboss_reserved_local_value.ValueOrDefault())); + return emboss_reserved_local_value.ValueOrDefault(); + } + ::std::int32_t UncheckedRead() const { + return MaybeRead().ValueOrDefault(); + } + bool Ok() const { + auto emboss_reserved_local_value = MaybeRead(); + return emboss_reserved_local_value.Known() && + ValueIsOk(emboss_reserved_local_value.ValueOrDefault()); + } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + + private: + ::emboss::support::Maybe MaybeRead() const { + const auto emboss_reserved_local_subexpr_1 = view_.outer(); + const auto emboss_reserved_local_subexpr_2 = + (emboss_reserved_local_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_3 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_2, + ::emboss::support::Maybe( + static_cast(1LL))); + const auto emboss_reserved_local_subexpr_4 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_3, + ::emboss::support::Maybe( + static_cast(2LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_5 = view_.tag(); + const auto emboss_reserved_local_subexpr_6 = + (emboss_reserved_local_subexpr_5.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_5.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_7 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_8 = + ::emboss::support::And( + emboss_reserved_local_subexpr_7, emboss_reserved_local_subexpr_3); + const auto emboss_reserved_local_subexpr_9 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_8, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_10 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(1LL))); + const auto emboss_reserved_local_subexpr_11 = + ::emboss::support::And( + emboss_reserved_local_subexpr_10, + emboss_reserved_local_subexpr_3); + const auto emboss_reserved_local_subexpr_12 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_11, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_13 = ::emboss::support::Maximum< + /**/ ::std::int32_t, ::std::int32_t, ::std::int32_t, ::std::int32_t, + ::std::int32_t, ::std::int32_t, ::std::int32_t>( + ::emboss::support::Maybe( + static_cast(0LL)), + ::emboss::support::Maybe( + static_cast(1LL)), + emboss_reserved_local_subexpr_4, emboss_reserved_local_subexpr_9, + emboss_reserved_local_subexpr_12); + + return emboss_reserved_local_subexpr_13; + } + + static constexpr bool ValueIsOk( + ::std::int32_t emboss_reserved_local_value) { + return (void)emboss_reserved_local_value, // Silence -Wunused-parameter + ::emboss::support::Maybe(true).ValueOr(false); + } + + const GenericResidualConditionalDiscriminantView view_; + }; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView IntrinsicSizeInBytes() + const; + ::emboss::support::Maybe has_IntrinsicSizeInBytes() const; + + public: + class EmbossReservedDollarVirtualMaxSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMaxSizeInBytesView() {} + EmbossReservedDollarVirtualMaxSizeInBytesView( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMaxSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMaxSizeInBytesView + MaxSizeInBytes() { + return EmbossReservedDollarVirtualMaxSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MaxSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + public: + class EmbossReservedDollarVirtualMinSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMinSizeInBytesView() {} + EmbossReservedDollarVirtualMinSizeInBytesView( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMinSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMinSizeInBytesView + MinSizeInBytes() { + return EmbossReservedDollarVirtualMinSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MinSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + private: + Storage backing_; + + template + friend class GenericResidualConditionalDiscriminantView; +}; +using ResidualConditionalDiscriminantView = + GenericResidualConditionalDiscriminantView< + /**/ ::emboss::support::ReadOnlyContiguousBuffer>; +using ResidualConditionalDiscriminantWriter = + GenericResidualConditionalDiscriminantView< + /**/ ::emboss::support::ReadWriteContiguousBuffer>; + +template +struct EmbossReservedInternalIsGenericResidualConditionalDiscriminantView { + static constexpr const bool value = false; +}; + +template +struct EmbossReservedInternalIsGenericResidualConditionalDiscriminantView< + GenericResidualConditionalDiscriminantView> { + static constexpr const bool value = true; +}; + +template +inline GenericResidualConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>> +MakeResidualConditionalDiscriminantView(T&& emboss_reserved_local_arg) { + return GenericResidualConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>>(::std::forward(emboss_reserved_local_arg)); +} + +template +inline GenericResidualConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeResidualConditionalDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericResidualConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +template +inline GenericResidualConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeAlignedResidualConditionalDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericResidualConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +namespace BareConditionalDiscriminant { + +} // namespace BareConditionalDiscriminant + +template +struct EmbossReservedInternalIsGenericBareConditionalDiscriminantView; + +template +class GenericBareConditionalDiscriminantView final { + public: + GenericBareConditionalDiscriminantView() : backing_() {} + explicit GenericBareConditionalDiscriminantView( + Storage emboss_reserved_local_bytes) + : backing_(emboss_reserved_local_bytes) {} + + template + GenericBareConditionalDiscriminantView( + const GenericBareConditionalDiscriminantView& + emboss_reserved_local_other) + : backing_{emboss_reserved_local_other.BackingStorage()} {} + + template ::type>::type>::value>::type> + explicit GenericBareConditionalDiscriminantView( + Arg&& emboss_reserved_local_arg) + : backing_(::std::forward(emboss_reserved_local_arg)) {} + template + explicit GenericBareConditionalDiscriminantView( + Arg0&& emboss_reserved_local_arg0, Arg1&& emboss_reserved_local_arg1, + Args&&... emboss_reserved_local_args) + : backing_(::std::forward(emboss_reserved_local_arg0), + ::std::forward(emboss_reserved_local_arg1), + ::std::forward(emboss_reserved_local_args)...) {} + + template + GenericBareConditionalDiscriminantView& operator=( + const GenericBareConditionalDiscriminantView& + emboss_reserved_local_other) { + backing_ = emboss_reserved_local_other.BackingStorage(); + return *this; + } + + bool Ok() const { + if (!IsComplete()) return false; + + const auto emboss_reserved_local_ok_subexpr_1 = tag(); + const auto emboss_reserved_local_ok_subexpr_2 = + (emboss_reserved_local_ok_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_ok_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + + if (!has_outer().Known()) return false; + if (has_outer().ValueOrDefault() && !outer().Ok()) return false; + + if (!has_IntrinsicSizeInBytes().Known()) return false; + if (has_IntrinsicSizeInBytes().ValueOrDefault() && + !IntrinsicSizeInBytes().Ok()) + return false; + + if (!has_MaxSizeInBytes().Known()) return false; + if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) + return false; + + if (!has_MinSizeInBytes().Known()) return false; + if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) + return false; + + if (!has_tag().Known()) return false; + if (has_tag().ValueOrDefault() && !tag().Ok()) return false; + + { + const auto emboss_reserved_switch_discrim = + emboss_reserved_local_ok_subexpr_2; + if (!emboss_reserved_switch_discrim.Known()) return false; + switch (emboss_reserved_switch_discrim.ValueOrDefault()) { + case static_cast(0LL): + if (!a().Ok()) return false; + break; + + case static_cast(1LL): + if (!b().Ok()) return false; + break; + + default: + break; + } + } + + return true; + } + Storage BackingStorage() const { return backing_; } + bool IsComplete() const { + return backing_.Ok() && IntrinsicSizeInBytes().Ok() && + backing_.SizeInBytes() >= + static_cast( + IntrinsicSizeInBytes().UncheckedRead()); + } + ::std::size_t SizeInBytes() const { + return static_cast(IntrinsicSizeInBytes().Read()); + } + bool SizeIsKnown() const { return IntrinsicSizeInBytes().Ok(); } + + template + bool Equals(GenericBareConditionalDiscriminantView + emboss_reserved_local_other) const { + if (!has_outer().Known()) return false; + if (!emboss_reserved_local_other.has_outer().Known()) return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + !has_outer().ValueOrDefault()) + return false; + if (has_outer().ValueOrDefault() && + !emboss_reserved_local_other.has_outer().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + has_outer().ValueOrDefault() && + !outer().Equals(emboss_reserved_local_other.outer())) + return false; + + if (!has_tag().Known()) return false; + if (!emboss_reserved_local_other.has_tag().Known()) return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + !has_tag().ValueOrDefault()) + return false; + if (has_tag().ValueOrDefault() && + !emboss_reserved_local_other.has_tag().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + has_tag().ValueOrDefault() && + !tag().Equals(emboss_reserved_local_other.tag())) + return false; + + if (!has_a().Known()) return false; + if (!emboss_reserved_local_other.has_a().Known()) return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + !has_a().ValueOrDefault()) + return false; + if (has_a().ValueOrDefault() && + !emboss_reserved_local_other.has_a().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + has_a().ValueOrDefault() && + !a().Equals(emboss_reserved_local_other.a())) + return false; + + if (!has_b().Known()) return false; + if (!emboss_reserved_local_other.has_b().Known()) return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + !has_b().ValueOrDefault()) + return false; + if (has_b().ValueOrDefault() && + !emboss_reserved_local_other.has_b().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + has_b().ValueOrDefault() && + !b().Equals(emboss_reserved_local_other.b())) + return false; + + return true; + } + template + bool UncheckedEquals(GenericBareConditionalDiscriminantView + emboss_reserved_local_other) const { + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + !has_outer().ValueOr(false)) + return false; + if (has_outer().ValueOr(false) && + !emboss_reserved_local_other.has_outer().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + has_outer().ValueOr(false) && + !outer().UncheckedEquals(emboss_reserved_local_other.outer())) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + !has_tag().ValueOr(false)) + return false; + if (has_tag().ValueOr(false) && + !emboss_reserved_local_other.has_tag().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + has_tag().ValueOr(false) && + !tag().UncheckedEquals(emboss_reserved_local_other.tag())) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + !has_a().ValueOr(false)) + return false; + if (has_a().ValueOr(false) && + !emboss_reserved_local_other.has_a().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + has_a().ValueOr(false) && + !a().UncheckedEquals(emboss_reserved_local_other.a())) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + !has_b().ValueOr(false)) + return false; + if (has_b().ValueOr(false) && + !emboss_reserved_local_other.has_b().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + has_b().ValueOr(false) && + !b().UncheckedEquals(emboss_reserved_local_other.b())) + return false; + + return true; + } + template + void UncheckedCopyFrom(GenericBareConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.UncheckedCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().UncheckedRead()); + } + + template + void CopyFrom(GenericBareConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.CopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + template + bool TryToCopyFrom(GenericBareConditionalDiscriminantView + emboss_reserved_local_other) const { + return emboss_reserved_local_other.Ok() && + backing_.TryToCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + + template + bool UpdateFromTextStream(Stream* emboss_reserved_local_stream) const { + ::std::string emboss_reserved_local_brace; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_brace)) + return false; + if (emboss_reserved_local_brace != "{") return false; + for (;;) { + ::std::string emboss_reserved_local_name; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == ",") + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == "}") return true; + ::std::string emboss_reserved_local_colon; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_colon)) + return false; + if (emboss_reserved_local_colon != ":") return false; + if (emboss_reserved_local_name == "outer") { + if (!outer().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "tag") { + if (!tag().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "a") { + if (!a().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "b") { + if (!b().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + return false; + } + } + + template + void WriteToTextStream( + Stream* emboss_reserved_local_stream, + ::emboss::TextOutputOptions emboss_reserved_local_options) const { + ::emboss::TextOutputOptions emboss_reserved_local_field_options = + emboss_reserved_local_options.PlusOneIndent(); + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write("{\n"); + } else { + emboss_reserved_local_stream->Write("{"); + } + bool emboss_reserved_local_wrote_field = false; + if (has_outer().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + outer().IsAggregate() || outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("outer: "); + outer().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !outer().IsAggregate() && !outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# outer: UNREADABLE\n"); + } + } + + if (has_tag().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + tag().IsAggregate() || tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("tag: "); + tag().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !tag().IsAggregate() && !tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# tag: UNREADABLE\n"); + } + } + + if (has_a().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + a().IsAggregate() || a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("a: "); + a().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !a().IsAggregate() && !a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# a: UNREADABLE\n"); + } + } + + if (has_b().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + b().IsAggregate() || b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("b: "); + b().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !b().IsAggregate() && !b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# b: UNREADABLE\n"); + } + } + + (void)emboss_reserved_local_wrote_field; + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_options.current_indent()); + emboss_reserved_local_stream->Write("}"); + } else { + emboss_reserved_local_stream->Write(" }"); + } + } + + static constexpr bool IsAggregate() { return true; } + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + outer() const; + ::emboss::support::Maybe has_outer() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + tag() const; + ::emboss::support::Maybe has_tag() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + a() const; + ::emboss::support::Maybe has_a() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + b() const; + ::emboss::support::Maybe has_b() const; + + public: + class EmbossReservedDollarVirtualIntrinsicSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + explicit EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const GenericBareConditionalDiscriminantView& + emboss_reserved_local_view) + : view_(emboss_reserved_local_view) {} + EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = delete; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = default; + + ::std::int32_t Read() const { + EMBOSS_CHECK(view_.has_IntrinsicSizeInBytes().ValueOr(false)); + auto emboss_reserved_local_value = MaybeRead(); + EMBOSS_CHECK(emboss_reserved_local_value.Known()); + EMBOSS_CHECK(ValueIsOk(emboss_reserved_local_value.ValueOrDefault())); + return emboss_reserved_local_value.ValueOrDefault(); + } + ::std::int32_t UncheckedRead() const { + return MaybeRead().ValueOrDefault(); + } + bool Ok() const { + auto emboss_reserved_local_value = MaybeRead(); + return emboss_reserved_local_value.Known() && + ValueIsOk(emboss_reserved_local_value.ValueOrDefault()); + } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + + private: + ::emboss::support::Maybe MaybeRead() const { + const auto emboss_reserved_local_subexpr_1 = view_.outer(); + const auto emboss_reserved_local_subexpr_2 = + (emboss_reserved_local_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_3 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_2, + ::emboss::support::Maybe( + static_cast(1LL))); + const auto emboss_reserved_local_subexpr_4 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_3, + ::emboss::support::Maybe( + static_cast(2LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_5 = view_.tag(); + const auto emboss_reserved_local_subexpr_6 = + (emboss_reserved_local_subexpr_5.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_5.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_7 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_8 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_7, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_9 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(1LL))); + const auto emboss_reserved_local_subexpr_10 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_9, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_11 = ::emboss::support::Maximum< + /**/ ::std::int32_t, ::std::int32_t, ::std::int32_t, ::std::int32_t, + ::std::int32_t, ::std::int32_t, ::std::int32_t>( + ::emboss::support::Maybe( + static_cast(0LL)), + ::emboss::support::Maybe( + static_cast(1LL)), + emboss_reserved_local_subexpr_4, emboss_reserved_local_subexpr_8, + emboss_reserved_local_subexpr_10); + + return emboss_reserved_local_subexpr_11; + } + + static constexpr bool ValueIsOk( + ::std::int32_t emboss_reserved_local_value) { + return (void)emboss_reserved_local_value, // Silence -Wunused-parameter + ::emboss::support::Maybe(true).ValueOr(false); + } + + const GenericBareConditionalDiscriminantView view_; + }; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView IntrinsicSizeInBytes() + const; + ::emboss::support::Maybe has_IntrinsicSizeInBytes() const; + + public: + class EmbossReservedDollarVirtualMaxSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMaxSizeInBytesView() {} + EmbossReservedDollarVirtualMaxSizeInBytesView( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMaxSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMaxSizeInBytesView + MaxSizeInBytes() { + return EmbossReservedDollarVirtualMaxSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MaxSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + public: + class EmbossReservedDollarVirtualMinSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMinSizeInBytesView() {} + EmbossReservedDollarVirtualMinSizeInBytesView( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMinSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMinSizeInBytesView + MinSizeInBytes() { + return EmbossReservedDollarVirtualMinSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MinSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + private: + Storage backing_; + + template + friend class GenericBareConditionalDiscriminantView; +}; +using BareConditionalDiscriminantView = GenericBareConditionalDiscriminantView< + /**/ ::emboss::support::ReadOnlyContiguousBuffer>; +using BareConditionalDiscriminantWriter = + GenericBareConditionalDiscriminantView< + /**/ ::emboss::support::ReadWriteContiguousBuffer>; + +template +struct EmbossReservedInternalIsGenericBareConditionalDiscriminantView { + static constexpr const bool value = false; +}; + +template +struct EmbossReservedInternalIsGenericBareConditionalDiscriminantView< + GenericBareConditionalDiscriminantView> { + static constexpr const bool value = true; +}; + +template +inline GenericBareConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>> +MakeBareConditionalDiscriminantView(T&& emboss_reserved_local_arg) { + return GenericBareConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>>(::std::forward(emboss_reserved_local_arg)); +} + +template +inline GenericBareConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeBareConditionalDiscriminantView(T* emboss_reserved_local_data, + ::std::size_t emboss_reserved_local_size) { + return GenericBareConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +template +inline GenericBareConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeAlignedBareConditionalDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericBareConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +namespace DominatedBareDiscriminant {} // namespace DominatedBareDiscriminant + +template +struct EmbossReservedInternalIsGenericDominatedBareDiscriminantView; + +template +class GenericDominatedBareDiscriminantView final { + public: + GenericDominatedBareDiscriminantView() : backing_() {} + explicit GenericDominatedBareDiscriminantView( + Storage emboss_reserved_local_bytes) + : backing_(emboss_reserved_local_bytes) {} + + template + GenericDominatedBareDiscriminantView( + const GenericDominatedBareDiscriminantView& + emboss_reserved_local_other) + : backing_{emboss_reserved_local_other.BackingStorage()} {} + + template ::type>::type>::value>::type> + explicit GenericDominatedBareDiscriminantView(Arg&& emboss_reserved_local_arg) + : backing_(::std::forward(emboss_reserved_local_arg)) {} + template + explicit GenericDominatedBareDiscriminantView( + Arg0&& emboss_reserved_local_arg0, Arg1&& emboss_reserved_local_arg1, + Args&&... emboss_reserved_local_args) + : backing_(::std::forward(emboss_reserved_local_arg0), + ::std::forward(emboss_reserved_local_arg1), + ::std::forward(emboss_reserved_local_args)...) {} + + template + GenericDominatedBareDiscriminantView& operator=( + const GenericDominatedBareDiscriminantView& + emboss_reserved_local_other) { + backing_ = emboss_reserved_local_other.BackingStorage(); + return *this; + } + + bool Ok() const { + if (!IsComplete()) return false; + + const auto emboss_reserved_local_ok_subexpr_1 = tag(); + const auto emboss_reserved_local_ok_subexpr_2 = + (emboss_reserved_local_ok_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_ok_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + + if (!has_outer().Known()) return false; + if (has_outer().ValueOrDefault() && !outer().Ok()) return false; + + if (!has_tail().Known()) return false; + if (has_tail().ValueOrDefault() && !tail().Ok()) return false; + + if (!has_IntrinsicSizeInBytes().Known()) return false; + if (has_IntrinsicSizeInBytes().ValueOrDefault() && + !IntrinsicSizeInBytes().Ok()) + return false; + + if (!has_MaxSizeInBytes().Known()) return false; + if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) + return false; + + if (!has_MinSizeInBytes().Known()) return false; + if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) + return false; + + if (!has_tag().Known()) return false; + if (has_tag().ValueOrDefault() && !tag().Ok()) return false; + + { + const auto emboss_reserved_switch_discrim = + emboss_reserved_local_ok_subexpr_2; + if (!emboss_reserved_switch_discrim.Known()) return false; + switch (emboss_reserved_switch_discrim.ValueOrDefault()) { + case static_cast(0LL): + if (!a().Ok()) return false; + break; + + case static_cast(1LL): + if (!b().Ok()) return false; + break; + + default: + break; + } + } + + return true; + } + Storage BackingStorage() const { return backing_; } + bool IsComplete() const { + return backing_.Ok() && IntrinsicSizeInBytes().Ok() && + backing_.SizeInBytes() >= + static_cast( + IntrinsicSizeInBytes().UncheckedRead()); + } + static constexpr ::std::size_t SizeInBytes() { + return static_cast(IntrinsicSizeInBytes().Read()); + } + static constexpr bool SizeIsKnown() { return IntrinsicSizeInBytes().Ok(); } + + template + bool Equals(GenericDominatedBareDiscriminantView + emboss_reserved_local_other) const { + if (!has_outer().Known()) return false; + if (!emboss_reserved_local_other.has_outer().Known()) return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + !has_outer().ValueOrDefault()) + return false; + if (has_outer().ValueOrDefault() && + !emboss_reserved_local_other.has_outer().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + has_outer().ValueOrDefault() && + !outer().Equals(emboss_reserved_local_other.outer())) + return false; + + if (!has_tag().Known()) return false; + if (!emboss_reserved_local_other.has_tag().Known()) return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + !has_tag().ValueOrDefault()) + return false; + if (has_tag().ValueOrDefault() && + !emboss_reserved_local_other.has_tag().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + has_tag().ValueOrDefault() && + !tag().Equals(emboss_reserved_local_other.tag())) + return false; + + if (!has_a().Known()) return false; + if (!emboss_reserved_local_other.has_a().Known()) return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + !has_a().ValueOrDefault()) + return false; + if (has_a().ValueOrDefault() && + !emboss_reserved_local_other.has_a().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + has_a().ValueOrDefault() && + !a().Equals(emboss_reserved_local_other.a())) + return false; + + if (!has_b().Known()) return false; + if (!emboss_reserved_local_other.has_b().Known()) return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + !has_b().ValueOrDefault()) + return false; + if (has_b().ValueOrDefault() && + !emboss_reserved_local_other.has_b().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + has_b().ValueOrDefault() && + !b().Equals(emboss_reserved_local_other.b())) + return false; + + if (!has_tail().Known()) return false; + if (!emboss_reserved_local_other.has_tail().Known()) return false; + + if (emboss_reserved_local_other.has_tail().ValueOrDefault() && + !has_tail().ValueOrDefault()) + return false; + if (has_tail().ValueOrDefault() && + !emboss_reserved_local_other.has_tail().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_tail().ValueOrDefault() && + has_tail().ValueOrDefault() && + !tail().Equals(emboss_reserved_local_other.tail())) + return false; + + return true; + } + template + bool UncheckedEquals(GenericDominatedBareDiscriminantView + emboss_reserved_local_other) const { + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + !has_outer().ValueOr(false)) + return false; + if (has_outer().ValueOr(false) && + !emboss_reserved_local_other.has_outer().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + has_outer().ValueOr(false) && + !outer().UncheckedEquals(emboss_reserved_local_other.outer())) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + !has_tag().ValueOr(false)) + return false; + if (has_tag().ValueOr(false) && + !emboss_reserved_local_other.has_tag().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + has_tag().ValueOr(false) && + !tag().UncheckedEquals(emboss_reserved_local_other.tag())) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + !has_a().ValueOr(false)) + return false; + if (has_a().ValueOr(false) && + !emboss_reserved_local_other.has_a().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + has_a().ValueOr(false) && + !a().UncheckedEquals(emboss_reserved_local_other.a())) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + !has_b().ValueOr(false)) + return false; + if (has_b().ValueOr(false) && + !emboss_reserved_local_other.has_b().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + has_b().ValueOr(false) && + !b().UncheckedEquals(emboss_reserved_local_other.b())) + return false; + + if (emboss_reserved_local_other.has_tail().ValueOr(false) && + !has_tail().ValueOr(false)) + return false; + if (has_tail().ValueOr(false) && + !emboss_reserved_local_other.has_tail().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_tail().ValueOr(false) && + has_tail().ValueOr(false) && + !tail().UncheckedEquals(emboss_reserved_local_other.tail())) + return false; + + return true; + } + template + void UncheckedCopyFrom(GenericDominatedBareDiscriminantView + emboss_reserved_local_other) const { + backing_.UncheckedCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().UncheckedRead()); + } + + template + void CopyFrom(GenericDominatedBareDiscriminantView + emboss_reserved_local_other) const { + backing_.CopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + template + bool TryToCopyFrom(GenericDominatedBareDiscriminantView + emboss_reserved_local_other) const { + return emboss_reserved_local_other.Ok() && + backing_.TryToCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + + template + bool UpdateFromTextStream(Stream* emboss_reserved_local_stream) const { + ::std::string emboss_reserved_local_brace; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_brace)) + return false; + if (emboss_reserved_local_brace != "{") return false; + for (;;) { + ::std::string emboss_reserved_local_name; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == ",") + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == "}") return true; + ::std::string emboss_reserved_local_colon; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_colon)) + return false; + if (emboss_reserved_local_colon != ":") return false; + if (emboss_reserved_local_name == "outer") { + if (!outer().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "tag") { + if (!tag().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "a") { + if (!a().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "b") { + if (!b().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "tail") { + if (!tail().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + return false; + } + } + + template + void WriteToTextStream( + Stream* emboss_reserved_local_stream, + ::emboss::TextOutputOptions emboss_reserved_local_options) const { + ::emboss::TextOutputOptions emboss_reserved_local_field_options = + emboss_reserved_local_options.PlusOneIndent(); + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write("{\n"); + } else { + emboss_reserved_local_stream->Write("{"); + } + bool emboss_reserved_local_wrote_field = false; + if (has_outer().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + outer().IsAggregate() || outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("outer: "); + outer().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !outer().IsAggregate() && !outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# outer: UNREADABLE\n"); + } + } + + if (has_tag().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + tag().IsAggregate() || tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("tag: "); + tag().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !tag().IsAggregate() && !tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# tag: UNREADABLE\n"); + } + } + + if (has_a().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + a().IsAggregate() || a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("a: "); + a().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !a().IsAggregate() && !a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# a: UNREADABLE\n"); + } + } + + if (has_b().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + b().IsAggregate() || b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("b: "); + b().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !b().IsAggregate() && !b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# b: UNREADABLE\n"); + } + } + + if (has_tail().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + tail().IsAggregate() || tail().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("tail: "); + tail().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !tail().IsAggregate() && !tail().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# tail: UNREADABLE\n"); + } + } + + (void)emboss_reserved_local_wrote_field; + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_options.current_indent()); + emboss_reserved_local_stream->Write("}"); + } else { + emboss_reserved_local_stream->Write(" }"); + } + } + + static constexpr bool IsAggregate() { return true; } + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + outer() const; + ::emboss::support::Maybe has_outer() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + tag() const; + ::emboss::support::Maybe has_tag() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + a() const; + ::emboss::support::Maybe has_a() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + b() const; + ::emboss::support::Maybe has_b() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + tail() const; + ::emboss::support::Maybe has_tail() const; + + public: + class EmbossReservedDollarVirtualIntrinsicSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualIntrinsicSizeInBytesView() {} + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualIntrinsicSizeInBytesView + IntrinsicSizeInBytes() { + return EmbossReservedDollarVirtualIntrinsicSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_IntrinsicSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + public: + class EmbossReservedDollarVirtualMaxSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMaxSizeInBytesView() {} + EmbossReservedDollarVirtualMaxSizeInBytesView( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMaxSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMaxSizeInBytesView + MaxSizeInBytes() { + return EmbossReservedDollarVirtualMaxSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MaxSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + public: + class EmbossReservedDollarVirtualMinSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMinSizeInBytesView() {} + EmbossReservedDollarVirtualMinSizeInBytesView( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMinSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMinSizeInBytesView + MinSizeInBytes() { + return EmbossReservedDollarVirtualMinSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MinSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + private: + Storage backing_; + + template + friend class GenericDominatedBareDiscriminantView; +}; +using DominatedBareDiscriminantView = GenericDominatedBareDiscriminantView< + /**/ ::emboss::support::ReadOnlyContiguousBuffer>; +using DominatedBareDiscriminantWriter = GenericDominatedBareDiscriminantView< + /**/ ::emboss::support::ReadWriteContiguousBuffer>; + +template +struct EmbossReservedInternalIsGenericDominatedBareDiscriminantView { + static constexpr const bool value = false; +}; + +template +struct EmbossReservedInternalIsGenericDominatedBareDiscriminantView< + GenericDominatedBareDiscriminantView> { + static constexpr const bool value = true; +}; + +template +inline GenericDominatedBareDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>> +MakeDominatedBareDiscriminantView(T&& emboss_reserved_local_arg) { + return GenericDominatedBareDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>>(::std::forward(emboss_reserved_local_arg)); +} + +template +inline GenericDominatedBareDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeDominatedBareDiscriminantView(T* emboss_reserved_local_data, + ::std::size_t emboss_reserved_local_size) { + return GenericDominatedBareDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +template +inline GenericDominatedBareDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeAlignedDominatedBareDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericDominatedBareDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +namespace DisjunctionConditionalDiscriminant { + +} // namespace DisjunctionConditionalDiscriminant + +template +struct EmbossReservedInternalIsGenericDisjunctionConditionalDiscriminantView; + +template +class GenericDisjunctionConditionalDiscriminantView final { + public: + GenericDisjunctionConditionalDiscriminantView() : backing_() {} + explicit GenericDisjunctionConditionalDiscriminantView( + Storage emboss_reserved_local_bytes) + : backing_(emboss_reserved_local_bytes) {} + + template + GenericDisjunctionConditionalDiscriminantView( + const GenericDisjunctionConditionalDiscriminantView& + emboss_reserved_local_other) + : backing_{emboss_reserved_local_other.BackingStorage()} {} + + template < + typename Arg, + typename = typename ::std::enable_if< + !EmbossReservedInternalIsGenericDisjunctionConditionalDiscriminantView< + typename ::std::remove_cv::type>::type>::value>::type> + explicit GenericDisjunctionConditionalDiscriminantView( + Arg&& emboss_reserved_local_arg) + : backing_(::std::forward(emboss_reserved_local_arg)) {} + template + explicit GenericDisjunctionConditionalDiscriminantView( + Arg0&& emboss_reserved_local_arg0, Arg1&& emboss_reserved_local_arg1, + Args&&... emboss_reserved_local_args) + : backing_(::std::forward(emboss_reserved_local_arg0), + ::std::forward(emboss_reserved_local_arg1), + ::std::forward(emboss_reserved_local_args)...) {} + + template + GenericDisjunctionConditionalDiscriminantView& operator=( + const GenericDisjunctionConditionalDiscriminantView& + emboss_reserved_local_other) { + backing_ = emboss_reserved_local_other.BackingStorage(); + return *this; + } + + bool Ok() const { + if (!IsComplete()) return false; + + const auto emboss_reserved_local_ok_subexpr_1 = tag(); + const auto emboss_reserved_local_ok_subexpr_2 = + (emboss_reserved_local_ok_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_ok_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + + if (!has_outer().Known()) return false; + if (has_outer().ValueOrDefault() && !outer().Ok()) return false; + + if (!has_IntrinsicSizeInBytes().Known()) return false; + if (has_IntrinsicSizeInBytes().ValueOrDefault() && + !IntrinsicSizeInBytes().Ok()) + return false; + + if (!has_MaxSizeInBytes().Known()) return false; + if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) + return false; + + if (!has_MinSizeInBytes().Known()) return false; + if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) + return false; + + if (!has_tag().Known()) return false; + if (has_tag().ValueOrDefault() && !tag().Ok()) return false; + + { + const auto emboss_reserved_switch_discrim = + emboss_reserved_local_ok_subexpr_2; + if (emboss_reserved_switch_discrim.Known()) { + switch (emboss_reserved_switch_discrim.ValueOrDefault()) { + case static_cast(0LL): + case static_cast(1LL): + if (!has_a().Known()) return false; + if (has_a().ValueOrDefault() && !a().Ok()) return false; + break; + + case static_cast(2LL): + case static_cast(3LL): + if (!has_b().Known()) return false; + if (has_b().ValueOrDefault() && !b().Ok()) return false; + break; + + default: + break; + } + } else { + if (!has_a().Known()) return false; + if (!has_b().Known()) return false; + } + } + + return true; + } + Storage BackingStorage() const { return backing_; } + bool IsComplete() const { + return backing_.Ok() && IntrinsicSizeInBytes().Ok() && + backing_.SizeInBytes() >= + static_cast( + IntrinsicSizeInBytes().UncheckedRead()); + } + ::std::size_t SizeInBytes() const { + return static_cast(IntrinsicSizeInBytes().Read()); + } + bool SizeIsKnown() const { return IntrinsicSizeInBytes().Ok(); } + + template + bool Equals(GenericDisjunctionConditionalDiscriminantView + emboss_reserved_local_other) const { + if (!has_outer().Known()) return false; + if (!emboss_reserved_local_other.has_outer().Known()) return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + !has_outer().ValueOrDefault()) + return false; + if (has_outer().ValueOrDefault() && + !emboss_reserved_local_other.has_outer().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + has_outer().ValueOrDefault() && + !outer().Equals(emboss_reserved_local_other.outer())) + return false; + + if (!has_tag().Known()) return false; + if (!emboss_reserved_local_other.has_tag().Known()) return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + !has_tag().ValueOrDefault()) + return false; + if (has_tag().ValueOrDefault() && + !emboss_reserved_local_other.has_tag().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + has_tag().ValueOrDefault() && + !tag().Equals(emboss_reserved_local_other.tag())) + return false; + + if (!has_a().Known()) return false; + if (!emboss_reserved_local_other.has_a().Known()) return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + !has_a().ValueOrDefault()) + return false; + if (has_a().ValueOrDefault() && + !emboss_reserved_local_other.has_a().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + has_a().ValueOrDefault() && + !a().Equals(emboss_reserved_local_other.a())) + return false; + + if (!has_b().Known()) return false; + if (!emboss_reserved_local_other.has_b().Known()) return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + !has_b().ValueOrDefault()) + return false; + if (has_b().ValueOrDefault() && + !emboss_reserved_local_other.has_b().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + has_b().ValueOrDefault() && + !b().Equals(emboss_reserved_local_other.b())) + return false; + + return true; + } + template + bool UncheckedEquals( + GenericDisjunctionConditionalDiscriminantView + emboss_reserved_local_other) const { + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + !has_outer().ValueOr(false)) + return false; + if (has_outer().ValueOr(false) && + !emboss_reserved_local_other.has_outer().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + has_outer().ValueOr(false) && + !outer().UncheckedEquals(emboss_reserved_local_other.outer())) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + !has_tag().ValueOr(false)) + return false; + if (has_tag().ValueOr(false) && + !emboss_reserved_local_other.has_tag().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + has_tag().ValueOr(false) && + !tag().UncheckedEquals(emboss_reserved_local_other.tag())) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + !has_a().ValueOr(false)) + return false; + if (has_a().ValueOr(false) && + !emboss_reserved_local_other.has_a().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + has_a().ValueOr(false) && + !a().UncheckedEquals(emboss_reserved_local_other.a())) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + !has_b().ValueOr(false)) + return false; + if (has_b().ValueOr(false) && + !emboss_reserved_local_other.has_b().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + has_b().ValueOr(false) && + !b().UncheckedEquals(emboss_reserved_local_other.b())) + return false; + + return true; + } + template + void UncheckedCopyFrom( + GenericDisjunctionConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.UncheckedCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().UncheckedRead()); + } + + template + void CopyFrom(GenericDisjunctionConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.CopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + template + bool TryToCopyFrom(GenericDisjunctionConditionalDiscriminantView + emboss_reserved_local_other) const { + return emboss_reserved_local_other.Ok() && + backing_.TryToCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + + template + bool UpdateFromTextStream(Stream* emboss_reserved_local_stream) const { + ::std::string emboss_reserved_local_brace; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_brace)) + return false; + if (emboss_reserved_local_brace != "{") return false; + for (;;) { + ::std::string emboss_reserved_local_name; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == ",") + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == "}") return true; + ::std::string emboss_reserved_local_colon; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_colon)) + return false; + if (emboss_reserved_local_colon != ":") return false; + if (emboss_reserved_local_name == "outer") { + if (!outer().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "tag") { + if (!tag().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "a") { + if (!a().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "b") { + if (!b().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + return false; + } + } + + template + void WriteToTextStream( + Stream* emboss_reserved_local_stream, + ::emboss::TextOutputOptions emboss_reserved_local_options) const { + ::emboss::TextOutputOptions emboss_reserved_local_field_options = + emboss_reserved_local_options.PlusOneIndent(); + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write("{\n"); + } else { + emboss_reserved_local_stream->Write("{"); + } + bool emboss_reserved_local_wrote_field = false; + if (has_outer().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + outer().IsAggregate() || outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("outer: "); + outer().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !outer().IsAggregate() && !outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# outer: UNREADABLE\n"); + } + } + + if (has_tag().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + tag().IsAggregate() || tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("tag: "); + tag().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !tag().IsAggregate() && !tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# tag: UNREADABLE\n"); + } + } + + if (has_a().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + a().IsAggregate() || a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("a: "); + a().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !a().IsAggregate() && !a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# a: UNREADABLE\n"); + } + } + + if (has_b().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + b().IsAggregate() || b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("b: "); + b().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !b().IsAggregate() && !b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# b: UNREADABLE\n"); + } + } + + (void)emboss_reserved_local_wrote_field; + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_options.current_indent()); + emboss_reserved_local_stream->Write("}"); + } else { + emboss_reserved_local_stream->Write(" }"); + } + } + + static constexpr bool IsAggregate() { return true; } + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + outer() const; + ::emboss::support::Maybe has_outer() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + tag() const; + ::emboss::support::Maybe has_tag() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + a() const; + ::emboss::support::Maybe has_a() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + b() const; + ::emboss::support::Maybe has_b() const; + + public: + class EmbossReservedDollarVirtualIntrinsicSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + explicit EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const GenericDisjunctionConditionalDiscriminantView& + emboss_reserved_local_view) + : view_(emboss_reserved_local_view) {} + EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = delete; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = default; + + ::std::int32_t Read() const { + EMBOSS_CHECK(view_.has_IntrinsicSizeInBytes().ValueOr(false)); + auto emboss_reserved_local_value = MaybeRead(); + EMBOSS_CHECK(emboss_reserved_local_value.Known()); + EMBOSS_CHECK(ValueIsOk(emboss_reserved_local_value.ValueOrDefault())); + return emboss_reserved_local_value.ValueOrDefault(); + } + ::std::int32_t UncheckedRead() const { + return MaybeRead().ValueOrDefault(); + } + bool Ok() const { + auto emboss_reserved_local_value = MaybeRead(); + return emboss_reserved_local_value.Known() && + ValueIsOk(emboss_reserved_local_value.ValueOrDefault()); + } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + + private: + ::emboss::support::Maybe MaybeRead() const { + const auto emboss_reserved_local_subexpr_1 = view_.outer(); + const auto emboss_reserved_local_subexpr_2 = + (emboss_reserved_local_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_3 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_2, + ::emboss::support::Maybe( + static_cast(1LL))); + const auto emboss_reserved_local_subexpr_4 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_3, + ::emboss::support::Maybe( + static_cast(2LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_5 = view_.tag(); + const auto emboss_reserved_local_subexpr_6 = + (emboss_reserved_local_subexpr_5.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_5.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_7 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_8 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(1LL))); + const auto emboss_reserved_local_subexpr_9 = + ::emboss::support::Or( + emboss_reserved_local_subexpr_7, emboss_reserved_local_subexpr_8); + const auto emboss_reserved_local_subexpr_10 = + ::emboss::support::And( + emboss_reserved_local_subexpr_9, emboss_reserved_local_subexpr_3); + const auto emboss_reserved_local_subexpr_11 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_10, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_12 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(2LL))); + const auto emboss_reserved_local_subexpr_13 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(3LL))); + const auto emboss_reserved_local_subexpr_14 = + ::emboss::support::Or( + emboss_reserved_local_subexpr_12, + emboss_reserved_local_subexpr_13); + const auto emboss_reserved_local_subexpr_15 = + ::emboss::support::And( + emboss_reserved_local_subexpr_14, + emboss_reserved_local_subexpr_3); + const auto emboss_reserved_local_subexpr_16 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_15, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_17 = ::emboss::support::Maximum< + /**/ ::std::int32_t, ::std::int32_t, ::std::int32_t, ::std::int32_t, + ::std::int32_t, ::std::int32_t, ::std::int32_t>( + ::emboss::support::Maybe( + static_cast(0LL)), + ::emboss::support::Maybe( + static_cast(1LL)), + emboss_reserved_local_subexpr_4, emboss_reserved_local_subexpr_11, + emboss_reserved_local_subexpr_16); + + return emboss_reserved_local_subexpr_17; + } + + static constexpr bool ValueIsOk( + ::std::int32_t emboss_reserved_local_value) { + return (void)emboss_reserved_local_value, // Silence -Wunused-parameter + ::emboss::support::Maybe(true).ValueOr(false); + } + + const GenericDisjunctionConditionalDiscriminantView view_; + }; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView IntrinsicSizeInBytes() + const; + ::emboss::support::Maybe has_IntrinsicSizeInBytes() const; + + public: + class EmbossReservedDollarVirtualMaxSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMaxSizeInBytesView() {} + EmbossReservedDollarVirtualMaxSizeInBytesView( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMaxSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMaxSizeInBytesView + MaxSizeInBytes() { + return EmbossReservedDollarVirtualMaxSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MaxSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + public: + class EmbossReservedDollarVirtualMinSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMinSizeInBytesView() {} + EmbossReservedDollarVirtualMinSizeInBytesView( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMinSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMinSizeInBytesView + MinSizeInBytes() { + return EmbossReservedDollarVirtualMinSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MinSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + private: + Storage backing_; + + template + friend class GenericDisjunctionConditionalDiscriminantView; +}; +using DisjunctionConditionalDiscriminantView = + GenericDisjunctionConditionalDiscriminantView< + /**/ ::emboss::support::ReadOnlyContiguousBuffer>; +using DisjunctionConditionalDiscriminantWriter = + GenericDisjunctionConditionalDiscriminantView< + /**/ ::emboss::support::ReadWriteContiguousBuffer>; + +template +struct EmbossReservedInternalIsGenericDisjunctionConditionalDiscriminantView { + static constexpr const bool value = false; +}; + +template +struct EmbossReservedInternalIsGenericDisjunctionConditionalDiscriminantView< + GenericDisjunctionConditionalDiscriminantView> { + static constexpr const bool value = true; +}; + +template +inline GenericDisjunctionConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>> +MakeDisjunctionConditionalDiscriminantView(T&& emboss_reserved_local_arg) { + return GenericDisjunctionConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>>(::std::forward(emboss_reserved_local_arg)); +} + +template +inline GenericDisjunctionConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeDisjunctionConditionalDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericDisjunctionConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +template +inline GenericDisjunctionConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeAlignedDisjunctionConditionalDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericDisjunctionConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +namespace SingleEntryConditionalDiscriminant { + +} // namespace SingleEntryConditionalDiscriminant + +template +struct EmbossReservedInternalIsGenericSingleEntryConditionalDiscriminantView; + +template +class GenericSingleEntryConditionalDiscriminantView final { + public: + GenericSingleEntryConditionalDiscriminantView() : backing_() {} + explicit GenericSingleEntryConditionalDiscriminantView( + Storage emboss_reserved_local_bytes) + : backing_(emboss_reserved_local_bytes) {} + + template + GenericSingleEntryConditionalDiscriminantView( + const GenericSingleEntryConditionalDiscriminantView& + emboss_reserved_local_other) + : backing_{emboss_reserved_local_other.BackingStorage()} {} + + template < + typename Arg, + typename = typename ::std::enable_if< + !EmbossReservedInternalIsGenericSingleEntryConditionalDiscriminantView< + typename ::std::remove_cv::type>::type>::value>::type> + explicit GenericSingleEntryConditionalDiscriminantView( + Arg&& emboss_reserved_local_arg) + : backing_(::std::forward(emboss_reserved_local_arg)) {} + template + explicit GenericSingleEntryConditionalDiscriminantView( + Arg0&& emboss_reserved_local_arg0, Arg1&& emboss_reserved_local_arg1, + Args&&... emboss_reserved_local_args) + : backing_(::std::forward(emboss_reserved_local_arg0), + ::std::forward(emboss_reserved_local_arg1), + ::std::forward(emboss_reserved_local_args)...) {} + + template + GenericSingleEntryConditionalDiscriminantView& operator=( + const GenericSingleEntryConditionalDiscriminantView& + emboss_reserved_local_other) { + backing_ = emboss_reserved_local_other.BackingStorage(); + return *this; + } + + bool Ok() const { + if (!IsComplete()) return false; + + if (!has_outer().Known()) return false; + if (has_outer().ValueOrDefault() && !outer().Ok()) return false; + + if (!has_IntrinsicSizeInBytes().Known()) return false; + if (has_IntrinsicSizeInBytes().ValueOrDefault() && + !IntrinsicSizeInBytes().Ok()) + return false; + + if (!has_MaxSizeInBytes().Known()) return false; + if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) + return false; + + if (!has_MinSizeInBytes().Known()) return false; + if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) + return false; + + if (!has_tag().Known()) return false; + if (has_tag().ValueOrDefault() && !tag().Ok()) return false; + + if (!has_a().Known()) return false; + if (has_a().ValueOrDefault() && !a().Ok()) return false; + + return true; + } + Storage BackingStorage() const { return backing_; } + bool IsComplete() const { + return backing_.Ok() && IntrinsicSizeInBytes().Ok() && + backing_.SizeInBytes() >= + static_cast( + IntrinsicSizeInBytes().UncheckedRead()); + } + ::std::size_t SizeInBytes() const { + return static_cast(IntrinsicSizeInBytes().Read()); + } + bool SizeIsKnown() const { return IntrinsicSizeInBytes().Ok(); } + + template + bool Equals(GenericSingleEntryConditionalDiscriminantView + emboss_reserved_local_other) const { + if (!has_outer().Known()) return false; + if (!emboss_reserved_local_other.has_outer().Known()) return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + !has_outer().ValueOrDefault()) + return false; + if (has_outer().ValueOrDefault() && + !emboss_reserved_local_other.has_outer().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + has_outer().ValueOrDefault() && + !outer().Equals(emboss_reserved_local_other.outer())) + return false; + + if (!has_tag().Known()) return false; + if (!emboss_reserved_local_other.has_tag().Known()) return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + !has_tag().ValueOrDefault()) + return false; + if (has_tag().ValueOrDefault() && + !emboss_reserved_local_other.has_tag().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + has_tag().ValueOrDefault() && + !tag().Equals(emboss_reserved_local_other.tag())) + return false; + + if (!has_a().Known()) return false; + if (!emboss_reserved_local_other.has_a().Known()) return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + !has_a().ValueOrDefault()) + return false; + if (has_a().ValueOrDefault() && + !emboss_reserved_local_other.has_a().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + has_a().ValueOrDefault() && + !a().Equals(emboss_reserved_local_other.a())) + return false; + + return true; + } + template + bool UncheckedEquals( + GenericSingleEntryConditionalDiscriminantView + emboss_reserved_local_other) const { + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + !has_outer().ValueOr(false)) + return false; + if (has_outer().ValueOr(false) && + !emboss_reserved_local_other.has_outer().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + has_outer().ValueOr(false) && + !outer().UncheckedEquals(emboss_reserved_local_other.outer())) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + !has_tag().ValueOr(false)) + return false; + if (has_tag().ValueOr(false) && + !emboss_reserved_local_other.has_tag().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + has_tag().ValueOr(false) && + !tag().UncheckedEquals(emboss_reserved_local_other.tag())) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + !has_a().ValueOr(false)) + return false; + if (has_a().ValueOr(false) && + !emboss_reserved_local_other.has_a().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + has_a().ValueOr(false) && + !a().UncheckedEquals(emboss_reserved_local_other.a())) + return false; + + return true; + } + template + void UncheckedCopyFrom( + GenericSingleEntryConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.UncheckedCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().UncheckedRead()); + } + + template + void CopyFrom(GenericSingleEntryConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.CopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + template + bool TryToCopyFrom(GenericSingleEntryConditionalDiscriminantView + emboss_reserved_local_other) const { + return emboss_reserved_local_other.Ok() && + backing_.TryToCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + + template + bool UpdateFromTextStream(Stream* emboss_reserved_local_stream) const { + ::std::string emboss_reserved_local_brace; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_brace)) + return false; + if (emboss_reserved_local_brace != "{") return false; + for (;;) { + ::std::string emboss_reserved_local_name; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == ",") + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == "}") return true; + ::std::string emboss_reserved_local_colon; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_colon)) + return false; + if (emboss_reserved_local_colon != ":") return false; + if (emboss_reserved_local_name == "outer") { + if (!outer().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "tag") { + if (!tag().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "a") { + if (!a().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + return false; + } + } + + template + void WriteToTextStream( + Stream* emboss_reserved_local_stream, + ::emboss::TextOutputOptions emboss_reserved_local_options) const { + ::emboss::TextOutputOptions emboss_reserved_local_field_options = + emboss_reserved_local_options.PlusOneIndent(); + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write("{\n"); + } else { + emboss_reserved_local_stream->Write("{"); + } + bool emboss_reserved_local_wrote_field = false; + if (has_outer().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + outer().IsAggregate() || outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("outer: "); + outer().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !outer().IsAggregate() && !outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# outer: UNREADABLE\n"); + } + } + + if (has_tag().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + tag().IsAggregate() || tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("tag: "); + tag().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !tag().IsAggregate() && !tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# tag: UNREADABLE\n"); + } + } + + if (has_a().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + a().IsAggregate() || a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("a: "); + a().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !a().IsAggregate() && !a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# a: UNREADABLE\n"); + } + } + + (void)emboss_reserved_local_wrote_field; + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_options.current_indent()); + emboss_reserved_local_stream->Write("}"); + } else { + emboss_reserved_local_stream->Write(" }"); + } + } + + static constexpr bool IsAggregate() { return true; } + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + outer() const; + ::emboss::support::Maybe has_outer() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + tag() const; + ::emboss::support::Maybe has_tag() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + a() const; + ::emboss::support::Maybe has_a() const; + + public: + class EmbossReservedDollarVirtualIntrinsicSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + explicit EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const GenericSingleEntryConditionalDiscriminantView& + emboss_reserved_local_view) + : view_(emboss_reserved_local_view) {} + EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = delete; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = default; + + ::std::int32_t Read() const { + EMBOSS_CHECK(view_.has_IntrinsicSizeInBytes().ValueOr(false)); + auto emboss_reserved_local_value = MaybeRead(); + EMBOSS_CHECK(emboss_reserved_local_value.Known()); + EMBOSS_CHECK(ValueIsOk(emboss_reserved_local_value.ValueOrDefault())); + return emboss_reserved_local_value.ValueOrDefault(); + } + ::std::int32_t UncheckedRead() const { + return MaybeRead().ValueOrDefault(); + } + bool Ok() const { + auto emboss_reserved_local_value = MaybeRead(); + return emboss_reserved_local_value.Known() && + ValueIsOk(emboss_reserved_local_value.ValueOrDefault()); + } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + + private: + ::emboss::support::Maybe MaybeRead() const { + const auto emboss_reserved_local_subexpr_1 = view_.outer(); + const auto emboss_reserved_local_subexpr_2 = + (emboss_reserved_local_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_3 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_2, + ::emboss::support::Maybe( + static_cast(1LL))); + const auto emboss_reserved_local_subexpr_4 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_3, + ::emboss::support::Maybe( + static_cast(2LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_5 = view_.tag(); + const auto emboss_reserved_local_subexpr_6 = + (emboss_reserved_local_subexpr_5.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_5.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_7 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_8 = + ::emboss::support::And( + emboss_reserved_local_subexpr_7, emboss_reserved_local_subexpr_3); + const auto emboss_reserved_local_subexpr_9 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_8, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_10 = + ::emboss::support::Maximum( + ::emboss::support::Maybe( + static_cast(0LL)), + ::emboss::support::Maybe( + static_cast(1LL)), + emboss_reserved_local_subexpr_4, emboss_reserved_local_subexpr_9); + + return emboss_reserved_local_subexpr_10; + } + + static constexpr bool ValueIsOk( + ::std::int32_t emboss_reserved_local_value) { + return (void)emboss_reserved_local_value, // Silence -Wunused-parameter + ::emboss::support::Maybe(true).ValueOr(false); + } + + const GenericSingleEntryConditionalDiscriminantView view_; + }; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView IntrinsicSizeInBytes() + const; + ::emboss::support::Maybe has_IntrinsicSizeInBytes() const; + + public: + class EmbossReservedDollarVirtualMaxSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMaxSizeInBytesView() {} + EmbossReservedDollarVirtualMaxSizeInBytesView( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMaxSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMaxSizeInBytesView + MaxSizeInBytes() { + return EmbossReservedDollarVirtualMaxSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MaxSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + public: + class EmbossReservedDollarVirtualMinSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMinSizeInBytesView() {} + EmbossReservedDollarVirtualMinSizeInBytesView( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMinSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMinSizeInBytesView + MinSizeInBytes() { + return EmbossReservedDollarVirtualMinSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MinSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + private: + Storage backing_; + + template + friend class GenericSingleEntryConditionalDiscriminantView; +}; +using SingleEntryConditionalDiscriminantView = + GenericSingleEntryConditionalDiscriminantView< + /**/ ::emboss::support::ReadOnlyContiguousBuffer>; +using SingleEntryConditionalDiscriminantWriter = + GenericSingleEntryConditionalDiscriminantView< + /**/ ::emboss::support::ReadWriteContiguousBuffer>; + +template +struct EmbossReservedInternalIsGenericSingleEntryConditionalDiscriminantView { + static constexpr const bool value = false; +}; + +template +struct EmbossReservedInternalIsGenericSingleEntryConditionalDiscriminantView< + GenericSingleEntryConditionalDiscriminantView> { + static constexpr const bool value = true; +}; + +template +inline GenericSingleEntryConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>> +MakeSingleEntryConditionalDiscriminantView(T&& emboss_reserved_local_arg) { + return GenericSingleEntryConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>>(::std::forward(emboss_reserved_local_arg)); +} + +template +inline GenericSingleEntryConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeSingleEntryConditionalDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericSingleEntryConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +template +inline GenericSingleEntryConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeAlignedSingleEntryConditionalDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericSingleEntryConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +namespace EnumConditionalDiscriminant { + +} // namespace EnumConditionalDiscriminant + +template +struct EmbossReservedInternalIsGenericEnumConditionalDiscriminantView; + +template +class GenericEnumConditionalDiscriminantView final { + public: + GenericEnumConditionalDiscriminantView() : backing_() {} + explicit GenericEnumConditionalDiscriminantView( + Storage emboss_reserved_local_bytes) + : backing_(emboss_reserved_local_bytes) {} + + template + GenericEnumConditionalDiscriminantView( + const GenericEnumConditionalDiscriminantView& + emboss_reserved_local_other) + : backing_{emboss_reserved_local_other.BackingStorage()} {} + + template ::type>::type>::value>::type> + explicit GenericEnumConditionalDiscriminantView( + Arg&& emboss_reserved_local_arg) + : backing_(::std::forward(emboss_reserved_local_arg)) {} + template + explicit GenericEnumConditionalDiscriminantView( + Arg0&& emboss_reserved_local_arg0, Arg1&& emboss_reserved_local_arg1, + Args&&... emboss_reserved_local_args) + : backing_(::std::forward(emboss_reserved_local_arg0), + ::std::forward(emboss_reserved_local_arg1), + ::std::forward(emboss_reserved_local_args)...) {} + + template + GenericEnumConditionalDiscriminantView& operator=( + const GenericEnumConditionalDiscriminantView& + emboss_reserved_local_other) { + backing_ = emboss_reserved_local_other.BackingStorage(); + return *this; + } + + bool Ok() const { + if (!IsComplete()) return false; + + const auto emboss_reserved_local_ok_subexpr_1 = tag(); + const auto emboss_reserved_local_ok_subexpr_2 = + (emboss_reserved_local_ok_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_ok_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + + if (!has_outer().Known()) return false; + if (has_outer().ValueOrDefault() && !outer().Ok()) return false; + + if (!has_IntrinsicSizeInBytes().Known()) return false; + if (has_IntrinsicSizeInBytes().ValueOrDefault() && + !IntrinsicSizeInBytes().Ok()) + return false; + + if (!has_MaxSizeInBytes().Known()) return false; + if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) + return false; + + if (!has_MinSizeInBytes().Known()) return false; + if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) + return false; + + if (!has_tag().Known()) return false; + if (has_tag().ValueOrDefault() && !tag().Ok()) return false; + + { + const auto emboss_reserved_switch_discrim = + emboss_reserved_local_ok_subexpr_2; + if (emboss_reserved_switch_discrim.Known()) { + switch (emboss_reserved_switch_discrim.ValueOrDefault()) { + case static_cast(0): + if (!has_a().Known()) return false; + if (has_a().ValueOrDefault() && !a().Ok()) return false; + break; + + case static_cast(1): + if (!has_b().Known()) return false; + if (has_b().ValueOrDefault() && !b().Ok()) return false; + break; + + default: + break; + } + } else { + if (!has_a().Known()) return false; + if (!has_b().Known()) return false; + } + } + + return true; + } + Storage BackingStorage() const { return backing_; } + bool IsComplete() const { + return backing_.Ok() && IntrinsicSizeInBytes().Ok() && + backing_.SizeInBytes() >= + static_cast( + IntrinsicSizeInBytes().UncheckedRead()); + } + ::std::size_t SizeInBytes() const { + return static_cast(IntrinsicSizeInBytes().Read()); + } + bool SizeIsKnown() const { return IntrinsicSizeInBytes().Ok(); } + + template + bool Equals(GenericEnumConditionalDiscriminantView + emboss_reserved_local_other) const { + if (!has_outer().Known()) return false; + if (!emboss_reserved_local_other.has_outer().Known()) return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + !has_outer().ValueOrDefault()) + return false; + if (has_outer().ValueOrDefault() && + !emboss_reserved_local_other.has_outer().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + has_outer().ValueOrDefault() && + !outer().Equals(emboss_reserved_local_other.outer())) + return false; + + if (!has_tag().Known()) return false; + if (!emboss_reserved_local_other.has_tag().Known()) return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + !has_tag().ValueOrDefault()) + return false; + if (has_tag().ValueOrDefault() && + !emboss_reserved_local_other.has_tag().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOrDefault() && + has_tag().ValueOrDefault() && + !tag().Equals(emboss_reserved_local_other.tag())) + return false; + + if (!has_a().Known()) return false; + if (!emboss_reserved_local_other.has_a().Known()) return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + !has_a().ValueOrDefault()) + return false; + if (has_a().ValueOrDefault() && + !emboss_reserved_local_other.has_a().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_a().ValueOrDefault() && + has_a().ValueOrDefault() && + !a().Equals(emboss_reserved_local_other.a())) + return false; + + if (!has_b().Known()) return false; + if (!emboss_reserved_local_other.has_b().Known()) return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + !has_b().ValueOrDefault()) + return false; + if (has_b().ValueOrDefault() && + !emboss_reserved_local_other.has_b().ValueOrDefault()) + return false; + + if (emboss_reserved_local_other.has_b().ValueOrDefault() && + has_b().ValueOrDefault() && + !b().Equals(emboss_reserved_local_other.b())) + return false; + + return true; + } + template + bool UncheckedEquals(GenericEnumConditionalDiscriminantView + emboss_reserved_local_other) const { + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + !has_outer().ValueOr(false)) + return false; + if (has_outer().ValueOr(false) && + !emboss_reserved_local_other.has_outer().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_outer().ValueOr(false) && + has_outer().ValueOr(false) && + !outer().UncheckedEquals(emboss_reserved_local_other.outer())) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + !has_tag().ValueOr(false)) + return false; + if (has_tag().ValueOr(false) && + !emboss_reserved_local_other.has_tag().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_tag().ValueOr(false) && + has_tag().ValueOr(false) && + !tag().UncheckedEquals(emboss_reserved_local_other.tag())) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + !has_a().ValueOr(false)) + return false; + if (has_a().ValueOr(false) && + !emboss_reserved_local_other.has_a().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_a().ValueOr(false) && + has_a().ValueOr(false) && + !a().UncheckedEquals(emboss_reserved_local_other.a())) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + !has_b().ValueOr(false)) + return false; + if (has_b().ValueOr(false) && + !emboss_reserved_local_other.has_b().ValueOr(false)) + return false; + + if (emboss_reserved_local_other.has_b().ValueOr(false) && + has_b().ValueOr(false) && + !b().UncheckedEquals(emboss_reserved_local_other.b())) + return false; + + return true; + } + template + void UncheckedCopyFrom(GenericEnumConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.UncheckedCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().UncheckedRead()); + } + + template + void CopyFrom(GenericEnumConditionalDiscriminantView + emboss_reserved_local_other) const { + backing_.CopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + template + bool TryToCopyFrom(GenericEnumConditionalDiscriminantView + emboss_reserved_local_other) const { + return emboss_reserved_local_other.Ok() && + backing_.TryToCopyFrom( + emboss_reserved_local_other.BackingStorage(), + emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); + } + + template + bool UpdateFromTextStream(Stream* emboss_reserved_local_stream) const { + ::std::string emboss_reserved_local_brace; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_brace)) + return false; + if (emboss_reserved_local_brace != "{") return false; + for (;;) { + ::std::string emboss_reserved_local_name; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == ",") + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_name)) + return false; + if (emboss_reserved_local_name == "}") return true; + ::std::string emboss_reserved_local_colon; + if (!::emboss::support::ReadToken(emboss_reserved_local_stream, + &emboss_reserved_local_colon)) + return false; + if (emboss_reserved_local_colon != ":") return false; + if (emboss_reserved_local_name == "outer") { + if (!outer().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "tag") { + if (!tag().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "a") { + if (!a().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + if (emboss_reserved_local_name == "b") { + if (!b().UpdateFromTextStream(emboss_reserved_local_stream)) { + return false; + } + continue; + } + + return false; + } + } + + template + void WriteToTextStream( + Stream* emboss_reserved_local_stream, + ::emboss::TextOutputOptions emboss_reserved_local_options) const { + ::emboss::TextOutputOptions emboss_reserved_local_field_options = + emboss_reserved_local_options.PlusOneIndent(); + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write("{\n"); + } else { + emboss_reserved_local_stream->Write("{"); + } + bool emboss_reserved_local_wrote_field = false; + if (has_outer().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + outer().IsAggregate() || outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("outer: "); + outer().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !outer().IsAggregate() && !outer().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# outer: UNREADABLE\n"); + } + } + + if (has_tag().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + tag().IsAggregate() || tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("tag: "); + tag().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !tag().IsAggregate() && !tag().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# tag: UNREADABLE\n"); + } + } + + if (has_a().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + a().IsAggregate() || a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("a: "); + a().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !a().IsAggregate() && !a().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# a: UNREADABLE\n"); + } + } + + if (has_b().ValueOr(false)) { + if (!emboss_reserved_local_field_options.allow_partial_output() || + b().IsAggregate() || b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } else { + if (emboss_reserved_local_wrote_field) { + emboss_reserved_local_stream->Write(","); + } + emboss_reserved_local_stream->Write(" "); + } + emboss_reserved_local_stream->Write("b: "); + b().WriteToTextStream(emboss_reserved_local_stream, + emboss_reserved_local_field_options); + emboss_reserved_local_wrote_field = true; + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write("\n"); + } + } else if (emboss_reserved_local_field_options.allow_partial_output() && + emboss_reserved_local_field_options.comments() && + !b().IsAggregate() && !b().Ok()) { + if (emboss_reserved_local_field_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_field_options.current_indent()); + } + emboss_reserved_local_stream->Write("# b: UNREADABLE\n"); + } + } + + (void)emboss_reserved_local_wrote_field; + if (emboss_reserved_local_options.multiline()) { + emboss_reserved_local_stream->Write( + emboss_reserved_local_options.current_indent()); + emboss_reserved_local_stream->Write("}"); + } else { + emboss_reserved_local_stream->Write(" }"); + } + } + + static constexpr bool IsAggregate() { return true; } + + public: + typename ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + outer() const; + ::emboss::support::Maybe has_outer() const; + + public: + typename ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + tag() const; + ::emboss::support::Maybe has_tag() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + a() const; + ::emboss::support::Maybe has_a() const; + + public: + typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + b() const; + ::emboss::support::Maybe has_b() const; + + public: + class EmbossReservedDollarVirtualIntrinsicSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + explicit EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const GenericEnumConditionalDiscriminantView& + emboss_reserved_local_view) + : view_(emboss_reserved_local_view) {} + EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = delete; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + const EmbossReservedDollarVirtualIntrinsicSizeInBytesView&) = default; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView& operator=( + EmbossReservedDollarVirtualIntrinsicSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualIntrinsicSizeInBytesView() = default; + + ::std::int32_t Read() const { + EMBOSS_CHECK(view_.has_IntrinsicSizeInBytes().ValueOr(false)); + auto emboss_reserved_local_value = MaybeRead(); + EMBOSS_CHECK(emboss_reserved_local_value.Known()); + EMBOSS_CHECK(ValueIsOk(emboss_reserved_local_value.ValueOrDefault())); + return emboss_reserved_local_value.ValueOrDefault(); + } + ::std::int32_t UncheckedRead() const { + return MaybeRead().ValueOrDefault(); + } + bool Ok() const { + auto emboss_reserved_local_value = MaybeRead(); + return emboss_reserved_local_value.Known() && + ValueIsOk(emboss_reserved_local_value.ValueOrDefault()); + } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + + private: + ::emboss::support::Maybe MaybeRead() const { + const auto emboss_reserved_local_subexpr_1 = view_.outer(); + const auto emboss_reserved_local_subexpr_2 = + (emboss_reserved_local_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_3 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_2, + ::emboss::support::Maybe( + static_cast(1))); + const auto emboss_reserved_local_subexpr_4 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_3, + ::emboss::support::Maybe( + static_cast(2LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_5 = view_.tag(); + const auto emboss_reserved_local_subexpr_6 = + (emboss_reserved_local_subexpr_5.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_5.UncheckedRead())) + : ::emboss::support::Maybe()); + const auto emboss_reserved_local_subexpr_7 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(0))); + const auto emboss_reserved_local_subexpr_8 = + ::emboss::support::And( + emboss_reserved_local_subexpr_7, emboss_reserved_local_subexpr_3); + const auto emboss_reserved_local_subexpr_9 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_8, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_10 = + ::emboss::support::Equal( + emboss_reserved_local_subexpr_6, + ::emboss::support::Maybe( + static_cast(1))); + const auto emboss_reserved_local_subexpr_11 = + ::emboss::support::And( + emboss_reserved_local_subexpr_10, + emboss_reserved_local_subexpr_3); + const auto emboss_reserved_local_subexpr_12 = + ::emboss::support::Choice( + emboss_reserved_local_subexpr_11, + ::emboss::support::Maybe( + static_cast(3LL)), + ::emboss::support::Maybe( + static_cast(0LL))); + const auto emboss_reserved_local_subexpr_13 = ::emboss::support::Maximum< + /**/ ::std::int32_t, ::std::int32_t, ::std::int32_t, ::std::int32_t, + ::std::int32_t, ::std::int32_t, ::std::int32_t>( + ::emboss::support::Maybe( + static_cast(0LL)), + ::emboss::support::Maybe( + static_cast(1LL)), + emboss_reserved_local_subexpr_4, emboss_reserved_local_subexpr_9, + emboss_reserved_local_subexpr_12); + + return emboss_reserved_local_subexpr_13; + } + + static constexpr bool ValueIsOk( + ::std::int32_t emboss_reserved_local_value) { + return (void)emboss_reserved_local_value, // Silence -Wunused-parameter + ::emboss::support::Maybe(true).ValueOr(false); + } + + const GenericEnumConditionalDiscriminantView view_; + }; + EmbossReservedDollarVirtualIntrinsicSizeInBytesView IntrinsicSizeInBytes() + const; + ::emboss::support::Maybe has_IntrinsicSizeInBytes() const; + + public: + class EmbossReservedDollarVirtualMaxSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMaxSizeInBytesView() {} + EmbossReservedDollarVirtualMaxSizeInBytesView( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMaxSizeInBytesView&) = default; + EmbossReservedDollarVirtualMaxSizeInBytesView& operator=( + EmbossReservedDollarVirtualMaxSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMaxSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMaxSizeInBytesView + MaxSizeInBytes() { + return EmbossReservedDollarVirtualMaxSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MaxSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + public: + class EmbossReservedDollarVirtualMinSizeInBytesView final { + public: + using ValueType = ::std::int32_t; + + constexpr EmbossReservedDollarVirtualMinSizeInBytesView() {} + EmbossReservedDollarVirtualMinSizeInBytesView( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + const EmbossReservedDollarVirtualMinSizeInBytesView&) = default; + EmbossReservedDollarVirtualMinSizeInBytesView& operator=( + EmbossReservedDollarVirtualMinSizeInBytesView&&) = default; + ~EmbossReservedDollarVirtualMinSizeInBytesView() = default; + + static constexpr ::std::int32_t Read(); + static constexpr ::std::int32_t UncheckedRead(); + static constexpr bool Ok() { return true; } + template + void WriteToTextStream(Stream* emboss_reserved_local_stream, + const ::emboss::TextOutputOptions& + emboss_reserved_local_options) const { + ::emboss::support::WriteIntegerViewToTextStream( + this, emboss_reserved_local_stream, emboss_reserved_local_options); + } + + static constexpr bool IsAggregate() { return false; } + }; + + static constexpr EmbossReservedDollarVirtualMinSizeInBytesView + MinSizeInBytes() { + return EmbossReservedDollarVirtualMinSizeInBytesView(); + } + static constexpr ::emboss::support::Maybe has_MinSizeInBytes() { + return ::emboss::support::Maybe(true); + } + + private: + Storage backing_; + + template + friend class GenericEnumConditionalDiscriminantView; +}; +using EnumConditionalDiscriminantView = GenericEnumConditionalDiscriminantView< + /**/ ::emboss::support::ReadOnlyContiguousBuffer>; +using EnumConditionalDiscriminantWriter = + GenericEnumConditionalDiscriminantView< + /**/ ::emboss::support::ReadWriteContiguousBuffer>; + +template +struct EmbossReservedInternalIsGenericEnumConditionalDiscriminantView { + static constexpr const bool value = false; +}; + +template +struct EmbossReservedInternalIsGenericEnumConditionalDiscriminantView< + GenericEnumConditionalDiscriminantView> { + static constexpr const bool value = true; +}; + +template +inline GenericEnumConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>> +MakeEnumConditionalDiscriminantView(T&& emboss_reserved_local_arg) { + return GenericEnumConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer< + typename ::std::remove_reference< + decltype(*::std::declval()->data())>::type, + 1, 0>>(::std::forward(emboss_reserved_local_arg)); +} + +template +inline GenericEnumConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeEnumConditionalDiscriminantView(T* emboss_reserved_local_data, + ::std::size_t emboss_reserved_local_size) { + return GenericEnumConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +template +inline GenericEnumConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer> +MakeAlignedEnumConditionalDiscriminantView( + T* emboss_reserved_local_data, ::std::size_t emboss_reserved_local_size) { + return GenericEnumConditionalDiscriminantView< + /**/ ::emboss::support::ContiguousBuffer>( + emboss_reserved_local_data, emboss_reserved_local_size); +} + +namespace BasicConditional {} // namespace BasicConditional + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericBasicConditionalView::x() const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericBasicConditionalView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericBasicConditionalView::xc() const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericBasicConditionalView::has_xc() const { + return ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +template +inline typename GenericBasicConditionalView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericBasicConditionalView::IntrinsicSizeInBytes() const { + return typename GenericBasicConditionalView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe +GenericBasicConditionalView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace BasicConditional { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace BasicConditional + +template +inline constexpr ::std::int32_t GenericBasicConditionalView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return BasicConditional::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericBasicConditionalView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return BasicConditional::MaxSizeInBytes(); +} + +namespace BasicConditional { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace BasicConditional + +template +inline constexpr ::std::int32_t GenericBasicConditionalView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return BasicConditional::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericBasicConditionalView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return BasicConditional::MinSizeInBytes(); +} +namespace NegativeConditional {} // namespace NegativeConditional + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericNegativeConditionalView::x() const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericNegativeConditionalView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericNegativeConditionalView::xc() const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericNegativeConditionalView::has_xc() const { + return ::emboss::support::NotEqual( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +template +inline typename GenericNegativeConditionalView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericNegativeConditionalView::IntrinsicSizeInBytes() const { + return typename GenericNegativeConditionalView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe +GenericNegativeConditionalView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace NegativeConditional { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace NegativeConditional + +template +inline constexpr ::std::int32_t GenericNegativeConditionalView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return NegativeConditional::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericNegativeConditionalView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return NegativeConditional::MaxSizeInBytes(); +} + +namespace NegativeConditional { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace NegativeConditional + +template +inline constexpr ::std::int32_t GenericNegativeConditionalView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return NegativeConditional::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericNegativeConditionalView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return NegativeConditional::MinSizeInBytes(); +} +namespace ConditionalAndUnconditionalOverlappingFinalField { + +} // namespace ConditionalAndUnconditionalOverlappingFinalField + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalAndUnconditionalOverlappingFinalFieldView::x() + const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionalAndUnconditionalOverlappingFinalFieldView::has_x() + const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalAndUnconditionalOverlappingFinalFieldView::xc() + const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionalAndUnconditionalOverlappingFinalFieldView::has_xc() + const { + return ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalAndUnconditionalOverlappingFinalFieldView::z() + const { + if (has_z().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionalAndUnconditionalOverlappingFinalFieldView::has_z() + const { + return ::emboss::support::Maybe(true); +} + +namespace ConditionalAndUnconditionalOverlappingFinalField { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace ConditionalAndUnconditionalOverlappingFinalField + +template +inline constexpr ::std::int32_t +GenericConditionalAndUnconditionalOverlappingFinalFieldView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return ConditionalAndUnconditionalOverlappingFinalField:: + IntrinsicSizeInBytes(); +} + +template +inline constexpr ::std::int32_t +GenericConditionalAndUnconditionalOverlappingFinalFieldView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return ConditionalAndUnconditionalOverlappingFinalField:: + IntrinsicSizeInBytes(); +} + +namespace ConditionalAndUnconditionalOverlappingFinalField { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace ConditionalAndUnconditionalOverlappingFinalField + +template +inline constexpr ::std::int32_t +GenericConditionalAndUnconditionalOverlappingFinalFieldView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return ConditionalAndUnconditionalOverlappingFinalField::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t +GenericConditionalAndUnconditionalOverlappingFinalFieldView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return ConditionalAndUnconditionalOverlappingFinalField::MaxSizeInBytes(); +} + +namespace ConditionalAndUnconditionalOverlappingFinalField { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace ConditionalAndUnconditionalOverlappingFinalField + +template +inline constexpr ::std::int32_t +GenericConditionalAndUnconditionalOverlappingFinalFieldView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return ConditionalAndUnconditionalOverlappingFinalField::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t +GenericConditionalAndUnconditionalOverlappingFinalFieldView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return ConditionalAndUnconditionalOverlappingFinalField::MinSizeInBytes(); +} +namespace ConditionalBasicConditionalFieldFirst { + +} // namespace ConditionalBasicConditionalFieldFirst + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalBasicConditionalFieldFirstView::x() const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionalBasicConditionalFieldFirstView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalBasicConditionalFieldFirstView::xc() const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionalBasicConditionalFieldFirstView::has_xc() const { + return ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +namespace ConditionalBasicConditionalFieldFirst { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace ConditionalBasicConditionalFieldFirst + +template +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return ConditionalBasicConditionalFieldFirst::IntrinsicSizeInBytes(); +} + +template +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return ConditionalBasicConditionalFieldFirst::IntrinsicSizeInBytes(); +} + +namespace ConditionalBasicConditionalFieldFirst { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace ConditionalBasicConditionalFieldFirst + +template +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return ConditionalBasicConditionalFieldFirst::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return ConditionalBasicConditionalFieldFirst::MaxSizeInBytes(); +} + +namespace ConditionalBasicConditionalFieldFirst { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace ConditionalBasicConditionalFieldFirst + +template +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return ConditionalBasicConditionalFieldFirst::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return ConditionalBasicConditionalFieldFirst::MinSizeInBytes(); +} +namespace ConditionalAndDynamicLocation { + +} // namespace ConditionalAndDynamicLocation + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalAndDynamicLocationView::x() const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionalAndDynamicLocationView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalAndDynamicLocationView::y() const { + if (has_y().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionalAndDynamicLocationView::has_y() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalAndDynamicLocationView::xc() const { + if (has_xc().ValueOr(false)) { + const auto emboss_reserved_local_subexpr_1 = y(); + const auto emboss_reserved_local_subexpr_2 = + (emboss_reserved_local_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = emboss_reserved_local_subexpr_2; + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<1, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionalAndDynamicLocationView::has_xc() const { + return ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +template +inline typename GenericConditionalAndDynamicLocationView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericConditionalAndDynamicLocationView::IntrinsicSizeInBytes() + const { + return typename GenericConditionalAndDynamicLocationView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe GenericConditionalAndDynamicLocationView< + Storage>::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace ConditionalAndDynamicLocation { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(256LL)) + .ValueOrDefault(); +} +} // namespace ConditionalAndDynamicLocation + +template +inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return ConditionalAndDynamicLocation::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return ConditionalAndDynamicLocation::MaxSizeInBytes(); +} + +namespace ConditionalAndDynamicLocation { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(3LL)) + .ValueOrDefault(); +} +} // namespace ConditionalAndDynamicLocation + +template +inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return ConditionalAndDynamicLocation::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return ConditionalAndDynamicLocation::MinSizeInBytes(); +} +namespace ConditionUsesMinInt {} // namespace ConditionUsesMinInt + +template +inline typename ::emboss::prelude::IntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionUsesMinIntView::x() const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::IntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::IntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionUsesMinIntView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionUsesMinIntView::xc() const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionUsesMinIntView::has_xc() const { + return ::emboss::support::Equal( + ::emboss::support::Difference( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(9223372036854775680LL))), + ::emboss::support::Maybe( + static_cast(-9223372036854775807LL - 1))); +} + +template +inline typename GenericConditionUsesMinIntView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericConditionUsesMinIntView::IntrinsicSizeInBytes() const { + return typename GenericConditionUsesMinIntView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe +GenericConditionUsesMinIntView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace ConditionUsesMinInt { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace ConditionUsesMinInt + +template +inline constexpr ::std::int32_t GenericConditionUsesMinIntView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return ConditionUsesMinInt::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericConditionUsesMinIntView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return ConditionUsesMinInt::MaxSizeInBytes(); +} + +namespace ConditionUsesMinInt { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace ConditionUsesMinInt + +template +inline constexpr ::std::int32_t GenericConditionUsesMinIntView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return ConditionUsesMinInt::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericConditionUsesMinIntView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return ConditionUsesMinInt::MinSizeInBytes(); +} +namespace NestedConditional {} // namespace NestedConditional + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericNestedConditionalView::x() const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericNestedConditionalView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericNestedConditionalView::xc() const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericNestedConditionalView::has_xc() const { + return ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericNestedConditionalView::xcc() const { + if (has_xcc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericNestedConditionalView::has_xcc() const { + return ::emboss::support::Equal( + (xc().Ok() ? ::emboss::support::Maybe( + static_cast(xc().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +template +inline typename GenericNestedConditionalView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericNestedConditionalView::IntrinsicSizeInBytes() const { + return typename GenericNestedConditionalView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe +GenericNestedConditionalView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace NestedConditional { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(3LL)) + .ValueOrDefault(); +} +} // namespace NestedConditional + +template +inline constexpr ::std::int32_t GenericNestedConditionalView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return NestedConditional::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericNestedConditionalView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return NestedConditional::MaxSizeInBytes(); +} + +namespace NestedConditional { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace NestedConditional + +template +inline constexpr ::std::int32_t GenericNestedConditionalView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return NestedConditional::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericNestedConditionalView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return NestedConditional::MinSizeInBytes(); +} +namespace CorrectNestedConditional {} // namespace CorrectNestedConditional + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericCorrectNestedConditionalView::x() const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericCorrectNestedConditionalView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericCorrectNestedConditionalView::xc() const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericCorrectNestedConditionalView::has_xc() const { + return ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericCorrectNestedConditionalView::xcc() const { + if (has_xcc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericCorrectNestedConditionalView::has_xcc() const { + return ::emboss::support::And( + ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))), + ::emboss::support::Equal( + (xc().Ok() + ? ::emboss::support::Maybe( + static_cast(xc().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL)))); +} + +template +inline typename GenericCorrectNestedConditionalView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericCorrectNestedConditionalView::IntrinsicSizeInBytes() const { + return typename GenericCorrectNestedConditionalView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe +GenericCorrectNestedConditionalView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace CorrectNestedConditional { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(3LL)) + .ValueOrDefault(); +} +} // namespace CorrectNestedConditional + +template +inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return CorrectNestedConditional::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return CorrectNestedConditional::MaxSizeInBytes(); +} + +namespace CorrectNestedConditional { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace CorrectNestedConditional + +template +inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return CorrectNestedConditional::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return CorrectNestedConditional::MinSizeInBytes(); +} +namespace AlwaysFalseCondition {} // namespace AlwaysFalseCondition + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< typename Storage::template OffsetStorageType>, 8>> -GenericNegativeConditionalView::x() const { - if (has_x().ValueOr(false)) { +GenericAlwaysFalseConditionView::x() const { + if (has_x().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericAlwaysFalseConditionView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericAlwaysFalseConditionView::xc() const { + if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(0LL)); + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -19636,10 +25629,10 @@ GenericNegativeConditionalView::x() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 0>( + (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -19649,7 +25642,7 @@ GenericNegativeConditionalView::x() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -19657,9 +25650,70 @@ GenericNegativeConditionalView::x() const { template inline ::emboss::support::Maybe -GenericNegativeConditionalView::has_x() const { - return ::emboss::support::Maybe(true); +GenericAlwaysFalseConditionView::has_xc() const { + return ::emboss::support::Maybe(false); +} + +namespace AlwaysFalseCondition { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace AlwaysFalseCondition + +template +inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return AlwaysFalseCondition::IntrinsicSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericAlwaysFalseConditionView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return AlwaysFalseCondition::IntrinsicSizeInBytes(); +} + +namespace AlwaysFalseCondition { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace AlwaysFalseCondition + +template +inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return AlwaysFalseCondition::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return AlwaysFalseCondition::MaxSizeInBytes(); +} + +namespace AlwaysFalseCondition { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace AlwaysFalseCondition + +template +inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return AlwaysFalseCondition::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return AlwaysFalseCondition::MinSizeInBytes(); } +namespace OnlyAlwaysFalseCondition {} // namespace OnlyAlwaysFalseCondition template inline typename ::emboss::prelude::UIntView< @@ -19667,17 +25721,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericNegativeConditionalView::xc() const { +GenericOnlyAlwaysFalseConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(0LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -19687,10 +25741,10 @@ GenericNegativeConditionalView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -19700,7 +25754,7 @@ GenericNegativeConditionalView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -19708,72 +25762,133 @@ GenericNegativeConditionalView::xc() const { template inline ::emboss::support::Maybe -GenericNegativeConditionalView::has_xc() const { - return ::emboss::support::NotEqual( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL))); +GenericOnlyAlwaysFalseConditionView::has_xc() const { + return ::emboss::support::Maybe(false); +} + +namespace OnlyAlwaysFalseCondition { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(0LL)) + .ValueOrDefault(); } +} // namespace OnlyAlwaysFalseCondition template -inline typename GenericNegativeConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericNegativeConditionalView::IntrinsicSizeInBytes() const { - return typename GenericNegativeConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return OnlyAlwaysFalseCondition::IntrinsicSizeInBytes(); } template -inline ::emboss::support::Maybe -GenericNegativeConditionalView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return OnlyAlwaysFalseCondition::IntrinsicSizeInBytes(); } -namespace NegativeConditional { +namespace OnlyAlwaysFalseCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(0LL)) .ValueOrDefault(); } -} // namespace NegativeConditional +} // namespace OnlyAlwaysFalseCondition template -inline constexpr ::std::int32_t GenericNegativeConditionalView< +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return NegativeConditional::MaxSizeInBytes(); + return OnlyAlwaysFalseCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNegativeConditionalView< +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return NegativeConditional::MaxSizeInBytes(); + return OnlyAlwaysFalseCondition::MaxSizeInBytes(); } -namespace NegativeConditional { +namespace OnlyAlwaysFalseCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(0LL)) .ValueOrDefault(); } -} // namespace NegativeConditional +} // namespace OnlyAlwaysFalseCondition template -inline constexpr ::std::int32_t GenericNegativeConditionalView< +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return NegativeConditional::MinSizeInBytes(); + return OnlyAlwaysFalseCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNegativeConditionalView< +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return NegativeConditional::MinSizeInBytes(); + return OnlyAlwaysFalseCondition::MinSizeInBytes(); } -namespace ConditionalAndUnconditionalOverlappingFinalField { +namespace EmptyStruct {} // namespace EmptyStruct -} // namespace ConditionalAndUnconditionalOverlappingFinalField +namespace EmptyStruct { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(0LL)) + .ValueOrDefault(); +} +} // namespace EmptyStruct + +template +inline constexpr ::std::int32_t GenericEmptyStructView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return EmptyStruct::IntrinsicSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericEmptyStructView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return EmptyStruct::IntrinsicSizeInBytes(); +} + +namespace EmptyStruct { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(0LL)) + .ValueOrDefault(); +} +} // namespace EmptyStruct + +template +inline constexpr ::std::int32_t GenericEmptyStructView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return EmptyStruct::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericEmptyStructView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return EmptyStruct::MaxSizeInBytes(); +} + +namespace EmptyStruct { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(0LL)) + .ValueOrDefault(); +} +} // namespace EmptyStruct + +template +inline constexpr ::std::int32_t GenericEmptyStructView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return EmptyStruct::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericEmptyStructView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return EmptyStruct::MinSizeInBytes(); +} +namespace AlwaysFalseConditionDynamicSize { + +} // namespace AlwaysFalseConditionDynamicSize template inline typename ::emboss::prelude::UIntView< @@ -19784,8 +25899,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAndUnconditionalOverlappingFinalFieldView::x() - const { +GenericAlwaysFalseConditionDynamicSizeView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -19823,8 +25937,7 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::x() template inline ::emboss::support::Maybe -GenericConditionalAndUnconditionalOverlappingFinalFieldView::has_x() - const { +GenericAlwaysFalseConditionDynamicSizeView::has_x() const { return ::emboss::support::Maybe(true); } @@ -19834,18 +25947,23 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAndUnconditionalOverlappingFinalFieldView::xc() - const { - if (has_xc().ValueOr(false)) { +GenericAlwaysFalseConditionDynamicSizeView::y() const { + if (has_y().ValueOr(false)) { + const auto emboss_reserved_local_subexpr_1 = x(); + const auto emboss_reserved_local_subexpr_2 = + (emboss_reserved_local_subexpr_1.Ok() + ? ::emboss::support::Maybe( + static_cast( + emboss_reserved_local_subexpr_1.UncheckedRead())) + : ::emboss::support::Maybe()); + auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(1LL)); + auto emboss_reserved_local_offset = emboss_reserved_local_subexpr_2; if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -19855,10 +25973,10 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::xc() 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<1, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -19868,23 +25986,16 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::xc() 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); } -template -inline ::emboss::support::Maybe -GenericConditionalAndUnconditionalOverlappingFinalFieldView::has_xc() - const { - return ::emboss::support::Equal( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL))); +template +inline ::emboss::support::Maybe +GenericAlwaysFalseConditionDynamicSizeView::has_y() const { + return ::emboss::support::Maybe(true); } template @@ -19896,9 +26007,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAndUnconditionalOverlappingFinalFieldView::z() - const { - if (has_z().ValueOr(false)) { +GenericAlwaysFalseConditionDynamicSizeView::xc() const { + if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -19935,81 +26045,68 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::z() template inline ::emboss::support::Maybe -GenericConditionalAndUnconditionalOverlappingFinalFieldView::has_z() - const { - return ::emboss::support::Maybe(true); -} - -namespace ConditionalAndUnconditionalOverlappingFinalField { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(2LL)) - .ValueOrDefault(); +GenericAlwaysFalseConditionDynamicSizeView::has_xc() const { + return ::emboss::support::Maybe(false); } -} // namespace ConditionalAndUnconditionalOverlappingFinalField template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ConditionalAndUnconditionalOverlappingFinalField:: - IntrinsicSizeInBytes(); +inline typename GenericAlwaysFalseConditionDynamicSizeView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericAlwaysFalseConditionDynamicSizeView::IntrinsicSizeInBytes() + const { + return typename GenericAlwaysFalseConditionDynamicSizeView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ConditionalAndUnconditionalOverlappingFinalField:: - IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericAlwaysFalseConditionDynamicSizeView::has_IntrinsicSizeInBytes() + const { + return ::emboss::support::Maybe(true); } -namespace ConditionalAndUnconditionalOverlappingFinalField { +namespace AlwaysFalseConditionDynamicSize { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(256LL)) .ValueOrDefault(); } -} // namespace ConditionalAndUnconditionalOverlappingFinalField +} // namespace AlwaysFalseConditionDynamicSize template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< +inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalAndUnconditionalOverlappingFinalField::MaxSizeInBytes(); + return AlwaysFalseConditionDynamicSize::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< +inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalAndUnconditionalOverlappingFinalField::MaxSizeInBytes(); + return AlwaysFalseConditionDynamicSize::MaxSizeInBytes(); } -namespace ConditionalAndUnconditionalOverlappingFinalField { +namespace AlwaysFalseConditionDynamicSize { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalAndUnconditionalOverlappingFinalField +} // namespace AlwaysFalseConditionDynamicSize template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< +inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalAndUnconditionalOverlappingFinalField::MinSizeInBytes(); + return AlwaysFalseConditionDynamicSize::MinSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< +inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalAndUnconditionalOverlappingFinalField::MinSizeInBytes(); + return AlwaysFalseConditionDynamicSize::MinSizeInBytes(); } -namespace ConditionalBasicConditionalFieldFirst { +namespace ConditionDoesNotContributeToSize { -} // namespace ConditionalBasicConditionalFieldFirst +} // namespace ConditionDoesNotContributeToSize template inline typename ::emboss::prelude::UIntView< @@ -20017,17 +26114,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericConditionalBasicConditionalFieldFirstView::x() const { +GenericConditionDoesNotContributeToSizeView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(0LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -20037,10 +26134,10 @@ GenericConditionalBasicConditionalFieldFirstView::x() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -20050,7 +26147,7 @@ GenericConditionalBasicConditionalFieldFirstView::x() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -20058,7 +26155,7 @@ GenericConditionalBasicConditionalFieldFirstView::x() const { template inline ::emboss::support::Maybe -GenericConditionalBasicConditionalFieldFirstView::has_x() const { +GenericConditionDoesNotContributeToSizeView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20068,17 +26165,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericConditionalBasicConditionalFieldFirstView::xc() const { +GenericConditionDoesNotContributeToSizeView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(0LL)); + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -20088,10 +26185,10 @@ GenericConditionalBasicConditionalFieldFirstView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 0>( + (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -20101,7 +26198,7 @@ GenericConditionalBasicConditionalFieldFirstView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -20109,7 +26206,7 @@ GenericConditionalBasicConditionalFieldFirstView::xc() const { template inline ::emboss::support::Maybe -GenericConditionalBasicConditionalFieldFirstView::has_xc() const { +GenericConditionDoesNotContributeToSizeView::has_xc() const { return ::emboss::support::Equal( (x().Ok() ? ::emboss::support::Maybe( @@ -20119,85 +26216,130 @@ GenericConditionalBasicConditionalFieldFirstView::has_xc() const { static_cast(0LL))); } -namespace ConditionalBasicConditionalFieldFirst { +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionDoesNotContributeToSizeView::y() const { + if (has_y().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericConditionDoesNotContributeToSizeView::has_y() const { + return ::emboss::support::Maybe(true); +} + +namespace ConditionDoesNotContributeToSize { inline constexpr ::std::int32_t IntrinsicSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionalBasicConditionalFieldFirst +} // namespace ConditionDoesNotContributeToSize template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ConditionalBasicConditionalFieldFirst::IntrinsicSizeInBytes(); + return ConditionDoesNotContributeToSize::IntrinsicSizeInBytes(); } template inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView:: +GenericConditionDoesNotContributeToSizeView:: EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ConditionalBasicConditionalFieldFirst::IntrinsicSizeInBytes(); + return ConditionDoesNotContributeToSize::IntrinsicSizeInBytes(); } -namespace ConditionalBasicConditionalFieldFirst { +namespace ConditionDoesNotContributeToSize { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionalBasicConditionalFieldFirst +} // namespace ConditionDoesNotContributeToSize template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalBasicConditionalFieldFirst::MaxSizeInBytes(); + return ConditionDoesNotContributeToSize::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalBasicConditionalFieldFirst::MaxSizeInBytes(); + return ConditionDoesNotContributeToSize::MaxSizeInBytes(); } -namespace ConditionalBasicConditionalFieldFirst { +namespace ConditionDoesNotContributeToSize { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionalBasicConditionalFieldFirst +} // namespace ConditionDoesNotContributeToSize template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalBasicConditionalFieldFirst::MinSizeInBytes(); + return ConditionDoesNotContributeToSize::MinSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalBasicConditionalFieldFirst::MinSizeInBytes(); + return ConditionDoesNotContributeToSize::MinSizeInBytes(); } -namespace ConditionalAndDynamicLocation { - -} // namespace ConditionalAndDynamicLocation +namespace EnumCondition {} // namespace EnumCondition template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< +inline typename ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAndDynamicLocationView::x() const { +GenericEnumConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20209,8 +26351,9 @@ GenericConditionalAndDynamicLocationView::x() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< + return ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -20222,8 +26365,9 @@ GenericConditionalAndDynamicLocationView::x() const { emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< + return ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -20234,8 +26378,8 @@ GenericConditionalAndDynamicLocationView::x() const { } template -inline ::emboss::support::Maybe -GenericConditionalAndDynamicLocationView::has_x() const { +inline ::emboss::support::Maybe GenericEnumConditionView::has_x() + const { return ::emboss::support::Maybe(true); } @@ -20245,17 +26389,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAndDynamicLocationView::y() const { - if (has_y().ValueOr(false)) { +GenericEnumConditionView::xc() const { + if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(2LL)); + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -20265,10 +26409,10 @@ GenericConditionalAndDynamicLocationView::y() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 2>( + (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -20278,7 +26422,7 @@ GenericConditionalAndDynamicLocationView::y() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -20286,8 +26430,15 @@ GenericConditionalAndDynamicLocationView::y() const { template inline ::emboss::support::Maybe -GenericConditionalAndDynamicLocationView::has_y() const { - return ::emboss::support::Maybe(true); +GenericEnumConditionView::has_xc() const { + return ::emboss::support::Equal( + (x().Ok() + ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1))); } template @@ -20296,23 +26447,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAndDynamicLocationView::xc() const { - if (has_xc().ValueOr(false)) { - const auto emboss_reserved_local_subexpr_1 = y(); - const auto emboss_reserved_local_subexpr_2 = - (emboss_reserved_local_subexpr_1.Ok() - ? ::emboss::support::Maybe( - static_cast( - emboss_reserved_local_subexpr_1.UncheckedRead())) - : ::emboss::support::Maybe()); - +GenericEnumConditionView::xc2() const { + if (has_xc2().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); - auto emboss_reserved_local_offset = emboss_reserved_local_subexpr_2; + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -20322,10 +26467,10 @@ GenericConditionalAndDynamicLocationView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<1, 0>( + (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -20335,7 +26480,7 @@ GenericConditionalAndDynamicLocationView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -20343,82 +26488,84 @@ GenericConditionalAndDynamicLocationView::xc() const { template inline ::emboss::support::Maybe -GenericConditionalAndDynamicLocationView::has_xc() const { - return ::emboss::support::Equal( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL))); +GenericEnumConditionView::has_xc2() const { + return ::emboss::support::GreaterThan( + (x().Ok() + ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0))); } template -inline typename GenericConditionalAndDynamicLocationView< +inline typename GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalAndDynamicLocationView::IntrinsicSizeInBytes() - const { - return typename GenericConditionalAndDynamicLocationView< +GenericEnumConditionView::IntrinsicSizeInBytes() const { + return typename GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline ::emboss::support::Maybe GenericConditionalAndDynamicLocationView< - Storage>::has_IntrinsicSizeInBytes() const { +inline ::emboss::support::Maybe +GenericEnumConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionalAndDynamicLocation { +namespace EnumCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(256LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace ConditionalAndDynamicLocation +} // namespace EnumCondition template -inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< +inline constexpr ::std::int32_t GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalAndDynamicLocation::MaxSizeInBytes(); + return EnumCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< +inline constexpr ::std::int32_t GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalAndDynamicLocation::MaxSizeInBytes(); + return EnumCondition::MaxSizeInBytes(); } -namespace ConditionalAndDynamicLocation { +namespace EnumCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalAndDynamicLocation +} // namespace EnumCondition template -inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< +inline constexpr ::std::int32_t GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalAndDynamicLocation::MinSizeInBytes(); + return EnumCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< +inline constexpr ::std::int32_t GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalAndDynamicLocation::MinSizeInBytes(); + return EnumCondition::MinSizeInBytes(); } -namespace ConditionUsesMinInt {} // namespace ConditionUsesMinInt +namespace NegativeEnumCondition {} // namespace NegativeEnumCondition template -inline typename ::emboss::prelude::IntView< - /**/ ::emboss::support::FixedSizeViewParameters< +inline typename ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< typename Storage::template OffsetStorageType>, 8>> -GenericConditionUsesMinIntView::x() const { +GenericNegativeEnumConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20430,8 +26577,9 @@ GenericConditionUsesMinIntView::x() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::IntView< - /**/ ::emboss::support::FixedSizeViewParameters< + return ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -20443,8 +26591,9 @@ GenericConditionUsesMinIntView::x() const { emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::IntView< - /**/ ::emboss::support::FixedSizeViewParameters< + return ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -20456,7 +26605,7 @@ GenericConditionUsesMinIntView::x() const { template inline ::emboss::support::Maybe -GenericConditionUsesMinIntView::has_x() const { +GenericNegativeEnumConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20469,7 +26618,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionUsesMinIntView::xc() const { +GenericNegativeEnumConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20507,74 +26656,72 @@ GenericConditionUsesMinIntView::xc() const { template inline ::emboss::support::Maybe -GenericConditionUsesMinIntView::has_xc() const { - return ::emboss::support::Equal( - ::emboss::support::Difference( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(9223372036854775680LL))), - ::emboss::support::Maybe( - static_cast(-9223372036854775807LL - 1))); +GenericNegativeEnumConditionView::has_xc() const { + return ::emboss::support::NotEqual( + (x().Ok() + ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1))); } template -inline typename GenericConditionUsesMinIntView< +inline typename GenericNegativeEnumConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionUsesMinIntView::IntrinsicSizeInBytes() const { - return typename GenericConditionUsesMinIntView< +GenericNegativeEnumConditionView::IntrinsicSizeInBytes() const { + return typename GenericNegativeEnumConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericConditionUsesMinIntView::has_IntrinsicSizeInBytes() const { +GenericNegativeEnumConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionUsesMinInt { +namespace NegativeEnumCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace ConditionUsesMinInt +} // namespace NegativeEnumCondition template -inline constexpr ::std::int32_t GenericConditionUsesMinIntView< +inline constexpr ::std::int32_t GenericNegativeEnumConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionUsesMinInt::MaxSizeInBytes(); + return NegativeEnumCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionUsesMinIntView< +inline constexpr ::std::int32_t GenericNegativeEnumConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionUsesMinInt::MaxSizeInBytes(); + return NegativeEnumCondition::MaxSizeInBytes(); } -namespace ConditionUsesMinInt { +namespace NegativeEnumCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionUsesMinInt +} // namespace NegativeEnumCondition template -inline constexpr ::std::int32_t GenericConditionUsesMinIntView< +inline constexpr ::std::int32_t GenericNegativeEnumConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionUsesMinInt::MinSizeInBytes(); + return NegativeEnumCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionUsesMinIntView< +inline constexpr ::std::int32_t GenericNegativeEnumConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionUsesMinInt::MinSizeInBytes(); + return NegativeEnumCondition::MinSizeInBytes(); } -namespace NestedConditional {} // namespace NestedConditional +namespace LessThanCondition {} // namespace LessThanCondition template inline typename ::emboss::prelude::UIntView< @@ -20585,7 +26732,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericNestedConditionalView::x() const { +GenericLessThanConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20623,7 +26770,7 @@ GenericNestedConditionalView::x() const { template inline ::emboss::support::Maybe -GenericNestedConditionalView::has_x() const { +GenericLessThanConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20636,7 +26783,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericNestedConditionalView::xc() const { +GenericLessThanConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20674,127 +26821,70 @@ GenericNestedConditionalView::xc() const { template inline ::emboss::support::Maybe -GenericNestedConditionalView::has_xc() const { - return ::emboss::support::Equal( +GenericLessThanConditionView::has_xc() const { + return ::emboss::support::LessThan( (x().Ok() ? ::emboss::support::Maybe( static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe( - static_cast(0LL))); -} - -template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - -GenericNestedConditionalView::xcc() const { - if (has_xcc().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(1LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(2LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - - (backing_.template GetOffsetStorage<0, 2>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } - } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - - (); -} - -template -inline ::emboss::support::Maybe -GenericNestedConditionalView::has_xcc() const { - return ::emboss::support::Equal( - (xc().Ok() ? ::emboss::support::Maybe( - static_cast(xc().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL))); + static_cast(5LL))); } template -inline typename GenericNestedConditionalView< +inline typename GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericNestedConditionalView::IntrinsicSizeInBytes() const { - return typename GenericNestedConditionalView< +GenericLessThanConditionView::IntrinsicSizeInBytes() const { + return typename GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericNestedConditionalView::has_IntrinsicSizeInBytes() const { +GenericLessThanConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace NestedConditional { +namespace LessThanCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace NestedConditional +} // namespace LessThanCondition template -inline constexpr ::std::int32_t GenericNestedConditionalView< +inline constexpr ::std::int32_t GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return NestedConditional::MaxSizeInBytes(); + return LessThanCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNestedConditionalView< +inline constexpr ::std::int32_t GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return NestedConditional::MaxSizeInBytes(); + return LessThanCondition::MaxSizeInBytes(); } -namespace NestedConditional { +namespace LessThanCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace NestedConditional +} // namespace LessThanCondition template -inline constexpr ::std::int32_t GenericNestedConditionalView< +inline constexpr ::std::int32_t GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return NestedConditional::MinSizeInBytes(); + return LessThanCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNestedConditionalView< +inline constexpr ::std::int32_t GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return NestedConditional::MinSizeInBytes(); + return LessThanCondition::MinSizeInBytes(); } -namespace CorrectNestedConditional {} // namespace CorrectNestedConditional +namespace LessThanOrEqualCondition {} // namespace LessThanOrEqualCondition template inline typename ::emboss::prelude::UIntView< @@ -20805,7 +26895,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericCorrectNestedConditionalView::x() const { +GenericLessThanOrEqualConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20843,7 +26933,7 @@ GenericCorrectNestedConditionalView::x() const { template inline ::emboss::support::Maybe -GenericCorrectNestedConditionalView::has_x() const { +GenericLessThanOrEqualConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20856,7 +26946,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericCorrectNestedConditionalView::xc() const { +GenericLessThanOrEqualConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20894,136 +26984,72 @@ GenericCorrectNestedConditionalView::xc() const { template inline ::emboss::support::Maybe -GenericCorrectNestedConditionalView::has_xc() const { - return ::emboss::support::Equal( +GenericLessThanOrEqualConditionView::has_xc() const { + return ::emboss::support::LessThanOrEqual( (x().Ok() ? ::emboss::support::Maybe( static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe( - static_cast(0LL))); -} - -template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - -GenericCorrectNestedConditionalView::xcc() const { - if (has_xcc().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(1LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(2LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - - (backing_.template GetOffsetStorage<0, 2>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } - } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - - (); -} - -template -inline ::emboss::support::Maybe -GenericCorrectNestedConditionalView::has_xcc() const { - return ::emboss::support::And( - ::emboss::support::Equal( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL))), - ::emboss::support::Equal( - (xc().Ok() - ? ::emboss::support::Maybe( - static_cast(xc().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL)))); + static_cast(5LL))); } template -inline typename GenericCorrectNestedConditionalView< +inline typename GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericCorrectNestedConditionalView::IntrinsicSizeInBytes() const { - return typename GenericCorrectNestedConditionalView< +GenericLessThanOrEqualConditionView::IntrinsicSizeInBytes() const { + return typename GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericCorrectNestedConditionalView::has_IntrinsicSizeInBytes() const { +GenericLessThanOrEqualConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace CorrectNestedConditional { +namespace LessThanOrEqualCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace CorrectNestedConditional +} // namespace LessThanOrEqualCondition template -inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< +inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return CorrectNestedConditional::MaxSizeInBytes(); + return LessThanOrEqualCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< +inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return CorrectNestedConditional::MaxSizeInBytes(); + return LessThanOrEqualCondition::MaxSizeInBytes(); } -namespace CorrectNestedConditional { +namespace LessThanOrEqualCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace CorrectNestedConditional +} // namespace LessThanOrEqualCondition template -inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< +inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return CorrectNestedConditional::MinSizeInBytes(); + return LessThanOrEqualCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< +inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return CorrectNestedConditional::MinSizeInBytes(); + return LessThanOrEqualCondition::MinSizeInBytes(); } -namespace AlwaysFalseCondition {} // namespace AlwaysFalseCondition +namespace GreaterThanOrEqualCondition { + +} // namespace GreaterThanOrEqualCondition template inline typename ::emboss::prelude::UIntView< @@ -21034,7 +27060,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAlwaysFalseConditionView::x() const { +GenericGreaterThanOrEqualConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21072,7 +27098,7 @@ GenericAlwaysFalseConditionView::x() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionView::has_x() const { +GenericGreaterThanOrEqualConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -21085,7 +27111,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAlwaysFalseConditionView::xc() const { +GenericGreaterThanOrEqualConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21123,70 +27149,70 @@ GenericAlwaysFalseConditionView::xc() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionView::has_xc() const { - return ::emboss::support::Maybe(false); -} - -namespace AlwaysFalseCondition { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); +GenericGreaterThanOrEqualConditionView::has_xc() const { + return ::emboss::support::GreaterThanOrEqual( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(5LL))); } -} // namespace AlwaysFalseCondition template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return AlwaysFalseCondition::IntrinsicSizeInBytes(); +inline typename GenericGreaterThanOrEqualConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericGreaterThanOrEqualConditionView::IntrinsicSizeInBytes() const { + return typename GenericGreaterThanOrEqualConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return AlwaysFalseCondition::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe GenericGreaterThanOrEqualConditionView< + Storage>::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace AlwaysFalseCondition { +namespace GreaterThanOrEqualCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace AlwaysFalseCondition +} // namespace GreaterThanOrEqualCondition template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< +inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return AlwaysFalseCondition::MaxSizeInBytes(); + return GreaterThanOrEqualCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< +inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return AlwaysFalseCondition::MaxSizeInBytes(); + return GreaterThanOrEqualCondition::MaxSizeInBytes(); } -namespace AlwaysFalseCondition { +namespace GreaterThanOrEqualCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace AlwaysFalseCondition +} // namespace GreaterThanOrEqualCondition template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< +inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return AlwaysFalseCondition::MinSizeInBytes(); + return GreaterThanOrEqualCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionView< +inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return AlwaysFalseCondition::MinSizeInBytes(); + return GreaterThanOrEqualCondition::MinSizeInBytes(); } -namespace OnlyAlwaysFalseCondition {} // namespace OnlyAlwaysFalseCondition +namespace GreaterThanCondition {} // namespace GreaterThanCondition template inline typename ::emboss::prelude::UIntView< @@ -21197,8 +27223,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericOnlyAlwaysFalseConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericGreaterThanConditionView::x() const { + if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -21235,133 +27261,121 @@ GenericOnlyAlwaysFalseConditionView::xc() const { template inline ::emboss::support::Maybe -GenericOnlyAlwaysFalseConditionView::has_xc() const { - return ::emboss::support::Maybe(false); -} - -namespace OnlyAlwaysFalseCondition { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(0LL)) - .ValueOrDefault(); -} -} // namespace OnlyAlwaysFalseCondition - -template -inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return OnlyAlwaysFalseCondition::IntrinsicSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return OnlyAlwaysFalseCondition::IntrinsicSizeInBytes(); -} - -namespace OnlyAlwaysFalseCondition { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(0LL)) - .ValueOrDefault(); +GenericGreaterThanConditionView::has_x() const { + return ::emboss::support::Maybe(true); } -} // namespace OnlyAlwaysFalseCondition template -inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return OnlyAlwaysFalseCondition::MaxSizeInBytes(); -} +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -template -inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return OnlyAlwaysFalseCondition::MaxSizeInBytes(); -} +GenericGreaterThanConditionView::xc() const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -namespace OnlyAlwaysFalseCondition { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(0LL)) - .ValueOrDefault(); -} -} // namespace OnlyAlwaysFalseCondition + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -template -inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return OnlyAlwaysFalseCondition::MinSizeInBytes(); + (); } template -inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return OnlyAlwaysFalseCondition::MinSizeInBytes(); -} -namespace EmptyStruct {} // namespace EmptyStruct - -namespace EmptyStruct { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(0LL)) - .ValueOrDefault(); +inline ::emboss::support::Maybe +GenericGreaterThanConditionView::has_xc() const { + return ::emboss::support::GreaterThan( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(5LL))); } -} // namespace EmptyStruct template -inline constexpr ::std::int32_t GenericEmptyStructView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return EmptyStruct::IntrinsicSizeInBytes(); +inline typename GenericGreaterThanConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericGreaterThanConditionView::IntrinsicSizeInBytes() const { + return typename GenericGreaterThanConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t GenericEmptyStructView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return EmptyStruct::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericGreaterThanConditionView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace EmptyStruct { +namespace GreaterThanCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(0LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace EmptyStruct +} // namespace GreaterThanCondition template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return EmptyStruct::MaxSizeInBytes(); + return GreaterThanCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return EmptyStruct::MaxSizeInBytes(); + return GreaterThanCondition::MaxSizeInBytes(); } -namespace EmptyStruct { +namespace GreaterThanCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(0LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace EmptyStruct +} // namespace GreaterThanCondition template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return EmptyStruct::MinSizeInBytes(); + return GreaterThanCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return EmptyStruct::MinSizeInBytes(); + return GreaterThanCondition::MinSizeInBytes(); } -namespace AlwaysFalseConditionDynamicSize { - -} // namespace AlwaysFalseConditionDynamicSize +namespace RangeCondition {} // namespace RangeCondition template inline typename ::emboss::prelude::UIntView< @@ -21372,7 +27386,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAlwaysFalseConditionDynamicSizeView::x() const { +GenericRangeConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21410,7 +27424,7 @@ GenericAlwaysFalseConditionDynamicSizeView::x() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_x() const { +GenericRangeConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -21420,23 +27434,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericAlwaysFalseConditionDynamicSizeView::y() const { +GenericRangeConditionView::y() const { if (has_y().ValueOr(false)) { - const auto emboss_reserved_local_subexpr_1 = x(); - const auto emboss_reserved_local_subexpr_2 = - (emboss_reserved_local_subexpr_1.Ok() - ? ::emboss::support::Maybe( - static_cast( - emboss_reserved_local_subexpr_1.UncheckedRead())) - : ::emboss::support::Maybe()); - auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); - auto emboss_reserved_local_offset = emboss_reserved_local_subexpr_2; + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -21446,10 +27454,10 @@ GenericAlwaysFalseConditionDynamicSizeView::y() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<1, 0>( + (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -21459,7 +27467,7 @@ GenericAlwaysFalseConditionDynamicSizeView::y() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -21467,7 +27475,7 @@ GenericAlwaysFalseConditionDynamicSizeView::y() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_y() const { +GenericRangeConditionView::has_y() const { return ::emboss::support::Maybe(true); } @@ -21477,17 +27485,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericAlwaysFalseConditionDynamicSizeView::xc() const { +GenericRangeConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -21497,10 +27505,10 @@ GenericAlwaysFalseConditionDynamicSizeView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -21510,7 +27518,7 @@ GenericAlwaysFalseConditionDynamicSizeView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -21518,68 +27526,90 @@ GenericAlwaysFalseConditionDynamicSizeView::xc() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_xc() const { - return ::emboss::support::Maybe(false); +GenericRangeConditionView::has_xc() const { + return ::emboss::support::And( + ::emboss::support::And( + ::emboss::support::LessThan( + ::emboss::support::Maybe( + static_cast(5LL)), + (x().Ok() + ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe())), + ::emboss::support::LessThanOrEqual( + (x().Ok() + ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + (y().Ok() + ? ::emboss::support::Maybe( + static_cast(y().UncheckedRead())) + : ::emboss::support::Maybe()))), + ::emboss::support::LessThan( + (y().Ok() ? ::emboss::support::Maybe( + static_cast(y().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(10LL)))); } template -inline typename GenericAlwaysFalseConditionDynamicSizeView< +inline typename GenericRangeConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericAlwaysFalseConditionDynamicSizeView::IntrinsicSizeInBytes() - const { - return typename GenericAlwaysFalseConditionDynamicSizeView< +GenericRangeConditionView::IntrinsicSizeInBytes() const { + return typename GenericRangeConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_IntrinsicSizeInBytes() - const { +GenericRangeConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace AlwaysFalseConditionDynamicSize { +namespace RangeCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(256LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace AlwaysFalseConditionDynamicSize +} // namespace RangeCondition template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< +inline constexpr ::std::int32_t GenericRangeConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return AlwaysFalseConditionDynamicSize::MaxSizeInBytes(); + return RangeCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< +inline constexpr ::std::int32_t GenericRangeConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return AlwaysFalseConditionDynamicSize::MaxSizeInBytes(); + return RangeCondition::MaxSizeInBytes(); } -namespace AlwaysFalseConditionDynamicSize { +namespace RangeCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace AlwaysFalseConditionDynamicSize +} // namespace RangeCondition template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< +inline constexpr ::std::int32_t GenericRangeConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return AlwaysFalseConditionDynamicSize::MinSizeInBytes(); + return RangeCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< +inline constexpr ::std::int32_t GenericRangeConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return AlwaysFalseConditionDynamicSize::MinSizeInBytes(); + return RangeCondition::MinSizeInBytes(); } -namespace ConditionDoesNotContributeToSize { - -} // namespace ConditionDoesNotContributeToSize +namespace ReverseRangeCondition {} // namespace ReverseRangeCondition template inline typename ::emboss::prelude::UIntView< @@ -21590,7 +27620,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionDoesNotContributeToSizeView::x() const { +GenericReverseRangeConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21628,7 +27658,7 @@ GenericConditionDoesNotContributeToSizeView::x() const { template inline ::emboss::support::Maybe -GenericConditionDoesNotContributeToSizeView::has_x() const { +GenericReverseRangeConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -21641,8 +27671,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionDoesNotContributeToSizeView::xc() const { - if (has_xc().ValueOr(false)) { +GenericReverseRangeConditionView::y() const { + if (has_y().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -21679,14 +27709,8 @@ GenericConditionDoesNotContributeToSizeView::xc() const { template inline ::emboss::support::Maybe -GenericConditionDoesNotContributeToSizeView::has_xc() const { - return ::emboss::support::Equal( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL))); +GenericReverseRangeConditionView::has_y() const { + return ::emboss::support::Maybe(true); } template @@ -21698,8 +27722,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionDoesNotContributeToSizeView::y() const { - if (has_y().ValueOr(false)) { +GenericReverseRangeConditionView::xc() const { + if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -21736,83 +27760,101 @@ GenericConditionDoesNotContributeToSizeView::y() const { template inline ::emboss::support::Maybe -GenericConditionDoesNotContributeToSizeView::has_y() const { - return ::emboss::support::Maybe(true); -} - -namespace ConditionDoesNotContributeToSize { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(3LL)) - .ValueOrDefault(); +GenericReverseRangeConditionView::has_xc() const { + return ::emboss::support::And( + ::emboss::support::And( + ::emboss::support::GreaterThan( + ::emboss::support::Maybe( + static_cast(10LL)), + (y().Ok() + ? ::emboss::support::Maybe( + static_cast(y().UncheckedRead())) + : ::emboss::support::Maybe())), + ::emboss::support::GreaterThanOrEqual( + (y().Ok() + ? ::emboss::support::Maybe( + static_cast(y().UncheckedRead())) + : ::emboss::support::Maybe()), + (x().Ok() + ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()))), + ::emboss::support::GreaterThan( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(5LL)))); } -} // namespace ConditionDoesNotContributeToSize template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ConditionDoesNotContributeToSize::IntrinsicSizeInBytes(); +inline typename GenericReverseRangeConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericReverseRangeConditionView::IntrinsicSizeInBytes() const { + return typename GenericReverseRangeConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t -GenericConditionDoesNotContributeToSizeView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ConditionDoesNotContributeToSize::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericReverseRangeConditionView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace ConditionDoesNotContributeToSize { +namespace ReverseRangeCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionDoesNotContributeToSize +} // namespace ReverseRangeCondition template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< +inline constexpr ::std::int32_t GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionDoesNotContributeToSize::MaxSizeInBytes(); + return ReverseRangeCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< +inline constexpr ::std::int32_t GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionDoesNotContributeToSize::MaxSizeInBytes(); + return ReverseRangeCondition::MaxSizeInBytes(); } -namespace ConditionDoesNotContributeToSize { +namespace ReverseRangeCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace ConditionDoesNotContributeToSize +} // namespace ReverseRangeCondition template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< +inline constexpr ::std::int32_t GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionDoesNotContributeToSize::MinSizeInBytes(); + return ReverseRangeCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< +inline constexpr ::std::int32_t GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionDoesNotContributeToSize::MinSizeInBytes(); + return ReverseRangeCondition::MinSizeInBytes(); } -namespace EnumCondition {} // namespace EnumCondition +namespace AndCondition {} // namespace AndCondition template -inline typename ::emboss::support::EnumView< - /**/ ::emboss::test::OnOff, - ::emboss::support::FixedSizeViewParameters< +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< typename Storage::template OffsetStorageType>, 8>> -GenericEnumConditionView::x() const { +GenericAndConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21824,9 +27866,8 @@ GenericEnumConditionView::x() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::support::EnumView< - /**/ ::emboss::test::OnOff, - ::emboss::support::FixedSizeViewParameters< + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -21838,9 +27879,8 @@ GenericEnumConditionView::x() const { emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::support::EnumView< - /**/ ::emboss::test::OnOff, - ::emboss::support::FixedSizeViewParameters< + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -21851,7 +27891,7 @@ GenericEnumConditionView::x() const { } template -inline ::emboss::support::Maybe GenericEnumConditionView::has_x() +inline ::emboss::support::Maybe GenericAndConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -21865,8 +27905,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericEnumConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericAndConditionView::y() const { + if (has_y().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -21902,16 +27942,9 @@ GenericEnumConditionView::xc() const { } template -inline ::emboss::support::Maybe -GenericEnumConditionView::has_xc() const { - return ::emboss::support::Equal( - (x().Ok() - ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(1))); +inline ::emboss::support::Maybe GenericAndConditionView::has_y() + const { + return ::emboss::support::Maybe(true); } template @@ -21920,17 +27953,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericEnumConditionView::xc2() const { - if (has_xc2().ValueOr(false)) { +GenericAndConditionView::xc() const { + if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -21940,10 +27973,10 @@ GenericEnumConditionView::xc2() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -21953,92 +27986,97 @@ GenericEnumConditionView::xc2() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); } template -inline ::emboss::support::Maybe -GenericEnumConditionView::has_xc2() const { - return ::emboss::support::GreaterThan( - (x().Ok() - ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0))); +inline ::emboss::support::Maybe GenericAndConditionView::has_xc() + const { + return ::emboss::support::And( + ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(5LL))), + ::emboss::support::Equal( + (y().Ok() ? ::emboss::support::Maybe( + static_cast(y().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(5LL)))); } template -inline typename GenericEnumConditionView< +inline typename GenericAndConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericEnumConditionView::IntrinsicSizeInBytes() const { - return typename GenericEnumConditionView< +GenericAndConditionView::IntrinsicSizeInBytes() const { + return typename GenericAndConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericEnumConditionView::has_IntrinsicSizeInBytes() const { +GenericAndConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace EnumCondition { +namespace AndCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace EnumCondition +} // namespace AndCondition template -inline constexpr ::std::int32_t GenericEnumConditionView< +inline constexpr ::std::int32_t GenericAndConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return EnumCondition::MaxSizeInBytes(); + return AndCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEnumConditionView< +inline constexpr ::std::int32_t GenericAndConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return EnumCondition::MaxSizeInBytes(); + return AndCondition::MaxSizeInBytes(); } -namespace EnumCondition { +namespace AndCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace EnumCondition +} // namespace AndCondition template -inline constexpr ::std::int32_t GenericEnumConditionView< +inline constexpr ::std::int32_t GenericAndConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return EnumCondition::MinSizeInBytes(); + return AndCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEnumConditionView< +inline constexpr ::std::int32_t GenericAndConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return EnumCondition::MinSizeInBytes(); + return AndCondition::MinSizeInBytes(); } -namespace NegativeEnumCondition {} // namespace NegativeEnumCondition +namespace OrCondition {} // namespace OrCondition template -inline typename ::emboss::support::EnumView< - /**/ ::emboss::test::OnOff, - ::emboss::support::FixedSizeViewParameters< +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< typename Storage::template OffsetStorageType>, 8>> -GenericNegativeEnumConditionView::x() const { +GenericOrConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22050,9 +28088,8 @@ GenericNegativeEnumConditionView::x() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::support::EnumView< - /**/ ::emboss::test::OnOff, - ::emboss::support::FixedSizeViewParameters< + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -22064,9 +28101,8 @@ GenericNegativeEnumConditionView::x() const { emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::support::EnumView< - /**/ ::emboss::test::OnOff, - ::emboss::support::FixedSizeViewParameters< + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -22077,8 +28113,8 @@ GenericNegativeEnumConditionView::x() const { } template -inline ::emboss::support::Maybe -GenericNegativeEnumConditionView::has_x() const { +inline ::emboss::support::Maybe GenericOrConditionView::has_x() + const { return ::emboss::support::Maybe(true); } @@ -22091,8 +28127,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericNegativeEnumConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericOrConditionView::y() const { + if (has_y().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -22128,85 +28164,143 @@ GenericNegativeEnumConditionView::xc() const { } template -inline ::emboss::support::Maybe -GenericNegativeEnumConditionView::has_xc() const { - return ::emboss::support::NotEqual( - (x().Ok() - ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(1))); +inline ::emboss::support::Maybe GenericOrConditionView::has_y() + const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericOrConditionView::xc() const { + if (has_xc().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); } template -inline typename GenericNegativeEnumConditionView< +inline ::emboss::support::Maybe GenericOrConditionView::has_xc() + const { + return ::emboss::support::Or( + ::emboss::support::Equal( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(5LL))), + ::emboss::support::Equal( + (y().Ok() ? ::emboss::support::Maybe( + static_cast(y().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(5LL)))); +} + +template +inline typename GenericOrConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericNegativeEnumConditionView::IntrinsicSizeInBytes() const { - return typename GenericNegativeEnumConditionView< +GenericOrConditionView::IntrinsicSizeInBytes() const { + return typename GenericOrConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericNegativeEnumConditionView::has_IntrinsicSizeInBytes() const { +GenericOrConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace NegativeEnumCondition { +namespace OrCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace NegativeEnumCondition +} // namespace OrCondition template -inline constexpr ::std::int32_t GenericNegativeEnumConditionView< +inline constexpr ::std::int32_t GenericOrConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return NegativeEnumCondition::MaxSizeInBytes(); + return OrCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNegativeEnumConditionView< +inline constexpr ::std::int32_t GenericOrConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return NegativeEnumCondition::MaxSizeInBytes(); + return OrCondition::MaxSizeInBytes(); } -namespace NegativeEnumCondition { +namespace OrCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace NegativeEnumCondition +} // namespace OrCondition template -inline constexpr ::std::int32_t GenericNegativeEnumConditionView< +inline constexpr ::std::int32_t GenericOrConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return NegativeEnumCondition::MinSizeInBytes(); + return OrCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNegativeEnumConditionView< +inline constexpr ::std::int32_t GenericOrConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return NegativeEnumCondition::MinSizeInBytes(); + return OrCondition::MinSizeInBytes(); } -namespace LessThanCondition {} // namespace LessThanCondition +namespace ChoiceCondition {} // namespace ChoiceCondition template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< +inline typename ::emboss::support::EnumView< + /**/ ::emboss::test::ChoiceCondition::Field, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< typename Storage::template OffsetStorageType>, 8>> -GenericLessThanConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericChoiceConditionView::field() const { + if (has_field().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -22217,8 +28311,9 @@ GenericLessThanConditionView::x() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< + return ::emboss::support::EnumView< + /**/ ::emboss::test::ChoiceCondition::Field, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -22230,8 +28325,9 @@ GenericLessThanConditionView::x() const { emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< + return ::emboss::support::EnumView< + /**/ ::emboss::test::ChoiceCondition::Field, + ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< @@ -22243,7 +28339,7 @@ GenericLessThanConditionView::x() const { template inline ::emboss::support::Maybe -GenericLessThanConditionView::has_x() const { +GenericChoiceConditionView::has_field() const { return ::emboss::support::Maybe(true); } @@ -22256,8 +28352,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericLessThanConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericChoiceConditionView::x() const { + if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -22294,88 +28390,27 @@ GenericLessThanConditionView::xc() const { template inline ::emboss::support::Maybe -GenericLessThanConditionView::has_xc() const { - return ::emboss::support::LessThan( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(5LL))); -} - -template -inline typename GenericLessThanConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericLessThanConditionView::IntrinsicSizeInBytes() const { - return typename GenericLessThanConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); -} - -template -inline ::emboss::support::Maybe -GenericLessThanConditionView::has_IntrinsicSizeInBytes() const { +GenericChoiceConditionView::has_x() const { return ::emboss::support::Maybe(true); } -namespace LessThanCondition { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(2LL)) - .ValueOrDefault(); -} -} // namespace LessThanCondition - -template -inline constexpr ::std::int32_t GenericLessThanConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return LessThanCondition::MaxSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericLessThanConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return LessThanCondition::MaxSizeInBytes(); -} - -namespace LessThanCondition { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace LessThanCondition - -template -inline constexpr ::std::int32_t GenericLessThanConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return LessThanCondition::MinSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericLessThanConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return LessThanCondition::MinSizeInBytes(); -} -namespace LessThanOrEqualCondition {} // namespace LessThanOrEqualCondition - template inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericLessThanOrEqualConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericChoiceConditionView::y() const { + if (has_y().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(0LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -22385,10 +28420,10 @@ GenericLessThanOrEqualConditionView::x() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 0>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -22398,7 +28433,7 @@ GenericLessThanOrEqualConditionView::x() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -22406,7 +28441,7 @@ GenericLessThanOrEqualConditionView::x() const { template inline ::emboss::support::Maybe -GenericLessThanOrEqualConditionView::has_x() const { +GenericChoiceConditionView::has_y() const { return ::emboss::support::Maybe(true); } @@ -22416,17 +28451,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericLessThanOrEqualConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericChoiceConditionView::xyc() const { + if (has_xyc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(3LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -22436,10 +28471,10 @@ GenericLessThanOrEqualConditionView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 3>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -22449,7 +28484,7 @@ GenericLessThanOrEqualConditionView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -22457,247 +28492,251 @@ GenericLessThanOrEqualConditionView::xc() const { template inline ::emboss::support::Maybe -GenericLessThanOrEqualConditionView::has_xc() const { - return ::emboss::support::LessThanOrEqual( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), +GenericChoiceConditionView::has_xyc() const { + return ::emboss::support::Equal( + ::emboss::support::Choice( + ::emboss::support::Equal( + (field().Ok() + ? ::emboss::support::Maybe< + /**/ ::emboss::test::ChoiceCondition::Field>( + static_cast< + /**/ ::emboss::test::ChoiceCondition::Field>( + field().UncheckedRead())) + : ::emboss::support::Maybe< + /**/ ::emboss::test::ChoiceCondition::Field>()), + ::emboss::support::Maybe< + /**/ ::emboss::test::ChoiceCondition::Field>( + static_cast(1))), + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), + (y().Ok() ? ::emboss::support::Maybe( + static_cast(y().UncheckedRead())) + : ::emboss::support::Maybe())), ::emboss::support::Maybe( static_cast(5LL))); } template -inline typename GenericLessThanOrEqualConditionView< +inline typename GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericLessThanOrEqualConditionView::IntrinsicSizeInBytes() const { - return typename GenericLessThanOrEqualConditionView< +GenericChoiceConditionView::IntrinsicSizeInBytes() const { + return typename GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericLessThanOrEqualConditionView::has_IntrinsicSizeInBytes() const { +GenericChoiceConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace LessThanOrEqualCondition { +namespace ChoiceCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace LessThanOrEqualCondition +} // namespace ChoiceCondition template -inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< +inline constexpr ::std::int32_t GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return LessThanOrEqualCondition::MaxSizeInBytes(); + return ChoiceCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< +inline constexpr ::std::int32_t GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return LessThanOrEqualCondition::MaxSizeInBytes(); + return ChoiceCondition::MaxSizeInBytes(); } -namespace LessThanOrEqualCondition { +namespace ChoiceCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace LessThanOrEqualCondition +} // namespace ChoiceCondition template -inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< +inline constexpr ::std::int32_t GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return LessThanOrEqualCondition::MinSizeInBytes(); + return ChoiceCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< +inline constexpr ::std::int32_t GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return LessThanOrEqualCondition::MinSizeInBytes(); + return ChoiceCondition::MinSizeInBytes(); } -namespace GreaterThanOrEqualCondition { +namespace ContainsBits { +namespace EmbossReservedAnonymousField3 { -} // namespace GreaterThanOrEqualCondition +} // namespace EmbossReservedAnonymousField3 template inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> -GenericGreaterThanOrEqualConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericEmbossReservedAnonymousField3View::has_top() const { + if (has_has_top().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(0LL)); + static_cast(7LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> - (backing_.template GetOffsetStorage<0, 0>( + (backing_.template GetOffsetStorage<0, 7>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> (); } template inline ::emboss::support::Maybe -GenericGreaterThanOrEqualConditionView::has_x() const { +GenericEmbossReservedAnonymousField3View::has_has_top() const { return ::emboss::support::Maybe(true); } template inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> -GenericGreaterThanOrEqualConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericEmbossReservedAnonymousField3View::has_bottom() const { + if (has_has_bottom().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(0LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> (); } template inline ::emboss::support::Maybe -GenericGreaterThanOrEqualConditionView::has_xc() const { - return ::emboss::support::GreaterThanOrEqual( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(5LL))); +GenericEmbossReservedAnonymousField3View::has_has_bottom() const { + return ::emboss::support::Maybe(true); } +namespace EmbossReservedAnonymousField3 { +inline constexpr ::std::int32_t IntrinsicSizeInBits() { + return ::emboss::support::Maybe( + static_cast(8LL)) + .ValueOrDefault(); +} +} // namespace EmbossReservedAnonymousField3 + template -inline typename GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericGreaterThanOrEqualConditionView::IntrinsicSizeInBytes() const { - return typename GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { + return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); } template -inline ::emboss::support::Maybe GenericGreaterThanOrEqualConditionView< - Storage>::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t +GenericEmbossReservedAnonymousField3View:: + EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); } -namespace GreaterThanOrEqualCondition { -inline constexpr ::std::int32_t MaxSizeInBytes() { +namespace EmbossReservedAnonymousField3 { +inline constexpr ::std::int32_t MaxSizeInBits() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(8LL)) .ValueOrDefault(); } -} // namespace GreaterThanOrEqualCondition +} // namespace EmbossReservedAnonymousField3 template -inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return GreaterThanOrEqualCondition::MaxSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { + return EmbossReservedAnonymousField3::MaxSizeInBits(); } template -inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return GreaterThanOrEqualCondition::MaxSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField3::MaxSizeInBits(); } -namespace GreaterThanOrEqualCondition { -inline constexpr ::std::int32_t MinSizeInBytes() { +namespace EmbossReservedAnonymousField3 { +inline constexpr ::std::int32_t MinSizeInBits() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(8LL)) .ValueOrDefault(); } -} // namespace GreaterThanOrEqualCondition +} // namespace EmbossReservedAnonymousField3 template -inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return GreaterThanOrEqualCondition::MinSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { + return EmbossReservedAnonymousField3::MinSizeInBits(); } template -inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return GreaterThanOrEqualCondition::MinSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField3::MinSizeInBits(); } -namespace GreaterThanCondition {} // namespace GreaterThanCondition + +} // namespace ContainsBits template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline typename ::emboss::test::ContainsBits:: + GenericEmbossReservedAnonymousField3View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericGreaterThanConditionView::x() const { - if (has_x().ValueOr(false)) { + GenericContainsBitsView::emboss_reserved_anonymous_field_3() + const { + if (has_emboss_reserved_anonymous_field_3().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -22708,22 +28747,19 @@ GenericGreaterThanConditionView::x() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::test::ContainsBits:: + GenericEmbossReservedAnonymousField3View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, + return ::emboss::test::ContainsBits::GenericEmbossReservedAnonymousField3View< typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< typename Storage::template OffsetStorageType>, @@ -22733,134 +28769,94 @@ GenericGreaterThanConditionView::x() const { } template -inline ::emboss::support::Maybe -GenericGreaterThanConditionView::has_x() const { +inline ::emboss::support::Maybe GenericContainsBitsView< + Storage>::has_emboss_reserved_anonymous_field_3() const { return ::emboss::support::Maybe(true); } template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - -GenericGreaterThanConditionView::xc() const { - if (has_xc().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(1LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(1LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - - (backing_.template GetOffsetStorage<0, 1>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } - } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - - (); +inline ::emboss::support::Maybe +GenericContainsBitsView::has_has_top() const { + return ::emboss::support::And( + ::emboss::support::Maybe(true), + ::emboss::support::Maybe(true)); } template inline ::emboss::support::Maybe -GenericGreaterThanConditionView::has_xc() const { - return ::emboss::support::GreaterThan( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(5LL))); +GenericContainsBitsView::has_has_bottom() const { + return ::emboss::support::And( + ::emboss::support::Maybe(true), + ::emboss::support::Maybe(true)); +} + +namespace ContainsBits { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); } +} // namespace ContainsBits template -inline typename GenericGreaterThanConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericGreaterThanConditionView::IntrinsicSizeInBytes() const { - return typename GenericGreaterThanConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericContainsBitsView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return ContainsBits::IntrinsicSizeInBytes(); } template -inline ::emboss::support::Maybe -GenericGreaterThanConditionView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericContainsBitsView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return ContainsBits::IntrinsicSizeInBytes(); } -namespace GreaterThanCondition { +namespace ContainsBits { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace GreaterThanCondition +} // namespace ContainsBits template -inline constexpr ::std::int32_t GenericGreaterThanConditionView< +inline constexpr ::std::int32_t GenericContainsBitsView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return GreaterThanCondition::MaxSizeInBytes(); + return ContainsBits::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericGreaterThanConditionView< +inline constexpr ::std::int32_t GenericContainsBitsView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return GreaterThanCondition::MaxSizeInBytes(); + return ContainsBits::MaxSizeInBytes(); } -namespace GreaterThanCondition { +namespace ContainsBits { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace GreaterThanCondition +} // namespace ContainsBits template -inline constexpr ::std::int32_t GenericGreaterThanConditionView< +inline constexpr ::std::int32_t GenericContainsBitsView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return GreaterThanCondition::MinSizeInBytes(); + return ContainsBits::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericGreaterThanConditionView< +inline constexpr ::std::int32_t GenericContainsBitsView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return GreaterThanCondition::MinSizeInBytes(); + return ContainsBits::MinSizeInBytes(); } -namespace RangeCondition {} // namespace RangeCondition +namespace ContainsContainsBits {} // namespace ContainsContainsBits template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline typename ::emboss::test::GenericContainsBitsView< + typename Storage::template OffsetStorageType> -GenericRangeConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericContainsContainsBitsView::condition() const { + if (has_condition().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -22871,33 +28867,23 @@ GenericRangeConditionView::x() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::test::GenericContainsBitsView< + typename Storage::template OffsetStorageType> (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::test::GenericContainsBitsView< + typename Storage::template OffsetStorageType> (); } template inline ::emboss::support::Maybe -GenericRangeConditionView::has_x() const { +GenericContainsContainsBitsView::has_condition() const { return ::emboss::support::Maybe(true); } @@ -22910,8 +28896,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericRangeConditionView::y() const { - if (has_y().ValueOr(false)) { +GenericContainsContainsBitsView::top() const { + if (has_top().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -22948,141 +28934,73 @@ GenericRangeConditionView::y() const { template inline ::emboss::support::Maybe -GenericRangeConditionView::has_y() const { - return ::emboss::support::Maybe(true); -} - -template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - -GenericRangeConditionView::xc() const { - if (has_xc().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(1LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(2LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - - (backing_.template GetOffsetStorage<0, 2>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } - } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> - - (); -} - -template -inline ::emboss::support::Maybe -GenericRangeConditionView::has_xc() const { - return ::emboss::support::And( - ::emboss::support::And( - ::emboss::support::LessThan( - ::emboss::support::Maybe( - static_cast(5LL)), - (x().Ok() - ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe())), - ::emboss::support::LessThanOrEqual( - (x().Ok() - ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - (y().Ok() - ? ::emboss::support::Maybe( - static_cast(y().UncheckedRead())) - : ::emboss::support::Maybe()))), - ::emboss::support::LessThan::has_top() const { + return ::emboss::support::Equal( - (y().Ok() ? ::emboss::support::Maybe( - static_cast(y().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(10LL)))); + (condition().has_top().Ok() + ? ::emboss::support::Maybe( + static_cast( + condition().has_top().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))); } template -inline typename GenericRangeConditionView< +inline typename GenericContainsContainsBitsView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericRangeConditionView::IntrinsicSizeInBytes() const { - return typename GenericRangeConditionView< +GenericContainsContainsBitsView::IntrinsicSizeInBytes() const { + return typename GenericContainsContainsBitsView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericRangeConditionView::has_IntrinsicSizeInBytes() const { +GenericContainsContainsBitsView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace RangeCondition { +namespace ContainsContainsBits { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace RangeCondition +} // namespace ContainsContainsBits template -inline constexpr ::std::int32_t GenericRangeConditionView< +inline constexpr ::std::int32_t GenericContainsContainsBitsView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return RangeCondition::MaxSizeInBytes(); + return ContainsContainsBits::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericRangeConditionView< +inline constexpr ::std::int32_t GenericContainsContainsBitsView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return RangeCondition::MaxSizeInBytes(); + return ContainsContainsBits::MaxSizeInBytes(); } -namespace RangeCondition { +namespace ContainsContainsBits { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace RangeCondition +} // namespace ContainsContainsBits template -inline constexpr ::std::int32_t GenericRangeConditionView< +inline constexpr ::std::int32_t GenericContainsContainsBitsView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return RangeCondition::MinSizeInBytes(); + return ContainsContainsBits::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericRangeConditionView< +inline constexpr ::std::int32_t GenericContainsContainsBitsView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return RangeCondition::MinSizeInBytes(); + return ContainsContainsBits::MinSizeInBytes(); } -namespace ReverseRangeCondition {} // namespace ReverseRangeCondition +namespace ConditionalInline { +namespace Type0 {} // namespace Type0 template inline typename ::emboss::prelude::UIntView< @@ -23093,8 +29011,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericReverseRangeConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericType0View::a() const { + if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23130,8 +29048,7 @@ GenericReverseRangeConditionView::x() const { } template -inline ::emboss::support::Maybe -GenericReverseRangeConditionView::has_x() const { +inline ::emboss::support::Maybe GenericType0View::has_a() const { return ::emboss::support::Maybe(true); } @@ -23144,8 +29061,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericReverseRangeConditionView::y() const { - if (has_y().ValueOr(false)) { +GenericType0View::b() const { + if (has_b().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23181,8 +29098,7 @@ GenericReverseRangeConditionView::y() const { } template -inline ::emboss::support::Maybe -GenericReverseRangeConditionView::has_y() const { +inline ::emboss::support::Maybe GenericType0View::has_b() const { return ::emboss::support::Maybe(true); } @@ -23195,8 +29111,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericReverseRangeConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericType0View::c() const { + if (has_c().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23232,91 +29148,71 @@ GenericReverseRangeConditionView::xc() const { } template -inline ::emboss::support::Maybe -GenericReverseRangeConditionView::has_xc() const { - return ::emboss::support::And( - ::emboss::support::And( - ::emboss::support::GreaterThan( - ::emboss::support::Maybe( - static_cast(10LL)), - (y().Ok() - ? ::emboss::support::Maybe( - static_cast(y().UncheckedRead())) - : ::emboss::support::Maybe())), - ::emboss::support::GreaterThanOrEqual( - (y().Ok() - ? ::emboss::support::Maybe( - static_cast(y().UncheckedRead())) - : ::emboss::support::Maybe()), - (x().Ok() - ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()))), - ::emboss::support::GreaterThan( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(5LL)))); +inline ::emboss::support::Maybe GenericType0View::has_c() const { + return ::emboss::support::Maybe(true); +} + +namespace Type0 { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(3LL)) + .ValueOrDefault(); } +} // namespace Type0 template -inline typename GenericReverseRangeConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericReverseRangeConditionView::IntrinsicSizeInBytes() const { - return typename GenericReverseRangeConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericType0View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return Type0::IntrinsicSizeInBytes(); } template -inline ::emboss::support::Maybe -GenericReverseRangeConditionView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericType0View:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return Type0::IntrinsicSizeInBytes(); } -namespace ReverseRangeCondition { +namespace Type0 { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(3LL)) .ValueOrDefault(); } -} // namespace ReverseRangeCondition +} // namespace Type0 template -inline constexpr ::std::int32_t GenericReverseRangeConditionView< +inline constexpr ::std::int32_t GenericType0View< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ReverseRangeCondition::MaxSizeInBytes(); + return Type0::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericReverseRangeConditionView< +inline constexpr ::std::int32_t GenericType0View< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ReverseRangeCondition::MaxSizeInBytes(); + return Type0::MaxSizeInBytes(); } -namespace ReverseRangeCondition { +namespace Type0 { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ReverseRangeCondition +} // namespace Type0 template -inline constexpr ::std::int32_t GenericReverseRangeConditionView< +inline constexpr ::std::int32_t GenericType0View< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ReverseRangeCondition::MinSizeInBytes(); + return Type0::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericReverseRangeConditionView< +inline constexpr ::std::int32_t GenericType0View< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ReverseRangeCondition::MinSizeInBytes(); + return Type0::MinSizeInBytes(); } -namespace AndCondition {} // namespace AndCondition + +namespace Type1 {} // namespace Type1 template inline typename ::emboss::prelude::UIntView< @@ -23327,8 +29223,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAndConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericType1View::a() const { + if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23364,8 +29260,7 @@ GenericAndConditionView::x() const { } template -inline ::emboss::support::Maybe GenericAndConditionView::has_x() - const { +inline ::emboss::support::Maybe GenericType1View::has_a() const { return ::emboss::support::Maybe(true); } @@ -23378,8 +29273,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAndConditionView::y() const { - if (has_y().ValueOr(false)) { +GenericType1View::b() const { + if (has_b().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23415,8 +29310,7 @@ GenericAndConditionView::y() const { } template -inline ::emboss::support::Maybe GenericAndConditionView::has_y() - const { +inline ::emboss::support::Maybe GenericType1View::has_b() const { return ::emboss::support::Maybe(true); } @@ -23429,8 +29323,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAndConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericType1View::c() const { + if (has_c().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23466,79 +29360,71 @@ GenericAndConditionView::xc() const { } template -inline ::emboss::support::Maybe GenericAndConditionView::has_xc() - const { - return ::emboss::support::And( - ::emboss::support::Equal( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(5LL))), - ::emboss::support::Equal( - (y().Ok() ? ::emboss::support::Maybe( - static_cast(y().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(5LL)))); +inline ::emboss::support::Maybe GenericType1View::has_c() const { + return ::emboss::support::Maybe(true); +} + +namespace Type1 { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(3LL)) + .ValueOrDefault(); } +} // namespace Type1 template -inline typename GenericAndConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericAndConditionView::IntrinsicSizeInBytes() const { - return typename GenericAndConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericType1View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return Type1::IntrinsicSizeInBytes(); } template -inline ::emboss::support::Maybe -GenericAndConditionView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericType1View:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return Type1::IntrinsicSizeInBytes(); } -namespace AndCondition { +namespace Type1 { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(3LL)) .ValueOrDefault(); } -} // namespace AndCondition +} // namespace Type1 template -inline constexpr ::std::int32_t GenericAndConditionView< +inline constexpr ::std::int32_t GenericType1View< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return AndCondition::MaxSizeInBytes(); + return Type1::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAndConditionView< +inline constexpr ::std::int32_t GenericType1View< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return AndCondition::MaxSizeInBytes(); + return Type1::MaxSizeInBytes(); } -namespace AndCondition { +namespace Type1 { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace AndCondition +} // namespace Type1 template -inline constexpr ::std::int32_t GenericAndConditionView< +inline constexpr ::std::int32_t GenericType1View< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return AndCondition::MinSizeInBytes(); + return Type1::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAndConditionView< +inline constexpr ::std::int32_t GenericType1View< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return AndCondition::MinSizeInBytes(); + return Type1::MinSizeInBytes(); } -namespace OrCondition {} // namespace OrCondition + +} // namespace ConditionalInline template inline typename ::emboss::prelude::UIntView< @@ -23549,8 +29435,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericOrConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericConditionalInlineView::payload_id() const { + if (has_payload_id().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23586,25 +29472,20 @@ GenericOrConditionView::x() const { } template -inline ::emboss::support::Maybe GenericOrConditionView::has_x() - const { +inline ::emboss::support::Maybe +GenericConditionalInlineView::has_payload_id() const { return ::emboss::support::Maybe(true); } template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline typename ::emboss::test::ConditionalInline::GenericType0View< + typename Storage::template OffsetStorageType> -GenericOrConditionView::y() const { - if (has_y().ValueOr(false)) { +GenericConditionalInlineView::type_0() const { + if (has_type_0().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(3LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( static_cast(1LL)); @@ -23612,168 +29493,142 @@ GenericOrConditionView::y() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::test::ConditionalInline::GenericType0View< + typename Storage::template OffsetStorageType> (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::test::ConditionalInline::GenericType0View< + typename Storage::template OffsetStorageType> (); } template -inline ::emboss::support::Maybe GenericOrConditionView::has_y() - const { - return ::emboss::support::Maybe(true); +inline ::emboss::support::Maybe +GenericConditionalInlineView::has_type_0() const { + return ::emboss::support::Equal( + (payload_id().Ok() + ? ::emboss::support::Maybe( + static_cast(payload_id().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); } template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline typename ::emboss::test::ConditionalInline::GenericType1View< + typename Storage::template OffsetStorageType> -GenericOrConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericConditionalInlineView::type_1() const { + if (has_type_1().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(3LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(2LL)); + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::test::ConditionalInline::GenericType1View< + typename Storage::template OffsetStorageType> - (backing_.template GetOffsetStorage<0, 2>( + (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::test::ConditionalInline::GenericType1View< + typename Storage::template OffsetStorageType> (); } template -inline ::emboss::support::Maybe GenericOrConditionView::has_xc() - const { - return ::emboss::support::Or( - ::emboss::support::Equal( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(5LL))), - ::emboss::support::Equal( - (y().Ok() ? ::emboss::support::Maybe( - static_cast(y().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(5LL)))); +inline ::emboss::support::Maybe +GenericConditionalInlineView::has_type_1() const { + return ::emboss::support::Equal( + (payload_id().Ok() + ? ::emboss::support::Maybe( + static_cast(payload_id().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))); } template -inline typename GenericOrConditionView< +inline typename GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericOrConditionView::IntrinsicSizeInBytes() const { - return typename GenericOrConditionView< +GenericConditionalInlineView::IntrinsicSizeInBytes() const { + return typename GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericOrConditionView::has_IntrinsicSizeInBytes() const { +GenericConditionalInlineView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace OrCondition { +namespace ConditionalInline { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace OrCondition +} // namespace ConditionalInline template -inline constexpr ::std::int32_t GenericOrConditionView< +inline constexpr ::std::int32_t GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return OrCondition::MaxSizeInBytes(); + return ConditionalInline::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericOrConditionView< +inline constexpr ::std::int32_t GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return OrCondition::MaxSizeInBytes(); + return ConditionalInline::MaxSizeInBytes(); } -namespace OrCondition { +namespace ConditionalInline { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace OrCondition +} // namespace ConditionalInline template -inline constexpr ::std::int32_t GenericOrConditionView< +inline constexpr ::std::int32_t GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return OrCondition::MinSizeInBytes(); + return ConditionalInline::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericOrConditionView< +inline constexpr ::std::int32_t GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return OrCondition::MinSizeInBytes(); + return ConditionalInline::MinSizeInBytes(); } -namespace ChoiceCondition {} // namespace ChoiceCondition +namespace ConditionalAnonymous { +namespace EmbossReservedAnonymousField2 { + +} // namespace EmbossReservedAnonymousField2 template -inline typename ::emboss::support::EnumView< - /**/ ::emboss::test::ChoiceCondition::Field, - ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> -GenericChoiceConditionView::field() const { - if (has_field().ValueOr(false)) { +GenericEmbossReservedAnonymousField2View::low() const { + if (has_low().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23784,157 +29639,200 @@ GenericChoiceConditionView::field() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::support::EnumView< - /**/ ::emboss::test::ChoiceCondition::Field, - ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::support::EnumView< - /**/ ::emboss::test::ChoiceCondition::Field, - ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> (); } template inline ::emboss::support::Maybe -GenericChoiceConditionView::has_field() const { +GenericEmbossReservedAnonymousField2View::has_low() const { return ::emboss::support::Maybe(true); } template inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 2, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> -GenericChoiceConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericEmbossReservedAnonymousField2View::mid() const { + if (has_mid().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(2LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(3LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 2, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 3>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 2, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> (); } template inline ::emboss::support::Maybe -GenericChoiceConditionView::has_x() const { - return ::emboss::support::Maybe(true); +GenericEmbossReservedAnonymousField2View::has_mid() const { + return ::emboss::support::Equal( + (low().Ok() ? ::emboss::support::Maybe( + static_cast(low().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))); } template inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> -GenericChoiceConditionView::y() const { - if (has_y().ValueOr(false)) { +GenericEmbossReservedAnonymousField2View::high() const { + if (has_high().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(2LL)); + static_cast(7LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> - (backing_.template GetOffsetStorage<0, 2>( + (backing_.template GetOffsetStorage<0, 7>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> (); } template inline ::emboss::support::Maybe -GenericChoiceConditionView::has_y() const { +GenericEmbossReservedAnonymousField2View::has_high() const { return ::emboss::support::Maybe(true); } +namespace EmbossReservedAnonymousField2 { +inline constexpr ::std::int32_t IntrinsicSizeInBits() { + return ::emboss::support::Maybe( + static_cast(8LL)) + .ValueOrDefault(); +} +} // namespace EmbossReservedAnonymousField2 + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); +} + +template +inline constexpr ::std::int32_t +GenericEmbossReservedAnonymousField2View:: + EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); +} + +namespace EmbossReservedAnonymousField2 { +inline constexpr ::std::int32_t MaxSizeInBits() { + return ::emboss::support::Maybe( + static_cast(8LL)) + .ValueOrDefault(); +} +} // namespace EmbossReservedAnonymousField2 + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::MaxSizeInBits(); +} + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::MaxSizeInBits(); +} + +namespace EmbossReservedAnonymousField2 { +inline constexpr ::std::int32_t MinSizeInBits() { + return ::emboss::support::Maybe( + static_cast(8LL)) + .ValueOrDefault(); +} +} // namespace EmbossReservedAnonymousField2 + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::MinSizeInBits(); +} + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::MinSizeInBits(); +} + +} // namespace ConditionalAnonymous + template inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericChoiceConditionView::xyc() const { - if (has_xyc().ValueOr(false)) { +GenericConditionalAnonymousView::x() const { + if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(3LL)); + static_cast(0LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -23944,10 +29842,10 @@ GenericChoiceConditionView::xyc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 3>( + (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -23957,151 +29855,163 @@ GenericChoiceConditionView::xyc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); } template -inline ::emboss::support::Maybe -GenericChoiceConditionView::has_xyc() const { - return ::emboss::support::Equal( - ::emboss::support::Choice( - ::emboss::support::Equal( - (field().Ok() - ? ::emboss::support::Maybe< - /**/ ::emboss::test::ChoiceCondition::Field>( - static_cast< - /**/ ::emboss::test::ChoiceCondition::Field>( - field().UncheckedRead())) - : ::emboss::support::Maybe< - /**/ ::emboss::test::ChoiceCondition::Field>()), - ::emboss::support::Maybe< - /**/ ::emboss::test::ChoiceCondition::Field>( - static_cast(1))), - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), - (y().Ok() ? ::emboss::support::Maybe( - static_cast(y().UncheckedRead())) - : ::emboss::support::Maybe())), +inline ::emboss::support::Maybe +GenericConditionalAnonymousView::has_x() const { + return ::emboss::support::Maybe(true); +} + +template +inline typename ::emboss::test::ConditionalAnonymous:: + GenericEmbossReservedAnonymousField2View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + GenericConditionalAnonymousView< + Storage>::emboss_reserved_anonymous_field_2() const { + if (has_emboss_reserved_anonymous_field_2().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::test::ConditionalAnonymous:: + GenericEmbossReservedAnonymousField2View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::test::ConditionalAnonymous:: + GenericEmbossReservedAnonymousField2View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe GenericConditionalAnonymousView< + Storage>::has_emboss_reserved_anonymous_field_2() const { + return ::emboss::support::GreaterThan( + (x().Ok() ? ::emboss::support::Maybe( + static_cast(x().UncheckedRead())) + : ::emboss::support::Maybe()), ::emboss::support::Maybe( - static_cast(5LL))); + static_cast(10LL))); } template -inline typename GenericChoiceConditionView< +inline ::emboss::support::Maybe +GenericConditionalAnonymousView::has_low() const { + return ::emboss::support::And( + has_emboss_reserved_anonymous_field_2(), + ::emboss::support::Maybe(true)); +} + +template +inline ::emboss::support::Maybe +GenericConditionalAnonymousView::has_mid() const { + return ::emboss::support::And( + has_emboss_reserved_anonymous_field_2(), + emboss_reserved_anonymous_field_2().has_mid()); +} + +template +inline ::emboss::support::Maybe +GenericConditionalAnonymousView::has_high() const { + return ::emboss::support::And( + has_emboss_reserved_anonymous_field_2(), + ::emboss::support::Maybe(true)); +} + +template +inline typename GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericChoiceConditionView::IntrinsicSizeInBytes() const { - return typename GenericChoiceConditionView< +GenericConditionalAnonymousView::IntrinsicSizeInBytes() const { + return typename GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericChoiceConditionView::has_IntrinsicSizeInBytes() const { +GenericConditionalAnonymousView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ChoiceCondition { +namespace ConditionalAnonymous { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(4LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace ChoiceCondition +} // namespace ConditionalAnonymous template -inline constexpr ::std::int32_t GenericChoiceConditionView< +inline constexpr ::std::int32_t GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ChoiceCondition::MaxSizeInBytes(); + return ConditionalAnonymous::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericChoiceConditionView< +inline constexpr ::std::int32_t GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ChoiceCondition::MaxSizeInBytes(); + return ConditionalAnonymous::MaxSizeInBytes(); } -namespace ChoiceCondition { +namespace ConditionalAnonymous { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace ChoiceCondition +} // namespace ConditionalAnonymous template -inline constexpr ::std::int32_t GenericChoiceConditionView< +inline constexpr ::std::int32_t GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ChoiceCondition::MinSizeInBytes(); + return ConditionalAnonymous::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericChoiceConditionView< +inline constexpr ::std::int32_t GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ChoiceCondition::MinSizeInBytes(); -} -namespace ContainsBits { -namespace EmbossReservedAnonymousField3 { - -} // namespace EmbossReservedAnonymousField3 - -template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> - -GenericEmbossReservedAnonymousField3View::has_top() const { - if (has_has_top().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(1LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(7LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> - - (backing_.template GetOffsetStorage<0, 7>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } - } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> - - (); + return ConditionalAnonymous::MinSizeInBytes(); } +namespace ConditionalOnFlag { +namespace EmbossReservedAnonymousField1 { -template -inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField3View::has_has_top() const { - return ::emboss::support::Maybe(true); -} +} // namespace EmbossReservedAnonymousField1 template -inline typename ::emboss::prelude::UIntView< +inline typename ::emboss::prelude::FlagView< /**/ ::emboss::support::FixedSizeViewParameters< 1, ::emboss::support::AllValuesAreOk>, typename Storage::template OffsetStorageType> -GenericEmbossReservedAnonymousField3View::has_bottom() const { - if (has_has_bottom().ValueOr(false)) { +GenericEmbossReservedAnonymousField1View::enabled() const { + if (has_enabled().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24112,7 +30022,7 @@ GenericEmbossReservedAnonymousField3View::has_bottom() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< + return ::emboss::prelude::FlagView< /**/ ::emboss::support::FixedSizeViewParameters< 1, ::emboss::support::AllValuesAreOk>, typename Storage::template OffsetStorageType> @@ -24122,7 +30032,7 @@ GenericEmbossReservedAnonymousField3View::has_bottom() const { emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::UIntView< + return ::emboss::prelude::FlagView< /**/ ::emboss::support::FixedSizeViewParameters< 1, ::emboss::support::AllValuesAreOk>, typename Storage::template OffsetStorageType> @@ -24132,204 +30042,252 @@ GenericEmbossReservedAnonymousField3View::has_bottom() const { template inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField3View::has_has_bottom() const { +GenericEmbossReservedAnonymousField1View::has_enabled() const { return ::emboss::support::Maybe(true); } -namespace EmbossReservedAnonymousField3 { +namespace EmbossReservedAnonymousField1 { inline constexpr ::std::int32_t IntrinsicSizeInBits() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField3 +} // namespace EmbossReservedAnonymousField1 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); + return EmbossReservedAnonymousField1::IntrinsicSizeInBits(); } template inline constexpr ::std::int32_t -GenericEmbossReservedAnonymousField3View:: +GenericEmbossReservedAnonymousField1View:: EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); + return EmbossReservedAnonymousField1::IntrinsicSizeInBits(); } -namespace EmbossReservedAnonymousField3 { +namespace EmbossReservedAnonymousField1 { inline constexpr ::std::int32_t MaxSizeInBits() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField3 +} // namespace EmbossReservedAnonymousField1 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::MaxSizeInBits(); + return EmbossReservedAnonymousField1::MaxSizeInBits(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::MaxSizeInBits(); + return EmbossReservedAnonymousField1::MaxSizeInBits(); } -namespace EmbossReservedAnonymousField3 { +namespace EmbossReservedAnonymousField1 { inline constexpr ::std::int32_t MinSizeInBits() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField3 +} // namespace EmbossReservedAnonymousField1 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::MinSizeInBits(); + return EmbossReservedAnonymousField1::MinSizeInBits(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::MinSizeInBits(); + return EmbossReservedAnonymousField1::MinSizeInBits(); } -} // namespace ContainsBits +} // namespace ConditionalOnFlag template -inline typename ::emboss::test::ContainsBits:: - GenericEmbossReservedAnonymousField3View< +inline typename ::emboss::test::ConditionalOnFlag:: + GenericEmbossReservedAnonymousField1View< typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< typename Storage::template OffsetStorageType>, 8>> - GenericContainsBitsView::emboss_reserved_anonymous_field_3() - const { - if (has_emboss_reserved_anonymous_field_3().ValueOr(false)) { + GenericConditionalOnFlagView::emboss_reserved_anonymous_field_1() + const { + if (has_emboss_reserved_anonymous_field_1().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(0LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::test::ConditionalOnFlag:: + GenericEmbossReservedAnonymousField1View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 0>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::test::ConditionalOnFlag:: + GenericEmbossReservedAnonymousField1View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe GenericConditionalOnFlagView< + Storage>::has_emboss_reserved_anonymous_field_1() const { + return ::emboss::support::Maybe(true); +} + +template +inline ::emboss::support::Maybe +GenericConditionalOnFlagView::has_enabled() const { + return ::emboss::support::And( + ::emboss::support::Maybe(true), + ::emboss::support::Maybe(true)); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericConditionalOnFlagView::value() const { + if (has_value().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(0LL)); + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::test::ContainsBits:: - GenericEmbossReservedAnonymousField3View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> - (backing_.template GetOffsetStorage<0, 0>( + (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::test::ContainsBits::GenericEmbossReservedAnonymousField3View< + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); } -template -inline ::emboss::support::Maybe GenericContainsBitsView< - Storage>::has_emboss_reserved_anonymous_field_3() const { - return ::emboss::support::Maybe(true); -} - -template -inline ::emboss::support::Maybe -GenericContainsBitsView::has_has_top() const { - return ::emboss::support::And( - ::emboss::support::Maybe(true), - ::emboss::support::Maybe(true)); -} - template inline ::emboss::support::Maybe -GenericContainsBitsView::has_has_bottom() const { - return ::emboss::support::And( - ::emboss::support::Maybe(true), - ::emboss::support::Maybe(true)); -} - -namespace ContainsBits { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); +GenericConditionalOnFlagView::has_value() const { + return (enabled().Ok() + ? ::emboss::support::Maybe( + static_cast(enabled().UncheckedRead())) + : ::emboss::support::Maybe()); } -} // namespace ContainsBits template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ContainsBits::IntrinsicSizeInBytes(); +inline typename GenericConditionalOnFlagView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericConditionalOnFlagView::IntrinsicSizeInBytes() const { + return typename GenericConditionalOnFlagView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t GenericContainsBitsView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ContainsBits::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericConditionalOnFlagView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace ContainsBits { +namespace ConditionalOnFlag { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace ContainsBits +} // namespace ConditionalOnFlag template -inline constexpr ::std::int32_t GenericContainsBitsView< +inline constexpr ::std::int32_t GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ContainsBits::MaxSizeInBytes(); + return ConditionalOnFlag::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericContainsBitsView< +inline constexpr ::std::int32_t GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ContainsBits::MaxSizeInBytes(); + return ConditionalOnFlag::MaxSizeInBytes(); } -namespace ContainsBits { +namespace ConditionalOnFlag { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ContainsBits +} // namespace ConditionalOnFlag template -inline constexpr ::std::int32_t GenericContainsBitsView< +inline constexpr ::std::int32_t GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ContainsBits::MinSizeInBytes(); + return ConditionalOnFlag::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericContainsBitsView< +inline constexpr ::std::int32_t GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ContainsBits::MinSizeInBytes(); + return ConditionalOnFlag::MinSizeInBytes(); } -namespace ContainsContainsBits {} // namespace ContainsContainsBits +namespace ResidualConditionalDiscriminant { + +} // namespace ResidualConditionalDiscriminant template -inline typename ::emboss::test::GenericContainsBitsView< - typename Storage::template OffsetStorageType> +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericContainsContainsBitsView::condition() const { - if (has_condition().ValueOr(false)) { +GenericResidualConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24340,23 +30298,33 @@ GenericContainsContainsBitsView::condition() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::test::GenericContainsBitsView< - typename Storage::template OffsetStorageType> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::test::GenericContainsBitsView< - typename Storage::template OffsetStorageType> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template inline ::emboss::support::Maybe -GenericContainsContainsBitsView::has_condition() const { +GenericResidualConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } @@ -24369,8 +30337,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericContainsContainsBitsView::top() const { - if (has_top().ValueOr(false)) { +GenericResidualConditionalDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24407,73 +30375,209 @@ GenericContainsContainsBitsView::top() const { template inline ::emboss::support::Maybe -GenericContainsContainsBitsView::has_top() const { - return ::emboss::support::Equal( - (condition().has_top().Ok() - ? ::emboss::support::Maybe( - static_cast( - condition().has_top().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(1LL))); +GenericResidualConditionalDiscriminantView::has_tag() const { + return ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericResidualConditionalDiscriminantView::a() const { + if (has_a().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericResidualConditionalDiscriminantView::has_a() const { + return ::emboss::support::And( + ::emboss::support::Equal( + (tag().Ok() + ? ::emboss::support::Maybe( + static_cast(tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))), + ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL)))); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericResidualConditionalDiscriminantView::b() const { + if (has_b().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericResidualConditionalDiscriminantView::has_b() const { + return ::emboss::support::And( + ::emboss::support::Equal( + (tag().Ok() + ? ::emboss::support::Maybe( + static_cast(tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))), + ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL)))); } template -inline typename GenericContainsContainsBitsView< +inline typename GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericContainsContainsBitsView::IntrinsicSizeInBytes() const { - return typename GenericContainsContainsBitsView< +GenericResidualConditionalDiscriminantView::IntrinsicSizeInBytes() + const { + return typename GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericContainsContainsBitsView::has_IntrinsicSizeInBytes() const { +GenericResidualConditionalDiscriminantView::has_IntrinsicSizeInBytes() + const { return ::emboss::support::Maybe(true); } -namespace ContainsContainsBits { +namespace ResidualConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ContainsContainsBits +} // namespace ResidualConditionalDiscriminant template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ContainsContainsBits::MaxSizeInBytes(); + return ResidualConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ContainsContainsBits::MaxSizeInBytes(); + return ResidualConditionalDiscriminant::MaxSizeInBytes(); } -namespace ContainsContainsBits { +namespace ResidualConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ContainsContainsBits +} // namespace ResidualConditionalDiscriminant template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ContainsContainsBits::MinSizeInBytes(); + return ResidualConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ContainsContainsBits::MinSizeInBytes(); + return ResidualConditionalDiscriminant::MinSizeInBytes(); } -namespace ConditionalInline { -namespace Type0 {} // namespace Type0 +namespace BareConditionalDiscriminant { + +} // namespace BareConditionalDiscriminant template inline typename ::emboss::prelude::UIntView< @@ -24484,8 +30588,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType0View::a() const { - if (has_a().ValueOr(false)) { +GenericBareConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24521,7 +30625,8 @@ GenericType0View::a() const { } template -inline ::emboss::support::Maybe GenericType0View::has_a() const { +inline ::emboss::support::Maybe +GenericBareConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } @@ -24534,8 +30639,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType0View::b() const { - if (has_b().ValueOr(false)) { +GenericBareConditionalDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24571,8 +30676,16 @@ GenericType0View::b() const { } template -inline ::emboss::support::Maybe GenericType0View::has_b() const { - return ::emboss::support::Maybe(true); +inline ::emboss::support::Maybe +GenericBareConditionalDiscriminantView::has_tag() const { + return ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))); } template @@ -24584,8 +30697,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType0View::c() const { - if (has_c().ValueOr(false)) { +GenericBareConditionalDiscriminantView::a() const { + if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24621,71 +30734,128 @@ GenericType0View::c() const { } template -inline ::emboss::support::Maybe GenericType0View::has_c() const { - return ::emboss::support::Maybe(true); +inline ::emboss::support::Maybe +GenericBareConditionalDiscriminantView::has_a() const { + return ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast(tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); } -namespace Type0 { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(3LL)) - .ValueOrDefault(); +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericBareConditionalDiscriminantView::b() const { + if (has_b().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); } -} // namespace Type0 template -inline constexpr ::std::int32_t GenericType0View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return Type0::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericBareConditionalDiscriminantView::has_b() const { + return ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast(tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))); } template -inline constexpr ::std::int32_t GenericType0View:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return Type0::IntrinsicSizeInBytes(); +inline typename GenericBareConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericBareConditionalDiscriminantView::IntrinsicSizeInBytes() const { + return typename GenericBareConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } -namespace Type0 { +template +inline ::emboss::support::Maybe GenericBareConditionalDiscriminantView< + Storage>::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace BareConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(3LL)) .ValueOrDefault(); } -} // namespace Type0 +} // namespace BareConditionalDiscriminant template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return Type0::MaxSizeInBytes(); + return BareConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return Type0::MaxSizeInBytes(); + return BareConditionalDiscriminant::MaxSizeInBytes(); } -namespace Type0 { +namespace BareConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace Type0 +} // namespace BareConditionalDiscriminant template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return Type0::MinSizeInBytes(); + return BareConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return Type0::MinSizeInBytes(); + return BareConditionalDiscriminant::MinSizeInBytes(); } - -namespace Type1 {} // namespace Type1 +namespace DominatedBareDiscriminant {} // namespace DominatedBareDiscriminant template inline typename ::emboss::prelude::UIntView< @@ -24696,8 +30866,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType1View::a() const { - if (has_a().ValueOr(false)) { +GenericDominatedBareDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24733,7 +30903,8 @@ GenericType1View::a() const { } template -inline ::emboss::support::Maybe GenericType1View::has_a() const { +inline ::emboss::support::Maybe +GenericDominatedBareDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } @@ -24743,17 +30914,132 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, + 8>> + +GenericDominatedBareDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericDominatedBareDiscriminantView::has_tag() const { + return ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + +GenericDominatedBareDiscriminantView::a() const { + if (has_a().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); +} + +template +inline ::emboss::support::Maybe +GenericDominatedBareDiscriminantView::has_a() const { + return ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast(tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))); +} + +template +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, 8>> -GenericType1View::b() const { +GenericDominatedBareDiscriminantView::b() const { if (has_b().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -24763,10 +31049,10 @@ GenericType1View::b() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -24776,15 +31062,22 @@ GenericType1View::b() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); } template -inline ::emboss::support::Maybe GenericType1View::has_b() const { - return ::emboss::support::Maybe(true); +inline ::emboss::support::Maybe +GenericDominatedBareDiscriminantView::has_b() const { + return ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast(tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL))); } template @@ -24793,17 +31086,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericType1View::c() const { - if (has_c().ValueOr(false)) { +GenericDominatedBareDiscriminantView::tail() const { + if (has_tail().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(2LL)); + static_cast(3LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -24813,10 +31106,10 @@ GenericType1View::c() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 2>( + (backing_.template GetOffsetStorage<0, 3>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -24826,78 +31119,80 @@ GenericType1View::c() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); } template -inline ::emboss::support::Maybe GenericType1View::has_c() const { +inline ::emboss::support::Maybe +GenericDominatedBareDiscriminantView::has_tail() const { return ::emboss::support::Maybe(true); } -namespace Type1 { +namespace DominatedBareDiscriminant { inline constexpr ::std::int32_t IntrinsicSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace Type1 +} // namespace DominatedBareDiscriminant template -inline constexpr ::std::int32_t GenericType1View< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return Type1::IntrinsicSizeInBytes(); + return DominatedBareDiscriminant::IntrinsicSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType1View:: +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView:: EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return Type1::IntrinsicSizeInBytes(); + return DominatedBareDiscriminant::IntrinsicSizeInBytes(); } -namespace Type1 { +namespace DominatedBareDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace Type1 +} // namespace DominatedBareDiscriminant template -inline constexpr ::std::int32_t GenericType1View< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return Type1::MaxSizeInBytes(); + return DominatedBareDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType1View< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return Type1::MaxSizeInBytes(); + return DominatedBareDiscriminant::MaxSizeInBytes(); } -namespace Type1 { +namespace DominatedBareDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace Type1 +} // namespace DominatedBareDiscriminant template -inline constexpr ::std::int32_t GenericType1View< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return Type1::MinSizeInBytes(); + return DominatedBareDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType1View< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return Type1::MinSizeInBytes(); + return DominatedBareDiscriminant::MinSizeInBytes(); } +namespace DisjunctionConditionalDiscriminant { -} // namespace ConditionalInline +} // namespace DisjunctionConditionalDiscriminant template inline typename ::emboss::prelude::UIntView< @@ -24908,8 +31203,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalInlineView::payload_id() const { - if (has_payload_id().ValueOr(false)) { +GenericDisjunctionConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24946,62 +31241,24 @@ GenericConditionalInlineView::payload_id() const { template inline ::emboss::support::Maybe -GenericConditionalInlineView::has_payload_id() const { +GenericDisjunctionConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } template -inline typename ::emboss::test::ConditionalInline::GenericType0View< - typename Storage::template OffsetStorageType> +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericConditionalInlineView::type_0() const { - if (has_type_0().ValueOr(false)) { +GenericDisjunctionConditionalDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(3LL)); - auto emboss_reserved_local_offset = ::emboss::support::Maybe( static_cast(1LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::test::ConditionalInline::GenericType0View< - typename Storage::template OffsetStorageType> - - (backing_.template GetOffsetStorage<0, 1>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } - } - return ::emboss::test::ConditionalInline::GenericType0View< - typename Storage::template OffsetStorageType> - - (); -} - -template -inline ::emboss::support::Maybe -GenericConditionalInlineView::has_type_0() const { - return ::emboss::support::Equal( - (payload_id().Ok() - ? ::emboss::support::Maybe( - static_cast(payload_id().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(0LL))); -} - -template -inline typename ::emboss::test::ConditionalInline::GenericType1View< - typename Storage::template OffsetStorageType> - -GenericConditionalInlineView::type_1() const { - if (has_type_1().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(3LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( static_cast(1LL)); @@ -25009,285 +31266,253 @@ GenericConditionalInlineView::type_1() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::test::ConditionalInline::GenericType1View< - typename Storage::template OffsetStorageType> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::test::ConditionalInline::GenericType1View< - typename Storage::template OffsetStorageType> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template inline ::emboss::support::Maybe -GenericConditionalInlineView::has_type_1() const { +GenericDisjunctionConditionalDiscriminantView::has_tag() const { return ::emboss::support::Equal( - (payload_id().Ok() + (outer().Ok() ? ::emboss::support::Maybe( - static_cast(payload_id().UncheckedRead())) + static_cast(outer().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe( static_cast(1LL))); } -template -inline typename GenericConditionalInlineView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalInlineView::IntrinsicSizeInBytes() const { - return typename GenericConditionalInlineView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); -} - -template -inline ::emboss::support::Maybe -GenericConditionalInlineView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); -} - -namespace ConditionalInline { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(4LL)) - .ValueOrDefault(); -} -} // namespace ConditionalInline - -template -inline constexpr ::std::int32_t GenericConditionalInlineView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalInline::MaxSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericConditionalInlineView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalInline::MaxSizeInBytes(); -} - -namespace ConditionalInline { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace ConditionalInline - -template -inline constexpr ::std::int32_t GenericConditionalInlineView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalInline::MinSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericConditionalInlineView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalInline::MinSizeInBytes(); -} -namespace ConditionalAnonymous { -namespace EmbossReservedAnonymousField2 { - -} // namespace EmbossReservedAnonymousField2 - template inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericEmbossReservedAnonymousField2View::low() const { - if (has_low().ValueOr(false)) { +GenericDisjunctionConditionalDiscriminantView::a() const { + if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(0LL)); - if (emboss_reserved_local_size.Known() && - emboss_reserved_local_size.ValueOr(0) >= 0 && - emboss_reserved_local_offset.Known() && - emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> - - (backing_.template GetOffsetStorage<0, 0>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } - } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> - - (); -} - -template -inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField2View::has_low() const { - return ::emboss::support::Maybe(true); -} - -template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 2, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> - -GenericEmbossReservedAnonymousField2View::mid() const { - if (has_mid().ValueOr(false)) { - auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(2LL)); - auto emboss_reserved_local_offset = - ::emboss::support::Maybe( - static_cast(3LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 2, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> - (backing_.template GetOffsetStorage<0, 3>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 2, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField2View::has_mid() const { - return ::emboss::support::Equal( - (low().Ok() ? ::emboss::support::Maybe( - static_cast(low().UncheckedRead())) - : ::emboss::support::Maybe()), - ::emboss::support::Maybe( - static_cast(1LL))); +GenericDisjunctionConditionalDiscriminantView::has_a() const { + return ::emboss::support::And( + ::emboss::support::Or( + ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast( + tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))), + ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast( + tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL)))), + ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL)))); } template inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericEmbossReservedAnonymousField2View::high() const { - if (has_high().ValueOr(false)) { +GenericDisjunctionConditionalDiscriminantView::b() const { + if (has_b().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(7LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> - (backing_.template GetOffsetStorage<0, 7>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField2View::has_high() const { - return ::emboss::support::Maybe(true); -} - -namespace EmbossReservedAnonymousField2 { -inline constexpr ::std::int32_t IntrinsicSizeInBits() { - return ::emboss::support::Maybe( - static_cast(8LL)) - .ValueOrDefault(); +GenericDisjunctionConditionalDiscriminantView::has_b() const { + return ::emboss::support::And( + ::emboss::support::Or( + ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast( + tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(2LL))), + ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast( + tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(3LL)))), + ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL)))); } -} // namespace EmbossReservedAnonymousField2 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { - return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); +inline typename GenericDisjunctionConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericDisjunctionConditionalDiscriminantView::IntrinsicSizeInBytes() + const { + return typename GenericDisjunctionConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t -GenericEmbossReservedAnonymousField2View:: - EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); +inline ::emboss::support::Maybe +GenericDisjunctionConditionalDiscriminantView< + Storage>::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace EmbossReservedAnonymousField2 { -inline constexpr ::std::int32_t MaxSizeInBits() { +namespace DisjunctionConditionalDiscriminant { +inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField2 +} // namespace DisjunctionConditionalDiscriminant template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { - return EmbossReservedAnonymousField2::MaxSizeInBits(); +inline constexpr ::std::int32_t GenericDisjunctionConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return DisjunctionConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField2::MaxSizeInBits(); +inline constexpr ::std::int32_t GenericDisjunctionConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return DisjunctionConditionalDiscriminant::MaxSizeInBytes(); } -namespace EmbossReservedAnonymousField2 { -inline constexpr ::std::int32_t MinSizeInBits() { +namespace DisjunctionConditionalDiscriminant { +inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField2 +} // namespace DisjunctionConditionalDiscriminant template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { - return EmbossReservedAnonymousField2::MinSizeInBits(); +inline constexpr ::std::int32_t GenericDisjunctionConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return DisjunctionConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField2::MinSizeInBits(); +inline constexpr ::std::int32_t GenericDisjunctionConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return DisjunctionConditionalDiscriminant::MinSizeInBytes(); } +namespace SingleEntryConditionalDiscriminant { -} // namespace ConditionalAnonymous +} // namespace SingleEntryConditionalDiscriminant template inline typename ::emboss::prelude::UIntView< @@ -25298,8 +31523,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAnonymousView::x() const { - if (has_x().ValueOr(false)) { +GenericSingleEntryConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25336,21 +31561,21 @@ GenericConditionalAnonymousView::x() const { template inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_x() const { +GenericSingleEntryConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } template -inline typename ::emboss::test::ConditionalAnonymous:: - GenericEmbossReservedAnonymousField2View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> - GenericConditionalAnonymousView< - Storage>::emboss_reserved_anonymous_field_2() const { - if (has_emboss_reserved_anonymous_field_2().ValueOr(false)) { +GenericSingleEntryConditionalDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25361,130 +31586,181 @@ inline typename ::emboss::test::ConditionalAnonymous:: emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::test::ConditionalAnonymous:: - GenericEmbossReservedAnonymousField2View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (backing_.template GetOffsetStorage<0, 1>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::test::ConditionalAnonymous:: - GenericEmbossReservedAnonymousField2View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template -inline ::emboss::support::Maybe GenericConditionalAnonymousView< - Storage>::has_emboss_reserved_anonymous_field_2() const { - return ::emboss::support::GreaterThan( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), +inline ::emboss::support::Maybe +GenericSingleEntryConditionalDiscriminantView::has_tag() const { + return ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), ::emboss::support::Maybe( - static_cast(10LL))); + static_cast(1LL))); } template -inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_low() const { - return ::emboss::support::And( - has_emboss_reserved_anonymous_field_2(), - ::emboss::support::Maybe(true)); -} +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -template -inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_mid() const { - return ::emboss::support::And( - has_emboss_reserved_anonymous_field_2(), - emboss_reserved_anonymous_field_2().has_mid()); +GenericSingleEntryConditionalDiscriminantView::a() const { + if (has_a().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(2LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (backing_.template GetOffsetStorage<0, 2>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> + + (); } template inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_high() const { +GenericSingleEntryConditionalDiscriminantView::has_a() const { return ::emboss::support::And( - has_emboss_reserved_anonymous_field_2(), - ::emboss::support::Maybe(true)); + ::emboss::support::Equal( + (tag().Ok() + ? ::emboss::support::Maybe( + static_cast(tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0LL))), + ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1LL)))); } template -inline typename GenericConditionalAnonymousView< +inline typename GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalAnonymousView::IntrinsicSizeInBytes() const { - return typename GenericConditionalAnonymousView< +GenericSingleEntryConditionalDiscriminantView::IntrinsicSizeInBytes() + const { + return typename GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_IntrinsicSizeInBytes() const { +GenericSingleEntryConditionalDiscriminantView< + Storage>::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionalAnonymous { +namespace SingleEntryConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionalAnonymous +} // namespace SingleEntryConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalAnonymous::MaxSizeInBytes(); + return SingleEntryConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalAnonymous::MaxSizeInBytes(); + return SingleEntryConditionalDiscriminant::MaxSizeInBytes(); } -namespace ConditionalAnonymous { +namespace SingleEntryConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalAnonymous +} // namespace SingleEntryConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalAnonymous::MinSizeInBytes(); + return SingleEntryConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalAnonymous::MinSizeInBytes(); + return SingleEntryConditionalDiscriminant::MinSizeInBytes(); } -namespace ConditionalOnFlag { -namespace EmbossReservedAnonymousField1 { +namespace EnumConditionalDiscriminant { -} // namespace EmbossReservedAnonymousField1 +} // namespace EnumConditionalDiscriminant template -inline typename ::emboss::prelude::FlagView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> +inline typename ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericEmbossReservedAnonymousField1View::enabled() const { - if (has_enabled().ValueOr(false)) { +GenericEnumConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25495,148 +31771,165 @@ GenericEmbossReservedAnonymousField1View::enabled() const { emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::FlagView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + return ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::FlagView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + return ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField1View::has_enabled() const { +GenericEnumConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } -namespace EmbossReservedAnonymousField1 { -inline constexpr ::std::int32_t IntrinsicSizeInBits() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace EmbossReservedAnonymousField1 - -template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { - return EmbossReservedAnonymousField1::IntrinsicSizeInBits(); -} - -template -inline constexpr ::std::int32_t -GenericEmbossReservedAnonymousField1View:: - EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField1::IntrinsicSizeInBits(); -} - -namespace EmbossReservedAnonymousField1 { -inline constexpr ::std::int32_t MaxSizeInBits() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace EmbossReservedAnonymousField1 - template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { - return EmbossReservedAnonymousField1::MaxSizeInBits(); -} +inline typename ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField1::MaxSizeInBits(); -} +GenericEnumConditionalDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { + auto emboss_reserved_local_size = + ::emboss::support::Maybe( + static_cast(1LL)); + auto emboss_reserved_local_offset = + ::emboss::support::Maybe( + static_cast(1LL)); + if (emboss_reserved_local_size.Known() && + emboss_reserved_local_size.ValueOr(0) >= 0 && + emboss_reserved_local_offset.Known() && + emboss_reserved_local_offset.ValueOr(0) >= 0) { + return ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -namespace EmbossReservedAnonymousField1 { -inline constexpr ::std::int32_t MinSizeInBits() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace EmbossReservedAnonymousField1 + (backing_.template GetOffsetStorage<0, 1>( + emboss_reserved_local_offset.ValueOrDefault(), + emboss_reserved_local_size.ValueOrDefault())); + } + } + return ::emboss::support::EnumView< + /**/ ::emboss::test::OnOff, + ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { - return EmbossReservedAnonymousField1::MinSizeInBits(); + (); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField1::MinSizeInBits(); +inline ::emboss::support::Maybe +GenericEnumConditionalDiscriminantView::has_tag() const { + return ::emboss::support::Equal( + (outer().Ok() ? ::emboss::support::Maybe( + static_cast( + outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1))); } -} // namespace ConditionalOnFlag - template -inline typename ::emboss::test::ConditionalOnFlag:: - GenericEmbossReservedAnonymousField1View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline typename ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> - GenericConditionalOnFlagView::emboss_reserved_anonymous_field_1() - const { - if (has_emboss_reserved_anonymous_field_1().ValueOr(false)) { +GenericEnumConditionalDiscriminantView::a() const { + if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(0LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::test::ConditionalOnFlag:: - GenericEmbossReservedAnonymousField1View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> - (backing_.template GetOffsetStorage<0, 0>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::test::ConditionalOnFlag:: - GenericEmbossReservedAnonymousField1View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::prelude::UIntView< + /**/ ::emboss::support::FixedSizeViewParameters< + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } -template -inline ::emboss::support::Maybe GenericConditionalOnFlagView< - Storage>::has_emboss_reserved_anonymous_field_1() const { - return ::emboss::support::Maybe(true); -} - template inline ::emboss::support::Maybe -GenericConditionalOnFlagView::has_enabled() const { +GenericEnumConditionalDiscriminantView::has_a() const { return ::emboss::support::And( - ::emboss::support::Maybe(true), - ::emboss::support::Maybe(true)); + ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast( + tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(0))), + ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast( + outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1)))); } template @@ -25645,17 +31938,17 @@ inline typename ::emboss::prelude::UIntView< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericConditionalOnFlagView::value() const { - if (has_value().ValueOr(false)) { +GenericEnumConditionalDiscriminantView::b() const { + if (has_b().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(1LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -25665,10 +31958,10 @@ GenericConditionalOnFlagView::value() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> - (backing_.template GetOffsetStorage<0, 1>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -25678,7 +31971,7 @@ GenericConditionalOnFlagView::value() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -25686,65 +31979,79 @@ GenericConditionalOnFlagView::value() const { template inline ::emboss::support::Maybe -GenericConditionalOnFlagView::has_value() const { - return (enabled().Ok() - ? ::emboss::support::Maybe( - static_cast(enabled().UncheckedRead())) - : ::emboss::support::Maybe()); +GenericEnumConditionalDiscriminantView::has_b() const { + return ::emboss::support::And( + ::emboss::support::Equal( + (tag().Ok() ? ::emboss::support::Maybe( + static_cast( + tag().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1))), + ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast( + outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1)))); } template -inline typename GenericConditionalOnFlagView< +inline typename GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalOnFlagView::IntrinsicSizeInBytes() const { - return typename GenericConditionalOnFlagView< +GenericEnumConditionalDiscriminantView::IntrinsicSizeInBytes() const { + return typename GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline ::emboss::support::Maybe -GenericConditionalOnFlagView::has_IntrinsicSizeInBytes() const { +inline ::emboss::support::Maybe GenericEnumConditionalDiscriminantView< + Storage>::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionalOnFlag { +namespace EnumConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionalOnFlag +} // namespace EnumConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalOnFlag::MaxSizeInBytes(); + return EnumConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalOnFlag::MaxSizeInBytes(); + return EnumConditionalDiscriminant::MaxSizeInBytes(); } -namespace ConditionalOnFlag { +namespace EnumConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalOnFlag +} // namespace EnumConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalOnFlag::MinSizeInBytes(); + return EnumConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalOnFlag::MinSizeInBytes(); + return EnumConditionalDiscriminant::MinSizeInBytes(); } } // namespace test