| // Copyright 2019 Google LLC |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // -*- mode: C++ -*- |
| // vim: set filetype=cpp: |
| |
| // Fragments of C++ code used by the Emboss C++ code generator. Anything before |
| // the first template is ignored. The names between ** ** are used as template |
| // names. See code_template.py for more details. Local variable names are |
| // prefixed with `emboss_reserved_local_` to avoid conflicting with struct field |
| // names. |
| |
| // clang-format off |
| |
| // ** outline ** /////////////////////////////////////////////////////////////// |
| /** |
| * Generated by the Emboss compiler. DO NOT EDIT! |
| */ |
| #ifndef ${header_guard} |
| #define ${header_guard} |
| #include <stdint.h> |
| #include <string.h> |
| |
| #include <algorithm> |
| #include <ostream> |
| #include <type_traits> |
| #include <utility> |
| |
| #include "runtime/cpp/emboss_cpp_util.h" |
| |
| ${includes} |
| |
| /* NOLINTBEGIN */ |
| ${body} |
| /* NOLINTEND */ |
| |
| #endif // ${header_guard} |
| |
| |
| // ** include ** /////////////////////////////////////////////////////////////// |
| #include "${file_name}" |
| |
| |
| // ** body ** ////////////////////////////////////////////////////////////////// |
| ${type_declarations} |
| ${type_definitions} |
| ${method_definitions} |
| |
| |
| // ** namespace_wrap ** //////////////////////////////////////////////////////// |
| namespace ${component} { |
| ${body} |
| } // namespace ${component} |
| |
| |
| // ** structure_view_declaration ** //////////////////////////////////////////// |
| template <class Storage> |
| class Generic${name}View; |
| |
| |
| // ** structure_view_class ** ////////////////////////////////////////////////// |
| template <class View> |
| struct EmbossReservedInternalIsGeneric${name}View; |
| |
| template <class Storage> |
| class Generic${name}View final { |
| public: |
| Generic${name}View() : backing_() {} |
| explicit Generic${name}View( |
| ${constructor_parameters} Storage emboss_reserved_local_bytes) |
| : backing_(emboss_reserved_local_bytes) ${parameter_initializers} |
| ${initialize_parameters_initialized_true} {} |
| |
| // Views over compatible backing storage should be freely assignable. |
| template <typename OtherStorage> |
| Generic${name}View( |
| const Generic${name}View<OtherStorage> &emboss_reserved_local_other) |
| : backing_{emboss_reserved_local_other.BackingStorage()} |
| ${parameter_copy_initializers} {} |
| |
| // Allow pass-through construction of backing_, but only if there is at least |
| // one argument, and, if exactly one argument, that argument is not a |
| // (possibly c/v/ref-qualified) Generic${name}View. |
| // |
| // Explicitly ruling out overloads that might match the copy or move |
| // constructor is necessary in order for the copy and move constructors to be |
| // reliably found during overload resolution. |
| template <typename Arg, |
| typename = typename ::std::enable_if< |
| !EmbossReservedInternalIsGeneric${name}View< |
| typename ::std::remove_cv<typename ::std::remove_reference< |
| Arg>::type>::type>::value>::type> |
| explicit Generic${name}View( |
| ${constructor_parameters} Arg &&emboss_reserved_local_arg) |
| : backing_(::std::forward<Arg>( |
| emboss_reserved_local_arg)) ${parameter_initializers} |
| ${initialize_parameters_initialized_true} {} |
| template <typename Arg0, typename Arg1, typename... Args> |
| explicit Generic${name}View( |
| ${constructor_parameters} Arg0 &&emboss_reserved_local_arg0, |
| Arg1 &&emboss_reserved_local_arg1, Args &&... emboss_reserved_local_args) |
| : backing_(::std::forward<Arg0>(emboss_reserved_local_arg0), |
| ::std::forward<Arg1>(emboss_reserved_local_arg1), |
| ::std::forward<Args>( |
| emboss_reserved_local_args)...) ${parameter_initializers} |
| ${initialize_parameters_initialized_true} {} |
| |
| template <typename OtherStorage> |
| Generic${name}View<Storage> &operator=( |
| const Generic${name}View<OtherStorage> &emboss_reserved_local_other) { |
| backing_ = emboss_reserved_local_other.BackingStorage(); |
| return *this; |
| } |
| |
| ${enum_usings} |
| |
| bool Ok() const { |
| if (!IsComplete()) return false; |
| ${parameter_ok_checks} |
| ${field_ok_checks} |
| ${requires_check} |
| return true; |
| } |
| Storage BackingStorage() const { return backing_; } |
| bool IsComplete() const { |
| return backing_.Ok() && IntrinsicSizeIn${units}().Ok() && |
| backing_.SizeIn${units}() >= |
| static_cast</**/ ::std::size_t>( |
| IntrinsicSizeIn${units}().UncheckedRead()); |
| } |
| ${size_method} |
| |
| template <typename OtherStorage> |
| bool Equals( |
| Generic${name}View<OtherStorage> emboss_reserved_local_other) const { |
| ${equals_method_body} return true; |
| } |
| template <typename OtherStorage> |
| bool UncheckedEquals( |
| Generic${name}View<OtherStorage> emboss_reserved_local_other) const { |
| ${unchecked_equals_method_body} return true; |
| } |
| // (Unchecked)CopyFrom copies the number of bytes included in the other view, |
| // and ignores the size of the current view. Even if they differ before |
| // copying, the destination view's size should match the source view's size |
| // after copying, because any fields used in the calculation of the |
| // destination view's size should be updated by the copy. |
| template <typename OtherStorage> |
| void UncheckedCopyFrom( |
| Generic${name}View<OtherStorage> emboss_reserved_local_other) const { |
| backing_.UncheckedCopyFrom( |
| emboss_reserved_local_other.BackingStorage(), |
| emboss_reserved_local_other.IntrinsicSizeIn${units}().UncheckedRead()); |
| } |
| |
| template <typename OtherStorage> |
| void CopyFrom( |
| Generic${name}View<OtherStorage> emboss_reserved_local_other) const { |
| backing_.CopyFrom( |
| emboss_reserved_local_other.BackingStorage(), |
| emboss_reserved_local_other.IntrinsicSizeIn${units}().Read()); |
| } |
| template <typename OtherStorage> |
| bool TryToCopyFrom( |
| Generic${name}View<OtherStorage> emboss_reserved_local_other) const { |
| return emboss_reserved_local_other.Ok() && backing_.TryToCopyFrom( |
| emboss_reserved_local_other.BackingStorage(), |
| emboss_reserved_local_other.IntrinsicSizeIn${units}().Read()); |
| } |
| |
| template <class Stream> |
| 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; |
| ${decode_fields} |
| // decode_fields will `continue` if it successfully finds a field. |
| return false; |
| } |
| } |
| |
| template <class Stream> |
| 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; |
| ${write_fields} |
| // Avoid unused variable warnings for empty structures: |
| (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; } |
| |
| ${field_method_declarations} |
| |
| private: |
| Storage backing_; |
| ${parameter_fields} |
| ${parameters_initialized_flag} |
| |
| // This is a bit of a hack to handle Equals() and UncheckedEquals() between |
| // views with different underlying storage -- otherwise, structs with |
| // anonymous members run into access violations. |
| // |
| // TODO(bolms): Revisit this once the special-case code for anonymous members |
| // is replaced by explicit read/write virtual fields in the IR. |
| template <class OtherStorage> |
| friend class Generic${name}View; |
| }; |
| using ${name}View = |
| Generic${name}View</**/ ::emboss::support::ReadOnlyContiguousBuffer>; |
| using ${name}Writer = |
| Generic${name}View</**/ ::emboss::support::ReadWriteContiguousBuffer>; |
| |
| template <class View> |
| struct EmbossReservedInternalIsGeneric${name}View { |
| static constexpr const bool value = false; |
| }; |
| |
| template <class Storage> |
| struct EmbossReservedInternalIsGeneric${name}View< |
| Generic${name}View<Storage>> { |
| static constexpr const bool value = true; |
| }; |
| |
| template <typename T> |
| inline Generic${name}View< |
| /**/ ::emboss::support::ContiguousBuffer< |
| typename ::std::remove_reference< |
| decltype(*::std::declval<T>()->data())>::type, |
| 1, 0>> |
| Make${name}View(${constructor_parameters} T &&emboss_reserved_local_arg) { |
| return Generic${name}View< |
| /**/ ::emboss::support::ContiguousBuffer< |
| typename ::std::remove_reference<decltype( |
| *::std::declval<T>()->data())>::type, |
| 1, 0>>( |
| ${forwarded_parameters} ::std::forward<T>(emboss_reserved_local_arg)); |
| } |
| |
| template <typename T> |
| inline Generic${name}View</**/ ::emboss::support::ContiguousBuffer<T, 1, 0>> |
| Make${name}View(${constructor_parameters} T *emboss_reserved_local_data, |
| ::std::size_t emboss_reserved_local_size) { |
| return Generic${name}View</**/ ::emboss::support::ContiguousBuffer<T, 1, 0>>( |
| ${forwarded_parameters} emboss_reserved_local_data, |
| emboss_reserved_local_size); |
| } |
| |
| template <typename T, ::std::size_t kAlignment> |
| inline Generic${name}View< |
| /**/ ::emboss::support::ContiguousBuffer<T, kAlignment, 0>> |
| MakeAligned${name}View( |
| ${constructor_parameters} T *emboss_reserved_local_data, |
| ::std::size_t emboss_reserved_local_size) { |
| return Generic${name}View< |
| /**/ ::emboss::support::ContiguousBuffer<T, kAlignment, 0>>( |
| ${forwarded_parameters} emboss_reserved_local_data, |
| emboss_reserved_local_size); |
| } |
| |
| // ** decode_field ** ////////////////////////////////////////////////////////// |
| // If the field name matches ${field_name}, handle it, otherwise fall |
| // through to the next field. |
| if (emboss_reserved_local_name == "${field_name}") { |
| // TODO(bolms): How should missing optional fields be handled? |
| if (!${field_name}().UpdateFromTextStream( |
| emboss_reserved_local_stream)) { |
| return false; |
| } |
| continue; |
| } |
| |
| // ** write_field_to_text_stream ** //////////////////////////////////////////// |
| if (has_${field_name}().ValueOr(false)) { |
| // Don't try to read the field if `allow_partial_output` is set and the |
| // field can't be `Read()`. Aggregates should still be visited, even if |
| // they are not `Ok()` overall, since submembers may still be `Ok()`. |
| if (!emboss_reserved_local_field_options.allow_partial_output() || |
| ${field_name}().IsAggregate() || ${field_name}().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("${field_name}: "); |
| ${field_name}().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() && |
| !${field_name}().IsAggregate() && !${field_name}().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("# ${field_name}: UNREADABLE\n"); |
| } |
| } |
| |
| // ** write_read_only_field_to_text_stream ** ////////////////////////////////// |
| if (has_${field_name}().ValueOr(false) && |
| emboss_reserved_local_field_options.comments()) { |
| if (!emboss_reserved_local_field_options.allow_partial_output() || |
| ${field_name}().IsAggregate() || ${field_name}().Ok()) { |
| emboss_reserved_local_stream->Write( |
| emboss_reserved_local_field_options.current_indent()); |
| // TODO(bolms): When there are multiline read-only fields, add an option |
| // to TextOutputOptions to add `# ` to the current indent and use it |
| // here, so that subsequent lines are also commented out. |
| emboss_reserved_local_stream->Write("# ${field_name}: "); |
| ${field_name}().WriteToTextStream(emboss_reserved_local_stream, |
| emboss_reserved_local_field_options); |
| emboss_reserved_local_stream->Write("\n"); |
| } else { |
| if (emboss_reserved_local_field_options.multiline()) { |
| emboss_reserved_local_stream->Write( |
| emboss_reserved_local_field_options.current_indent()); |
| } |
| emboss_reserved_local_stream->Write("# ${field_name}: UNREADABLE\n"); |
| } |
| } |
| |
| // ** constant_structure_size_method ** //////////////////////////////////////// |
| static constexpr ::std::size_t SizeIn${units}() { |
| return static_cast</**/ ::std::size_t>(IntrinsicSizeIn${units}().Read()); |
| } |
| static constexpr bool SizeIsKnown() { |
| return IntrinsicSizeIn${units}().Ok(); |
| } |
| |
| // ** runtime_structure_size_method ** ///////////////////////////////////////// |
| ::std::size_t SizeIn${units}() const { |
| return static_cast</**/ ::std::size_t>(IntrinsicSizeIn${units}().Read()); |
| } |
| bool SizeIsKnown() const { return IntrinsicSizeIn${units}().Ok(); } |
| |
| |
| // ** ok_method_test ** //////////////////////////////////////////////////////// |
| // If we don't have enough information to determine whether ${field} is |
| // present in the structure, then structure.Ok() should be false. |
| if (!has_${field}.Known()) return false; |
| // If ${field} is present, but not Ok(), then structure.Ok() should be |
| // false. If ${field} is not present, it does not matter whether it is |
| // Ok(). |
| if (has_${field}.ValueOrDefault() && !${field}.Ok()) return false; |
| |
| |
| // ** equals_method_test ** //////////////////////////////////////////////////// |
| // If this->${field} is not equal to emboss_reserved_local_other.${field}, |
| // then the structures are not equal. |
| |
| // If either structure's has_${field} is unknown, then default to not |
| // Equals(). |
| // |
| // TODO(bolms): Should Equals() return Maybe<bool> and/or return true for |
| // non-Ok()-but-equivalent structures? |
| if (!has_${field}.Known()) return false; |
| if (!emboss_reserved_local_other.has_${field}.Known()) return false; |
| |
| // If one side has ${field} but the other side does not, then the fields |
| // are not equal. We use ValueOrDefault() instead of Value() since Value() |
| // is more complex and non-constexpr, and we already know that |
| // has_${field}.Known() is true for both structures. |
| if (emboss_reserved_local_other.has_${field}.ValueOrDefault() && |
| !has_${field}.ValueOrDefault()) |
| return false; |
| if (has_${field}.ValueOrDefault() && |
| !emboss_reserved_local_other.has_${field}.ValueOrDefault()) |
| return false; |
| |
| // If both sides have ${field}, then check that their Equals() returns |
| // true. |
| if (emboss_reserved_local_other.has_${field}.ValueOrDefault() && |
| has_${field}.ValueOrDefault() && |
| !${field}.Equals(emboss_reserved_local_other.${field})) |
| return false; |
| |
| |
| // ** unchecked_equals_method_test ** ////////////////////////////////////////// |
| // The contract for UncheckedEquals() is that the caller must assure that |
| // both views are Ok() (which implies that has_${field}.Known() is true), |
| // and UncheckedEquals() will never perform any assertion checks (which |
| // implies that UncheckedEquals() cannot call has_${field}.Value()). |
| |
| // If this->has_${field} but !emboss_reserved_local_other.has_${field}, or |
| // vice versa, then the structures are not equal. If neither structure |
| // has_${field}, then ${field} is considered equal. |
| if (emboss_reserved_local_other.has_${field}.ValueOr(false) && |
| !has_${field}.ValueOr(false)) |
| return false; |
| if (has_${field}.ValueOr(false) && |
| !emboss_reserved_local_other.has_${field}.ValueOr(false)) |
| return false; |
| |
| // If ${field} is present in both structures, then check its equality. |
| if (emboss_reserved_local_other.has_${field}.ValueOr(false) && |
| has_${field}.ValueOr(false) && |
| !${field}.UncheckedEquals(emboss_reserved_local_other.${field})) |
| return false; |
| |
| |
| // ** structure_view_type ** /////////////////////////////////////////////////// |
| ${namespace}::Generic${name}View<typename ${buffer_type}> |
| |
| |
| // ** external_view_type ** //////////////////////////////////////////////////// |
| ${namespace}::${name}View< |
| /**/ ::emboss::support::FixedSizeViewParameters<${bits}, ${validator}>, |
| typename ${buffer_type}> |
| |
| |
| // ** enum_view_type ** //////////////////////////////////////////////////////// |
| ${support_namespace}::EnumView< |
| /**/ ${enum_type}, |
| ::emboss::support::FixedSizeViewParameters<${bits}, ${validator}>, |
| typename ${buffer_type}> |
| |
| |
| // ** array_view_adapter ** //////////////////////////////////////////////////// |
| ${support_namespace}::GenericArrayView< |
| typename ${element_view_type}, typename ${buffer_type}, ${element_size}, |
| ${addressable_unit_size} ${element_view_parameter_types}> |
| |
| |
| // ** structure_field_validator ** ///////////////////////////////////////////// |
| struct ${name} { |
| template <typename ValueType> |
| static constexpr bool ValueIsOk(ValueType emboss_reserved_local_value) { |
| (void)emboss_reserved_local_value; // Silence -Wunused-parameter |
| return (${expression}).ValueOrDefault(); |
| } |
| }; |
| |
| |
| // ** structure_single_field_method_declarations ** //////////////////////////// |
| ${visibility}: |
| typename ${type_reader} ${name}() const; |
| ::emboss::support::Maybe<bool> has_${name}() const; |
| |
| |
| // ** structure_single_field_method_definitions ** ///////////////////////////// |
| template <class Storage> |
| inline typename ${type_reader} Generic${parent_type}View<Storage>::${name}() |
| const { |
| // If it's not possible to read the location of this field, provide a view |
| // into a null storage -- the only safe methods to call on it will be Ok() and |
| // IsComplete(), but it is necessary to return a view so that client code can |
| // call those methods at all. Similarly, if the end of the field would come |
| // before the start, we provide a null storage, though arguably we should |
| // not. |
| ${parameter_subexpressions} |
| if (${parameters_known} has_${name}().ValueOr(false)) { |
| ${size_and_offset_subexpressions} |
| auto emboss_reserved_local_size = ${size}; |
| auto emboss_reserved_local_offset = ${offset}; |
| 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 ${type_reader}( |
| ${parameter_values} backing_ |
| .template GetOffsetStorage<${alignment}, |
| ${static_offset}>( |
| emboss_reserved_local_offset.ValueOrDefault(), |
| emboss_reserved_local_size.ValueOrDefault())); |
| } |
| } |
| return ${type_reader}(); |
| } |
| |
| template <class Storage> |
| inline ::emboss::support::Maybe<bool> |
| Generic${parent_type}View<Storage>::has_${name}() const { |
| return ${field_exists}; |
| } |
| |
| |
| // ** structure_single_const_virtual_field_method_declarations ** ////////////// |
| ${visibility}: |
| class ${virtual_view_type_name} final { |
| public: |
| using ValueType = ${logical_type}; |
| |
| constexpr ${virtual_view_type_name}() {} |
| ${virtual_view_type_name}(const ${virtual_view_type_name} &) = default; |
| ${virtual_view_type_name}(${virtual_view_type_name} &&) = default; |
| ${virtual_view_type_name} &operator=(const ${virtual_view_type_name} &) = |
| default; |
| ${virtual_view_type_name} &operator=(${virtual_view_type_name} &&) = |
| default; |
| ~${virtual_view_type_name}() = default; |
| |
| static constexpr ${logical_type} Read(); |
| static constexpr ${logical_type} UncheckedRead(); |
| static constexpr bool Ok() { return true; } |
| template <class Stream> |
| void WriteToTextStream(Stream *emboss_reserved_local_stream, |
| const ::emboss::TextOutputOptions |
| &emboss_reserved_local_options) const { |
| ::emboss::support::${write_to_text_stream_function}( |
| this, emboss_reserved_local_stream, emboss_reserved_local_options); |
| } |
| |
| static constexpr bool IsAggregate() { return false; } |
| }; |
| |
| static constexpr ${virtual_view_type_name} ${name}() { |
| return ${virtual_view_type_name}(); |
| } |
| static constexpr ::emboss::support::Maybe<bool> has_${name}() { |
| return ::emboss::support::Maybe<bool>(true); |
| } |
| |
| |
| // ** structure_single_const_virtual_field_method_definitions ** /////////////// |
| namespace ${parent_type} { |
| inline constexpr ${logical_type} ${name}() { |
| return ${read_value}.ValueOrDefault(); |
| } |
| } // namespace ${parent_type} |
| |
| template <class Storage> |
| inline constexpr ${logical_type} |
| Generic${parent_type}View<Storage>::${virtual_view_type_name}::Read() { |
| return ${parent_type}::${name}(); |
| } |
| |
| template <class Storage> |
| inline constexpr ${logical_type} |
| Generic${parent_type}View< |
| Storage>::${virtual_view_type_name}::UncheckedRead() { |
| return ${parent_type}::${name}(); |
| } |
| |
| // ** structure_single_virtual_field_method_declarations ** //////////////////// |
| ${visibility}: |
| class ${virtual_view_type_name} final { |
| public: |
| using ValueType = ${logical_type}; |
| |
| explicit ${virtual_view_type_name}( |
| const Generic${parent_type}View &emboss_reserved_local_view) |
| : view_(emboss_reserved_local_view) {} |
| ${virtual_view_type_name}() = delete; |
| ${virtual_view_type_name}(const ${virtual_view_type_name} &) = default; |
| ${virtual_view_type_name}(${virtual_view_type_name} &&) = default; |
| ${virtual_view_type_name} &operator=(const ${virtual_view_type_name} &) = |
| default; |
| ${virtual_view_type_name} &operator=(${virtual_view_type_name} &&) = |
| default; |
| ~${virtual_view_type_name}() = default; |
| |
| ${logical_type} Read() const { |
| EMBOSS_CHECK(view_.has_${name}().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(); |
| } |
| ${logical_type} UncheckedRead() const { |
| // UncheckedRead() on a virtual still calls Ok() on its dependencies; |
| // i.e., it still does some bounds checking. This is because of a subtle |
| // case, illustrated by the example below: |
| // |
| // # .emb |
| // struct Foo: |
| // 0 [+1] UInt x |
| // if x != 0: |
| // 1 [+1] UInt y |
| // let x_and_y = x != 0 && y != 0 |
| // |
| // // .cc |
| // std::array<char, 1> buffer = {0}; |
| // const auto view = MakeFooView(&buffer); |
| // assert(!view.x_and_y().UncheckedRead()); |
| // |
| // Without the checks for Ok(), the implementation of UncheckedRead() |
| // looks something like: |
| // |
| // bool UncheckedRead() const { |
| // return And(view_.x().UncheckedRead(), |
| // view_.y().UncheckedRead()).ValueOrDefault(); |
| // } |
| // |
| // Unfortunately, even if x().UncheckedRead() is false, this will call |
| // UncheckedRead() on y(), which will segfault. |
| // |
| // TODO(bolms): Figure out a way to minimize bounds checking, instead of |
| // just always checking here. |
| return MaybeRead().ValueOrDefault(); |
| } |
| // Ok() can be false if some dependency is unreadable, *or* if there is an |
| // error somewhere in the arithmetic -- say, division by zero. |
| bool Ok() const { |
| auto emboss_reserved_local_value = MaybeRead(); |
| return emboss_reserved_local_value.Known() && |
| ValueIsOk(emboss_reserved_local_value.ValueOrDefault()); |
| } |
| template <class Stream> |
| void WriteToTextStream(Stream *emboss_reserved_local_stream, |
| const ::emboss::TextOutputOptions |
| &emboss_reserved_local_options) const { |
| ::emboss::support::${write_to_text_stream_function}( |
| this, emboss_reserved_local_stream, emboss_reserved_local_options); |
| } |
| |
| static constexpr bool IsAggregate() { return false; } |
| |
| ${write_methods} |
| |
| private: |
| ::emboss::support::Maybe</**/ ${logical_type}> MaybeRead() const { |
| ${read_subexpressions} |
| return ${read_value}; |
| } |
| |
| static constexpr bool ValueIsOk( |
| ${logical_type} emboss_reserved_local_value) { |
| (void)emboss_reserved_local_value; // Silence -Wunused-parameter |
| return ${value_is_ok}.ValueOr(false); |
| } |
| |
| const Generic${parent_type}View view_; |
| }; |
| ${virtual_view_type_name} ${name}() const; |
| ::emboss::support::Maybe<bool> has_${name}() const; |
| |
| |
| // ** structure_single_virtual_field_write_methods ** ////////////////////////// |
| bool TryToWrite(${logical_type} emboss_reserved_local_value) { |
| const auto emboss_reserved_local_maybe_new_value = ${transform}; |
| if (!CouldWriteValue(emboss_reserved_local_value)) return false; |
| return view_.${destination}.TryToWrite( |
| emboss_reserved_local_maybe_new_value.ValueOrDefault()); |
| } |
| void Write(${logical_type} emboss_reserved_local_value) { |
| const bool result = TryToWrite(emboss_reserved_local_value); |
| (void)result; |
| EMBOSS_CHECK(result); |
| } |
| void UncheckedWrite(${logical_type} emboss_reserved_local_value) { |
| view_.${destination}.UncheckedWrite((${transform}).ValueOrDefault()); |
| } |
| bool CouldWriteValue(${logical_type} emboss_reserved_local_value) { |
| if (!ValueIsOk(emboss_reserved_local_value)) return false; |
| const auto emboss_reserved_local_maybe_new_value = ${transform}; |
| if (!emboss_reserved_local_maybe_new_value.Known()) return false; |
| return view_.${destination}.CouldWriteValue( |
| emboss_reserved_local_maybe_new_value.ValueOrDefault()); |
| } |
| template <class Stream> |
| bool UpdateFromTextStream(Stream *emboss_reserved_local_stream) { |
| return ::emboss::support::ReadIntegerFromTextStream( |
| this, emboss_reserved_local_stream); |
| } |
| |
| |
| // ** structure_single_virtual_field_method_definitions ** ///////////////////// |
| template <class Storage> |
| inline typename Generic${parent_type}View<Storage>::${virtual_view_type_name} |
| Generic${parent_type}View<Storage>::${name}() const { |
| return |
| typename Generic${parent_type}View<Storage>::${virtual_view_type_name}( |
| *this); |
| } |
| |
| template <class Storage> |
| inline ::emboss::support::Maybe<bool> |
| Generic${parent_type}View<Storage>::has_${name}() const { |
| return ${field_exists}; |
| } |
| |
| |
| // ** structure_single_field_indirect_method_declarations ** /////////////////// |
| ${visibility}: |
| // The "this->" is required for (some versions of?) GCC. |
| auto ${name}() const -> decltype(this->${aliased_field}) { |
| return has_${name}().ValueOrDefault() ? ${aliased_field} |
| : decltype(this->${aliased_field})(); |
| } |
| ::emboss::support::Maybe<bool> has_${name}() const; |
| |
| |
| // ** struct_single_field_indirect_method_definitions ** /////////////////////// |
| template <class Storage> |
| inline ::emboss::support::Maybe<bool> |
| Generic${parent_type}View<Storage>::has_${name}() const { |
| return ${field_exists}; |
| } |
| |
| |
| // ** structure_single_parameter_field_method_declarations ** ////////////////// |
| private: |
| // TODO(bolms): Is there any harm if these are public methods? |
| constexpr ::emboss::support::MaybeConstantView</**/ ${logical_type}> |
| ${name}() const { |
| return parameters_initialized_ |
| ? ::emboss::support::MaybeConstantView</**/ ${logical_type}>( |
| ${name}_) |
| : ::emboss::support::MaybeConstantView</**/ ${logical_type}>(); |
| } |
| constexpr ::emboss::support::Maybe<bool> has_${name}() const { |
| return ::emboss::support::Maybe<bool>(parameters_initialized_); |
| } |
| |
| |
| // ** enum_declaration ** ////////////////////////////////////////////////////// |
| enum class ${enum} : ${enum_type}; |
| |
| |
| // ** enum_definition ** /////////////////////////////////////////////////////// |
| enum class ${enum} : ${enum_type} { |
| ${enum_values} |
| }; |
| |
| // This setup (ab)uses the fact that C++ templates can be defined in many |
| // translation units, but will be collapsed to a single definition at link time |
| // (or no definition, if no client code instantiates the template). |
| // |
| // Emboss could accomplish almost the same result by generating multiple .cc |
| // files (one per function), but Bazel doesn't have great support for specifying |
| // "the output of this rule is an indeterminate number of files, all of which |
| // should be used as input to this other rule," which would be necessary to |
| // generate all the .cc files and then build and link them into a library. |
| template <class Enum> |
| class EnumTraits; |
| |
| template <> |
| class EnumTraits<${enum}> final { |
| public: |
| static bool TryToGetEnumFromName(const char *emboss_reserved_local_name, |
| ${enum} *emboss_reserved_local_result) { |
| if (emboss_reserved_local_name == nullptr) return false; |
| // TODO(bolms): The generated code here would be much more efficient for |
| // large enums if the mapping were performed using a prefix trie rather than |
| // repeated strcmp(). |
| ${enum_from_name_cases} |
| return false; |
| } |
| |
| static const char *TryToGetNameFromEnum( |
| ${enum} emboss_reserved_local_value) { |
| switch (emboss_reserved_local_value) { |
| ${name_from_enum_cases} |
| default: return nullptr; |
| } |
| } |
| |
| static bool EnumIsKnown(${enum} emboss_reserved_local_value) { |
| switch (emboss_reserved_local_value) { |
| ${enum_is_known_cases} |
| default: |
| return false; |
| } |
| } |
| |
| static ::std::ostream &SendToOstream(::std::ostream &emboss_reserved_local_os, |
| ${enum} emboss_reserved_local_value) { |
| const char *emboss_reserved_local_name = |
| TryToGetNameFromEnum(emboss_reserved_local_value); |
| if (emboss_reserved_local_name == nullptr) { |
| emboss_reserved_local_os |
| << static_cast</**/ ::std::underlying_type<${enum}>::type>( |
| emboss_reserved_local_value); |
| } else { |
| emboss_reserved_local_os << emboss_reserved_local_name; |
| } |
| return emboss_reserved_local_os; |
| } |
| }; |
| |
| // These functions are intended to be found via ADL. |
| static inline bool TryToGetEnumFromName( |
| const char *emboss_reserved_local_name, |
| ${enum} *emboss_reserved_local_result) { |
| return EnumTraits<${enum}>::TryToGetEnumFromName( |
| emboss_reserved_local_name, emboss_reserved_local_result); |
| } |
| |
| static inline const char *TryToGetNameFromEnum( |
| ${enum} emboss_reserved_local_value) { |
| return EnumTraits<${enum}>::TryToGetNameFromEnum( |
| emboss_reserved_local_value); |
| } |
| |
| static inline bool EnumIsKnown(${enum} emboss_reserved_local_value) { |
| return EnumTraits<${enum}>::EnumIsKnown(emboss_reserved_local_value); |
| } |
| |
| static inline ::std::ostream &operator<<( |
| ::std::ostream &emboss_reserved_local_os, |
| ${enum} emboss_reserved_local_value) { |
| return EnumTraits<${enum}>::SendToOstream(emboss_reserved_local_os, |
| emboss_reserved_local_value); |
| } |
| |
| // ** enum_from_name_case ** /////////////////////////////////////////////////// |
| if (!strcmp("${name}", emboss_reserved_local_name)) { |
| *emboss_reserved_local_result = ${enum}::${value}; |
| return true; |
| } |
| |
| // ** name_from_enum_case ** /////////////////////////////////////////////////// |
| case ${enum}::${value}: return "${name}"; |
| |
| // ** enum_is_known_case ** //////////////////////////////////////////////////// |
| case ${enum}::${name}: return true; |
| |
| // ** enum_value ** //////////////////////////////////////////////////////////// |
| ${name} = ${value}, |
| |
| // ** enum_using_statement ** ////////////////////////////////////////////////// |
| using ${name} = ${component}; |
