From e9fac32b4d3b0d943bba023508e5bc3ba6c78a4f Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Thu, 4 Jun 2026 12:22:13 -0700 Subject: [PATCH 1/3] Guard conditional switch discriminants in optimized Ok() The optimized Ok() switch reads its discriminant once and emits `if (!emboss_reserved_switch_discrim.Known()) return false;` as a safety net. When the discriminant is a conditionally-present field read from a buffer too short to contain it, the discriminant is Unknown and that guard makes Ok() reject a message that is actually valid: the fields gated on the (absent) discriminant simply do not exist. The guard is only sound when the group has a "bare" arm whose existence condition is exactly `discrim == K`. Then an Unknown discriminant leaves that field's has_X() Unknown, so the unoptimized Ok() bails for the same reason. When every arm carries a residual, an out-of-bounds discriminant can coexist with a valid message whose residuals are all statically false (so every has_X() is Known-false / absent). For that case emit a guarded switch: dispatch only when the discriminant is in bounds, otherwise fall back to per-field has_X().Known() checks (an Unknown discriminant can never make has_X() Known-true, so the value check is unnecessary). Provably-present and bare-armed switches are unchanged, so every existing golden is byte-for-byte identical. Adds ResidualConditionalDiscriminant (the bug) and BareConditionalDiscriminant (the sound-guard case) to condition.emb with regression tests that pass under both the optimized and unoptimized Ok() implementations. --- .../back_end/cpp/generated_code_templates | 20 + compiler/back_end/cpp/header_generator.py | 52 +- .../back_end/cpp/testcode/condition_test.cc | 96 + testdata/condition.emb | 34 + testdata/golden_cpp/condition.emb.h | 6720 +++++++++++------ 5 files changed, 4617 insertions(+), 2305 deletions(-) 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..bccde439 100644 --- a/compiler/back_end/cpp/testcode/condition_test.cc +++ b/compiler/back_end/cpp/testcode/condition_test.cc @@ -300,6 +300,102 @@ 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()); +} + 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..cb8b3cd7 100644 --- a/testdata/condition.emb +++ b/testdata/condition.emb @@ -229,3 +229,37 @@ 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: + 3 [+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: + 3 [+1] UInt b diff --git a/testdata/golden_cpp/condition.emb.h b/testdata/golden_cpp/condition.emb.h index 725fe824..92802f31 100644 --- a/testdata/golden_cpp/condition.emb.h +++ b/testdata/golden_cpp/condition.emb.h @@ -215,6 +215,20 @@ class GenericEmbossReservedAnonymousField1View; template class GenericConditionalOnFlagView; +namespace ResidualConditionalDiscriminant { + +} // namespace ResidualConditionalDiscriminant + +template +class GenericResidualConditionalDiscriminantView; + +namespace BareConditionalDiscriminant { + +} // namespace BareConditionalDiscriminant + +template +class GenericBareConditionalDiscriminantView; + namespace BasicConditional {} // namespace BasicConditional template @@ -19445,188 +19459,1935 @@ 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>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + 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; -GenericNegativeConditionalView::x() const { - if (has_x().ValueOr(false)) { - auto emboss_reserved_local_size = - ::emboss::support::Maybe( - static_cast(1LL)); + 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(4LL)), + ::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(4LL)), + ::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 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(0LL)); + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -19636,10 +21397,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 +21410,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,10 +21418,141 @@ GenericNegativeConditionalView::x() const { template inline ::emboss::support::Maybe -GenericNegativeConditionalView::has_x() const { +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< @@ -19670,8 +21562,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericNegativeConditionalView::xc() const { - if (has_xc().ValueOr(false)) { +GenericConditionalBasicConditionalFieldFirstView::x() const { + if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -19708,9 +21600,60 @@ GenericNegativeConditionalView::xc() const { template inline ::emboss::support::Maybe -GenericNegativeConditionalView::has_xc() const { - return ::emboss::support::NotEqual( +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()), @@ -19718,62 +21661,74 @@ GenericNegativeConditionalView::has_xc() const { static_cast(0LL))); } -template -inline typename GenericNegativeConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericNegativeConditionalView::IntrinsicSizeInBytes() const { - return typename GenericNegativeConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +namespace ConditionalBasicConditionalFieldFirst { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); } +} // namespace ConditionalBasicConditionalFieldFirst template -inline ::emboss::support::Maybe -GenericNegativeConditionalView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +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 NegativeConditional { +namespace ConditionalBasicConditionalFieldFirst { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace NegativeConditional +} // namespace ConditionalBasicConditionalFieldFirst template -inline constexpr ::std::int32_t GenericNegativeConditionalView< +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return NegativeConditional::MaxSizeInBytes(); + return ConditionalBasicConditionalFieldFirst::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNegativeConditionalView< +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return NegativeConditional::MaxSizeInBytes(); + return ConditionalBasicConditionalFieldFirst::MaxSizeInBytes(); } -namespace NegativeConditional { +namespace ConditionalBasicConditionalFieldFirst { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace NegativeConditional +} // namespace ConditionalBasicConditionalFieldFirst template -inline constexpr ::std::int32_t GenericNegativeConditionalView< +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return NegativeConditional::MinSizeInBytes(); + return ConditionalBasicConditionalFieldFirst::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNegativeConditionalView< +inline constexpr ::std::int32_t +GenericConditionalBasicConditionalFieldFirstView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return NegativeConditional::MinSizeInBytes(); + return ConditionalBasicConditionalFieldFirst::MinSizeInBytes(); } -namespace ConditionalAndUnconditionalOverlappingFinalField { +namespace ConditionalAndDynamicLocation { -} // namespace ConditionalAndUnconditionalOverlappingFinalField +} // namespace ConditionalAndDynamicLocation template inline typename ::emboss::prelude::UIntView< @@ -19784,8 +21739,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAndUnconditionalOverlappingFinalFieldView::x() - const { +GenericConditionalAndDynamicLocationView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -19823,8 +21777,7 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::x() template inline ::emboss::support::Maybe -GenericConditionalAndUnconditionalOverlappingFinalFieldView::has_x() - const { +GenericConditionalAndDynamicLocationView::has_x() const { return ::emboss::support::Maybe(true); } @@ -19834,18 +21787,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>> -GenericConditionalAndUnconditionalOverlappingFinalFieldView::xc() - const { - if (has_xc().ValueOr(false)) { +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(1LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -19855,10 +21807,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<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -19868,7 +21820,7 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::xc() 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -19876,15 +21828,8 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::xc() 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))); +GenericConditionalAndDynamicLocationView::has_y() const { + return ::emboss::support::Maybe(true); } template @@ -19893,18 +21838,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::z() - const { - if (has_z().ValueOr(false)) { +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::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() && @@ -19914,10 +21864,10 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::z() 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())); } @@ -19927,7 +21877,7 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::z() 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -19935,122 +21885,112 @@ 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(); +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))); } -} // namespace ConditionalAndUnconditionalOverlappingFinalField template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ConditionalAndUnconditionalOverlappingFinalField:: - IntrinsicSizeInBytes(); +inline typename GenericConditionalAndDynamicLocationView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericConditionalAndDynamicLocationView::IntrinsicSizeInBytes() + const { + return typename GenericConditionalAndDynamicLocationView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ConditionalAndUnconditionalOverlappingFinalField:: - IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe GenericConditionalAndDynamicLocationView< + Storage>::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace ConditionalAndUnconditionalOverlappingFinalField { +namespace ConditionalAndDynamicLocation { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(256LL)) .ValueOrDefault(); } -} // namespace ConditionalAndUnconditionalOverlappingFinalField +} // namespace ConditionalAndDynamicLocation template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< +inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalAndUnconditionalOverlappingFinalField::MaxSizeInBytes(); + return ConditionalAndDynamicLocation::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< +inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalAndUnconditionalOverlappingFinalField::MaxSizeInBytes(); + return ConditionalAndDynamicLocation::MaxSizeInBytes(); } -namespace ConditionalAndUnconditionalOverlappingFinalField { +namespace ConditionalAndDynamicLocation { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionalAndUnconditionalOverlappingFinalField +} // namespace ConditionalAndDynamicLocation template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< +inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalAndUnconditionalOverlappingFinalField::MinSizeInBytes(); + return ConditionalAndDynamicLocation::MinSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericConditionalAndUnconditionalOverlappingFinalFieldView< +inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalAndUnconditionalOverlappingFinalField::MinSizeInBytes(); + return ConditionalAndDynamicLocation::MinSizeInBytes(); } -namespace ConditionalBasicConditionalFieldFirst { - -} // namespace ConditionalBasicConditionalFieldFirst +namespace ConditionUsesMinInt {} // namespace ConditionUsesMinInt template -inline typename ::emboss::prelude::UIntView< +inline typename ::emboss::prelude::IntView< /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> -GenericConditionalBasicConditionalFieldFirstView::x() const { +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(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< + return ::emboss::prelude::IntView< /**/ ::emboss::support::FixedSizeViewParameters< 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())); } } - return ::emboss::prelude::UIntView< + return ::emboss::prelude::IntView< /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -20058,7 +21998,7 @@ GenericConditionalBasicConditionalFieldFirstView::x() const { template inline ::emboss::support::Maybe -GenericConditionalBasicConditionalFieldFirstView::has_x() const { +GenericConditionUsesMinIntView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20068,17 +22008,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 { +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(0LL)); + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -20088,10 +22028,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 +22041,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,84 +22049,74 @@ GenericConditionalBasicConditionalFieldFirstView::xc() const { 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(); +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))); } -} // namespace ConditionalBasicConditionalFieldFirst template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ConditionalBasicConditionalFieldFirst::IntrinsicSizeInBytes(); +inline typename GenericConditionUsesMinIntView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericConditionUsesMinIntView::IntrinsicSizeInBytes() const { + return typename GenericConditionUsesMinIntView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ConditionalBasicConditionalFieldFirst::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericConditionUsesMinIntView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace ConditionalBasicConditionalFieldFirst { +namespace ConditionUsesMinInt { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace ConditionalBasicConditionalFieldFirst +} // namespace ConditionUsesMinInt template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionUsesMinIntView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalBasicConditionalFieldFirst::MaxSizeInBytes(); + return ConditionUsesMinInt::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionUsesMinIntView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalBasicConditionalFieldFirst::MaxSizeInBytes(); + return ConditionUsesMinInt::MaxSizeInBytes(); } -namespace ConditionalBasicConditionalFieldFirst { +namespace ConditionUsesMinInt { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalBasicConditionalFieldFirst +} // namespace ConditionUsesMinInt template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionUsesMinIntView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalBasicConditionalFieldFirst::MinSizeInBytes(); + return ConditionUsesMinInt::MinSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericConditionalBasicConditionalFieldFirstView< +inline constexpr ::std::int32_t GenericConditionUsesMinIntView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalBasicConditionalFieldFirst::MinSizeInBytes(); + return ConditionUsesMinInt::MinSizeInBytes(); } -namespace ConditionalAndDynamicLocation { - -} // namespace ConditionalAndDynamicLocation +namespace NestedConditional {} // namespace NestedConditional template inline typename ::emboss::prelude::UIntView< @@ -20197,7 +22127,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAndDynamicLocationView::x() const { +GenericNestedConditionalView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20235,7 +22165,7 @@ GenericConditionalAndDynamicLocationView::x() const { template inline ::emboss::support::Maybe -GenericConditionalAndDynamicLocationView::has_x() const { +GenericNestedConditionalView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20245,17 +22175,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)) { +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(2LL)); + static_cast(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -20265,10 +22195,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 +22208,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 +22216,14 @@ GenericConditionalAndDynamicLocationView::y() const { template inline ::emboss::support::Maybe -GenericConditionalAndDynamicLocationView::has_y() const { - return ::emboss::support::Maybe(true); +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 @@ -20296,23 +22232,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()); - +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_reserved_local_subexpr_2; + 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() && @@ -20322,10 +22252,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, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -20335,7 +22265,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,74 +22273,73 @@ GenericConditionalAndDynamicLocationView::xc() const { template inline ::emboss::support::Maybe -GenericConditionalAndDynamicLocationView::has_xc() const { +GenericNestedConditionalView::has_xcc() const { return ::emboss::support::Equal( - (x().Ok() ? ::emboss::support::Maybe( - static_cast(x().UncheckedRead())) - : ::emboss::support::Maybe()), + (xc().Ok() ? ::emboss::support::Maybe( + static_cast(xc().UncheckedRead())) + : ::emboss::support::Maybe()), ::emboss::support::Maybe( static_cast(0LL))); } template -inline typename GenericConditionalAndDynamicLocationView< +inline typename GenericNestedConditionalView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalAndDynamicLocationView::IntrinsicSizeInBytes() - const { - return typename GenericConditionalAndDynamicLocationView< +GenericNestedConditionalView::IntrinsicSizeInBytes() const { + return typename GenericNestedConditionalView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline ::emboss::support::Maybe GenericConditionalAndDynamicLocationView< - Storage>::has_IntrinsicSizeInBytes() const { +inline ::emboss::support::Maybe +GenericNestedConditionalView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionalAndDynamicLocation { +namespace NestedConditional { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(256LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionalAndDynamicLocation +} // namespace NestedConditional template -inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< +inline constexpr ::std::int32_t GenericNestedConditionalView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalAndDynamicLocation::MaxSizeInBytes(); + return NestedConditional::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< +inline constexpr ::std::int32_t GenericNestedConditionalView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalAndDynamicLocation::MaxSizeInBytes(); + return NestedConditional::MaxSizeInBytes(); } -namespace ConditionalAndDynamicLocation { +namespace NestedConditional { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalAndDynamicLocation +} // namespace NestedConditional template -inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< +inline constexpr ::std::int32_t GenericNestedConditionalView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalAndDynamicLocation::MinSizeInBytes(); + return NestedConditional::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAndDynamicLocationView< +inline constexpr ::std::int32_t GenericNestedConditionalView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalAndDynamicLocation::MinSizeInBytes(); + return NestedConditional::MinSizeInBytes(); } -namespace ConditionUsesMinInt {} // namespace ConditionUsesMinInt +namespace CorrectNestedConditional {} // namespace CorrectNestedConditional template -inline typename ::emboss::prelude::IntView< +inline typename ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< @@ -20418,7 +22347,7 @@ inline typename ::emboss::prelude::IntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionUsesMinIntView::x() const { +GenericCorrectNestedConditionalView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20430,7 +22359,7 @@ 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< + return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< @@ -20443,7 +22372,7 @@ GenericConditionUsesMinIntView::x() const { emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::IntView< + return ::emboss::prelude::UIntView< /**/ ::emboss::support::FixedSizeViewParameters< 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< @@ -20456,7 +22385,7 @@ GenericConditionUsesMinIntView::x() const { template inline ::emboss::support::Maybe -GenericConditionUsesMinIntView::has_x() const { +GenericCorrectNestedConditionalView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20469,7 +22398,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionUsesMinIntView::xc() const { +GenericCorrectNestedConditionalView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20507,74 +22436,136 @@ GenericConditionUsesMinIntView::xc() const { template inline ::emboss::support::Maybe -GenericConditionUsesMinIntView::has_xc() const { - return ::emboss::support::Equal( - ::emboss::support::Difference( +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(9223372036854775680LL))), - ::emboss::support::Maybe( - static_cast(-9223372036854775807LL - 1))); + ::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 GenericConditionUsesMinIntView< +inline typename GenericCorrectNestedConditionalView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionUsesMinIntView::IntrinsicSizeInBytes() const { - return typename GenericConditionUsesMinIntView< +GenericCorrectNestedConditionalView::IntrinsicSizeInBytes() const { + return typename GenericCorrectNestedConditionalView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericConditionUsesMinIntView::has_IntrinsicSizeInBytes() const { +GenericCorrectNestedConditionalView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionUsesMinInt { +namespace CorrectNestedConditional { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ConditionUsesMinInt +} // namespace CorrectNestedConditional template -inline constexpr ::std::int32_t GenericConditionUsesMinIntView< +inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionUsesMinInt::MaxSizeInBytes(); + return CorrectNestedConditional::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionUsesMinIntView< +inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionUsesMinInt::MaxSizeInBytes(); + return CorrectNestedConditional::MaxSizeInBytes(); } -namespace ConditionUsesMinInt { +namespace CorrectNestedConditional { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionUsesMinInt +} // namespace CorrectNestedConditional template -inline constexpr ::std::int32_t GenericConditionUsesMinIntView< +inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionUsesMinInt::MinSizeInBytes(); + return CorrectNestedConditional::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionUsesMinIntView< +inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionUsesMinInt::MinSizeInBytes(); + return CorrectNestedConditional::MinSizeInBytes(); } -namespace NestedConditional {} // namespace NestedConditional +namespace AlwaysFalseCondition {} // namespace AlwaysFalseCondition template inline typename ::emboss::prelude::UIntView< @@ -20585,7 +22576,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericNestedConditionalView::x() const { +GenericAlwaysFalseConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20623,7 +22614,7 @@ GenericNestedConditionalView::x() const { template inline ::emboss::support::Maybe -GenericNestedConditionalView::has_x() const { +GenericAlwaysFalseConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20636,7 +22627,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericNestedConditionalView::xc() const { +GenericAlwaysFalseConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20674,15 +22665,70 @@ GenericNestedConditionalView::xc() const { 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))); +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< @@ -20690,17 +22736,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>> -GenericNestedConditionalView::xcc() const { - if (has_xcc().ValueOr(false)) { +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(2LL)); + static_cast(0LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -20710,10 +22756,10 @@ GenericNestedConditionalView::xcc() 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, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -20723,7 +22769,7 @@ GenericNestedConditionalView::xcc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -20731,70 +22777,133 @@ GenericNestedConditionalView::xcc() const { 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))); +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 GenericNestedConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericNestedConditionalView::IntrinsicSizeInBytes() const { - return typename GenericNestedConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return OnlyAlwaysFalseCondition::IntrinsicSizeInBytes(); } template -inline ::emboss::support::Maybe -GenericNestedConditionalView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return OnlyAlwaysFalseCondition::IntrinsicSizeInBytes(); } -namespace NestedConditional { +namespace OnlyAlwaysFalseCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(0LL)) .ValueOrDefault(); } -} // namespace NestedConditional +} // namespace OnlyAlwaysFalseCondition template -inline constexpr ::std::int32_t GenericNestedConditionalView< +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return NestedConditional::MaxSizeInBytes(); + return OnlyAlwaysFalseCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNestedConditionalView< +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return NestedConditional::MaxSizeInBytes(); + return OnlyAlwaysFalseCondition::MaxSizeInBytes(); } -namespace NestedConditional { +namespace OnlyAlwaysFalseCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(0LL)) .ValueOrDefault(); } -} // namespace NestedConditional +} // namespace OnlyAlwaysFalseCondition template -inline constexpr ::std::int32_t GenericNestedConditionalView< +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return NestedConditional::MinSizeInBytes(); + return OnlyAlwaysFalseCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNestedConditionalView< +inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return NestedConditional::MinSizeInBytes(); + return OnlyAlwaysFalseCondition::MinSizeInBytes(); } -namespace CorrectNestedConditional {} // namespace CorrectNestedConditional +namespace EmptyStruct {} // namespace EmptyStruct + +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< @@ -20805,7 +22914,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericCorrectNestedConditionalView::x() const { +GenericAlwaysFalseConditionDynamicSizeView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -20843,7 +22952,7 @@ GenericCorrectNestedConditionalView::x() const { template inline ::emboss::support::Maybe -GenericCorrectNestedConditionalView::has_x() const { +GenericAlwaysFalseConditionDynamicSizeView::has_x() const { return ::emboss::support::Maybe(true); } @@ -20853,17 +22962,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>> -GenericCorrectNestedConditionalView::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() && @@ -20873,10 +22988,10 @@ GenericCorrectNestedConditionalView::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<1, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -20886,7 +23001,7 @@ GenericCorrectNestedConditionalView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -20894,14 +23009,8 @@ GenericCorrectNestedConditionalView::xc() const { 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))); +GenericAlwaysFalseConditionDynamicSizeView::has_y() const { + return ::emboss::support::Maybe(true); } template @@ -20910,17 +23019,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>> -GenericCorrectNestedConditionalView::xcc() const { - if (has_xcc().ValueOr(false)) { +GenericAlwaysFalseConditionDynamicSizeView::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() && @@ -20930,10 +23039,10 @@ GenericCorrectNestedConditionalView::xcc() 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())); } @@ -20943,7 +23052,7 @@ GenericCorrectNestedConditionalView::xcc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -20951,79 +23060,68 @@ GenericCorrectNestedConditionalView::xcc() const { 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)))); +GenericAlwaysFalseConditionDynamicSizeView::has_xc() const { + return ::emboss::support::Maybe(false); } template -inline typename GenericCorrectNestedConditionalView< +inline typename GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericCorrectNestedConditionalView::IntrinsicSizeInBytes() const { - return typename GenericCorrectNestedConditionalView< +GenericAlwaysFalseConditionDynamicSizeView::IntrinsicSizeInBytes() + const { + return typename GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericCorrectNestedConditionalView::has_IntrinsicSizeInBytes() const { +GenericAlwaysFalseConditionDynamicSizeView::has_IntrinsicSizeInBytes() + const { return ::emboss::support::Maybe(true); } -namespace CorrectNestedConditional { +namespace AlwaysFalseConditionDynamicSize { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(256LL)) .ValueOrDefault(); } -} // namespace CorrectNestedConditional +} // namespace AlwaysFalseConditionDynamicSize template -inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< +inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return CorrectNestedConditional::MaxSizeInBytes(); + return AlwaysFalseConditionDynamicSize::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< +inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return CorrectNestedConditional::MaxSizeInBytes(); + return AlwaysFalseConditionDynamicSize::MaxSizeInBytes(); } -namespace CorrectNestedConditional { +namespace AlwaysFalseConditionDynamicSize { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace CorrectNestedConditional +} // namespace AlwaysFalseConditionDynamicSize template -inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< +inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return CorrectNestedConditional::MinSizeInBytes(); + return AlwaysFalseConditionDynamicSize::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericCorrectNestedConditionalView< +inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return CorrectNestedConditional::MinSizeInBytes(); + return AlwaysFalseConditionDynamicSize::MinSizeInBytes(); } -namespace AlwaysFalseCondition {} // namespace AlwaysFalseCondition +namespace ConditionDoesNotContributeToSize { + +} // namespace ConditionDoesNotContributeToSize template inline typename ::emboss::prelude::UIntView< @@ -21034,7 +23132,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAlwaysFalseConditionView::x() const { +GenericConditionDoesNotContributeToSizeView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21072,7 +23170,7 @@ GenericAlwaysFalseConditionView::x() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionView::has_x() const { +GenericConditionDoesNotContributeToSizeView::has_x() const { return ::emboss::support::Maybe(true); } @@ -21085,7 +23183,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAlwaysFalseConditionView::xc() const { +GenericConditionDoesNotContributeToSizeView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21123,70 +23221,15 @@ 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(); -} -} // 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(); +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))); } -namespace OnlyAlwaysFalseCondition {} // namespace OnlyAlwaysFalseCondition template inline typename ::emboss::prelude::UIntView< @@ -21194,17 +23237,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>> -GenericOnlyAlwaysFalseConditionView::xc() const { - if (has_xc().ValueOr(false)) { +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(0LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -21214,10 +23257,10 @@ GenericOnlyAlwaysFalseConditionView::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, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -21227,7 +23270,7 @@ GenericOnlyAlwaysFalseConditionView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -21235,144 +23278,83 @@ 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(); -} -} // namespace OnlyAlwaysFalseCondition - -template -inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return OnlyAlwaysFalseCondition::MaxSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericOnlyAlwaysFalseConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return OnlyAlwaysFalseCondition::MaxSizeInBytes(); -} - -namespace OnlyAlwaysFalseCondition { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(0LL)) - .ValueOrDefault(); -} -} // namespace OnlyAlwaysFalseCondition - -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(); +GenericConditionDoesNotContributeToSizeView::has_y() const { + return ::emboss::support::Maybe(true); } -namespace EmptyStruct {} // namespace EmptyStruct -namespace EmptyStruct { +namespace ConditionDoesNotContributeToSize { inline constexpr ::std::int32_t IntrinsicSizeInBytes() { return ::emboss::support::Maybe( - static_cast(0LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace EmptyStruct +} // namespace ConditionDoesNotContributeToSize template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return EmptyStruct::IntrinsicSizeInBytes(); + return ConditionDoesNotContributeToSize::IntrinsicSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmptyStructView:: +inline constexpr ::std::int32_t +GenericConditionDoesNotContributeToSizeView:: EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return EmptyStruct::IntrinsicSizeInBytes(); + return ConditionDoesNotContributeToSize::IntrinsicSizeInBytes(); } -namespace EmptyStruct { +namespace ConditionDoesNotContributeToSize { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(0LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace EmptyStruct +} // namespace ConditionDoesNotContributeToSize template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return EmptyStruct::MaxSizeInBytes(); + return ConditionDoesNotContributeToSize::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return EmptyStruct::MaxSizeInBytes(); + return ConditionDoesNotContributeToSize::MaxSizeInBytes(); } -namespace EmptyStruct { +namespace ConditionDoesNotContributeToSize { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(0LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace EmptyStruct +} // namespace ConditionDoesNotContributeToSize template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return EmptyStruct::MinSizeInBytes(); + return ConditionDoesNotContributeToSize::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmptyStructView< +inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return EmptyStruct::MinSizeInBytes(); + return ConditionDoesNotContributeToSize::MinSizeInBytes(); } -namespace AlwaysFalseConditionDynamicSize { - -} // namespace AlwaysFalseConditionDynamicSize +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>> -GenericAlwaysFalseConditionDynamicSizeView::x() const { +GenericEnumConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21384,8 +23366,9 @@ GenericAlwaysFalseConditionDynamicSizeView::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< @@ -21397,8 +23380,9 @@ GenericAlwaysFalseConditionDynamicSizeView::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< @@ -21409,8 +23393,8 @@ GenericAlwaysFalseConditionDynamicSizeView::x() const { } template -inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_x() const { +inline ::emboss::support::Maybe GenericEnumConditionView::has_x() + const { return ::emboss::support::Maybe(true); } @@ -21420,23 +23404,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 { - 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()); - +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_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 +23424,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 +23437,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,8 +23445,15 @@ GenericAlwaysFalseConditionDynamicSizeView::y() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::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 @@ -21480,8 +23465,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAlwaysFalseConditionDynamicSizeView::xc() const { - if (has_xc().ValueOr(false)) { +GenericEnumConditionView::xc2() const { + if (has_xc2().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -21518,79 +23503,84 @@ GenericAlwaysFalseConditionDynamicSizeView::xc() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_xc() const { - return ::emboss::support::Maybe(false); +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 GenericAlwaysFalseConditionDynamicSizeView< +inline typename GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericAlwaysFalseConditionDynamicSizeView::IntrinsicSizeInBytes() - const { - return typename GenericAlwaysFalseConditionDynamicSizeView< +GenericEnumConditionView::IntrinsicSizeInBytes() const { + return typename GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_IntrinsicSizeInBytes() - const { +GenericEnumConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace AlwaysFalseConditionDynamicSize { +namespace EnumCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(256LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace AlwaysFalseConditionDynamicSize +} // namespace EnumCondition template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< +inline constexpr ::std::int32_t GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return AlwaysFalseConditionDynamicSize::MaxSizeInBytes(); + return EnumCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< +inline constexpr ::std::int32_t GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return AlwaysFalseConditionDynamicSize::MaxSizeInBytes(); + return EnumCondition::MaxSizeInBytes(); } -namespace AlwaysFalseConditionDynamicSize { +namespace EnumCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace AlwaysFalseConditionDynamicSize +} // namespace EnumCondition template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< +inline constexpr ::std::int32_t GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return AlwaysFalseConditionDynamicSize::MinSizeInBytes(); + return EnumCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAlwaysFalseConditionDynamicSizeView< +inline constexpr ::std::int32_t GenericEnumConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return AlwaysFalseConditionDynamicSize::MinSizeInBytes(); + return EnumCondition::MinSizeInBytes(); } -namespace ConditionDoesNotContributeToSize { - -} // namespace ConditionDoesNotContributeToSize +namespace NegativeEnumCondition {} // namespace NegativeEnumCondition 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>> -GenericConditionDoesNotContributeToSizeView::x() const { +GenericNegativeEnumConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21602,8 +23592,9 @@ GenericConditionDoesNotContributeToSizeView::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< @@ -21615,12 +23606,64 @@ GenericConditionDoesNotContributeToSizeView::x() const { 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 ::emboss::support::Maybe +GenericNegativeEnumConditionView::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>> + +GenericNegativeEnumConditionView::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>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -21628,27 +23671,90 @@ GenericConditionDoesNotContributeToSizeView::x() const { template inline ::emboss::support::Maybe -GenericConditionDoesNotContributeToSizeView::has_x() const { +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 GenericNegativeEnumConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericNegativeEnumConditionView::IntrinsicSizeInBytes() const { + return typename GenericNegativeEnumConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe +GenericNegativeEnumConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } +namespace NegativeEnumCondition { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // namespace NegativeEnumCondition + +template +inline constexpr ::std::int32_t GenericNegativeEnumConditionView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return NegativeEnumCondition::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericNegativeEnumConditionView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return NegativeEnumCondition::MaxSizeInBytes(); +} + +namespace NegativeEnumCondition { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace NegativeEnumCondition + +template +inline constexpr ::std::int32_t GenericNegativeEnumConditionView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return NegativeEnumCondition::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericNegativeEnumConditionView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return NegativeEnumCondition::MinSizeInBytes(); +} +namespace LessThanCondition {} // namespace LessThanCondition + 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>> -GenericConditionDoesNotContributeToSizeView::xc() const { - if (has_xc().ValueOr(false)) { +GenericLessThanConditionView::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() && @@ -21658,10 +23764,10 @@ GenericConditionDoesNotContributeToSizeView::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())); } @@ -21671,7 +23777,7 @@ GenericConditionDoesNotContributeToSizeView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -21679,14 +23785,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))); +GenericLessThanConditionView::has_x() const { + return ::emboss::support::Maybe(true); } template @@ -21695,17 +23795,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>> -GenericConditionDoesNotContributeToSizeView::y() const { - if (has_y().ValueOr(false)) { +GenericLessThanConditionView::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() && @@ -21715,10 +23815,10 @@ GenericConditionDoesNotContributeToSizeView::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())); } @@ -21728,7 +23828,7 @@ GenericConditionDoesNotContributeToSizeView::y() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -21736,83 +23836,81 @@ 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(); +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))); } -} // namespace ConditionDoesNotContributeToSize template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ConditionDoesNotContributeToSize::IntrinsicSizeInBytes(); +inline typename GenericLessThanConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericLessThanConditionView::IntrinsicSizeInBytes() const { + return typename GenericLessThanConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t -GenericConditionDoesNotContributeToSizeView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ConditionDoesNotContributeToSize::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericLessThanConditionView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace ConditionDoesNotContributeToSize { +namespace LessThanCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace ConditionDoesNotContributeToSize +} // namespace LessThanCondition template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< +inline constexpr ::std::int32_t GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionDoesNotContributeToSize::MaxSizeInBytes(); + return LessThanCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< +inline constexpr ::std::int32_t GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionDoesNotContributeToSize::MaxSizeInBytes(); + return LessThanCondition::MaxSizeInBytes(); } -namespace ConditionDoesNotContributeToSize { +namespace LessThanCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionDoesNotContributeToSize +} // namespace LessThanCondition template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< +inline constexpr ::std::int32_t GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionDoesNotContributeToSize::MinSizeInBytes(); + return LessThanCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionDoesNotContributeToSizeView< +inline constexpr ::std::int32_t GenericLessThanConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionDoesNotContributeToSize::MinSizeInBytes(); + return LessThanCondition::MinSizeInBytes(); } -namespace EnumCondition {} // namespace EnumCondition +namespace LessThanOrEqualCondition {} // namespace LessThanOrEqualCondition 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 { +GenericLessThanOrEqualConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -21820,59 +23918,6 @@ GenericEnumConditionView::x() const { 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::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::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 GenericEnumConditionView::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>> - -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(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -21882,10 +23927,10 @@ GenericEnumConditionView::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())); } @@ -21895,7 +23940,7 @@ GenericEnumConditionView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -21903,15 +23948,8 @@ 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))); +GenericLessThanOrEqualConditionView::has_x() const { + return ::emboss::support::Maybe(true); } template @@ -21923,8 +23961,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericEnumConditionView::xc2() const { - if (has_xc2().ValueOr(false)) { +GenericLessThanOrEqualConditionView::xc() const { + if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -21961,84 +23999,83 @@ GenericEnumConditionView::xc2() const { 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))); +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(5LL))); } template -inline typename GenericEnumConditionView< +inline typename GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericEnumConditionView::IntrinsicSizeInBytes() const { - return typename GenericEnumConditionView< +GenericLessThanOrEqualConditionView::IntrinsicSizeInBytes() const { + return typename GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericEnumConditionView::has_IntrinsicSizeInBytes() const { +GenericLessThanOrEqualConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace EnumCondition { +namespace LessThanOrEqualCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace EnumCondition +} // namespace LessThanOrEqualCondition template -inline constexpr ::std::int32_t GenericEnumConditionView< +inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return EnumCondition::MaxSizeInBytes(); + return LessThanOrEqualCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEnumConditionView< +inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return EnumCondition::MaxSizeInBytes(); + return LessThanOrEqualCondition::MaxSizeInBytes(); } -namespace EnumCondition { +namespace LessThanOrEqualCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace EnumCondition +} // namespace LessThanOrEqualCondition template -inline constexpr ::std::int32_t GenericEnumConditionView< +inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return EnumCondition::MinSizeInBytes(); + return LessThanOrEqualCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEnumConditionView< +inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return EnumCondition::MinSizeInBytes(); + return LessThanOrEqualCondition::MinSizeInBytes(); } -namespace NegativeEnumCondition {} // namespace NegativeEnumCondition +namespace GreaterThanOrEqualCondition { + +} // namespace GreaterThanOrEqualCondition 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 { +GenericGreaterThanOrEqualConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22050,9 +24087,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< @@ -22062,11 +24098,10 @@ GenericNegativeEnumConditionView::x() const { (backing_.template GetOffsetStorage<0, 0>( emboss_reserved_local_offset.ValueOrDefault(), 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< @@ -22078,7 +24113,7 @@ GenericNegativeEnumConditionView::x() const { template inline ::emboss::support::Maybe -GenericNegativeEnumConditionView::has_x() const { +GenericGreaterThanOrEqualConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -22091,7 +24126,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericNegativeEnumConditionView::xc() const { +GenericGreaterThanOrEqualConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22129,72 +24164,70 @@ 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))); +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))); } template -inline typename GenericNegativeEnumConditionView< +inline typename GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericNegativeEnumConditionView::IntrinsicSizeInBytes() const { - return typename GenericNegativeEnumConditionView< +GenericGreaterThanOrEqualConditionView::IntrinsicSizeInBytes() const { + return typename GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline ::emboss::support::Maybe -GenericNegativeEnumConditionView::has_IntrinsicSizeInBytes() const { +inline ::emboss::support::Maybe GenericGreaterThanOrEqualConditionView< + Storage>::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace NegativeEnumCondition { +namespace GreaterThanOrEqualCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace NegativeEnumCondition +} // namespace GreaterThanOrEqualCondition template -inline constexpr ::std::int32_t GenericNegativeEnumConditionView< +inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return NegativeEnumCondition::MaxSizeInBytes(); + return GreaterThanOrEqualCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNegativeEnumConditionView< +inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return NegativeEnumCondition::MaxSizeInBytes(); + return GreaterThanOrEqualCondition::MaxSizeInBytes(); } -namespace NegativeEnumCondition { +namespace GreaterThanOrEqualCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace NegativeEnumCondition +} // namespace GreaterThanOrEqualCondition template -inline constexpr ::std::int32_t GenericNegativeEnumConditionView< +inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return NegativeEnumCondition::MinSizeInBytes(); + return GreaterThanOrEqualCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericNegativeEnumConditionView< +inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return NegativeEnumCondition::MinSizeInBytes(); + return GreaterThanOrEqualCondition::MinSizeInBytes(); } -namespace LessThanCondition {} // namespace LessThanCondition +namespace GreaterThanCondition {} // namespace GreaterThanCondition template inline typename ::emboss::prelude::UIntView< @@ -22205,7 +24238,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericLessThanConditionView::x() const { +GenericGreaterThanConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22243,7 +24276,7 @@ GenericLessThanConditionView::x() const { template inline ::emboss::support::Maybe -GenericLessThanConditionView::has_x() const { +GenericGreaterThanConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -22256,7 +24289,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericLessThanConditionView::xc() const { +GenericGreaterThanConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22294,9 +24327,9 @@ GenericLessThanConditionView::xc() const { template inline ::emboss::support::Maybe -GenericLessThanConditionView::has_xc() const { - return ::emboss::support::LessThan( +GenericGreaterThanConditionView::has_xc() const { + return ::emboss::support::GreaterThan( (x().Ok() ? ::emboss::support::Maybe( static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), @@ -22305,59 +24338,59 @@ GenericLessThanConditionView::has_xc() const { } template -inline typename GenericLessThanConditionView< +inline typename GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericLessThanConditionView::IntrinsicSizeInBytes() const { - return typename GenericLessThanConditionView< +GenericGreaterThanConditionView::IntrinsicSizeInBytes() const { + return typename GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericLessThanConditionView::has_IntrinsicSizeInBytes() const { +GenericGreaterThanConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace LessThanCondition { +namespace GreaterThanCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace LessThanCondition +} // namespace GreaterThanCondition template -inline constexpr ::std::int32_t GenericLessThanConditionView< +inline constexpr ::std::int32_t GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return LessThanCondition::MaxSizeInBytes(); + return GreaterThanCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericLessThanConditionView< +inline constexpr ::std::int32_t GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return LessThanCondition::MaxSizeInBytes(); + return GreaterThanCondition::MaxSizeInBytes(); } -namespace LessThanCondition { +namespace GreaterThanCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace LessThanCondition +} // namespace GreaterThanCondition template -inline constexpr ::std::int32_t GenericLessThanConditionView< +inline constexpr ::std::int32_t GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return LessThanCondition::MinSizeInBytes(); + return GreaterThanCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericLessThanConditionView< +inline constexpr ::std::int32_t GenericGreaterThanConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return LessThanCondition::MinSizeInBytes(); + return GreaterThanCondition::MinSizeInBytes(); } -namespace LessThanOrEqualCondition {} // namespace LessThanOrEqualCondition +namespace RangeCondition {} // namespace RangeCondition template inline typename ::emboss::prelude::UIntView< @@ -22368,7 +24401,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericLessThanOrEqualConditionView::x() const { +GenericRangeConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22406,7 +24439,7 @@ GenericLessThanOrEqualConditionView::x() const { template inline ::emboss::support::Maybe -GenericLessThanOrEqualConditionView::has_x() const { +GenericRangeConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -22419,8 +24452,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericLessThanOrEqualConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericRangeConditionView::y() const { + if (has_y().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -22457,90 +24490,27 @@ 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()), - ::emboss::support::Maybe( - static_cast(5LL))); -} - -template -inline typename GenericLessThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericLessThanOrEqualConditionView::IntrinsicSizeInBytes() const { - return typename GenericLessThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); -} - -template -inline ::emboss::support::Maybe -GenericLessThanOrEqualConditionView::has_IntrinsicSizeInBytes() const { +GenericRangeConditionView::has_y() const { return ::emboss::support::Maybe(true); } -namespace LessThanOrEqualCondition { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(2LL)) - .ValueOrDefault(); -} -} // namespace LessThanOrEqualCondition - -template -inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return LessThanOrEqualCondition::MaxSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return LessThanOrEqualCondition::MaxSizeInBytes(); -} - -namespace LessThanOrEqualCondition { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace LessThanOrEqualCondition - -template -inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return LessThanOrEqualCondition::MinSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericLessThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return LessThanOrEqualCondition::MinSizeInBytes(); -} -namespace GreaterThanOrEqualCondition { - -} // namespace GreaterThanOrEqualCondition - 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>> -GenericGreaterThanOrEqualConditionView::x() const { - if (has_x().ValueOr(false)) { +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(0LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -22550,10 +24520,10 @@ GenericGreaterThanOrEqualConditionView::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())); } @@ -22563,17 +24533,98 @@ GenericGreaterThanOrEqualConditionView::x() 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 +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 GenericRangeConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericRangeConditionView::IntrinsicSizeInBytes() const { + return typename GenericRangeConditionView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe +GenericRangeConditionView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace RangeCondition { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(3LL)) + .ValueOrDefault(); +} +} // namespace RangeCondition + +template +inline constexpr ::std::int32_t GenericRangeConditionView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return RangeCondition::MaxSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericRangeConditionView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return RangeCondition::MaxSizeInBytes(); +} + +namespace RangeCondition { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); } +} // namespace RangeCondition template -inline ::emboss::support::Maybe -GenericGreaterThanOrEqualConditionView::has_x() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericRangeConditionView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return RangeCondition::MinSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericRangeConditionView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return RangeCondition::MinSizeInBytes(); } +namespace ReverseRangeCondition {} // namespace ReverseRangeCondition template inline typename ::emboss::prelude::UIntView< @@ -22581,17 +24632,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>> -GenericGreaterThanOrEqualConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericReverseRangeConditionView::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() && @@ -22601,10 +24652,10 @@ GenericGreaterThanOrEqualConditionView::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())); } @@ -22614,7 +24665,7 @@ GenericGreaterThanOrEqualConditionView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -22622,88 +24673,27 @@ GenericGreaterThanOrEqualConditionView::xc() const { 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))); -} - -template -inline typename GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericGreaterThanOrEqualConditionView::IntrinsicSizeInBytes() const { - return typename GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); -} - -template -inline ::emboss::support::Maybe GenericGreaterThanOrEqualConditionView< - Storage>::has_IntrinsicSizeInBytes() const { +GenericReverseRangeConditionView::has_x() const { return ::emboss::support::Maybe(true); } -namespace GreaterThanOrEqualCondition { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(2LL)) - .ValueOrDefault(); -} -} // namespace GreaterThanOrEqualCondition - -template -inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return GreaterThanOrEqualCondition::MaxSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return GreaterThanOrEqualCondition::MaxSizeInBytes(); -} - -namespace GreaterThanOrEqualCondition { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace GreaterThanOrEqualCondition - -template -inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return GreaterThanOrEqualCondition::MinSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericGreaterThanOrEqualConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return GreaterThanOrEqualCondition::MinSizeInBytes(); -} -namespace GreaterThanCondition {} // namespace GreaterThanCondition - 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>> -GenericGreaterThanConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericReverseRangeConditionView::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(1LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -22713,10 +24703,10 @@ GenericGreaterThanConditionView::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())); } @@ -22726,7 +24716,7 @@ GenericGreaterThanConditionView::x() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -22734,7 +24724,7 @@ GenericGreaterThanConditionView::x() const { template inline ::emboss::support::Maybe -GenericGreaterThanConditionView::has_x() const { +GenericReverseRangeConditionView::has_y() const { return ::emboss::support::Maybe(true); } @@ -22744,17 +24734,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>> -GenericGreaterThanConditionView::xc() const { +GenericReverseRangeConditionView::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() && @@ -22764,10 +24754,10 @@ GenericGreaterThanConditionView::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())); } @@ -22777,7 +24767,7 @@ GenericGreaterThanConditionView::xc() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -22785,70 +24775,90 @@ GenericGreaterThanConditionView::xc() const { 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))); +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)))); } template -inline typename GenericGreaterThanConditionView< +inline typename GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericGreaterThanConditionView::IntrinsicSizeInBytes() const { - return typename GenericGreaterThanConditionView< +GenericReverseRangeConditionView::IntrinsicSizeInBytes() const { + return typename GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericGreaterThanConditionView::has_IntrinsicSizeInBytes() const { +GenericReverseRangeConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace GreaterThanCondition { +namespace ReverseRangeCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace GreaterThanCondition +} // namespace ReverseRangeCondition template -inline constexpr ::std::int32_t GenericGreaterThanConditionView< +inline constexpr ::std::int32_t GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return GreaterThanCondition::MaxSizeInBytes(); + return ReverseRangeCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericGreaterThanConditionView< +inline constexpr ::std::int32_t GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return GreaterThanCondition::MaxSizeInBytes(); + return ReverseRangeCondition::MaxSizeInBytes(); } -namespace GreaterThanCondition { +namespace ReverseRangeCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace GreaterThanCondition +} // namespace ReverseRangeCondition template -inline constexpr ::std::int32_t GenericGreaterThanConditionView< +inline constexpr ::std::int32_t GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return GreaterThanCondition::MinSizeInBytes(); + return ReverseRangeCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericGreaterThanConditionView< +inline constexpr ::std::int32_t GenericReverseRangeConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return GreaterThanCondition::MinSizeInBytes(); + return ReverseRangeCondition::MinSizeInBytes(); } -namespace RangeCondition {} // namespace RangeCondition +namespace AndCondition {} // namespace AndCondition template inline typename ::emboss::prelude::UIntView< @@ -22859,7 +24869,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericRangeConditionView::x() const { +GenericAndConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22896,8 +24906,8 @@ GenericRangeConditionView::x() const { } template -inline ::emboss::support::Maybe -GenericRangeConditionView::has_x() const { +inline ::emboss::support::Maybe GenericAndConditionView::has_x() + const { return ::emboss::support::Maybe(true); } @@ -22910,7 +24920,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericRangeConditionView::y() const { +GenericAndConditionView::y() const { if (has_y().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22947,8 +24957,8 @@ GenericRangeConditionView::y() const { } template -inline ::emboss::support::Maybe -GenericRangeConditionView::has_y() const { +inline ::emboss::support::Maybe GenericAndConditionView::has_y() + const { return ::emboss::support::Maybe(true); } @@ -22961,7 +24971,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericRangeConditionView::xc() const { +GenericAndConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -22998,91 +25008,79 @@ GenericRangeConditionView::xc() const { } template -inline ::emboss::support::Maybe -GenericRangeConditionView::has_xc() const { +inline ::emboss::support::Maybe GenericAndConditionView::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( + ::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(10LL)))); + static_cast(5LL)))); } template -inline typename GenericRangeConditionView< +inline typename GenericAndConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericRangeConditionView::IntrinsicSizeInBytes() const { - return typename GenericRangeConditionView< +GenericAndConditionView::IntrinsicSizeInBytes() const { + return typename GenericAndConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericRangeConditionView::has_IntrinsicSizeInBytes() const { +GenericAndConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace RangeCondition { +namespace AndCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(3LL)) .ValueOrDefault(); } -} // namespace RangeCondition +} // namespace AndCondition template -inline constexpr ::std::int32_t GenericRangeConditionView< +inline constexpr ::std::int32_t GenericAndConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return RangeCondition::MaxSizeInBytes(); + return AndCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericRangeConditionView< +inline constexpr ::std::int32_t GenericAndConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return RangeCondition::MaxSizeInBytes(); + return AndCondition::MaxSizeInBytes(); } -namespace RangeCondition { +namespace AndCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace RangeCondition +} // namespace AndCondition template -inline constexpr ::std::int32_t GenericRangeConditionView< +inline constexpr ::std::int32_t GenericAndConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return RangeCondition::MinSizeInBytes(); + return AndCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericRangeConditionView< +inline constexpr ::std::int32_t GenericAndConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return RangeCondition::MinSizeInBytes(); + return AndCondition::MinSizeInBytes(); } -namespace ReverseRangeCondition {} // namespace ReverseRangeCondition +namespace OrCondition {} // namespace OrCondition template inline typename ::emboss::prelude::UIntView< @@ -23093,7 +25091,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericReverseRangeConditionView::x() const { +GenericOrConditionView::x() const { if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -23130,8 +25128,8 @@ GenericReverseRangeConditionView::x() const { } template -inline ::emboss::support::Maybe -GenericReverseRangeConditionView::has_x() const { +inline ::emboss::support::Maybe GenericOrConditionView::has_x() + const { return ::emboss::support::Maybe(true); } @@ -23144,7 +25142,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericReverseRangeConditionView::y() const { +GenericOrConditionView::y() const { if (has_y().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -23181,8 +25179,8 @@ GenericReverseRangeConditionView::y() const { } template -inline ::emboss::support::Maybe -GenericReverseRangeConditionView::has_y() const { +inline ::emboss::support::Maybe GenericOrConditionView::has_y() + const { return ::emboss::support::Maybe(true); } @@ -23195,7 +25193,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericReverseRangeConditionView::xc() const { +GenericOrConditionView::xc() const { if (has_xc().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -23232,103 +25230,92 @@ 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( +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 GenericReverseRangeConditionView< +inline typename GenericOrConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericReverseRangeConditionView::IntrinsicSizeInBytes() const { - return typename GenericReverseRangeConditionView< +GenericOrConditionView::IntrinsicSizeInBytes() const { + return typename GenericOrConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericReverseRangeConditionView::has_IntrinsicSizeInBytes() const { +GenericOrConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ReverseRangeCondition { +namespace OrCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(3LL)) .ValueOrDefault(); } -} // namespace ReverseRangeCondition +} // namespace OrCondition template -inline constexpr ::std::int32_t GenericReverseRangeConditionView< +inline constexpr ::std::int32_t GenericOrConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ReverseRangeCondition::MaxSizeInBytes(); + return OrCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericReverseRangeConditionView< +inline constexpr ::std::int32_t GenericOrConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ReverseRangeCondition::MaxSizeInBytes(); + return OrCondition::MaxSizeInBytes(); } -namespace ReverseRangeCondition { +namespace OrCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace ReverseRangeCondition +} // namespace OrCondition template -inline constexpr ::std::int32_t GenericReverseRangeConditionView< +inline constexpr ::std::int32_t GenericOrConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ReverseRangeCondition::MinSizeInBytes(); + return OrCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericReverseRangeConditionView< +inline constexpr ::std::int32_t GenericOrConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ReverseRangeCondition::MinSizeInBytes(); + return OrCondition::MinSizeInBytes(); } -namespace AndCondition {} // namespace AndCondition +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>> -GenericAndConditionView::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)); @@ -23339,8 +25326,9 @@ GenericAndConditionView::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< @@ -23352,8 +25340,9 @@ GenericAndConditionView::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< @@ -23364,8 +25353,8 @@ GenericAndConditionView::x() const { } template -inline ::emboss::support::Maybe GenericAndConditionView::has_x() - const { +inline ::emboss::support::Maybe +GenericChoiceConditionView::has_field() const { return ::emboss::support::Maybe(true); } @@ -23378,8 +25367,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAndConditionView::y() const { - if (has_y().ValueOr(false)) { +GenericChoiceConditionView::x() const { + if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23415,8 +25404,8 @@ GenericAndConditionView::y() const { } template -inline ::emboss::support::Maybe GenericAndConditionView::has_y() - const { +inline ::emboss::support::Maybe +GenericChoiceConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -23429,8 +25418,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericAndConditionView::xc() const { - if (has_xc().ValueOr(false)) { +GenericChoiceConditionView::y() const { + if (has_y().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23466,314 +25455,423 @@ GenericAndConditionView::xc() const { } template -inline ::emboss::support::Maybe GenericAndConditionView::has_xc() - const { - return ::emboss::support::And( - ::emboss::support::Equal( +inline ::emboss::support::Maybe +GenericChoiceConditionView::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>> + +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(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>> + + (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>> + + (); +} + +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()), - ::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)))); + : ::emboss::support::Maybe())), + ::emboss::support::Maybe( + static_cast(5LL))); } template -inline typename GenericAndConditionView< +inline typename GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericAndConditionView::IntrinsicSizeInBytes() const { - return typename GenericAndConditionView< +GenericChoiceConditionView::IntrinsicSizeInBytes() const { + return typename GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericAndConditionView::has_IntrinsicSizeInBytes() const { +GenericChoiceConditionView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace AndCondition { +namespace ChoiceCondition { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace AndCondition +} // namespace ChoiceCondition template -inline constexpr ::std::int32_t GenericAndConditionView< +inline constexpr ::std::int32_t GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return AndCondition::MaxSizeInBytes(); + return ChoiceCondition::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAndConditionView< +inline constexpr ::std::int32_t GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return AndCondition::MaxSizeInBytes(); + return ChoiceCondition::MaxSizeInBytes(); } -namespace AndCondition { +namespace ChoiceCondition { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace AndCondition +} // namespace ChoiceCondition template -inline constexpr ::std::int32_t GenericAndConditionView< +inline constexpr ::std::int32_t GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return AndCondition::MinSizeInBytes(); + return ChoiceCondition::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericAndConditionView< +inline constexpr ::std::int32_t GenericChoiceConditionView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return AndCondition::MinSizeInBytes(); + return ChoiceCondition::MinSizeInBytes(); } -namespace OrCondition {} // namespace OrCondition +namespace ContainsBits { +namespace EmbossReservedAnonymousField3 { + +} // 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> -GenericOrConditionView::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 GenericOrConditionView::has_x() - const { +inline ::emboss::support::Maybe +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> -GenericOrConditionView::y() const { - if (has_y().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 GenericOrConditionView::has_y() - const { +inline ::emboss::support::Maybe +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 ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 8, ::emboss::support::AllValuesAreOk>, - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { + return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); +} -GenericOrConditionView::xc() const { - if (has_xc().ValueOr(false)) { +template +inline constexpr ::std::int32_t +GenericEmbossReservedAnonymousField3View:: + EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); +} + +namespace EmbossReservedAnonymousField3 { +inline constexpr ::std::int32_t MaxSizeInBits() { + return ::emboss::support::Maybe( + static_cast(8LL)) + .ValueOrDefault(); +} +} // namespace EmbossReservedAnonymousField3 + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { + return EmbossReservedAnonymousField3::MaxSizeInBits(); +} + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField3::MaxSizeInBits(); +} + +namespace EmbossReservedAnonymousField3 { +inline constexpr ::std::int32_t MinSizeInBits() { + return ::emboss::support::Maybe( + static_cast(8LL)) + .ValueOrDefault(); +} +} // namespace EmbossReservedAnonymousField3 + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { + return EmbossReservedAnonymousField3::MinSizeInBits(); +} + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField3::MinSizeInBits(); +} + +} // namespace ContainsBits + +template +inline typename ::emboss::test::ContainsBits:: + GenericEmbossReservedAnonymousField3View< + 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)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(2LL)); + 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>> + return ::emboss::test::ContainsBits:: + GenericEmbossReservedAnonymousField3View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> - (backing_.template GetOffsetStorage<0, 2>( + (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>, + typename Storage::template OffsetStorageType>, 8>> (); } 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 GenericContainsBitsView< + Storage>::has_emboss_reserved_anonymous_field_3() const { + return ::emboss::support::Maybe(true); } template -inline typename GenericOrConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericOrConditionView::IntrinsicSizeInBytes() const { - return typename GenericOrConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +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 -GenericOrConditionView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +GenericContainsBitsView::has_has_bottom() const { + return ::emboss::support::And( + ::emboss::support::Maybe(true), + ::emboss::support::Maybe(true)); } -namespace OrCondition { +namespace ContainsBits { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace ContainsBits + +template +inline constexpr ::std::int32_t GenericContainsBitsView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return ContainsBits::IntrinsicSizeInBytes(); +} + +template +inline constexpr ::std::int32_t GenericContainsBitsView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return ContainsBits::IntrinsicSizeInBytes(); +} + +namespace ContainsBits { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace OrCondition +} // namespace ContainsBits template -inline constexpr ::std::int32_t GenericOrConditionView< +inline constexpr ::std::int32_t GenericContainsBitsView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return OrCondition::MaxSizeInBytes(); + return ContainsBits::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericOrConditionView< +inline constexpr ::std::int32_t GenericContainsBitsView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return OrCondition::MaxSizeInBytes(); + return ContainsBits::MaxSizeInBytes(); } -namespace OrCondition { +namespace ContainsBits { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace OrCondition +} // namespace ContainsBits template -inline constexpr ::std::int32_t GenericOrConditionView< +inline constexpr ::std::int32_t GenericContainsBitsView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return OrCondition::MinSizeInBytes(); + return ContainsBits::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericOrConditionView< +inline constexpr ::std::int32_t GenericContainsBitsView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return OrCondition::MinSizeInBytes(); + return ContainsBits::MinSizeInBytes(); } -namespace ChoiceCondition {} // namespace ChoiceCondition +namespace ContainsContainsBits {} // namespace ContainsContainsBits 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::test::GenericContainsBitsView< + typename Storage::template OffsetStorageType> -GenericChoiceConditionView::field() const { - if (has_field().ValueOr(false)) { +GenericContainsContainsBitsView::condition() const { + if (has_condition().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23784,35 +25882,23 @@ 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::test::GenericContainsBitsView< + 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::test::GenericContainsBitsView< + typename Storage::template OffsetStorageType> (); } template inline ::emboss::support::Maybe -GenericChoiceConditionView::has_field() const { +GenericContainsContainsBitsView::has_condition() const { return ::emboss::support::Maybe(true); } @@ -23825,8 +25911,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericChoiceConditionView::x() const { - if (has_x().ValueOr(false)) { +GenericContainsContainsBitsView::top() const { + if (has_top().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -23863,60 +25949,73 @@ GenericChoiceConditionView::x() const { template inline ::emboss::support::Maybe -GenericChoiceConditionView::has_x() const { +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))); +} + +template +inline typename GenericContainsContainsBitsView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericContainsContainsBitsView::IntrinsicSizeInBytes() const { + return typename GenericContainsContainsBitsView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +} + +template +inline ::emboss::support::Maybe +GenericContainsContainsBitsView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } +namespace ContainsContainsBits { +inline constexpr ::std::int32_t MaxSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(2LL)) + .ValueOrDefault(); +} +} // 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 constexpr ::std::int32_t GenericContainsContainsBitsView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return ContainsContainsBits::MaxSizeInBytes(); +} -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(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>> +template +inline constexpr ::std::int32_t GenericContainsContainsBitsView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return ContainsContainsBits::MaxSizeInBytes(); +} - (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 ContainsContainsBits { +inline constexpr ::std::int32_t MinSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace ContainsContainsBits - (); +template +inline constexpr ::std::int32_t GenericContainsContainsBitsView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return ContainsContainsBits::MinSizeInBytes(); } template -inline ::emboss::support::Maybe -GenericChoiceConditionView::has_y() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericContainsContainsBitsView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return ContainsContainsBits::MinSizeInBytes(); } +namespace ConditionalInline { +namespace Type0 {} // namespace Type0 template inline typename ::emboss::prelude::UIntView< @@ -23924,17 +26023,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>> -GenericChoiceConditionView::xyc() const { - if (has_xyc().ValueOr(false)) { +GenericType0View::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(3LL)); + static_cast(0LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -23944,10 +26043,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())); } @@ -23955,261 +26054,192 @@ GenericChoiceConditionView::xyc() const { 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 -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 GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericChoiceConditionView::IntrinsicSizeInBytes() const { - return typename GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); -} - -template -inline ::emboss::support::Maybe -GenericChoiceConditionView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); -} - -namespace ChoiceCondition { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(4LL)) - .ValueOrDefault(); -} -} // namespace ChoiceCondition - -template -inline constexpr ::std::int32_t GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ChoiceCondition::MaxSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ChoiceCondition::MaxSizeInBytes(); -} - -namespace ChoiceCondition { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(3LL)) - .ValueOrDefault(); -} -} // namespace ChoiceCondition + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -template -inline constexpr ::std::int32_t GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ChoiceCondition::MinSizeInBytes(); + (); } template -inline constexpr ::std::int32_t GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ChoiceCondition::MinSizeInBytes(); +inline ::emboss::support::Maybe GenericType0View::has_a() const { + return ::emboss::support::Maybe(true); } -namespace ContainsBits { -namespace EmbossReservedAnonymousField3 { - -} // namespace EmbossReservedAnonymousField3 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>> -GenericEmbossReservedAnonymousField3View::has_top() const { - if (has_has_top().ValueOr(false)) { +GenericType0View::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(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< - 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, 1>( 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 -GenericEmbossReservedAnonymousField3View::has_has_top() const { +inline ::emboss::support::Maybe GenericType0View::has_b() const { return ::emboss::support::Maybe(true); } 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>> -GenericEmbossReservedAnonymousField3View::has_bottom() const { - if (has_has_bottom().ValueOr(false)) { +GenericType0View::c() const { + if (has_c().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::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, 0>( + (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 -GenericEmbossReservedAnonymousField3View::has_has_bottom() const { +inline ::emboss::support::Maybe GenericType0View::has_c() const { return ::emboss::support::Maybe(true); } -namespace EmbossReservedAnonymousField3 { -inline constexpr ::std::int32_t IntrinsicSizeInBits() { +namespace Type0 { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField3 +} // namespace Type0 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); +inline constexpr ::std::int32_t GenericType0View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return Type0::IntrinsicSizeInBytes(); } template -inline constexpr ::std::int32_t -GenericEmbossReservedAnonymousField3View:: - EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); +inline constexpr ::std::int32_t GenericType0View:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return Type0::IntrinsicSizeInBytes(); } -namespace EmbossReservedAnonymousField3 { -inline constexpr ::std::int32_t MaxSizeInBits() { +namespace Type0 { +inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField3 +} // namespace Type0 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::MaxSizeInBits(); +inline constexpr ::std::int32_t GenericType0View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return Type0::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::MaxSizeInBits(); +inline constexpr ::std::int32_t GenericType0View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return Type0::MaxSizeInBytes(); } -namespace EmbossReservedAnonymousField3 { -inline constexpr ::std::int32_t MinSizeInBits() { +namespace Type0 { +inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField3 +} // namespace Type0 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::MinSizeInBits(); +inline constexpr ::std::int32_t GenericType0View< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return Type0::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::MinSizeInBits(); +inline constexpr ::std::int32_t GenericType0View< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return Type0::MinSizeInBytes(); } -} // namespace ContainsBits +namespace Type1 {} // namespace Type1 template -inline typename ::emboss::test::ContainsBits:: - GenericEmbossReservedAnonymousField3View< - 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>> - GenericContainsBitsView::emboss_reserved_anonymous_field_3() - const { - if (has_emboss_reserved_anonymous_field_3().ValueOr(false)) { +GenericType1View::a() const { + if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24220,143 +26250,82 @@ inline typename ::emboss::test::ContainsBits:: 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>( 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>, - 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(); -} -} // namespace ContainsBits - -template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ContainsBits::IntrinsicSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericContainsBitsView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ContainsBits::IntrinsicSizeInBytes(); -} - -namespace ContainsBits { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace ContainsBits - -template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ContainsBits::MaxSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ContainsBits::MaxSizeInBytes(); -} - -namespace ContainsBits { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace ContainsBits + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ContainsBits::MinSizeInBytes(); + (); } template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ContainsBits::MinSizeInBytes(); +inline ::emboss::support::Maybe GenericType1View::has_a() const { + return ::emboss::support::Maybe(true); } -namespace ContainsContainsBits {} // namespace ContainsContainsBits 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)) { +GenericType1View::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(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::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>( + (backing_.template GetOffsetStorage<0, 1>( 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 { +inline ::emboss::support::Maybe GenericType1View::has_b() const { return ::emboss::support::Maybe(true); } @@ -24366,17 +26335,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>> -GenericContainsContainsBitsView::top() const { - if (has_top().ValueOr(false)) { +GenericType1View::c() const { + if (has_c().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() && @@ -24386,10 +26355,10 @@ GenericContainsContainsBitsView::top() 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())); } @@ -24399,81 +26368,78 @@ GenericContainsContainsBitsView::top() 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 -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))); +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 GenericContainsContainsBitsView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericContainsContainsBitsView::IntrinsicSizeInBytes() const { - return typename GenericContainsContainsBitsView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericType1View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return Type1::IntrinsicSizeInBytes(); } template -inline ::emboss::support::Maybe -GenericContainsContainsBitsView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericType1View:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return Type1::IntrinsicSizeInBytes(); } -namespace ContainsContainsBits { +namespace Type1 { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ContainsContainsBits +} // namespace Type1 template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericType1View< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ContainsContainsBits::MaxSizeInBytes(); + return Type1::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericType1View< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ContainsContainsBits::MaxSizeInBytes(); + return Type1::MaxSizeInBytes(); } -namespace ContainsContainsBits { +namespace Type1 { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ContainsContainsBits +} // namespace Type1 template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericType1View< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ContainsContainsBits::MinSizeInBytes(); + return Type1::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericType1View< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ContainsContainsBits::MinSizeInBytes(); + return Type1::MinSizeInBytes(); } -namespace ConditionalInline { -namespace Type0 {} // namespace Type0 + +} // namespace ConditionalInline template inline typename ::emboss::prelude::UIntView< @@ -24484,8 +26450,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType0View::a() const { - if (has_a().ValueOr(false)) { +GenericConditionalInlineView::payload_id() const { + if (has_payload_id().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24521,24 +26487,20 @@ GenericType0View::a() const { } template -inline ::emboss::support::Maybe GenericType0View::has_a() 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> -GenericType0View::b() const { - if (has_b().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)); @@ -24546,158 +26508,142 @@ GenericType0View::b() 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 GenericType0View::has_b() 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> -GenericType0View::c() const { - if (has_c().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 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(); +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))); } -} // namespace Type0 template -inline constexpr ::std::int32_t GenericType0View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return Type0::IntrinsicSizeInBytes(); +inline typename GenericConditionalInlineView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericConditionalInlineView::IntrinsicSizeInBytes() const { + return typename GenericConditionalInlineView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t GenericType0View:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return Type0::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericConditionalInlineView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace Type0 { +namespace ConditionalInline { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace Type0 +} // namespace ConditionalInline template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return Type0::MaxSizeInBytes(); + return ConditionalInline::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return Type0::MaxSizeInBytes(); + return ConditionalInline::MaxSizeInBytes(); } -namespace Type0 { +namespace ConditionalInline { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace Type0 +} // namespace ConditionalInline template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return Type0::MinSizeInBytes(); + return ConditionalInline::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericConditionalInlineView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return Type0::MinSizeInBytes(); + return ConditionalInline::MinSizeInBytes(); } +namespace ConditionalAnonymous { +namespace EmbossReservedAnonymousField2 { -namespace Type1 {} // namespace Type1 +} // namespace EmbossReservedAnonymousField2 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> -GenericType1View::a() const { - if (has_a().ValueOr(false)) { +GenericEmbossReservedAnonymousField2View::low() const { + if (has_low().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24710,11 +26656,8 @@ GenericType1View::a() const { 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>( emboss_reserved_local_offset.ValueOrDefault(), @@ -24723,181 +26666,170 @@ GenericType1View::a() const { } 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 GenericType1View::has_a() const { +inline ::emboss::support::Maybe +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> -GenericType1View::b() const { - if (has_b().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 GenericType1View::has_b() const { - return ::emboss::support::Maybe(true); +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))); } 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> -GenericType1View::c() const { - if (has_c().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 GenericType1View::has_c() const { +inline ::emboss::support::Maybe +GenericEmbossReservedAnonymousField2View::has_high() const { return ::emboss::support::Maybe(true); } -namespace Type1 { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { +namespace EmbossReservedAnonymousField2 { +inline constexpr ::std::int32_t IntrinsicSizeInBits() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(8LL)) .ValueOrDefault(); } -} // namespace Type1 +} // namespace EmbossReservedAnonymousField2 template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return Type1::IntrinsicSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); } template -inline constexpr ::std::int32_t GenericType1View:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return Type1::IntrinsicSizeInBytes(); +inline constexpr ::std::int32_t +GenericEmbossReservedAnonymousField2View:: + EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); } -namespace Type1 { -inline constexpr ::std::int32_t MaxSizeInBytes() { +namespace EmbossReservedAnonymousField2 { +inline constexpr ::std::int32_t MaxSizeInBits() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(8LL)) .ValueOrDefault(); } -} // namespace Type1 +} // namespace EmbossReservedAnonymousField2 template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return Type1::MaxSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::MaxSizeInBits(); } template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return Type1::MaxSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::MaxSizeInBits(); } -namespace Type1 { -inline constexpr ::std::int32_t MinSizeInBytes() { +namespace EmbossReservedAnonymousField2 { +inline constexpr ::std::int32_t MinSizeInBits() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(8LL)) .ValueOrDefault(); } -} // namespace Type1 +} // namespace EmbossReservedAnonymousField2 template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return Type1::MinSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::MinSizeInBits(); } template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return Type1::MinSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::MinSizeInBits(); } -} // namespace ConditionalInline +} // namespace ConditionalAnonymous template inline typename ::emboss::prelude::UIntView< @@ -24908,8 +26840,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalInlineView::payload_id() const { - if (has_payload_id().ValueOr(false)) { +GenericConditionalAnonymousView::x() const { + if (has_x().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -24946,62 +26878,24 @@ GenericConditionalInlineView::payload_id() const { template inline ::emboss::support::Maybe -GenericConditionalInlineView::has_payload_id() const { +GenericConditionalAnonymousView::has_x() const { return ::emboss::support::Maybe(true); } template -inline typename ::emboss::test::ConditionalInline::GenericType0View< - typename Storage::template OffsetStorageType> - -GenericConditionalInlineView::type_0() const { - if (has_type_0().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> +inline typename ::emboss::test::ConditionalAnonymous:: + GenericEmbossReservedAnonymousField2View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericConditionalInlineView::type_1() const { - if (has_type_1().ValueOr(false)) { + 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(3LL)); + static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( static_cast(1LL)); @@ -25009,99 +26903,130 @@ 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::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::ConditionalInline::GenericType1View< - typename Storage::template OffsetStorageType> + return ::emboss::test::ConditionalAnonymous:: + GenericEmbossReservedAnonymousField2View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template -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()), +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(1LL))); + static_cast(10LL))); } template -inline typename GenericConditionalInlineView< +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 -GenericConditionalInlineView::IntrinsicSizeInBytes() const { - return typename GenericConditionalInlineView< +GenericConditionalAnonymousView::IntrinsicSizeInBytes() const { + return typename GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericConditionalInlineView::has_IntrinsicSizeInBytes() const { +GenericConditionalAnonymousView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionalInline { +namespace ConditionalAnonymous { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(4LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace ConditionalInline +} // namespace ConditionalAnonymous template -inline constexpr ::std::int32_t GenericConditionalInlineView< +inline constexpr ::std::int32_t GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalInline::MaxSizeInBytes(); + return ConditionalAnonymous::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalInlineView< +inline constexpr ::std::int32_t GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalInline::MaxSizeInBytes(); + return ConditionalAnonymous::MaxSizeInBytes(); } -namespace ConditionalInline { +namespace ConditionalAnonymous { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalInline +} // namespace ConditionalAnonymous template -inline constexpr ::std::int32_t GenericConditionalInlineView< +inline constexpr ::std::int32_t GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalInline::MinSizeInBytes(); + return ConditionalAnonymous::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalInlineView< +inline constexpr ::std::int32_t GenericConditionalAnonymousView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalInline::MinSizeInBytes(); + return ConditionalAnonymous::MinSizeInBytes(); } -namespace ConditionalAnonymous { -namespace EmbossReservedAnonymousField2 { +namespace ConditionalOnFlag { +namespace EmbossReservedAnonymousField1 { -} // namespace EmbossReservedAnonymousField2 +} // namespace EmbossReservedAnonymousField1 template -inline typename ::emboss::prelude::UIntView< +inline typename ::emboss::prelude::FlagView< /**/ ::emboss::support::FixedSizeViewParameters< 1, ::emboss::support::AllValuesAreOk>, typename Storage::template OffsetStorageType> -GenericEmbossReservedAnonymousField2View::low() const { - if (has_low().ValueOr(false)) { +GenericEmbossReservedAnonymousField1View::enabled() const { + if (has_enabled().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25112,7 +27037,7 @@ GenericEmbossReservedAnonymousField2View::low() 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> @@ -25122,7 +27047,7 @@ GenericEmbossReservedAnonymousField2View::low() 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> @@ -25132,162 +27057,240 @@ GenericEmbossReservedAnonymousField2View::low() const { template inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField2View::has_low() const { +GenericEmbossReservedAnonymousField1View::has_enabled() 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 typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 2, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { + return EmbossReservedAnonymousField1::IntrinsicSizeInBits(); +} -GenericEmbossReservedAnonymousField2View::mid() const { - if (has_mid().ValueOr(false)) { +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(); +} + +template +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField1::MaxSizeInBits(); +} + +namespace EmbossReservedAnonymousField1 { +inline constexpr ::std::int32_t MinSizeInBits() { + return ::emboss::support::Maybe( + static_cast(1LL)) + .ValueOrDefault(); +} +} // namespace EmbossReservedAnonymousField1 + +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(); +} + +} // namespace ConditionalOnFlag + +template +inline typename ::emboss::test::ConditionalOnFlag:: + GenericEmbossReservedAnonymousField1View< + 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)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( - static_cast(2LL)); + 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() && emboss_reserved_local_offset.ValueOr(0) >= 0) { - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 2, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + return ::emboss::test::ConditionalOnFlag:: + GenericEmbossReservedAnonymousField1View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + 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())); } } - return ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 2, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + 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 -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))); +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< - 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)) { +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(7LL)); + 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< - 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, 1>( 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(); +GenericConditionalOnFlagView::has_value() const { + return (enabled().Ok() + ? ::emboss::support::Maybe( + static_cast(enabled().UncheckedRead())) + : ::emboss::support::Maybe()); } -} // namespace EmbossReservedAnonymousField2 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { - return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); +inline typename GenericConditionalOnFlagView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericConditionalOnFlagView::IntrinsicSizeInBytes() const { + return typename GenericConditionalOnFlagView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t -GenericEmbossReservedAnonymousField2View:: - EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); +inline ::emboss::support::Maybe +GenericConditionalOnFlagView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); } -namespace EmbossReservedAnonymousField2 { -inline constexpr ::std::int32_t MaxSizeInBits() { +namespace ConditionalOnFlag { +inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField2 +} // namespace ConditionalOnFlag template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { - return EmbossReservedAnonymousField2::MaxSizeInBits(); +inline constexpr ::std::int32_t GenericConditionalOnFlagView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return ConditionalOnFlag::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField2::MaxSizeInBits(); +inline constexpr ::std::int32_t GenericConditionalOnFlagView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return ConditionalOnFlag::MaxSizeInBytes(); } -namespace EmbossReservedAnonymousField2 { -inline constexpr ::std::int32_t MinSizeInBits() { +namespace ConditionalOnFlag { +inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField2 +} // namespace ConditionalOnFlag template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { - return EmbossReservedAnonymousField2::MinSizeInBits(); +inline constexpr ::std::int32_t GenericConditionalOnFlagView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return ConditionalOnFlag::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField2::MinSizeInBits(); +inline constexpr ::std::int32_t GenericConditionalOnFlagView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return ConditionalOnFlag::MinSizeInBytes(); } +namespace ResidualConditionalDiscriminant { -} // namespace ConditionalAnonymous +} // namespace ResidualConditionalDiscriminant template inline typename ::emboss::prelude::UIntView< @@ -25298,8 +27301,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericConditionalAnonymousView::x() const { - if (has_x().ValueOr(false)) { +GenericResidualConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25336,21 +27339,21 @@ GenericConditionalAnonymousView::x() const { template inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_x() const { +GenericResidualConditionalDiscriminantView::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)) { +GenericResidualConditionalDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25361,130 +27364,247 @@ 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 +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(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>> + +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 -GenericConditionalAnonymousView::has_mid() const { +GenericResidualConditionalDiscriminantView::has_a() const { return ::emboss::support::And( - has_emboss_reserved_anonymous_field_2(), - emboss_reserved_anonymous_field_2().has_mid()); + ::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(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>> + + (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>> + + (); } template inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_high() const { +GenericResidualConditionalDiscriminantView::has_b() 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(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 GenericConditionalAnonymousView< +inline typename GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalAnonymousView::IntrinsicSizeInBytes() const { - return typename GenericConditionalAnonymousView< +GenericResidualConditionalDiscriminantView::IntrinsicSizeInBytes() + const { + return typename GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_IntrinsicSizeInBytes() const { +GenericResidualConditionalDiscriminantView::has_IntrinsicSizeInBytes() + const { return ::emboss::support::Maybe(true); } -namespace ConditionalAnonymous { +namespace ResidualConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace ConditionalAnonymous +} // namespace ResidualConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalAnonymous::MaxSizeInBytes(); + return ResidualConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalAnonymous::MaxSizeInBytes(); + return ResidualConditionalDiscriminant::MaxSizeInBytes(); } -namespace ConditionalAnonymous { +namespace ResidualConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalAnonymous +} // namespace ResidualConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalAnonymous::MinSizeInBytes(); + return ResidualConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalAnonymous::MinSizeInBytes(); + return ResidualConditionalDiscriminant::MinSizeInBytes(); } -namespace ConditionalOnFlag { -namespace EmbossReservedAnonymousField1 { +namespace BareConditionalDiscriminant { -} // namespace EmbossReservedAnonymousField1 +} // namespace BareConditionalDiscriminant template -inline typename ::emboss::prelude::FlagView< +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>> -GenericEmbossReservedAnonymousField1View::enabled() const { - if (has_enabled().ValueOr(false)) { +GenericBareConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25495,148 +27615,149 @@ 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< + 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, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::FlagView< + 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 -GenericEmbossReservedAnonymousField1View::has_enabled() const { +GenericBareConditionalDiscriminantView::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::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 GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField1::MaxSizeInBits(); -} +GenericBareConditionalDiscriminantView::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>> -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::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 GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { - return EmbossReservedAnonymousField1::MinSizeInBits(); + (); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField1::MinSizeInBits(); +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))); } -} // 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)) { +GenericBareConditionalDiscriminantView::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 { - return ::emboss::support::And( - ::emboss::support::Maybe(true), - ::emboss::support::Maybe(true)); +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))); } template @@ -25645,17 +27766,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)) { +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(1LL)); + static_cast(3LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -25665,10 +27786,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, 3>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -25678,7 +27799,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 +27807,68 @@ 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()); +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 typename GenericConditionalOnFlagView< +inline typename GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalOnFlagView::IntrinsicSizeInBytes() const { - return typename GenericConditionalOnFlagView< +GenericBareConditionalDiscriminantView::IntrinsicSizeInBytes() const { + return typename GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline ::emboss::support::Maybe -GenericConditionalOnFlagView::has_IntrinsicSizeInBytes() const { +inline ::emboss::support::Maybe GenericBareConditionalDiscriminantView< + Storage>::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionalOnFlag { +namespace BareConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace ConditionalOnFlag +} // namespace BareConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalOnFlag::MaxSizeInBytes(); + return BareConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalOnFlag::MaxSizeInBytes(); + return BareConditionalDiscriminant::MaxSizeInBytes(); } -namespace ConditionalOnFlag { +namespace BareConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalOnFlag +} // namespace BareConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalOnFlag::MinSizeInBytes(); + return BareConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalOnFlag::MinSizeInBytes(); + return BareConditionalDiscriminant::MinSizeInBytes(); } } // namespace test From 6ee6dafc7b2381752cc9c840d2e59c2be712984c Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Thu, 4 Jun 2026 13:43:56 -0700 Subject: [PATCH 2/3] Expand conditional-discriminant Ok() test coverage Adds regression structs that distinguish the guard fix from a presence-wrapper alternative and exercise the optimization chain: * DominatedBareDiscriminant: a bare arm on a conditional discriminant whose field is size-dominated by an always-present field, so IsComplete() stays Known. Only the discriminant Known() guard rejects the existence-indeterminate message; a has_().ValueOrDefault() wrapper would wrongly accept it. * DisjunctionConditionalDiscriminant: disjunction arms with residuals -> guarded switch with coalesced case labels. * SingleEntryConditionalDiscriminant: single-entry group demotes to a has_X() check, so no discriminant guard is emitted. * EnumConditionalDiscriminant: enum-typed conditional discriminant. Only condition.emb.h regenerates; all other goldens are unchanged. --- .../back_end/cpp/testcode/condition_test.cc | 114 + testdata/condition.emb | 62 + testdata/golden_cpp/condition.emb.h | 9267 ++++++++++++----- 3 files changed, 6901 insertions(+), 2542 deletions(-) diff --git a/compiler/back_end/cpp/testcode/condition_test.cc b/compiler/back_end/cpp/testcode/condition_test.cc index bccde439..7f17902a 100644 --- a/compiler/back_end/cpp/testcode/condition_test.cc +++ b/compiler/back_end/cpp/testcode/condition_test.cc @@ -396,6 +396,120 @@ TEST(Conditional, BareConditionalDiscriminantNotOkWhenGatedFieldTruncated) { 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`; tag == 9 selects neither (still valid). + ::std::uint8_t buffer2[4] = {1, 2, 0, 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 cb8b3cd7..04003ab9 100644 --- a/testdata/condition.emb +++ b/testdata/condition.emb @@ -263,3 +263,65 @@ struct BareConditionalDiscriminant: if tag == 1: 3 [+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: + 3 [+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: + 3 [+1] UInt b diff --git a/testdata/golden_cpp/condition.emb.h b/testdata/golden_cpp/condition.emb.h index 92802f31..0f425952 100644 --- a/testdata/golden_cpp/condition.emb.h +++ b/testdata/golden_cpp/condition.emb.h @@ -229,6 +229,32 @@ 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 @@ -20987,188 +21013,4613 @@ MakeAlignedBareConditionalDiscriminantView( emboss_reserved_local_data, emboss_reserved_local_size); } -namespace BasicConditional {} // namespace BasicConditional +namespace DominatedBareDiscriminant {} // namespace DominatedBareDiscriminant + +template +struct EmbossReservedInternalIsGenericDominatedBareDiscriminantView; 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 GenericDominatedBareDiscriminantView final { + public: + GenericDominatedBareDiscriminantView() : backing_() {} + explicit GenericDominatedBareDiscriminantView( + 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 + GenericDominatedBareDiscriminantView( + const GenericDominatedBareDiscriminantView& + 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 ::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; } - 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_tail().Known()) return false; + if (has_tail().ValueOrDefault() && !tail().Ok()) return false; - (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>> + 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; -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 (!has_MinSizeInBytes().Known()) return false; + if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) + return false; -template -inline typename GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericBasicConditionalView::IntrinsicSizeInBytes() const { - return typename GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); -} + if (!has_tag().Known()) return false; + if (has_tag().ValueOrDefault() && !tag().Ok()) return false; -template -inline ::emboss::support::Maybe -GenericBasicConditionalView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); -} + { + 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; -namespace BasicConditional { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(2LL)) - .ValueOrDefault(); -} -} // namespace BasicConditional + case static_cast(1LL): + if (!b().Ok()) return false; + break; -template -inline constexpr ::std::int32_t GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return BasicConditional::MaxSizeInBytes(); -} + default: + break; + } + } -template -inline constexpr ::std::int32_t GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return BasicConditional::MaxSizeInBytes(); -} + 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(); } -namespace BasicConditional { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(1LL)) - .ValueOrDefault(); -} -} // namespace BasicConditional + 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; -template -inline constexpr ::std::int32_t GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return BasicConditional::MinSizeInBytes(); -} + 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 constexpr ::std::int32_t GenericBasicConditionalView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return BasicConditional::MinSizeInBytes(); -} -namespace NegativeConditional {} // namespace NegativeConditional + if (emboss_reserved_local_other.has_outer().ValueOrDefault() && + has_outer().ValueOrDefault() && + !outer().Equals(emboss_reserved_local_other.outer())) + return false; -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_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(4LL)), + ::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(4LL)), + ::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>> + +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>> -GenericNegativeConditionalView::x() const { - if (has_x().ValueOr(false)) { +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() && @@ -21178,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())); } @@ -21191,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>> (); @@ -21199,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< @@ -21209,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() && @@ -21229,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())); } @@ -21242,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>> (); @@ -21250,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< @@ -21326,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( @@ -21365,8 +25937,7 @@ GenericConditionalAndUnconditionalOverlappingFinalFieldView::x() template inline ::emboss::support::Maybe -GenericConditionalAndUnconditionalOverlappingFinalFieldView::has_x() - const { +GenericAlwaysFalseConditionDynamicSizeView::has_x() const { return ::emboss::support::Maybe(true); } @@ -21376,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() && @@ -21397,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())); } @@ -21410,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 @@ -21438,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)); @@ -21477,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< @@ -21559,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() && @@ -21579,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())); } @@ -21592,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>> (); @@ -21600,7 +26155,7 @@ GenericConditionalBasicConditionalFieldFirstView::x() const { template inline ::emboss::support::Maybe -GenericConditionalBasicConditionalFieldFirstView::has_x() const { +GenericConditionDoesNotContributeToSizeView::has_x() const { return ::emboss::support::Maybe(true); } @@ -21610,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() && @@ -21630,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())); } @@ -21643,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>> (); @@ -21651,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( @@ -21661,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( @@ -21751,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< @@ -21764,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< @@ -21776,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); } @@ -21787,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() && @@ -21807,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())); } @@ -21820,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>> (); @@ -21828,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 @@ -21838,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() && @@ -21864,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())); } @@ -21877,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>> (); @@ -21885,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( @@ -21972,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< @@ -21985,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< @@ -21998,7 +26605,7 @@ GenericConditionUsesMinIntView::x() const { template inline ::emboss::support::Maybe -GenericConditionUsesMinIntView::has_x() const { +GenericNegativeEnumConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -22011,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( @@ -22049,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< @@ -22127,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( @@ -22165,7 +26770,7 @@ GenericNestedConditionalView::x() const { template inline ::emboss::support::Maybe -GenericNestedConditionalView::has_x() const { +GenericLessThanConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -22178,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( @@ -22216,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< @@ -22347,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( @@ -22385,7 +26933,7 @@ GenericCorrectNestedConditionalView::x() const { template inline ::emboss::support::Maybe -GenericCorrectNestedConditionalView::has_x() const { +GenericLessThanOrEqualConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -22398,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( @@ -22436,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< @@ -22576,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( @@ -22614,7 +27098,7 @@ GenericAlwaysFalseConditionView::x() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionView::has_x() const { +GenericGreaterThanOrEqualConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -22627,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( @@ -22665,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< @@ -22739,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)); @@ -22777,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< @@ -22914,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( @@ -22952,7 +27424,7 @@ GenericAlwaysFalseConditionDynamicSizeView::x() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_x() const { +GenericRangeConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -22962,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() && @@ -22988,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())); } @@ -23001,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>> (); @@ -23009,7 +27475,7 @@ GenericAlwaysFalseConditionDynamicSizeView::y() const { template inline ::emboss::support::Maybe -GenericAlwaysFalseConditionDynamicSizeView::has_y() const { +GenericRangeConditionView::has_y() const { return ::emboss::support::Maybe(true); } @@ -23019,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() && @@ -23039,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())); } @@ -23052,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>> (); @@ -23060,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< @@ -23132,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( @@ -23170,7 +27658,7 @@ GenericConditionDoesNotContributeToSizeView::x() const { template inline ::emboss::support::Maybe -GenericConditionDoesNotContributeToSizeView::has_x() const { +GenericReverseRangeConditionView::has_x() const { return ::emboss::support::Maybe(true); } @@ -23183,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)); @@ -23221,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 @@ -23240,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)); @@ -23278,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( @@ -23366,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< @@ -23380,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< @@ -23393,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); } @@ -23407,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)); @@ -23444,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 @@ -23462,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() && @@ -23482,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())); } @@ -23495,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( @@ -23592,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< @@ -23606,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< @@ -23619,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); } @@ -23633,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)); @@ -23670,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)); @@ -23759,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< @@ -23772,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< @@ -23785,7 +28339,7 @@ GenericLessThanConditionView::x() const { template inline ::emboss::support::Maybe -GenericLessThanConditionView::has_x() const { +GenericChoiceConditionView::has_field() const { return ::emboss::support::Maybe(true); } @@ -23798,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)); @@ -23836,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() && @@ -23927,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())); } @@ -23940,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>> (); @@ -23948,7 +28441,7 @@ GenericLessThanOrEqualConditionView::x() const { template inline ::emboss::support::Maybe -GenericLessThanOrEqualConditionView::has_x() const { +GenericChoiceConditionView::has_y() const { return ::emboss::support::Maybe(true); } @@ -23958,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() && @@ -23978,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())); } @@ -23991,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>> (); @@ -23999,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)); @@ -24250,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>, @@ -24275,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)); @@ -24413,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); } @@ -24452,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)); @@ -24490,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< @@ -24635,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)); @@ -24672,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); } @@ -24686,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)); @@ -24723,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); } @@ -24737,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)); @@ -24774,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< @@ -24869,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)); @@ -24906,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); } @@ -24920,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)); @@ -24957,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); } @@ -24971,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)); @@ -25008,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< @@ -25091,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)); @@ -25128,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)); @@ -25154,604 +29493,525 @@ 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(); -} -namespace ChoiceCondition {} // namespace ChoiceCondition - -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>> - -GenericChoiceConditionView::field() const { - if (has_field().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::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>> - - (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 ConditionalInline::MinSizeInBytes(); } +namespace ConditionalAnonymous { +namespace EmbossReservedAnonymousField2 { -template -inline ::emboss::support::Maybe -GenericChoiceConditionView::has_field() const { - return ::emboss::support::Maybe(true); -} +} // namespace EmbossReservedAnonymousField2 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::x() const { - if (has_x().ValueOr(false)) { +GenericEmbossReservedAnonymousField2View::low() const { + if (has_low().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 -GenericChoiceConditionView::has_x() 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::y() const { - if (has_y().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(2LL)); + 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, 2>( + (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_y() 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::xyc() const { - if (has_xyc().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(3LL)); + 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, 3>( + (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_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))); +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 typename GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericChoiceConditionView::IntrinsicSizeInBytes() const { - return typename GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); } template -inline ::emboss::support::Maybe -GenericChoiceConditionView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t +GenericEmbossReservedAnonymousField2View:: + EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::IntrinsicSizeInBits(); } -namespace ChoiceCondition { -inline constexpr ::std::int32_t MaxSizeInBytes() { +namespace EmbossReservedAnonymousField2 { +inline constexpr ::std::int32_t MaxSizeInBits() { return ::emboss::support::Maybe( - static_cast(4LL)) + static_cast(8LL)) .ValueOrDefault(); } -} // namespace ChoiceCondition +} // namespace EmbossReservedAnonymousField2 template -inline constexpr ::std::int32_t GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ChoiceCondition::MaxSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::MaxSizeInBits(); } template -inline constexpr ::std::int32_t GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ChoiceCondition::MaxSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::MaxSizeInBits(); } -namespace ChoiceCondition { -inline constexpr ::std::int32_t MinSizeInBytes() { +namespace EmbossReservedAnonymousField2 { +inline constexpr ::std::int32_t MinSizeInBits() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(8LL)) .ValueOrDefault(); } -} // namespace ChoiceCondition +} // namespace EmbossReservedAnonymousField2 template -inline constexpr ::std::int32_t GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ChoiceCondition::MinSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { + return EmbossReservedAnonymousField2::MinSizeInBits(); } template -inline constexpr ::std::int32_t GenericChoiceConditionView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ChoiceCondition::MinSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField2View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField2::MinSizeInBits(); } -namespace ContainsBits { -namespace EmbossReservedAnonymousField3 { -} // namespace EmbossReservedAnonymousField3 +} // namespace ConditionalAnonymous 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>> -GenericEmbossReservedAnonymousField3View::has_top() const { - if (has_has_top().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(7LL)); + 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> + 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, 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> + 8, ::emboss::support::AllValuesAreOk>, + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField3View::has_has_top() const { +GenericConditionalAnonymousView::has_x() const { return ::emboss::support::Maybe(true); } template -inline typename ::emboss::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> +inline typename ::emboss::test::ConditionalAnonymous:: + GenericEmbossReservedAnonymousField2View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericEmbossReservedAnonymousField3View::has_bottom() const { - if (has_has_bottom().ValueOr(false)) { + 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(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::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + return ::emboss::test::ConditionalAnonymous:: + GenericEmbossReservedAnonymousField2View< + 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::prelude::UIntView< - /**/ ::emboss::support::FixedSizeViewParameters< - 1, ::emboss::support::AllValuesAreOk>, - typename Storage::template OffsetStorageType> + 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(10LL))); +} + template inline ::emboss::support::Maybe -GenericEmbossReservedAnonymousField3View::has_has_bottom() const { - return ::emboss::support::Maybe(true); +GenericConditionalAnonymousView::has_low() const { + return ::emboss::support::And( + has_emboss_reserved_anonymous_field_2(), + ::emboss::support::Maybe(true)); } -namespace EmbossReservedAnonymousField3 { -inline constexpr ::std::int32_t IntrinsicSizeInBits() { - return ::emboss::support::Maybe( - static_cast(8LL)) - .ValueOrDefault(); +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()); } -} // namespace EmbossReservedAnonymousField3 template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); +inline ::emboss::support::Maybe +GenericConditionalAnonymousView::has_high() const { + return ::emboss::support::And( + has_emboss_reserved_anonymous_field_2(), + ::emboss::support::Maybe(true)); } template -inline constexpr ::std::int32_t -GenericEmbossReservedAnonymousField3View:: - EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::IntrinsicSizeInBits(); +inline typename GenericConditionalAnonymousView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericConditionalAnonymousView::IntrinsicSizeInBytes() const { + return typename GenericConditionalAnonymousView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } -namespace EmbossReservedAnonymousField3 { -inline constexpr ::std::int32_t MaxSizeInBits() { +template +inline ::emboss::support::Maybe +GenericConditionalAnonymousView::has_IntrinsicSizeInBytes() const { + return ::emboss::support::Maybe(true); +} + +namespace ConditionalAnonymous { +inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(2LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField3 +} // namespace ConditionalAnonymous template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::MaxSizeInBits(); +inline constexpr ::std::int32_t GenericConditionalAnonymousView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { + return ConditionalAnonymous::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::MaxSizeInBits(); +inline constexpr ::std::int32_t GenericConditionalAnonymousView< + Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { + return ConditionalAnonymous::MaxSizeInBytes(); } -namespace EmbossReservedAnonymousField3 { -inline constexpr ::std::int32_t MinSizeInBits() { +namespace ConditionalAnonymous { +inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(8LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace EmbossReservedAnonymousField3 +} // namespace ConditionalAnonymous template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { - return EmbossReservedAnonymousField3::MinSizeInBits(); +inline constexpr ::std::int32_t GenericConditionalAnonymousView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { + return ConditionalAnonymous::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField3View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField3::MinSizeInBits(); +inline constexpr ::std::int32_t GenericConditionalAnonymousView< + Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { + return ConditionalAnonymous::MinSizeInBytes(); } +namespace ConditionalOnFlag { +namespace EmbossReservedAnonymousField1 { -} // namespace ContainsBits +} // namespace EmbossReservedAnonymousField1 template -inline typename ::emboss::test::ContainsBits:: - GenericEmbossReservedAnonymousField3View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> +inline typename ::emboss::prelude::FlagView< + /**/ ::emboss::support::FixedSizeViewParameters< + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> - GenericContainsBitsView::emboss_reserved_anonymous_field_3() - const { - if (has_emboss_reserved_anonymous_field_3().ValueOr(false)) { +GenericEmbossReservedAnonymousField1View::enabled() const { + if (has_enabled().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25762,116 +30022,104 @@ inline typename ::emboss::test::ContainsBits:: 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::FlagView< + /**/ ::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::test::ContainsBits::GenericEmbossReservedAnonymousField3View< - typename ::emboss::support::BitBlock< - /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, - 8>> + return ::emboss::prelude::FlagView< + /**/ ::emboss::support::FixedSizeViewParameters< + 1, ::emboss::support::AllValuesAreOk>, + typename Storage::template OffsetStorageType> (); } -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)); +GenericEmbossReservedAnonymousField1View::has_enabled() const { + return ::emboss::support::Maybe(true); } -namespace ContainsBits { -inline constexpr ::std::int32_t IntrinsicSizeInBytes() { +namespace EmbossReservedAnonymousField1 { +inline constexpr ::std::int32_t IntrinsicSizeInBits() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ContainsBits +} // namespace EmbossReservedAnonymousField1 template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return ContainsBits::IntrinsicSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBitsView::Read() { + return EmbossReservedAnonymousField1::IntrinsicSizeInBits(); } template -inline constexpr ::std::int32_t GenericContainsBitsView:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return ContainsBits::IntrinsicSizeInBytes(); +inline constexpr ::std::int32_t +GenericEmbossReservedAnonymousField1View:: + EmbossReservedDollarVirtualIntrinsicSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField1::IntrinsicSizeInBits(); } - -namespace ContainsBits { -inline constexpr ::std::int32_t MaxSizeInBytes() { + +namespace EmbossReservedAnonymousField1 { +inline constexpr ::std::int32_t MaxSizeInBits() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ContainsBits +} // namespace EmbossReservedAnonymousField1 template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ContainsBits::MaxSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::Read() { + return EmbossReservedAnonymousField1::MaxSizeInBits(); } template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ContainsBits::MaxSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< + Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField1::MaxSizeInBits(); } -namespace ContainsBits { -inline constexpr ::std::int32_t MinSizeInBytes() { +namespace EmbossReservedAnonymousField1 { +inline constexpr ::std::int32_t MinSizeInBits() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ContainsBits +} // namespace EmbossReservedAnonymousField1 template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ContainsBits::MinSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { + return EmbossReservedAnonymousField1::MinSizeInBits(); } template -inline constexpr ::std::int32_t GenericContainsBitsView< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ContainsBits::MinSizeInBytes(); +inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< + Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { + return EmbossReservedAnonymousField1::MinSizeInBits(); } -namespace ContainsContainsBits {} // namespace ContainsContainsBits + +} // namespace ConditionalOnFlag template -inline typename ::emboss::test::GenericContainsBitsView< - typename Storage::template OffsetStorageType> +inline typename ::emboss::test::ConditionalOnFlag:: + GenericEmbossReservedAnonymousField1View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> -GenericContainsContainsBitsView::condition() const { - if (has_condition().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)); @@ -25882,26 +30130,42 @@ 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::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::GenericContainsBitsView< - typename Storage::template OffsetStorageType> + return ::emboss::test::ConditionalOnFlag:: + GenericEmbossReservedAnonymousField1View< + typename ::emboss::support::BitBlock< + /**/ ::emboss::support::LittleEndianByteOrderer< + typename Storage::template OffsetStorageType>, + 8>> (); } template -inline ::emboss::support::Maybe -GenericContainsContainsBitsView::has_condition() const { +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< @@ -25911,8 +30175,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericContainsContainsBitsView::top() const { - if (has_top().ValueOr(false)) { +GenericConditionalOnFlagView::value() const { + if (has_value().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -25949,73 +30213,69 @@ 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))); +GenericConditionalOnFlagView::has_value() const { + return (enabled().Ok() + ? ::emboss::support::Maybe( + static_cast(enabled().UncheckedRead())) + : ::emboss::support::Maybe()); } template -inline typename GenericContainsContainsBitsView< +inline typename GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericContainsContainsBitsView::IntrinsicSizeInBytes() const { - return typename GenericContainsContainsBitsView< +GenericConditionalOnFlagView::IntrinsicSizeInBytes() const { + return typename GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericContainsContainsBitsView::has_IntrinsicSizeInBytes() const { +GenericConditionalOnFlagView::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ContainsContainsBits { +namespace ConditionalOnFlag { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(2LL)) .ValueOrDefault(); } -} // namespace ContainsContainsBits +} // namespace ConditionalOnFlag template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ContainsContainsBits::MaxSizeInBytes(); + return ConditionalOnFlag::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ContainsContainsBits::MaxSizeInBytes(); + return ConditionalOnFlag::MaxSizeInBytes(); } -namespace ContainsContainsBits { +namespace ConditionalOnFlag { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ContainsContainsBits +} // namespace ConditionalOnFlag template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ContainsContainsBits::MinSizeInBytes(); + return ConditionalOnFlag::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericContainsContainsBitsView< +inline constexpr ::std::int32_t GenericConditionalOnFlagView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ContainsContainsBits::MinSizeInBytes(); + return ConditionalOnFlag::MinSizeInBytes(); } -namespace ConditionalInline { -namespace Type0 {} // namespace Type0 +namespace ResidualConditionalDiscriminant { + +} // namespace ResidualConditionalDiscriminant template inline typename ::emboss::prelude::UIntView< @@ -26026,8 +30286,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType0View::a() const { - if (has_a().ValueOr(false)) { +GenericResidualConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -26063,7 +30323,8 @@ GenericType0View::a() const { } template -inline ::emboss::support::Maybe GenericType0View::has_a() const { +inline ::emboss::support::Maybe +GenericResidualConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } @@ -26076,8 +30337,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType0View::b() const { - if (has_b().ValueOr(false)) { +GenericResidualConditionalDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -26113,8 +30374,16 @@ GenericType0View::b() const { } template -inline ::emboss::support::Maybe GenericType0View::has_b() const { - return ::emboss::support::Maybe(true); +inline ::emboss::support::Maybe +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 @@ -26126,8 +30395,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType0View::c() const { - if (has_c().ValueOr(false)) { +GenericResidualConditionalDiscriminantView::a() const { + if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -26163,71 +30432,152 @@ GenericType0View::c() const { } template -inline ::emboss::support::Maybe GenericType0View::has_c() const { - return ::emboss::support::Maybe(true); +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)))); } -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>> + +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(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>> + + (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>> + + (); } -} // namespace Type0 template -inline constexpr ::std::int32_t GenericType0View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return Type0::IntrinsicSizeInBytes(); +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 GenericResidualConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView +GenericResidualConditionalDiscriminantView::IntrinsicSizeInBytes() + const { + return typename GenericResidualConditionalDiscriminantView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline constexpr ::std::int32_t GenericType0View:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return Type0::IntrinsicSizeInBytes(); +inline ::emboss::support::Maybe +GenericResidualConditionalDiscriminantView::has_IntrinsicSizeInBytes() + const { + return ::emboss::support::Maybe(true); } -namespace Type0 { +namespace ResidualConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace Type0 +} // namespace ResidualConditionalDiscriminant template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return Type0::MaxSizeInBytes(); + return ResidualConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return Type0::MaxSizeInBytes(); + return ResidualConditionalDiscriminant::MaxSizeInBytes(); } -namespace Type0 { +namespace ResidualConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(3LL)) + static_cast(1LL)) .ValueOrDefault(); } -} // namespace Type0 +} // namespace ResidualConditionalDiscriminant template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return Type0::MinSizeInBytes(); + return ResidualConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericType0View< +inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return Type0::MinSizeInBytes(); + return ResidualConditionalDiscriminant::MinSizeInBytes(); } +namespace BareConditionalDiscriminant { -namespace Type1 {} // namespace Type1 +} // namespace BareConditionalDiscriminant template inline typename ::emboss::prelude::UIntView< @@ -26238,8 +30588,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType1View::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)); @@ -26275,7 +30625,8 @@ GenericType1View::a() const { } template -inline ::emboss::support::Maybe GenericType1View::has_a() const { +inline ::emboss::support::Maybe +GenericBareConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } @@ -26288,8 +30639,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType1View::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)); @@ -26325,8 +30676,16 @@ GenericType1View::b() const { } template -inline ::emboss::support::Maybe GenericType1View::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 @@ -26338,8 +30697,8 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericType1View::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)); @@ -26375,89 +30734,34 @@ GenericType1View::c() const { } template -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 constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { - return Type1::IntrinsicSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericType1View:: - EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { - return Type1::IntrinsicSizeInBytes(); -} - -namespace Type1 { -inline constexpr ::std::int32_t MaxSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(3LL)) - .ValueOrDefault(); -} -} // namespace Type1 - -template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return Type1::MaxSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return Type1::MaxSizeInBytes(); -} - -namespace Type1 { -inline constexpr ::std::int32_t MinSizeInBytes() { - return ::emboss::support::Maybe( - static_cast(3LL)) - .ValueOrDefault(); -} -} // namespace Type1 - -template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return Type1::MinSizeInBytes(); -} - -template -inline constexpr ::std::int32_t GenericType1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return Type1::MinSizeInBytes(); +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 ConditionalInline - 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>> -GenericConditionalInlineView::payload_id() const { - if (has_payload_id().ValueOr(false)) { +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(0LL)); + static_cast(3LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -26467,10 +30771,10 @@ GenericConditionalInlineView::payload_id() 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, 3>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -26480,7 +30784,7 @@ GenericConditionalInlineView::payload_id() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -26488,162 +30792,82 @@ GenericConditionalInlineView::payload_id() const { template inline ::emboss::support::Maybe -GenericConditionalInlineView::has_payload_id() const { - return ::emboss::support::Maybe(true); -} - -template -inline typename ::emboss::test::ConditionalInline::GenericType0View< - typename Storage::template OffsetStorageType> - -GenericConditionalInlineView::type_0() const { - if (has_type_0().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)); - 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::GenericType1View< - typename Storage::template OffsetStorageType> - - (backing_.template GetOffsetStorage<0, 1>( - emboss_reserved_local_offset.ValueOrDefault(), - emboss_reserved_local_size.ValueOrDefault())); - } - } - return ::emboss::test::ConditionalInline::GenericType1View< - typename Storage::template OffsetStorageType> - - (); -} - -template -inline ::emboss::support::Maybe -GenericConditionalInlineView::has_type_1() const { +GenericBareConditionalDiscriminantView::has_b() const { return ::emboss::support::Equal( - (payload_id().Ok() - ? ::emboss::support::Maybe( - static_cast(payload_id().UncheckedRead())) - : ::emboss::support::Maybe()), + (tag().Ok() ? ::emboss::support::Maybe( + static_cast(tag().UncheckedRead())) + : ::emboss::support::Maybe()), ::emboss::support::Maybe( static_cast(1LL))); } template -inline typename GenericConditionalInlineView< +inline typename GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalInlineView::IntrinsicSizeInBytes() const { - return typename GenericConditionalInlineView< +GenericBareConditionalDiscriminantView::IntrinsicSizeInBytes() const { + return typename GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } -template -inline ::emboss::support::Maybe -GenericConditionalInlineView::has_IntrinsicSizeInBytes() const { +template +inline ::emboss::support::Maybe GenericBareConditionalDiscriminantView< + Storage>::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionalInline { +namespace BareConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(4LL)) .ValueOrDefault(); } -} // namespace ConditionalInline +} // namespace BareConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalInlineView< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalInline::MaxSizeInBytes(); + return BareConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalInlineView< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalInline::MaxSizeInBytes(); + return BareConditionalDiscriminant::MaxSizeInBytes(); } -namespace ConditionalInline { +namespace BareConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalInline +} // namespace BareConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalInlineView< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalInline::MinSizeInBytes(); + return BareConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalInlineView< +inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalInline::MinSizeInBytes(); + return BareConditionalDiscriminant::MinSizeInBytes(); } -namespace ConditionalAnonymous { -namespace EmbossReservedAnonymousField2 { - -} // namespace EmbossReservedAnonymousField2 +namespace DominatedBareDiscriminant {} // namespace DominatedBareDiscriminant 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)) { +GenericDominatedBareDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -26656,8 +30880,11 @@ GenericEmbossReservedAnonymousField2View::low() const { 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, 0>( emboss_reserved_local_offset.ValueOrDefault(), @@ -26666,62 +30893,75 @@ GenericEmbossReservedAnonymousField2View::low() const { } 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_low() const { +GenericDominatedBareDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } template inline typename ::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>> -GenericEmbossReservedAnonymousField2View::mid() const { - if (has_mid().ValueOr(false)) { +GenericDominatedBareDiscriminantView::tag() const { + if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( - static_cast(2LL)); + static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(3LL)); + 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< - 2, ::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, 3>( + (backing_.template GetOffsetStorage<0, 1>( 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 { +GenericDominatedBareDiscriminantView::has_tag() const { return ::emboss::support::Equal( - (low().Ok() ? ::emboss::support::Maybe( - static_cast(low().UncheckedRead())) - : ::emboss::support::Maybe()), + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast(outer().UncheckedRead())) + : ::emboss::support::Maybe()), ::emboss::support::Maybe( static_cast(1LL))); } @@ -26729,125 +30969,77 @@ GenericEmbossReservedAnonymousField2View::has_mid() const { 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)) { +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(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(); -} -} // 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(); +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))); } -} // 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>> -GenericConditionalAnonymousView::x() const { - if (has_x().ValueOr(false)) { +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(0LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -26857,10 +31049,10 @@ GenericConditionalAnonymousView::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())); } @@ -26870,7 +31062,7 @@ GenericConditionalAnonymousView::x() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -26878,155 +31070,141 @@ GenericConditionalAnonymousView::x() const { template inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_x() const { - return ::emboss::support::Maybe(true); +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 -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)) { +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(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::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>( + (backing_.template GetOffsetStorage<0, 3>( 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()), - ::emboss::support::Maybe( - static_cast(10LL))); -} - -template -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()); +GenericDominatedBareDiscriminantView::has_tail() const { + return ::emboss::support::Maybe(true); } -template -inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_high() const { - return ::emboss::support::And( - has_emboss_reserved_anonymous_field_2(), - ::emboss::support::Maybe(true)); +namespace DominatedBareDiscriminant { +inline constexpr ::std::int32_t IntrinsicSizeInBytes() { + return ::emboss::support::Maybe( + static_cast(4LL)) + .ValueOrDefault(); } +} // namespace DominatedBareDiscriminant template -inline typename GenericConditionalAnonymousView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalAnonymousView::IntrinsicSizeInBytes() const { - return typename GenericConditionalAnonymousView< - Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< + Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView::Read() { + return DominatedBareDiscriminant::IntrinsicSizeInBytes(); } template -inline ::emboss::support::Maybe -GenericConditionalAnonymousView::has_IntrinsicSizeInBytes() const { - return ::emboss::support::Maybe(true); +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView:: + EmbossReservedDollarVirtualIntrinsicSizeInBytesView::UncheckedRead() { + return DominatedBareDiscriminant::IntrinsicSizeInBytes(); } -namespace ConditionalAnonymous { +namespace DominatedBareDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace ConditionalAnonymous +} // namespace DominatedBareDiscriminant template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalAnonymous::MaxSizeInBytes(); + return DominatedBareDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalAnonymous::MaxSizeInBytes(); + return DominatedBareDiscriminant::MaxSizeInBytes(); } -namespace ConditionalAnonymous { +namespace DominatedBareDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( - static_cast(1LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace ConditionalAnonymous +} // namespace DominatedBareDiscriminant template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalAnonymous::MinSizeInBytes(); + return DominatedBareDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalAnonymousView< +inline constexpr ::std::int32_t GenericDominatedBareDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalAnonymous::MinSizeInBytes(); + return DominatedBareDiscriminant::MinSizeInBytes(); } -namespace ConditionalOnFlag { -namespace EmbossReservedAnonymousField1 { +namespace DisjunctionConditionalDiscriminant { -} // namespace EmbossReservedAnonymousField1 +} // namespace DisjunctionConditionalDiscriminant template -inline typename ::emboss::prelude::FlagView< +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>> -GenericEmbossReservedAnonymousField1View::enabled() const { - if (has_enabled().ValueOr(false)) { +GenericDisjunctionConditionalDiscriminantView::outer() const { + if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( static_cast(1LL)); @@ -27037,148 +31215,168 @@ 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< + 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, 0>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } } - return ::emboss::prelude::FlagView< + 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 -GenericEmbossReservedAnonymousField1View::has_enabled() const { +GenericDisjunctionConditionalDiscriminantView::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::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 GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMaxSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField1::MaxSizeInBits(); -} +GenericDisjunctionConditionalDiscriminantView::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>> -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::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 GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::Read() { - return EmbossReservedAnonymousField1::MinSizeInBits(); + (); } template -inline constexpr ::std::int32_t GenericEmbossReservedAnonymousField1View< - Storage>::EmbossReservedDollarVirtualMinSizeInBitsView::UncheckedRead() { - return EmbossReservedAnonymousField1::MinSizeInBits(); +inline ::emboss::support::Maybe +GenericDisjunctionConditionalDiscriminantView::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))); } -} // 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)) { +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)); + 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 { +GenericDisjunctionConditionalDiscriminantView::has_a() const { return ::emboss::support::And( - ::emboss::support::Maybe(true), - ::emboss::support::Maybe(true)); + ::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 @@ -27187,17 +31385,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)) { +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(1LL)); + static_cast(3LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -27207,10 +31405,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, 3>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -27220,7 +31418,7 @@ GenericConditionalOnFlagView::value() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -27228,69 +31426,93 @@ 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()); +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)))); } template -inline typename GenericConditionalOnFlagView< +inline typename GenericDisjunctionConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericConditionalOnFlagView::IntrinsicSizeInBytes() const { - return typename GenericConditionalOnFlagView< +GenericDisjunctionConditionalDiscriminantView::IntrinsicSizeInBytes() + const { + return typename GenericDisjunctionConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericConditionalOnFlagView::has_IntrinsicSizeInBytes() const { +GenericDisjunctionConditionalDiscriminantView< + Storage>::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ConditionalOnFlag { +namespace DisjunctionConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(2LL)) + static_cast(4LL)) .ValueOrDefault(); } -} // namespace ConditionalOnFlag +} // namespace DisjunctionConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericDisjunctionConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ConditionalOnFlag::MaxSizeInBytes(); + return DisjunctionConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericDisjunctionConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ConditionalOnFlag::MaxSizeInBytes(); + return DisjunctionConditionalDiscriminant::MaxSizeInBytes(); } -namespace ConditionalOnFlag { +namespace DisjunctionConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ConditionalOnFlag +} // namespace DisjunctionConditionalDiscriminant template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericDisjunctionConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ConditionalOnFlag::MinSizeInBytes(); + return DisjunctionConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericConditionalOnFlagView< +inline constexpr ::std::int32_t GenericDisjunctionConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ConditionalOnFlag::MinSizeInBytes(); + return DisjunctionConditionalDiscriminant::MinSizeInBytes(); } -namespace ResidualConditionalDiscriminant { +namespace SingleEntryConditionalDiscriminant { -} // namespace ResidualConditionalDiscriminant +} // namespace SingleEntryConditionalDiscriminant template inline typename ::emboss::prelude::UIntView< @@ -27301,7 +31523,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericResidualConditionalDiscriminantView::outer() const { +GenericSingleEntryConditionalDiscriminantView::outer() const { if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -27339,7 +31561,7 @@ GenericResidualConditionalDiscriminantView::outer() const { template inline ::emboss::support::Maybe -GenericResidualConditionalDiscriminantView::has_outer() const { +GenericSingleEntryConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } @@ -27352,7 +31574,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericResidualConditionalDiscriminantView::tag() const { +GenericSingleEntryConditionalDiscriminantView::tag() const { if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -27390,7 +31612,7 @@ GenericResidualConditionalDiscriminantView::tag() const { template inline ::emboss::support::Maybe -GenericResidualConditionalDiscriminantView::has_tag() const { +GenericSingleEntryConditionalDiscriminantView::has_tag() const { return ::emboss::support::Equal( (outer().Ok() @@ -27410,7 +31632,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericResidualConditionalDiscriminantView::a() const { +GenericSingleEntryConditionalDiscriminantView::a() const { if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -27448,7 +31670,7 @@ GenericResidualConditionalDiscriminantView::a() const { template inline ::emboss::support::Maybe -GenericResidualConditionalDiscriminantView::has_a() const { +GenericSingleEntryConditionalDiscriminantView::has_a() const { return ::emboss::support::And( ::emboss::support::Equal( @@ -27469,141 +31691,75 @@ GenericResidualConditionalDiscriminantView::has_a() const { } 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(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>> - - (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>> - - (); -} - -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 GenericResidualConditionalDiscriminantView< +inline typename GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericResidualConditionalDiscriminantView::IntrinsicSizeInBytes() +GenericSingleEntryConditionalDiscriminantView::IntrinsicSizeInBytes() const { - return typename GenericResidualConditionalDiscriminantView< + return typename GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template inline ::emboss::support::Maybe -GenericResidualConditionalDiscriminantView::has_IntrinsicSizeInBytes() - const { +GenericSingleEntryConditionalDiscriminantView< + Storage>::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace ResidualConditionalDiscriminant { +namespace SingleEntryConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(4LL)) + static_cast(3LL)) .ValueOrDefault(); } -} // namespace ResidualConditionalDiscriminant +} // namespace SingleEntryConditionalDiscriminant template -inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< +inline constexpr ::std::int32_t GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return ResidualConditionalDiscriminant::MaxSizeInBytes(); + return SingleEntryConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< +inline constexpr ::std::int32_t GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return ResidualConditionalDiscriminant::MaxSizeInBytes(); + return SingleEntryConditionalDiscriminant::MaxSizeInBytes(); } -namespace ResidualConditionalDiscriminant { +namespace SingleEntryConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace ResidualConditionalDiscriminant +} // namespace SingleEntryConditionalDiscriminant template -inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< +inline constexpr ::std::int32_t GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return ResidualConditionalDiscriminant::MinSizeInBytes(); + return SingleEntryConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericResidualConditionalDiscriminantView< +inline constexpr ::std::int32_t GenericSingleEntryConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return ResidualConditionalDiscriminant::MinSizeInBytes(); + return SingleEntryConditionalDiscriminant::MinSizeInBytes(); } -namespace BareConditionalDiscriminant { +namespace EnumConditionalDiscriminant { -} // namespace BareConditionalDiscriminant +} // namespace EnumConditionalDiscriminant 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>> -GenericBareConditionalDiscriminantView::outer() const { +GenericEnumConditionalDiscriminantView::outer() const { if (has_outer().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -27615,8 +31771,9 @@ GenericBareConditionalDiscriminantView::outer() 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< @@ -27628,8 +31785,9 @@ GenericBareConditionalDiscriminantView::outer() 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< @@ -27641,20 +31799,21 @@ GenericBareConditionalDiscriminantView::outer() const { template inline ::emboss::support::Maybe -GenericBareConditionalDiscriminantView::has_outer() const { +GenericEnumConditionalDiscriminantView::has_outer() const { return ::emboss::support::Maybe(true); } 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>> -GenericBareConditionalDiscriminantView::tag() const { +GenericEnumConditionalDiscriminantView::tag() const { if (has_tag().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -27666,8 +31825,9 @@ GenericBareConditionalDiscriminantView::tag() 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< @@ -27679,8 +31839,9 @@ GenericBareConditionalDiscriminantView::tag() 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< @@ -27692,15 +31853,15 @@ GenericBareConditionalDiscriminantView::tag() const { template 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))); +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))); } template @@ -27712,7 +31873,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericBareConditionalDiscriminantView::a() const { +GenericEnumConditionalDiscriminantView::a() const { if (has_a().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -27750,14 +31911,25 @@ GenericBareConditionalDiscriminantView::a() const { template 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))); +GenericEnumConditionalDiscriminantView::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(0))), + ::emboss::support::Equal( + (outer().Ok() + ? ::emboss::support::Maybe( + static_cast( + outer().UncheckedRead())) + : ::emboss::support::Maybe()), + ::emboss::support::Maybe( + static_cast(1)))); } template @@ -27769,7 +31941,7 @@ inline typename ::emboss::prelude::UIntView< typename Storage::template OffsetStorageType>, 8>> -GenericBareConditionalDiscriminantView::b() const { +GenericEnumConditionalDiscriminantView::b() const { if (has_b().ValueOr(false)) { auto emboss_reserved_local_size = ::emboss::support::Maybe( @@ -27807,68 +31979,79 @@ GenericBareConditionalDiscriminantView::b() const { template 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))); +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 GenericBareConditionalDiscriminantView< +inline typename GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView -GenericBareConditionalDiscriminantView::IntrinsicSizeInBytes() const { - return typename GenericBareConditionalDiscriminantView< +GenericEnumConditionalDiscriminantView::IntrinsicSizeInBytes() const { + return typename GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualIntrinsicSizeInBytesView(*this); } template -inline ::emboss::support::Maybe GenericBareConditionalDiscriminantView< +inline ::emboss::support::Maybe GenericEnumConditionalDiscriminantView< Storage>::has_IntrinsicSizeInBytes() const { return ::emboss::support::Maybe(true); } -namespace BareConditionalDiscriminant { +namespace EnumConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( static_cast(4LL)) .ValueOrDefault(); } -} // namespace BareConditionalDiscriminant +} // namespace EnumConditionalDiscriminant template -inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< +inline constexpr ::std::int32_t GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::Read() { - return BareConditionalDiscriminant::MaxSizeInBytes(); + return EnumConditionalDiscriminant::MaxSizeInBytes(); } template -inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< +inline constexpr ::std::int32_t GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMaxSizeInBytesView::UncheckedRead() { - return BareConditionalDiscriminant::MaxSizeInBytes(); + return EnumConditionalDiscriminant::MaxSizeInBytes(); } -namespace BareConditionalDiscriminant { +namespace EnumConditionalDiscriminant { inline constexpr ::std::int32_t MinSizeInBytes() { return ::emboss::support::Maybe( static_cast(1LL)) .ValueOrDefault(); } -} // namespace BareConditionalDiscriminant +} // namespace EnumConditionalDiscriminant template -inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< +inline constexpr ::std::int32_t GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::Read() { - return BareConditionalDiscriminant::MinSizeInBytes(); + return EnumConditionalDiscriminant::MinSizeInBytes(); } template -inline constexpr ::std::int32_t GenericBareConditionalDiscriminantView< +inline constexpr ::std::int32_t GenericEnumConditionalDiscriminantView< Storage>::EmbossReservedDollarVirtualMinSizeInBytesView::UncheckedRead() { - return BareConditionalDiscriminant::MinSizeInBytes(); + return EnumConditionalDiscriminant::MinSizeInBytes(); } } // namespace test From f9a5cfb120d486b23658139456de65c4f2d28113 Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Thu, 4 Jun 2026 13:56:45 -0700 Subject: [PATCH 3/3] Overlap a/b at offset 2 in conditional-discriminant test structs Tagged-union alternatives are mutually exclusive, so placing `a` and `b` at the same offset is a more realistic layout (and avoids miscopying when these structs are reused as templates for new tests). Only the physical field layout changes -- the switch structure and Ok() behavior are identical. --- .../back_end/cpp/testcode/condition_test.cc | 5 +- testdata/condition.emb | 8 +-- testdata/golden_cpp/condition.emb.h | 64 +++++++++---------- 3 files changed, 39 insertions(+), 38 deletions(-) diff --git a/compiler/back_end/cpp/testcode/condition_test.cc b/compiler/back_end/cpp/testcode/condition_test.cc index 7f17902a..850fbadb 100644 --- a/compiler/back_end/cpp/testcode/condition_test.cc +++ b/compiler/back_end/cpp/testcode/condition_test.cc @@ -445,8 +445,9 @@ TEST(Conditional, DisjunctionConditionalDiscriminantBothDisjunctsSelectField) { } TEST(Conditional, DisjunctionConditionalDiscriminantSecondArmAndNoMatch) { - // tag == 2 selects `b`; tag == 9 selects neither (still valid). - ::std::uint8_t buffer2[4] = {1, 2, 0, 6}; + // 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()); diff --git a/testdata/condition.emb b/testdata/condition.emb index 04003ab9..e93dcce5 100644 --- a/testdata/condition.emb +++ b/testdata/condition.emb @@ -246,7 +246,7 @@ struct ResidualConditionalDiscriminant: 2 [+1] UInt a if tag == 1 && outer == 1: - 3 [+1] UInt b + 2 [+1] UInt b struct BareConditionalDiscriminant: @@ -262,7 +262,7 @@ struct BareConditionalDiscriminant: 2 [+1] UInt a if tag == 1: - 3 [+1] UInt b + 2 [+1] UInt b struct DominatedBareDiscriminant: @@ -298,7 +298,7 @@ struct DisjunctionConditionalDiscriminant: 2 [+1] UInt a if (tag == 2 || tag == 3) && outer == 1: - 3 [+1] UInt b + 2 [+1] UInt b struct SingleEntryConditionalDiscriminant: @@ -324,4 +324,4 @@ struct EnumConditionalDiscriminant: 2 [+1] UInt a if tag == OnOff.ON && outer == OnOff.ON: - 3 [+1] UInt b + 2 [+1] UInt b diff --git a/testdata/golden_cpp/condition.emb.h b/testdata/golden_cpp/condition.emb.h index 0f425952..be99df26 100644 --- a/testdata/golden_cpp/condition.emb.h +++ b/testdata/golden_cpp/condition.emb.h @@ -19982,7 +19982,7 @@ class GenericResidualConditionalDiscriminantView final { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> b() const; @@ -20095,7 +20095,7 @@ class GenericResidualConditionalDiscriminantView final { ::std::int32_t, ::std::int32_t>( emboss_reserved_local_subexpr_11, ::emboss::support::Maybe( - static_cast(4LL)), + static_cast(3LL)), ::emboss::support::Maybe( static_cast(0LL))); const auto emboss_reserved_local_subexpr_13 = ::emboss::support::Maximum< @@ -20746,7 +20746,7 @@ class GenericBareConditionalDiscriminantView final { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> b() const; @@ -20852,7 +20852,7 @@ class GenericBareConditionalDiscriminantView final { ::std::int32_t, ::std::int32_t>( emboss_reserved_local_subexpr_9, ::emboss::support::Maybe( - static_cast(4LL)), + static_cast(3LL)), ::emboss::support::Maybe( static_cast(0LL))); const auto emboss_reserved_local_subexpr_11 = ::emboss::support::Maximum< @@ -22254,7 +22254,7 @@ class GenericDisjunctionConditionalDiscriminantView final { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> b() const; @@ -22386,7 +22386,7 @@ class GenericDisjunctionConditionalDiscriminantView final { ::std::int32_t, ::std::int32_t>( emboss_reserved_local_subexpr_15, ::emboss::support::Maybe( - static_cast(4LL)), + static_cast(3LL)), ::emboss::support::Maybe( static_cast(0LL))); const auto emboss_reserved_local_subexpr_17 = ::emboss::support::Maximum< @@ -23695,7 +23695,7 @@ class GenericEnumConditionalDiscriminantView final { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> b() const; @@ -23811,7 +23811,7 @@ class GenericEnumConditionalDiscriminantView final { ::std::int32_t, ::std::int32_t>( emboss_reserved_local_subexpr_11, ::emboss::support::Maybe( - static_cast(4LL)), + static_cast(3LL)), ::emboss::support::Maybe( static_cast(0LL))); const auto emboss_reserved_local_subexpr_13 = ::emboss::support::Maximum< @@ -30459,7 +30459,7 @@ 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>> GenericResidualConditionalDiscriminantView::b() const { @@ -30469,7 +30469,7 @@ GenericResidualConditionalDiscriminantView::b() const { static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(3LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -30479,10 +30479,10 @@ GenericResidualConditionalDiscriminantView::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, 3>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -30492,7 +30492,7 @@ GenericResidualConditionalDiscriminantView::b() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -30539,7 +30539,7 @@ GenericResidualConditionalDiscriminantView::has_IntrinsicSizeInBytes() namespace ResidualConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(4LL)) + static_cast(3LL)) .ValueOrDefault(); } } // namespace ResidualConditionalDiscriminant @@ -30751,7 +30751,7 @@ 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>> GenericBareConditionalDiscriminantView::b() const { @@ -30761,7 +30761,7 @@ GenericBareConditionalDiscriminantView::b() const { static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(3LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -30771,10 +30771,10 @@ GenericBareConditionalDiscriminantView::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, 3>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -30784,7 +30784,7 @@ GenericBareConditionalDiscriminantView::b() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -30819,7 +30819,7 @@ inline ::emboss::support::Maybe GenericBareConditionalDiscriminantView< namespace BareConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(4LL)) + static_cast(3LL)) .ValueOrDefault(); } } // namespace BareConditionalDiscriminant @@ -31385,7 +31385,7 @@ 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>> GenericDisjunctionConditionalDiscriminantView::b() const { @@ -31395,7 +31395,7 @@ GenericDisjunctionConditionalDiscriminantView::b() const { static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(3LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -31405,10 +31405,10 @@ GenericDisjunctionConditionalDiscriminantView::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, 3>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -31418,7 +31418,7 @@ GenericDisjunctionConditionalDiscriminantView::b() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -31474,7 +31474,7 @@ GenericDisjunctionConditionalDiscriminantView< namespace DisjunctionConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(4LL)) + static_cast(3LL)) .ValueOrDefault(); } } // namespace DisjunctionConditionalDiscriminant @@ -31938,7 +31938,7 @@ 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>> GenericEnumConditionalDiscriminantView::b() const { @@ -31948,7 +31948,7 @@ GenericEnumConditionalDiscriminantView::b() const { static_cast(1LL)); auto emboss_reserved_local_offset = ::emboss::support::Maybe( - static_cast(3LL)); + static_cast(2LL)); if (emboss_reserved_local_size.Known() && emboss_reserved_local_size.ValueOr(0) >= 0 && emboss_reserved_local_offset.Known() && @@ -31958,10 +31958,10 @@ GenericEnumConditionalDiscriminantView::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, 3>( + (backing_.template GetOffsetStorage<0, 2>( emboss_reserved_local_offset.ValueOrDefault(), emboss_reserved_local_size.ValueOrDefault())); } @@ -31971,7 +31971,7 @@ GenericEnumConditionalDiscriminantView::b() const { 8, ::emboss::support::AllValuesAreOk>, typename ::emboss::support::BitBlock< /**/ ::emboss::support::LittleEndianByteOrderer< - typename Storage::template OffsetStorageType>, + typename Storage::template OffsetStorageType>, 8>> (); @@ -32017,7 +32017,7 @@ inline ::emboss::support::Maybe GenericEnumConditionalDiscriminantView< namespace EnumConditionalDiscriminant { inline constexpr ::std::int32_t MaxSizeInBytes() { return ::emboss::support::Maybe( - static_cast(4LL)) + static_cast(3LL)) .ValueOrDefault(); } } // namespace EnumConditionalDiscriminant