From 7f05ca01ba97866e536a9c9a989f61c46af99ef9 Mon Sep 17 00:00:00 2001 From: Dave Allison Date: Mon, 1 Jun 2026 18:04:23 -0700 Subject: [PATCH 1/7] Switch on pedantic warninga and add active_message to output --- .bazelrc | 5 ++ phaser/BUILD.bazel | 11 +++ phaser/active_message_test.cc | 44 +++++++++++ phaser/all_types_test.cc | 16 ++-- phaser/compiler/gen.cc | 18 ++++- phaser/compiler/gen.h | 7 +- phaser/compiler/main.cc | 2 +- phaser/compiler/message_gen.cc | 21 ++--- phaser/compiler/message_gen.h | 14 ++-- phaser/copts.bzl | 55 ++++++++++++- phaser/phaser_library.bzl | 18 +++-- phaser/phaser_test.cc | 8 +- phaser/runtime/any.h | 4 +- phaser/runtime/fields.h | 4 +- phaser/runtime/iterators.h | 5 +- phaser/runtime/message.cc | 4 +- phaser/runtime/message.h | 2 + phaser/runtime/message_test.cc | 127 ++++++++++++++++-------------- phaser/runtime/wireformat_test.cc | 2 +- phaser/testdata/BUILD | 10 +++ 20 files changed, 269 insertions(+), 108 deletions(-) create mode 100644 phaser/active_message_test.cc diff --git a/.bazelrc b/.bazelrc index f1cc28c..1290f59 100644 --- a/.bazelrc +++ b/.bazelrc @@ -30,6 +30,11 @@ test:valgrind --run_under='valgrind --leak-check=full --show-leak-kinds=definite build --enable_platform_specific_config +# Treat third-party (external repo) headers as system headers so the aggressive +# warning set used for our own code (see phaser/copts.bzl) does not flood the +# build with diagnostics from abseil/protobuf/googletest/toolbelt. +build --features=external_include_paths + # For all builds, use C++17 build --cxxopt="-std=c++17" build --cxxopt='-Wno-sign-compare' diff --git a/phaser/BUILD.bazel b/phaser/BUILD.bazel index cdc0354..703714c 100644 --- a/phaser/BUILD.bazel +++ b/phaser/BUILD.bazel @@ -31,6 +31,17 @@ cc_test( ], ) +cc_test( + name = "active_message_test", + srcs = ["active_message_test.cc"], + copts = PHASER_COPTS, + deps = [ + "//phaser/runtime:phaser_runtime", + "//phaser/testdata:foo_active_message_phaser", + "@com_google_googletest//:gtest", + ], +) + cc_test( name = "all_types_test", srcs = ["all_types_test.cc"], diff --git a/phaser/active_message_test.cc b/phaser/active_message_test.cc new file mode 100644 index 0000000..c56a874 --- /dev/null +++ b/phaser/active_message_test.cc @@ -0,0 +1,44 @@ +// Copyright 2024-2026 David Allison +// All Rights Reserved +// See LICENSE file for licensing information. + +#include "phaser/runtime/runtime.h" +#include "phaser/testdata/Foo.phaser.h" +#include +#include +#include + +// Verifies the optional `std::any active_message` field that is emitted when a +// phaser_library is built with enable_active_message = True (which passes the +// active_message=true plugin command-line option). +TEST(ActiveMessage, DefaultsToEmpty) { + char *buffer = static_cast(calloc(4096, 1)); + foo::bar::phaser::Foo msg = + foo::bar::phaser::Foo::CreateMutable(buffer, 4096); + EXPECT_FALSE(msg.active_message.has_value()); + free(buffer); +} + +TEST(ActiveMessage, HoldsArbitraryPayload) { + char *buffer = static_cast(calloc(4096, 1)); + foo::bar::phaser::Foo msg = + foo::bar::phaser::Foo::CreateMutable(buffer, 4096); + + // The field is a public std::any, independent of the wire-format fields. + msg.set_a(42); + msg.active_message = std::string("attached-payload"); + + ASSERT_TRUE(msg.active_message.has_value()); + EXPECT_EQ("attached-payload", + std::any_cast(msg.active_message)); + EXPECT_EQ(42, msg.a()); + + msg.active_message.reset(); + EXPECT_FALSE(msg.active_message.has_value()); + free(buffer); +} + +int main(int argc, char **argv) { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/phaser/all_types_test.cc b/phaser/all_types_test.cc index 2762b20..8d580b9 100644 --- a/phaser/all_types_test.cc +++ b/phaser/all_types_test.cc @@ -228,7 +228,7 @@ void ExpectRepeatedPackedMatchPb(const PbRepeatedPacked &pb, } } -void FillRepeatedUnpacked(RepeatedPrimitivesUnpacked &msg) { +[[maybe_unused]] void FillRepeatedUnpacked(RepeatedPrimitivesUnpacked &msg) { for (int i = -5; i < 5; i++) { msg.add_vi32(i * 11); } @@ -250,8 +250,9 @@ void ExpectRepeatedUnpackedMatchPb(const PbRepeatedUnpacked &pb, } } -void ExpectRepeatedUnpackedMatchPb(const PbRepeatedUnpacked &a, - const PbRepeatedUnpacked &b) { +[[maybe_unused]] void +ExpectRepeatedUnpackedMatchPb(const PbRepeatedUnpacked &a, + const PbRepeatedUnpacked &b) { ASSERT_EQ(a.vi32_size(), b.vi32_size()); for (int i = 0; i < a.vi32_size(); i++) { EXPECT_EQ(a.vi32(i), b.vi32(i)); @@ -372,7 +373,7 @@ void FillImportsMessage(PbImportsMessage &msg, bool include_any = true) { if (include_any) { PbCoverageInner packed; FillCoverageInner(packed); - msg.mutable_any_field()->PackFrom(packed); + EXPECT_TRUE(msg.mutable_any_field()->PackFrom(packed)); } } @@ -450,8 +451,9 @@ void ExpectImportsMessageMatchPb(const PbImportsMessage &pb, ExpectCoverageInnerMatchPb(inner_pb, inner_msg); } -void ExpectImportsMessageMatchPb(const PbImportsMessage &a, - const PbImportsMessage &b) { +[[maybe_unused]] void +ExpectImportsMessageMatchPb(const PbImportsMessage &a, + const PbImportsMessage &b) { EXPECT_EQ(a.imported_foo().a(), b.imported_foo().a()); EXPECT_EQ(a.imported_foo().b(), b.imported_foo().b()); EXPECT_EQ(a.inner().str(), b.inner().str()); @@ -542,7 +544,7 @@ TEST(AllTypesTest, LargeSintWireCompat) { const int32_t kSint32Values[] = {INT32_MIN, -1000000, -1, 0, 1, 1000000, INT32_MAX}; const int64_t kSint64Values[] = { - INT64_MIN, int64_t(INT32_MIN) - 1, int64_t(-1) << 40, + INT64_MIN, int64_t(INT32_MIN) - 1, -(int64_t(1) << 40), -1, 0, 1, int64_t(1) << 40, int64_t(INT32_MAX) + 1, INT64_MAX}; diff --git a/phaser/compiler/gen.cc b/phaser/compiler/gen.cc index 29f2a1b..9667da7 100644 --- a/phaser/compiler/gen.cc +++ b/phaser/compiler/gen.cc @@ -58,10 +58,16 @@ bool CodeGenerator::Generate( package_name_ = option.second; } else if (option.first == "target_name") { target_name_ = option.second; + } else if (option.first == "active_message") { + // Bare flag or explicit truthy value enables the field. + generate_active_message_ = + option.second.empty() || option.second == "true" || + option.second == "1"; } } - Generator gen(file, added_namespace_, package_name_, target_name_); + Generator gen(file, added_namespace_, package_name_, target_name_, + generate_active_message_); std::string filename = GeneratedFilename(package_name_, target_name_, std::string(file->name())); @@ -128,13 +134,14 @@ void Generator::CloseNamespace(std::ostream &os) { Generator::Generator(const google::protobuf::FileDescriptor *file, const std::string &ns, const std::string& pn, - const std::string& tn) - : file_(file), added_namespace_(ns), package_name_(pn), target_name_(tn) { + const std::string& tn, bool generate_active_message) + : file_(file), added_namespace_(ns), package_name_(pn), target_name_(tn), + generate_active_message_(generate_active_message) { for (int i = 0; i < file->message_type_count(); i++) { message_gens_.push_back( std::make_unique( file->message_type(i), added_namespace_, - std::string(file->package()))); + std::string(file->package()), generate_active_message_)); } // Enums for (int i = 0; i < file->enum_type_count(); i++) { @@ -145,6 +152,9 @@ Generator::Generator(const google::protobuf::FileDescriptor *file, void Generator::GenerateHeaders(std::ostream &os) { os << "#pragma once\n"; os << "#include \"phaser/runtime/runtime.h\"\n"; + if (generate_active_message_) { + os << "#include \n"; + } for (int i = 0; i < file_->dependency_count(); i++) { std::string base = GeneratedFilename( package_name_, target_name_, diff --git a/phaser/compiler/gen.h b/phaser/compiler/gen.h index 90043d5..ccc53f5 100644 --- a/phaser/compiler/gen.h +++ b/phaser/compiler/gen.h @@ -33,12 +33,16 @@ class CodeGenerator : public google::protobuf::compiler::CodeGenerator { mutable std::string added_namespace_; mutable std::string package_name_; mutable std::string target_name_; + // When true, generated message types get a public `std::any active_message` + // field. Enabled via the `active_message=true` plugin command-line option + // (set by phaser_library(enable_active_message = True)). + mutable bool generate_active_message_ = false; }; class Generator { public: - Generator(const google::protobuf::FileDescriptor *file, const std::string& ns, const std::string& pn, const std::string& tn); + Generator(const google::protobuf::FileDescriptor *file, const std::string& ns, const std::string& pn, const std::string& tn, bool generate_active_message = false); void GenerateHeaders(std::ostream& os); void GenerateSources(std::ostream& os); @@ -53,6 +57,7 @@ class Generator { const std::string& added_namespace_; const std::string& package_name_; const std::string& target_name_; + bool generate_active_message_; }; } // namespace phaser diff --git a/phaser/compiler/main.cc b/phaser/compiler/main.cc index bb80d40..4f97137 100644 --- a/phaser/compiler/main.cc +++ b/phaser/compiler/main.cc @@ -10,4 +10,4 @@ int main(int argc, char *argv[]) { phaser::CodeGenerator generator; return google::protobuf::compiler::PluginMain(argc, argv, &generator); -} \ No newline at end of file +} diff --git a/phaser/compiler/message_gen.cc b/phaser/compiler/message_gen.cc index 5806bd4..b86317b 100644 --- a/phaser/compiler/message_gen.cc +++ b/phaser/compiler/message_gen.cc @@ -11,7 +11,7 @@ namespace phaser { -bool IsCppReservedWord(const std::string &s) { +static bool IsCppReservedWord(const std::string &s) { static absl::flat_hash_set reserved_words = { "alignas", "alignof", @@ -545,6 +545,10 @@ void MessageGenerator::GenerateHeader(std::ostream &os) { os << "class " << MessageName(message_) << " : public ::phaser::Message {\n"; os << " public:\n"; + if (generate_active_message_) { + os << " // Optional user-attached payload, not part of the wire format.\n"; + os << " std::any active_message;\n\n"; + } // Generate constructors. GenerateConstructors(os, true); // Generate size functions. @@ -1226,7 +1230,6 @@ void MessageGenerator::GenerateFieldProtobufAccessors( case google::protobuf::FieldDescriptor::TYPE_GROUP: std::cerr << "Groups are not supported\n"; exit(1); - break; } } } @@ -1455,15 +1458,15 @@ void MessageGenerator::GenerateStreamer(std::ostream &os) { auto u = std::static_pointer_cast(field); os << " switch (msg." << u->member_name << ".Discriminator()) {\n"; for (size_t i = 0; i < u->members.size(); i++) { - auto &field = u->members[i]; - os << " case " << field->field->number() << ":\n"; + auto &member = u->members[i]; + os << " case " << member->field->number() << ":\n"; os << " msg." << u->member_name << ".PrintIndent(os);\n"; - if (field->field->type() == + if (member->field->type() == google::protobuf::FieldDescriptor::TYPE_MESSAGE) { - os << " os << \"" << field->field->name() << " \";\n"; + os << " os << \"" << member->field->name() << " \";\n"; } else { - os << " os << \"" << field->field->name() << ": \";\n"; + os << " os << \"" << member->field->name() << ": \";\n"; } os << " msg." << u->member_name << ".Print<" << i << ">(os);\n"; os << " os << std::endl;\n"; @@ -1867,8 +1870,8 @@ void MessageGenerator::GenerateMessageInfo(std::ostream &os, bool decl) { << index << "]);\n"; os << " u->fields_in_order.resize(" << u->members.size() << ");\n"; for (size_t i = 0; i < u->members.size(); i++) { - auto &field = u->members[i]; - GenerateFieldInfo(i, field, u, int(i), os); + auto &member = u->members[i]; + GenerateFieldInfo(i, member, u, int(i), os); } os << R"XXX( for (auto &f : u->fields_in_order) { info.fields_by_number[f->number] = f; diff --git a/phaser/compiler/message_gen.h b/phaser/compiler/message_gen.h index 55da5b6..5c004b7 100644 --- a/phaser/compiler/message_gen.h +++ b/phaser/compiler/message_gen.h @@ -37,24 +37,25 @@ struct UnionInfo : public FieldInfo { // Constructor UnionInfo(const google::protobuf::OneofDescriptor *o, uint32_t size, const std::string &name, const std::string &type) - : FieldInfo(nullptr, 0, 0, name, type, "", 4), oneof(o), - binary_size(size) {} + : FieldInfo(nullptr, 0, 0, name, type, "", size), oneof(o) {} bool IsUnion() const override { return true; } const google::protobuf::OneofDescriptor *oneof; std::vector> members; - uint32_t binary_size; }; class MessageGenerator { public: MessageGenerator(const google::protobuf::Descriptor *message, const std::string &added_namespace, - const std::string &package_name) + const std::string &package_name, + bool generate_active_message = false) : message_(message), added_namespace_(added_namespace), - package_name_(package_name) { + package_name_(package_name), + generate_active_message_(generate_active_message) { for (int i = 0; i < message_->nested_type_count(); i++) { nested_message_gens_.push_back(std::make_unique( - message_->nested_type(i), added_namespace, package_name)); + message_->nested_type(i), added_namespace, package_name, + generate_active_message)); } // Enums for (int i = 0; i < message_->enum_type_count(); i++) { @@ -136,6 +137,7 @@ class MessageGenerator { uint32_t presence_mask_size_ = 0; std::string added_namespace_; std::string package_name_; + bool generate_active_message_ = false; }; } // namespace phaser diff --git a/phaser/copts.bzl b/phaser/copts.bzl index 94f5337..221a0ca 100644 --- a/phaser/copts.bzl +++ b/phaser/copts.bzl @@ -4,8 +4,57 @@ These are intentionally applied per-target so they only affect code in this repository, and never leak into external dependencies or generated code. """ +# Our own code is compiled with clang's -Weverything and then opts out of the +# diagnostics that are not meaningful for this project. Everything that is left +# on is expected to stay clean. Third-party headers are treated as system +# headers (see --features=external_include_paths in .bazelrc) so these flags +# only police code in this repository. PHASER_COPTS = [ - "-Wall", - "-Wextra", - "-Wpedantic", + "-Weverything", + + # We target C++17; warnings that flag use of post-C++98/14 features (or + # incompatibilities with older standards we don't support) are pure noise. + "-Wno-c++98-compat", + "-Wno-c++98-compat-pedantic", + "-Wno-c++98-compat-local-type-template-args", + "-Wno-c++98-compat-unnamed-type-template-args", + "-Wno-pre-c++14-compat", + "-Wno-pre-c++17-compat", + + # Cosmetic / not actionable: struct padding and vtable emission decisions. + "-Wno-padded", + "-Wno-weak-vtables", + + # Static registration objects (reflection banks, type registries) rely on + # global constructors/destructors by design. + "-Wno-global-constructors", + "-Wno-exit-time-destructors", + + # Switches over enums cover the cases we care about and use a default for + # the rest; neither a mandatory default nor exhaustive case lists add value. + "-Wno-switch-default", + "-Wno-switch-enum", + + # Other innocuous diagnostics. + "-Wno-disabled-macro-expansion", + "-Wno-float-equal", + "-Wno-shadow-field-in-constructor", + "-Wno-implicit-int-float-conversion", + + # protoc-generated *.pb.h headers (pulled into our test TUs) use + # implementation-reserved identifiers like '_Foo_default_instance_'. That is + # protobuf's codegen, not our code, so the diagnostic is not actionable. + "-Wno-reserved-identifier", + + # clang 16/18 only (older clang silently ignores unknown -Wno-* flags). + "-Wno-documentation-unknown-command", + "-Wno-unsafe-buffer-usage", + + # The zero-copy runtime deliberately interconverts signed indices with + # unsigned 32-bit buffer offsets/sizes, and uses a handful of C-style casts + # when interfacing with the payload buffer. Auditing every such conversion + # is a separate effort; keep these off so the meaningful warnings stand out. + "-Wno-sign-conversion", + "-Wno-shorten-64-to-32", + "-Wno-old-style-cast", ] diff --git a/phaser/phaser_library.bzl b/phaser/phaser_library.bzl index 31d4ae8..4b16d44 100644 --- a/phaser/phaser_library.bzl +++ b/phaser/phaser_library.bzl @@ -25,11 +25,14 @@ def _phaser_action( # The protobuf compiler allow plugins to get arguments specified in the --plugin_out # argument. The args are passed as a comma separated list of key=value pairs followed # by a colon and the output directory. - options_and_out_dir = "" + options = [] if add_namespace != "": - options_and_out_dir = "--phaser_out=add_namespace={},package_name={},target_name={}:{}".format(add_namespace, package_name, target_name, out_dir) - else: - options_and_out_dir = "--phaser_out=package_name={},target_name={}:{}".format(package_name, target_name, out_dir) + options.append("add_namespace={}".format(add_namespace)) + options.append("package_name={}".format(package_name)) + options.append("target_name={}".format(target_name)) + if ctx.attr.enable_active_message: + options.append("active_message=true") + options_and_out_dir = "--phaser_out={}:{}".format(",".join(options), out_dir) inputs = depset(direct = direct_sources, transitive = transitive_sources) @@ -191,6 +194,7 @@ _phaser_gen = rule( "add_namespace": attr.string(), "package_name": attr.string(), "target_name": attr.string(), + "enable_active_message": attr.bool(default = False), }, implementation = _phaser_impl, ) @@ -211,7 +215,7 @@ _split_files = rule( implementation = _split_files_impl, ) -def phaser_library(name, deps = [], runtime = "@phaser//phaser/runtime:phaser_runtime", add_namespace = ""): +def phaser_library(name, deps = [], runtime = "@phaser//phaser/runtime:phaser_runtime", add_namespace = "", enable_active_message = False): """ Generate a cc_libary for protobuf files specified in deps. @@ -221,6 +225,9 @@ def phaser_library(name, deps = [], runtime = "@phaser//phaser/runtime:phaser_ru deps: dependencies runtime: label for phaser runtime. add_namespace: add given namespace to the message output + enable_active_message: if True, generated message types get a public + `std::any active_message` field (also enableable via the + `active_message=true` plugin command-line option). """ phaser = name + "_phaser" @@ -230,6 +237,7 @@ def phaser_library(name, deps = [], runtime = "@phaser//phaser/runtime:phaser_ru add_namespace = add_namespace, package_name = native.package_name(), target_name = name, + enable_active_message = enable_active_message, ) srcs = name + "_srcs" diff --git a/phaser/phaser_test.cc b/phaser/phaser_test.cc index 12bb6d0..f1b15b4 100644 --- a/phaser/phaser_test.cc +++ b/phaser/phaser_test.cc @@ -53,7 +53,7 @@ TEST(PhaserTest, ProtobufCompat) { msg.set_e(foo::bar::phaser::FOO); - msg.set_fl(1.3); + msg.set_fl(1.3f); msg.set_db(2.4); std::cout << msg; @@ -79,7 +79,7 @@ TEST(PhaserTest, ProtobufCompat) { // Deserialize from a string into a protobuf message. foo::bar::TestMessage msg2; - msg2.ParseFromString(serialized); + ASSERT_TRUE(msg2.ParseFromString(serialized)); ASSERT_EQ(msg2.x(), msg.x()); ASSERT_EQ(msg2.y(), msg.y()); ASSERT_EQ(msg2.s(), msg.s()); @@ -344,8 +344,8 @@ TEST(PhaserTest, GarbageSmall) { TEST(PhaserTest, GarbageLoop) { char buffer[256]; for (int i = 0; i < 1000; i++) { - for (int i = 0; i < 256; i++) { - buffer[i] = rand() & 0xff; + for (int j = 0; j < 256; j++) { + buffer[j] = rand() & 0xff; } auto msg = foo::bar::phaser::TestMessage::CreateReadonly(buffer, sizeof(buffer)); diff --git a/phaser/runtime/any.h b/phaser/runtime/any.h index 81fb4e4..f683fe1 100644 --- a/phaser/runtime/any.h +++ b/phaser/runtime/any.h @@ -33,9 +33,9 @@ class AnyMessage : public Message { : type_url_(offsetof(AnyMessage, type_url_), HeaderSize() + 0, 0, 1), value_(offsetof(AnyMessage, value_), HeaderSize() + 4, 1, 2) {} - AnyMessage(std::shared_ptr runtime, + AnyMessage(std::shared_ptr rt, ::toolbelt::BufferOffset offset) - : Message(runtime, offset), + : Message(rt, offset), type_url_(offsetof(AnyMessage, type_url_), HeaderSize() + 0, 0, 1), value_(offsetof(AnyMessage, value_), HeaderSize() + 4, 1, 2) {} diff --git a/phaser/runtime/fields.h b/phaser/runtime/fields.h index 3368cb1..b070573 100644 --- a/phaser/runtime/fields.h +++ b/phaser/runtime/fields.h @@ -29,6 +29,8 @@ class Field { public: Field() = default; Field(int id, int number) : id_(id), number_(number) {} + Field(const Field &) = default; + Field &operator=(const Field &) = default; virtual ~Field() = default; // The presence bit is in a set of words immediately after @@ -662,7 +664,7 @@ template class IndirectMessageField : public Field { template class MessageObject { public: - MessageObject() : msg_(InternalDefault{}){}; + MessageObject() : msg_(InternalDefault{}) {} explicit MessageObject(std::shared_ptr runtime, uint32_t absolute_binary_offset) : msg_(runtime, absolute_binary_offset) {} diff --git a/phaser/runtime/iterators.h b/phaser/runtime/iterators.h index 0ddcea4..19d086a 100644 --- a/phaser/runtime/iterators.h +++ b/phaser/runtime/iterators.h @@ -163,7 +163,10 @@ template struct EnumFieldIterator { T &operator*() const { using U = typename std::underlying_type::type; U *addr = field->GetBuffer()->template ToAddress(offset); - return *reinterpret_cast(addr); + // An enum and its fixed underlying type share representation; route the + // cast through void* so it is not flagged as a dereference of an unrelated + // reinterpret_cast. + return *static_cast(static_cast(addr)); } bool operator==(const EnumFieldIterator &it) const { diff --git a/phaser/runtime/message.cc b/phaser/runtime/message.cc index b9157cc..974129d 100644 --- a/phaser/runtime/message.cc +++ b/phaser/runtime/message.cc @@ -105,9 +105,9 @@ absl::StatusOr<::toolbelt::PayloadBuffer *> NewDynamicBuffer( memset(*buffer, 0, initial_size); ::toolbelt::PayloadBuffer *pb = new (*buffer)::toolbelt::PayloadBuffer( initial_size, - [ initial_size, realloc = std::move(realloc) ]( + [ initial_size, realloc_fn = std::move(realloc) ]( ::toolbelt::PayloadBuffer * *p, size_t old_size, size_t new_size) { - absl::StatusOr r = realloc(*p, old_size, new_size); + absl::StatusOr r = realloc_fn(*p, old_size, new_size); if (!r.ok()) { std::cerr << "Failed to resize PayloadBuffer from " << initial_size << " to " << new_size << std::endl; diff --git a/phaser/runtime/message.h b/phaser/runtime/message.h index fd0b70c..335d1e9 100644 --- a/phaser/runtime/message.h +++ b/phaser/runtime/message.h @@ -228,6 +228,8 @@ struct Message { Message() = default; Message(std::shared_ptr rt, ::toolbelt::BufferOffset start) : runtime(rt), absolute_binary_offset(start) {} + Message(const Message &) = default; + Message &operator=(const Message &) = default; virtual ~Message() = default; virtual const MessageInfo *GetMessageInfo() const { return nullptr; } diff --git a/phaser/runtime/message_test.cc b/phaser/runtime/message_test.cc index 1732c0e..dd1af57 100644 --- a/phaser/runtime/message_test.cc +++ b/phaser/runtime/message_test.cc @@ -47,16 +47,16 @@ struct EnumTestParser { }; struct InnerMessage : public Message { - InnerMessage(phaser::InternalDefault d) + InnerMessage(phaser::InternalDefault /*d*/) : str_(offsetof(InnerMessage, str_), HeaderSize() + 0, 0, 10), f_(offsetof(InnerMessage, f_), HeaderSize() + 8, 1, 20), e_(offsetof(InnerMessage, e_), HeaderSize() + 16, 2, 30), ev_(offsetof(InnerMessage, ev_), HeaderSize() + 20, 0, 40), uv_(offsetof(InnerMessage, uv_), HeaderSize() + 28, 0, 0, {50, 60}) {} - InnerMessage(std::shared_ptr runtime, + InnerMessage(std::shared_ptr rt, ::toolbelt::BufferOffset offset) - : Message(runtime, offset), + : Message(rt, offset), str_(offsetof(InnerMessage, str_), HeaderSize() + 0, 0, 10), f_(offsetof(InnerMessage, f_), HeaderSize() + 8, 1, 20), e_(offsetof(InnerMessage, e_), HeaderSize() + 16, 2, 30), @@ -383,7 +383,7 @@ inline std::ostream &operator<<(std::ostream &os, const InnerMessage &msg) { } static void InnerMessageStreamTo(const Message &msg, std::ostream &os, - int indent) { + int /*indent*/) { const InnerMessage *m = static_cast(&msg); os << *m; } @@ -533,9 +533,9 @@ struct TestMessage : public Message { InitDynamicMutable(initial_size); } - TestMessage(std::shared_ptr runtime, + TestMessage(std::shared_ptr rt, ::toolbelt::BufferOffset offset) - : Message(runtime, offset), + : Message(rt, offset), x_(offsetof(TestMessage, x_), HeaderSize() + 0, 0, 100), y_(offsetof(TestMessage, y_), HeaderSize() + 8, 1, 101), s_(offsetof(TestMessage, s_), HeaderSize() + 16, 0, 102), @@ -1179,7 +1179,7 @@ inline std::ostream &operator<<(std::ostream &os, const TestMessage &msg) { } static void TestMessageStreamTo(const Message &msg, std::ostream &os, - int indent) { + int /*indent*/) { const TestMessage *m = static_cast(&msg); os << *m; } @@ -1249,6 +1249,11 @@ static phaser::BankInfo kTestMessageBackInfo{ .copy = TestMessageCopy, .make_existing = TestMessageMakeExisting, .binary_size = TestMessageBinarySize, + // This mock intentionally does not provide reflection metadata. + .message_info = nullptr, + .has_field = nullptr, + .get_field_by_name = nullptr, + .get_field_by_number = nullptr, }; static struct TestMessageBankRegister { @@ -1293,24 +1298,24 @@ TEST(MessageTest, Basic) { { char *buffer2 = (char *)calloc(4096, 1); memcpy(buffer2, buffer, 4096); - TestMessage msg = TestMessage::CreateReadonly(buffer2); + TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); - ASSERT_TRUE(msg.x_.IsPresent()); - uint32_t x = msg.x_.Get(); - ASSERT_EQ(1234, x); + ASSERT_TRUE(ro_msg.x_.IsPresent()); + uint32_t ro_x = ro_msg.x_.Get(); + ASSERT_EQ(1234, ro_x); - ASSERT_TRUE(msg.y_.IsPresent()); - uint64_t y = msg.y_.Get(); - ASSERT_EQ(0xffff, y); + ASSERT_TRUE(ro_msg.y_.IsPresent()); + uint64_t ro_y = ro_msg.y_.Get(); + ASSERT_EQ(0xffff, ro_y); - ASSERT_TRUE(msg.s_.IsPresent()); - std::string_view s = msg.s_.Get(); - ASSERT_EQ("Hello, world!", s); + ASSERT_TRUE(ro_msg.s_.IsPresent()); + std::string_view ro_s = ro_msg.s_.Get(); + ASSERT_EQ("Hello, world!", ro_s); - ASSERT_TRUE(msg.m_.IsPresent()); - auto &inner2 = msg.m_.Get(); - ASSERT_EQ("Inner message", inner2.str_.Get()); - ASSERT_EQ(0xdeadbeef, inner2.f_.Get()); + ASSERT_TRUE(ro_msg.m_.IsPresent()); + auto &ro_inner = ro_msg.m_.Get(); + ASSERT_EQ("Inner message", ro_inner.str_.Get()); + ASSERT_EQ(0xdeadbeef, ro_inner.f_.Get()); free(buffer2); } free(buffer); @@ -1339,15 +1344,15 @@ TEST(MessageTest, RepeatedPrimitive) { { char *buffer2 = (char *)calloc(4096, 1); memcpy(buffer2, buffer, 4096); - TestMessage msg = TestMessage::CreateReadonly(buffer2); + TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); - int i = 1; - for (auto &v : msg.vi32_) { - ASSERT_EQ(i, v); - i++; + int ro_i = 1; + for (auto &v : ro_msg.vi32_) { + ASSERT_EQ(ro_i, v); + ro_i++; } - ASSERT_EQ(1, msg.vi32_.Get(0)); - ASSERT_EQ(2, msg.vi32_.Get(1)); + ASSERT_EQ(1, ro_msg.vi32_.Get(0)); + ASSERT_EQ(2, ro_msg.vi32_.Get(1)); free(buffer2); } free(buffer); @@ -1382,17 +1387,17 @@ TEST(MessageTest, RepeatedString) { { char *buffer2 = (char *)calloc(4096, 1); memcpy(buffer2, buffer, 4096); - TestMessage msg = TestMessage::CreateReadonly(buffer2); + TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); - int i = 0; - for (auto &v : msg.vstr_) { - ASSERT_EQ(strings[i], v.Get()); - i++; + int ro_i = 0; + for (auto &v : ro_msg.vstr_) { + ASSERT_EQ(strings[ro_i], v.Get()); + ro_i++; } - ASSERT_EQ("one", msg.vstr_.Get(0)); - ASSERT_EQ("two", msg.vstr_.Get(1)); - ASSERT_EQ("three", msg.vstr_.Get(2)); - ASSERT_EQ("four", msg.vstr_.Get(3)); + ASSERT_EQ("one", ro_msg.vstr_.Get(0)); + ASSERT_EQ("two", ro_msg.vstr_.Get(1)); + ASSERT_EQ("three", ro_msg.vstr_.Get(2)); + ASSERT_EQ("four", ro_msg.vstr_.Get(3)); free(buffer2); } free(buffer); @@ -1413,28 +1418,28 @@ TEST(MessageTest, RepeatedMessage) { msg.DebugDump(); { - auto &inner1 = msg.vm_.Get(0); - ASSERT_EQ("one", inner1.str_.Get()); - ASSERT_EQ(0xdeadbeef, inner1.f_.Get()); + auto &ro_inner1 = msg.vm_.Get(0); + ASSERT_EQ("one", ro_inner1.str_.Get()); + ASSERT_EQ(0xdeadbeef, ro_inner1.f_.Get()); - auto &inner2 = msg.vm_.Get(2); - ASSERT_EQ("two", inner2.str_.Get()); - ASSERT_EQ(0x1234, inner2.f_.Get()); + auto &ro_inner2 = msg.vm_.Get(2); + ASSERT_EQ("two", ro_inner2.str_.Get()); + ASSERT_EQ(0x1234, ro_inner2.f_.Get()); } // Copy message to test reading. { char *buffer2 = (char *)calloc(4096, 1); memcpy(buffer2, buffer, 4096); - TestMessage msg = TestMessage::CreateReadonly(buffer2); + TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); - auto &inner1 = msg.vm_.Get(0); - ASSERT_EQ("one", inner1.str_.Get()); - ASSERT_EQ(0xdeadbeef, inner1.f_.Get()); + auto &ro_inner1 = ro_msg.vm_.Get(0); + ASSERT_EQ("one", ro_inner1.str_.Get()); + ASSERT_EQ(0xdeadbeef, ro_inner1.f_.Get()); - auto &inner2 = msg.vm_.Get(2); - ASSERT_EQ("two", inner2.str_.Get()); - ASSERT_EQ(0x1234, inner2.f_.Get()); + auto &ro_inner2 = ro_msg.vm_.Get(2); + ASSERT_EQ("two", ro_inner2.str_.Get()); + ASSERT_EQ(0x1234, ro_inner2.f_.Get()); free(buffer2); } free(buffer); @@ -1628,17 +1633,17 @@ TEST(MessageTest, ProtobufBasic) { { char *buffer2 = (char *)calloc(4096, 1); memcpy(buffer2, buffer, 4096); - TestMessage msg = TestMessage::CreateReadonly(buffer2); - - ASSERT_TRUE(msg.has_x()); - ASSERT_EQ(1234, msg.x()); - ASSERT_TRUE(msg.has_y()); - ASSERT_EQ(0xffff, msg.y()); - ASSERT_TRUE(msg.has_s()); - ASSERT_EQ("Hello, world!", msg.s()); - ASSERT_TRUE(msg.has_m()); - ASSERT_EQ("Inner message", msg.m().str()); - ASSERT_EQ(0xdeadbeef, msg.m().f()); + TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); + + ASSERT_TRUE(ro_msg.has_x()); + ASSERT_EQ(1234, ro_msg.x()); + ASSERT_TRUE(ro_msg.has_y()); + ASSERT_EQ(0xffff, ro_msg.y()); + ASSERT_TRUE(ro_msg.has_s()); + ASSERT_EQ("Hello, world!", ro_msg.s()); + ASSERT_TRUE(ro_msg.has_m()); + ASSERT_EQ("Inner message", ro_msg.m().str()); + ASSERT_EQ(0xdeadbeef, ro_msg.m().f()); free(buffer2); } free(buffer); diff --git a/phaser/runtime/wireformat_test.cc b/phaser/runtime/wireformat_test.cc index a4487f0..807c6cc 100644 --- a/phaser/runtime/wireformat_test.cc +++ b/phaser/runtime/wireformat_test.cc @@ -65,7 +65,7 @@ TEST(Wireformat, ZigZagRoundTrip) { << "int32 value " << v; } for (int64_t v : {INT64_MIN, INT64_MIN + 1, int64_t(INT32_MIN) - 1, - int64_t(INT32_MIN), int64_t(-1) << 40, int64_t(-1), + int64_t(INT32_MIN), -(int64_t(1) << 40), int64_t(-1), int64_t(0), int64_t(1), int64_t(1) << 31, int64_t(1) << 40, int64_t(INT32_MAX) + 1, INT64_MAX - 1, INT64_MAX}) { EXPECT_EQ(v, ProtoBuffer::ZagZig(ProtoBuffer::ZigZag(v))) diff --git a/phaser/testdata/BUILD b/phaser/testdata/BUILD index 3a13ddf..64d1594 100644 --- a/phaser/testdata/BUILD +++ b/phaser/testdata/BUILD @@ -56,6 +56,16 @@ phaser_library( deps = [":test_proto"], ) +# Same as foo_proto but with the optional `std::any active_message` field +# enabled, used to exercise phaser_library(enable_active_message = True). +phaser_library( + name = "foo_active_message_phaser", + add_namespace = "phaser", + enable_active_message = True, + runtime = "//phaser/runtime:phaser_runtime", + deps = [":foo_proto"], +) + proto_library( name = "coverage_proto", srcs = ["coverage.proto"], From 2e0355862fdc7e151ccfda0732e841df03420ae7 Mon Sep 17 00:00:00 2001 From: Dave Allison Date: Mon, 1 Jun 2026 20:11:44 -0700 Subject: [PATCH 2/7] Fix really pendantic warnings --- phaser/BUILD.bazel | 7 +++ phaser/all_types_test.cc | 22 ++++---- phaser/compiler/gen.cc | 5 +- phaser/compiler/message_gen.cc | 27 +++++++--- phaser/copts.bzl | 59 ++++++++++++++++++++- phaser/phaser_test.cc | 17 +++--- phaser/runtime/fields.h | 48 ++++++++--------- phaser/runtime/iterators.h | 16 +++--- phaser/runtime/message.cc | 2 +- phaser/runtime/message.h | 6 ++- phaser/runtime/message_test.cc | 81 +++++++++++++++-------------- phaser/runtime/runtime.h | 6 +-- phaser/runtime/union.h | 45 ++++++++-------- phaser/runtime/vectors.h | 94 +++++++++++++++++----------------- phaser/runtime/wireformat.h | 37 +++++++------ phaser/stress_test.cc | 2 +- 16 files changed, 287 insertions(+), 187 deletions(-) diff --git a/phaser/BUILD.bazel b/phaser/BUILD.bazel index 703714c..289661a 100644 --- a/phaser/BUILD.bazel +++ b/phaser/BUILD.bazel @@ -5,6 +5,13 @@ package(default_visibility = ["//visibility:public"]) exports_files(["valgrind.supp"]) +# True when building with clang, which gates the clang-only -Weverything set in +# PHASER_COPTS (GCC does not understand -Weverything). +config_setting( + name = "is_clang", + flag_values = {"@bazel_tools//tools/cpp:compiler": "clang"}, +) + cc_library( name = "test_helpers", hdrs = ["test_helpers.h"], diff --git a/phaser/all_types_test.cc b/phaser/all_types_test.cc index 8d580b9..60f4c5a 100644 --- a/phaser/all_types_test.cc +++ b/phaser/all_types_test.cc @@ -200,7 +200,7 @@ void FillRepeatedPacked(RepeatedPrimitivesPacked &msg) { for (int i = -3; i < 10; i++) { msg.add_vi32(i); msg.add_vi64(i * 1000LL); - msg.add_vf64(static_cast(i * 100000ULL)); + msg.add_vf64(static_cast(i) * 100000); } } @@ -222,9 +222,9 @@ void ExpectRepeatedPackedMatchPb(const PbRepeatedPacked &pb, ASSERT_EQ(pb.vi64_size(), static_cast(msg.vi64_size())); ASSERT_EQ(pb.vf64_size(), static_cast(msg.vf64_size())); for (int i = 0; i < pb.vi32_size(); i++) { - EXPECT_EQ(pb.vi32(i), msg.vi32(i)); - EXPECT_EQ(pb.vi64(i), msg.vi64(i)); - EXPECT_EQ(pb.vf64(i), msg.vf64(i)); + EXPECT_EQ(pb.vi32(i), msg.vi32(static_cast(i))); + EXPECT_EQ(pb.vi64(i), msg.vi64(static_cast(i))); + EXPECT_EQ(pb.vf64(i), msg.vf64(static_cast(i))); } } @@ -246,7 +246,7 @@ void ExpectRepeatedUnpackedMatchPb(const PbRepeatedUnpacked &pb, const RepeatedPrimitivesUnpacked &msg) { ASSERT_EQ(pb.vi32_size(), static_cast(msg.vi32_size())); for (int i = 0; i < pb.vi32_size(); i++) { - EXPECT_EQ(pb.vi32(i), msg.vi32(i)); + EXPECT_EQ(pb.vi32(i), msg.vi32(static_cast(i))); } } @@ -277,7 +277,7 @@ void ExpectRepeatedStringsMatchPb(const PbRepeatedStrings &pb, const RepeatedStrings &msg) { ASSERT_EQ(pb.vstr_size(), static_cast(msg.vstr_size())); for (int i = 0; i < pb.vstr_size(); i++) { - EXPECT_EQ(pb.vstr(i), msg.vstr(i)); + EXPECT_EQ(pb.vstr(i), msg.vstr(static_cast(i))); } } @@ -297,7 +297,7 @@ void ExpectRepeatedBytesMatchPb(const PbRepeatedBytes &pb, const RepeatedBytes &msg) { ASSERT_EQ(pb.vbytes_size(), static_cast(msg.vbytes_size())); for (int i = 0; i < pb.vbytes_size(); i++) { - EXPECT_EQ(pb.vbytes(i), msg.vbytes(i)); + EXPECT_EQ(pb.vbytes(i), msg.vbytes(static_cast(i))); } } @@ -321,7 +321,7 @@ void ExpectRepeatedMessagesMatchPb(const PbRepeatedMessages &pb, const RepeatedMessages &msg) { ASSERT_EQ(pb.items_size(), static_cast(msg.items_size())); for (int i = 0; i < pb.items_size(); i++) { - ExpectAllScalarsMatchPb(pb.items(i), msg.items(i)); + ExpectAllScalarsMatchPb(pb.items(i), msg.items(static_cast(i))); } } @@ -386,7 +386,7 @@ void FillRepeatedPacked(PbRepeatedPacked &msg) { for (int i = -3; i < 10; i++) { msg.add_vi32(i); msg.add_vi64(i * 1000LL); - msg.add_vf64(static_cast(i * 100000ULL)); + msg.add_vf64(static_cast(i) * 100000); } } @@ -607,7 +607,7 @@ TEST(AllTypesTest, RepeatedPackedInt32GrowAndResize) { } ASSERT_EQ(static_cast(kCount), msg.vi32_size()); for (int i = 0; i < kCount; i++) { - EXPECT_EQ(i, msg.vi32(i)); + EXPECT_EQ(i, msg.vi32(static_cast(i))); } msg.resize_vi32(10); ASSERT_EQ(10u, msg.vi32_size()); @@ -637,7 +637,7 @@ TEST(AllTypesTest, RepeatedStringChurn) { ASSERT_EQ(100u, msg.vstr_size()); for (int i = 0; i < 100; i++) { EXPECT_EQ(::phaser::test::MakePatternString(32, static_cast('a' + (i % 26))), - msg.vstr(i)); + msg.vstr(static_cast(i))); } } } diff --git a/phaser/compiler/gen.cc b/phaser/compiler/gen.cc index 9667da7..92f080b 100644 --- a/phaser/compiler/gen.cc +++ b/phaser/compiler/gen.cc @@ -22,8 +22,9 @@ WriteToZeroCopyStream(const std::string &data, break; } int to_copy = std::min(size, static_cast(data.size() - offset)); - std::memcpy(data_buffer, data.data() + offset, to_copy); - offset += to_copy; + std::memcpy(data_buffer, data.data() + offset, + static_cast(to_copy)); + offset += static_cast(to_copy); stream->BackUp(size - to_copy); } } diff --git a/phaser/compiler/message_gen.cc b/phaser/compiler/message_gen.cc index b86317b..9600b23 100644 --- a/phaser/compiler/message_gen.cc +++ b/phaser/compiler/message_gen.cc @@ -7,6 +7,7 @@ #include "absl/strings/str_replace.h" #include #include +#include #include namespace phaser { @@ -196,6 +197,8 @@ std::string MessageGenerator::FieldCFieldType( std::cerr << "Groups are not supported\n"; exit(1); } + // Unreachable: every protobuf field type is handled above and GROUP exits. + abort(); } std::string MessageGenerator::FieldInfoType( @@ -240,6 +243,8 @@ std::string MessageGenerator::FieldInfoType( std::cerr << "Groups are not supported\n"; exit(1); } + // Unreachable: every protobuf field type is handled above and GROUP exits. + abort(); } std::string @@ -276,6 +281,8 @@ MessageGenerator::FieldCType(const google::protobuf::FieldDescriptor *field) { std::cerr << "Groups are not supported\n"; exit(1); } + // Unreachable: every protobuf field type is handled above and GROUP exits. + abort(); } std::string MessageGenerator::FieldRepeatedCType( @@ -322,6 +329,8 @@ std::string MessageGenerator::FieldRepeatedCType( std::cerr << "Groups are not supported\n"; exit(1); } + // Unreachable: every protobuf field type is handled above and GROUP exits. + abort(); } std::string MessageGenerator::FieldUnionCType( @@ -367,6 +376,8 @@ std::string MessageGenerator::FieldUnionCType( std::cerr << "Groups are not supported\n"; exit(1); } + // Unreachable: every protobuf field type is handled above and GROUP exits. + abort(); } uint32_t MessageGenerator::FieldBinarySize( @@ -403,6 +414,8 @@ uint32_t MessageGenerator::FieldBinarySize( std::cerr << "Groups are not supported\n"; exit(1); } + // Unreachable: every protobuf field type is handled above and GROUP exits. + abort(); } bool MessageGenerator::IsAny(const google::protobuf::Descriptor *desc) { @@ -451,12 +464,12 @@ void MessageGenerator::CompileUnions() { void MessageGenerator::CompileFields() { uint32_t offset = 0; uint32_t id = 0; - fields_.reserve(message_->field_count()); + fields_.reserve(static_cast(message_->field_count())); for (int i = 0; i < message_->field_count(); i++) { const auto &field = message_->field(i); std::string field_type; const google::protobuf::OneofDescriptor *oneof = field->containing_oneof(); - int32_t field_size; + uint32_t field_size; uint32_t next_id = id; if (oneof != nullptr) { // In order to keep oneof fields in the correct position for printing so @@ -507,7 +520,8 @@ void MessageGenerator::FinalizeOffsetsAndSizes() { for (auto &field : fields_) { max_id = std::max(max_id, int32_t(field->id)); } - presence_mask_size_ = max_id == -1 ? 0 : ((max_id >> 5) + 1) * 4; + presence_mask_size_ = + max_id == -1 ? 0 : static_cast(((max_id >> 5) + 1) * 4); size += presence_mask_size_; // Finalize the offsets in the fields vector now that we know the header size. @@ -520,7 +534,7 @@ void MessageGenerator::FinalizeOffsetsAndSizes() { fields_.empty() ? size : (fields_.back()->offset + fields_.back()->binary_size); // Align offset to 4 bytes. - offset = (offset + 3) & ~3; + offset = (offset + 3) & ~3u; size = offset; // Add the offset to the unions. @@ -1839,7 +1853,7 @@ void MessageGenerator::GenerateMessageInfo(std::ostream &os, bool decl) { os << "#pragma clang diagnostic ignored \"-Winvalid-offsetof\"\n"; // Generate fields_in_order. - size_t index = 0; + int index = 0; os << " info.fields_in_order.resize(" << fields_in_order_.size() << ");\n"; for (auto &field : fields_in_order_) { if (field->IsUnion()) { @@ -1871,7 +1885,8 @@ void MessageGenerator::GenerateMessageInfo(std::ostream &os, bool decl) { os << " u->fields_in_order.resize(" << u->members.size() << ");\n"; for (size_t i = 0; i < u->members.size(); i++) { auto &member = u->members[i]; - GenerateFieldInfo(i, member, u, int(i), os); + GenerateFieldInfo(static_cast(i), member, u, static_cast(i), + os); } os << R"XXX( for (auto &f : u->fields_in_order) { info.fields_by_number[f->number] = f; diff --git a/phaser/copts.bzl b/phaser/copts.bzl index 221a0ca..2d0d5f9 100644 --- a/phaser/copts.bzl +++ b/phaser/copts.bzl @@ -9,7 +9,11 @@ repository, and never leak into external dependencies or generated code. # on is expected to stay clean. Third-party headers are treated as system # headers (see --features=external_include_paths in .bazelrc) so these flags # only police code in this repository. -PHASER_COPTS = [ +# +# -Weverything is a clang-only flag; GCC rejects it outright. The warning set is +# therefore only applied when building with clang (see //phaser:is_clang), and +# GCC builds (e.g. the default Linux toolchain) compile without it. +_PHASER_CLANG_COPTS = [ "-Weverything", # We target C++17; warnings that flag use of post-C++98/14 features (or @@ -58,3 +62,56 @@ PHASER_COPTS = [ "-Wno-shorten-64-to-32", "-Wno-old-style-cast", ] + +# GCC has no single -Weverything switch, so we approximate the clang coverage by +# turning on -Wall/-Wextra/-Wpedantic plus the broad set of additional +# diagnostics GCC exposes individually. The opt-outs below mirror the clang list +# above so both compilers police the same things and ignore the same noise. +# These are warnings only (there is no -Werror), matching the clang build. +_PHASER_GCC_COPTS = [ + "-Wall", + "-Wextra", + "-Wcast-align", + "-Wcast-qual", + "-Wconversion", + "-Wctor-dtor-privacy", + "-Wdisabled-optimization", + "-Wdouble-promotion", + "-Wduplicated-branches", + "-Wduplicated-cond", + "-Wextra-semi", + "-Wformat=2", + "-Winit-self", + "-Wlogical-op", + "-Wmissing-declarations", + "-Wmissing-include-dirs", + "-Wnoexcept", + "-Wnon-virtual-dtor", + "-Wnull-dereference", + "-Wold-style-cast", + "-Woverloaded-virtual", + "-Wredundant-decls", + "-Wshadow", + "-Wsign-conversion", + "-Wsign-promo", + "-Wstrict-null-sentinel", + "-Wundef", + "-Wunused", + "-Wuseless-cast", + "-Wzero-as-null-pointer-constant", + + # The zero-copy message layout deliberately takes offsetof() of the + # generated non-standard-layout message structs, and the runtime/generated + # code uses C++20 designated initializers and a flexible array member by + # design. Those are intentional, not bugs, so silence the corresponding + # diagnostics (g++ enables -Winvalid-offsetof by default; -Wpedantic is + # intentionally not enabled). We also keep clang-only #pragma diagnostics in + # shared headers, which GCC reports as unknown pragmas. + "-Wno-invalid-offsetof", + "-Wno-unknown-pragmas", +] + +PHASER_COPTS = select({ + "//phaser:is_clang": _PHASER_CLANG_COPTS, + "//conditions:default": _PHASER_GCC_COPTS, +}) diff --git a/phaser/phaser_test.cc b/phaser/phaser_test.cc index f1b15b4..9bb710b 100644 --- a/phaser/phaser_test.cc +++ b/phaser/phaser_test.cc @@ -41,7 +41,7 @@ TEST(PhaserTest, ProtobufCompat) { std::string buffer_data; for (int i = 0; i < 100; i++) { - buffer_data.push_back(rand() & 0xff); + buffer_data.push_back(static_cast(rand() & 0xff)); } buffer_data.push_back('\n'); buffer_data.push_back('\r'); @@ -272,7 +272,7 @@ TEST(PhaserTest, Any) { TEST(PhaserTest, Garbage) { char buffer[256]; for (int i = 0; i < 256; i++) { - buffer[i] = rand() & 0xff; + buffer[i] = static_cast(rand() & 0xff); } auto msg = foo::bar::phaser::TestMessage::CreateReadonly(buffer, sizeof(buffer)); @@ -308,7 +308,7 @@ TEST(PhaserTest, Garbage) { TEST(PhaserTest, GarbageSmall) { char buffer[10]; for (int i = 0; i < 10; i++) { - buffer[i] = rand() & 0xff; + buffer[i] = static_cast(rand() & 0xff); } auto msg = foo::bar::phaser::TestMessage::CreateReadonly(buffer, sizeof(buffer)); @@ -345,7 +345,7 @@ TEST(PhaserTest, GarbageLoop) { char buffer[256]; for (int i = 0; i < 1000; i++) { for (int j = 0; j < 256; j++) { - buffer[j] = rand() & 0xff; + buffer[j] = static_cast(rand() & 0xff); } auto msg = foo::bar::phaser::TestMessage::CreateReadonly(buffer, sizeof(buffer)); @@ -382,7 +382,7 @@ TEST(PhaserTest, GarbageLoop) { TEST(PhaserTest, GarbageWithValidMagic) { char buffer[256]; for (int i = 0; i < 256; i++) { - buffer[i] = rand() & 0xff; + buffer[i] = static_cast(rand() & 0xff); } // Set the magic. *reinterpret_cast(buffer) = ::toolbelt::kFixedBufferMagic; @@ -421,7 +421,7 @@ TEST(PhaserTest, GarbageWithValidMagic) { TEST(PhaserTest, GarbageWithTailoring) { char buffer[256]; for (int i = 0; i < 256; i++) { - buffer[i] = rand() & 0xff; + buffer[i] = static_cast(rand() & 0xff); } // Set the magic and the header fields. *reinterpret_cast(buffer) = ::toolbelt::kFixedBufferMagic; @@ -509,8 +509,9 @@ TEST(PhaserTest, Reflection) { // Let's print all the fields. for (const auto &field : (*info)->fields_in_order) { - std::cout << field->name << " " << field->number << " " << (int)field->type - << " " << field->offset << std::endl; + std::cout << field->name << " " << field->number << " " + << static_cast(field->type) << " " << field->offset + << std::endl; } absl::StatusOr has_x = ::phaser::PhaserBankHasField("foo.bar.TestMessage", msg, x_number); diff --git a/phaser/runtime/fields.h b/phaser/runtime/fields.h index b070573..51fdf49 100644 --- a/phaser/runtime/fields.h +++ b/phaser/runtime/fields.h @@ -36,12 +36,12 @@ class Field { // The presence bit is in a set of words immediately after // the metadata at the start of the message. void SetPresence(::toolbelt::PayloadBuffer *buffer, uint32_t binary_offset) { - buffer->SetPresenceBit(id_, binary_offset); + buffer->SetPresenceBit(static_cast(id_), binary_offset); } void ClearPresence(::toolbelt::PayloadBuffer *buffer, uint32_t binary_offset) { - buffer->ClearPresenceBit(id_, binary_offset); + buffer->ClearPresenceBit(static_cast(id_), binary_offset); } bool IsPresent(uint32_t field_id, ::toolbelt::PayloadBuffer *buffer, @@ -57,16 +57,17 @@ class Field { int32_t FindFieldOffset(uint32_t source_offset) const { if (cached_offset_ == 0xffffffff) { - cached_offset_ = - Message::GetMessage(this, source_offset)->FindFieldOffset(number_); + cached_offset_ = static_cast<::toolbelt::BufferOffset>( + Message::GetMessage(this, source_offset) + ->FindFieldOffset(static_cast(number_))); } - return cached_offset_; + return static_cast(cached_offset_); } int32_t FindFieldId(uint32_t source_offset) const { if (cached_field_id_ == -1) { - cached_field_id_ = - Message::GetMessage(this, source_offset)->FindFieldId(number_); + cached_field_id_ = Message::GetMessage(this, source_offset) + ->FindFieldId(static_cast(number_)); } return cached_field_id_; } @@ -102,12 +103,13 @@ class Field { if (offset < 0) { \ return type(); \ } \ - return GetBuffer()->template Get(GetMessageBinaryStart() + \ - offset); \ + return GetBuffer()->template Get( \ + GetMessageBinaryStart() + \ + static_cast<::toolbelt::BufferOffset>(offset)); \ } \ type GetForPrinting() const { return Get(); } \ bool IsPresent() const { \ - return Field::IsPresent(FindFieldId(source_offset_), GetBuffer(), \ + return Field::IsPresent(static_cast(FindFieldId(source_offset_)), GetBuffer(), \ GetPresenceMaskStart()); \ } \ \ @@ -203,13 +205,13 @@ class EnumField : public Field { } return static_cast( GetBuffer()->template Get::type>( - GetMessageBinaryStart() + offset)); + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset))); } std::string GetForPrinting() const { return ToString(); } bool IsPresent() const { - return Field::IsPresent(FindFieldId(source_offset_), GetBuffer(), + return Field::IsPresent(static_cast(FindFieldId(source_offset_)), GetBuffer(), GetPresenceMaskStart()); } @@ -223,7 +225,7 @@ class EnumField : public Field { return 0; } return GetBuffer()->template Get::type>( - GetMessageBinaryStart() + offset); + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); } void Set(Enum e) { @@ -293,7 +295,7 @@ class StringField : public Field { if (offset < 0) { return std::string_view(); } - return GetBuffer()->GetStringView(GetMessageBinaryStart() + offset); + return GetBuffer()->GetStringView(GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); } bool IsPresent() const { @@ -303,7 +305,7 @@ class StringField : public Field { } const ::toolbelt::BufferOffset *addr = GetRuntime()->ToAddress( - GetMessageBinaryStart() + offset); + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); return *addr != 0; } @@ -348,7 +350,7 @@ class StringField : public Field { if (offset < 0) { return 0; } - return GetBuffer()->StringSize(GetMessageBinaryStart() + offset); + return GetBuffer()->StringSize(GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); } const char *data() const { @@ -356,7 +358,7 @@ class StringField : public Field { if (offset < 0) { return nullptr; } - return GetBuffer()->StringData(GetMessageBinaryStart() + offset); + return GetBuffer()->StringData(GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); } size_t SerializedSize() const { @@ -494,7 +496,7 @@ template class IndirectMessageField : public Field { if (offset < 0) { return msg_; } - ::toolbelt::BufferOffset *addr = GetIndirectAddress(offset); + ::toolbelt::BufferOffset *addr = GetIndirectAddress(static_cast(offset)); if (*addr != 0) { // Load up the message if it's already been allocated. msg_.runtime = GetRuntime(); @@ -508,7 +510,7 @@ template class IndirectMessageField : public Field { if (offset < 0) { return false; } - ::toolbelt::BufferOffset *addr = GetIndirectAddress(offset); + ::toolbelt::BufferOffset *addr = GetIndirectAddress(static_cast(offset)); return *addr != 0; } @@ -574,7 +576,7 @@ template class IndirectMessageField : public Field { if (offset < 0) { return 0; } - ::toolbelt::BufferOffset *addr = GetIndirectAddress(offset); + ::toolbelt::BufferOffset *addr = GetIndirectAddress(static_cast(offset)); if (*addr != 0) { // Load up the message if it's already been allocated. msg_.runtime = GetRuntime(); @@ -588,7 +590,7 @@ template class IndirectMessageField : public Field { if (offset < 0) { return absl::OkStatus(); } - ::toolbelt::BufferOffset *addr = GetIndirectAddress(offset); + ::toolbelt::BufferOffset *addr = GetIndirectAddress(static_cast(offset)); if (*addr != 0) { // Load up the message if it's already been allocated. msg_.runtime = GetRuntime(); @@ -640,9 +642,9 @@ template class IndirectMessageField : public Field { return Message::GetBuffer(this, source_offset_); } - ::toolbelt::BufferOffset *GetIndirectAddress(uint32_t offset) const { + ::toolbelt::BufferOffset *GetIndirectAddress(uint32_t abs_offset) const { return GetBuffer()->template ToAddress<::toolbelt::BufferOffset>( - GetMessageBinaryStart() + offset); + GetMessageBinaryStart() + abs_offset); } ::toolbelt::PayloadBuffer **GetBufferAddr() const { diff --git a/phaser/runtime/iterators.h b/phaser/runtime/iterators.h index 19d086a..b515b0b 100644 --- a/phaser/runtime/iterators.h +++ b/phaser/runtime/iterators.h @@ -24,17 +24,17 @@ template struct FieldIterator { FieldIterator &operator++() { if (reverse) { - offset -= sizeof(T); + offset -= static_cast<::toolbelt::BufferOffset>(sizeof(T)); } else { - offset += sizeof(T); + offset += static_cast<::toolbelt::BufferOffset>(sizeof(T)); } return *this; } FieldIterator &operator--() { if (reverse) { - offset += sizeof(T); + offset += static_cast<::toolbelt::BufferOffset>(sizeof(T)); } else { - offset -= sizeof(T); + offset -= static_cast<::toolbelt::BufferOffset>(sizeof(T)); } return *this; } @@ -125,17 +125,17 @@ template struct EnumFieldIterator { EnumFieldIterator &operator++() { if (reverse) { - offset -= sizeof(T); + offset -= static_cast<::toolbelt::BufferOffset>(sizeof(T)); } else { - offset += sizeof(T); + offset += static_cast<::toolbelt::BufferOffset>(sizeof(T)); } return *this; } EnumFieldIterator &operator--() { if (reverse) { - offset += sizeof(T); + offset += static_cast<::toolbelt::BufferOffset>(sizeof(T)); } else { - offset -= sizeof(T); + offset -= static_cast<::toolbelt::BufferOffset>(sizeof(T)); } return *this; } diff --git a/phaser/runtime/message.cc b/phaser/runtime/message.cc index 974129d..a32eb38 100644 --- a/phaser/runtime/message.cc +++ b/phaser/runtime/message.cc @@ -104,7 +104,7 @@ absl::StatusOr<::toolbelt::PayloadBuffer *> NewDynamicBuffer( // like valgrind when the allocator scans or copies free space. memset(*buffer, 0, initial_size); ::toolbelt::PayloadBuffer *pb = new (*buffer)::toolbelt::PayloadBuffer( - initial_size, + static_cast(initial_size), [ initial_size, realloc_fn = std::move(realloc) ]( ::toolbelt::PayloadBuffer * *p, size_t old_size, size_t new_size) { absl::StatusOr r = realloc_fn(*p, old_size, new_size); diff --git a/phaser/runtime/message.h b/phaser/runtime/message.h index 335d1e9..b29d603 100644 --- a/phaser/runtime/message.h +++ b/phaser/runtime/message.h @@ -305,7 +305,8 @@ struct Message { void *Allocate(size_t size, size_t alignment = 4, bool clear = true) { (void)alignment; - return toolbelt::PayloadBuffer::Allocate(&runtime->pb, size, clear); + return toolbelt::PayloadBuffer::Allocate( + &runtime->pb, static_cast(size), clear); } void Free(void *ptr) { runtime->pb->Free(ptr); } @@ -313,7 +314,8 @@ struct Message { void *Realloc(void *ptr, size_t size, size_t alignment = 4, bool clear = true) { (void)alignment; - return toolbelt::PayloadBuffer::Realloc(&runtime->pb, ptr, size, clear); + return toolbelt::PayloadBuffer::Realloc( + &runtime->pb, ptr, static_cast(size), clear); } toolbelt::BufferOffset ToOffset(void *addr) { diff --git a/phaser/runtime/message_test.cc b/phaser/runtime/message_test.cc index dd1af57..3e71e5c 100644 --- a/phaser/runtime/message_test.cc +++ b/phaser/runtime/message_test.cc @@ -32,6 +32,7 @@ struct EnumTestStringizer { case EnumTest::UNSET: return "UNSET"; } + return "UNKNOWN"; } }; @@ -144,7 +145,7 @@ struct InnerMessage : public Message { } static InnerMessage CreateMutable(void *addr, size_t size) { - ::toolbelt::PayloadBuffer *pb = new (addr)::toolbelt::PayloadBuffer(size); + ::toolbelt::PayloadBuffer *pb = new (addr)::toolbelt::PayloadBuffer(static_cast(size)); ::toolbelt::PayloadBuffer::AllocateMainMessage(&pb, InnerMessage::BinarySize()); auto runtime = std::make_shared(pb); @@ -548,7 +549,7 @@ struct TestMessage : public Message { u3_(offsetof(TestMessage, u3_), HeaderSize() + 64, 0, 0, {111, 112}) {} static TestMessage CreateMutable(void *addr, size_t size) { - ::toolbelt::PayloadBuffer *pb = new (addr)::toolbelt::PayloadBuffer(size); + ::toolbelt::PayloadBuffer *pb = new (addr)::toolbelt::PayloadBuffer(static_cast(size)); ::toolbelt::PayloadBuffer::AllocateMainMessage(&pb, TestMessage::BinarySize()); auto runtime = std::make_shared(pb); @@ -578,8 +579,8 @@ struct TestMessage : public Message { ::toolbelt::PayloadBuffer *pb = phaser::NewDynamicBuffer(initial_size); ::toolbelt::PayloadBuffer::AllocateMainMessage(&pb, TestMessage::BinarySize()); - auto runtime = std::make_shared(pb, ::free); - this->runtime = runtime; + auto rt = std::make_shared(pb, ::free); + this->runtime = rt; this->absolute_binary_offset = pb->message; this->InstallMetadata(); } @@ -994,7 +995,9 @@ struct TestMessage : public Message { } size_t vstr_size() const { return vstr_.size(); } - std::string_view vstr(size_t i) const { return vstr_.Get(i); } + std::string_view vstr(size_t i) const { + return vstr_.Get(static_cast(i)); + } template void add_vstr(Str v) { vstr_.Add(v); } template void set_vstr(size_t i, Str v) { vstr_.Set(i, v); } void clear_vstr() { vstr_.Clear(); } @@ -1005,7 +1008,9 @@ struct TestMessage : public Message { size_t vm_size() const { return vm_.size(); } const InnerMessage &vm(size_t i) const { return vm_.Get(i); } - InnerMessage *mutable_vm(size_t i) { return vm_.Mutable(i); } + InnerMessage *mutable_vm(size_t i) { + return vm_.Mutable(static_cast(i)); + } InnerMessage *add_vm() { return vm_.Add(); } void clear_vm() { vm_.Clear(); } phaser::MessageVectorField &vm() { @@ -1264,7 +1269,7 @@ static struct TestMessageBankRegister { } TestMessage_bank_register; TEST(MessageTest, Basic) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.DebugDump(); @@ -1296,7 +1301,7 @@ TEST(MessageTest, Basic) { // Copy message to test reading. { - char *buffer2 = (char *)calloc(4096, 1); + char *buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); @@ -1322,7 +1327,7 @@ TEST(MessageTest, Basic) { } TEST(MessageTest, RepeatedPrimitive) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); // This field is absent. @@ -1342,7 +1347,7 @@ TEST(MessageTest, RepeatedPrimitive) { // Copy message to test reading. { - char *buffer2 = (char *)calloc(4096, 1); + char *buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); @@ -1359,7 +1364,7 @@ TEST(MessageTest, RepeatedPrimitive) { } TEST(MessageTest, RepeatedString) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.DebugDump(); @@ -1385,7 +1390,7 @@ TEST(MessageTest, RepeatedString) { // Copy message to test reading. { - char *buffer2 = (char *)calloc(4096, 1); + char *buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); @@ -1404,7 +1409,7 @@ TEST(MessageTest, RepeatedString) { } TEST(MessageTest, RepeatedMessage) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); InnerMessage *inner1 = msg.vm_.Add(); @@ -1429,7 +1434,7 @@ TEST(MessageTest, RepeatedMessage) { // Copy message to test reading. { - char *buffer2 = (char *)calloc(4096, 1); + char *buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); @@ -1446,10 +1451,10 @@ TEST(MessageTest, RepeatedMessage) { } TEST(MessageTest, UnionField) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); - msg.u1_.Set<0>(1234); + msg.u1_.Set<0>(1234u); msg.u2_.Set<1>("Hello, world!"); InnerMessage *inner = msg.u3_.Mutable<1, InnerMessage>(); inner->str_.Set("Inner message"); @@ -1474,7 +1479,7 @@ TEST(MessageTest, UnionField) { // in-buffer storage to a smaller block, which drives toolbelt's // PayloadBuffer::Realloc -> ShrinkBlock path. TEST(MessageTest, UnionArmSwitchInPlace) { - char *buffer = (char *)calloc(8192, 1); + char *buffer = static_cast(calloc(8192, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 8192); // Grow then repeatedly shrink the string arm on the same message. Each shrink @@ -1484,9 +1489,9 @@ TEST(MessageTest, UnionArmSwitchInPlace) { ASSERT_EQ(std::string(512, 'x'), msg.u2b()); for (int len : {256, 64, 16, 4, 1}) { - msg.set_u2b(std::string(len, 'y')); + msg.set_u2b(std::string(static_cast(len), 'y')); ASSERT_EQ(110, msg.u2_case()); - ASSERT_EQ(std::string(len, 'y'), msg.u2b()); + ASSERT_EQ(std::string(static_cast(len), 'y'), msg.u2b()); } // Switch to the scalar arm and back. The high-level setters clear the @@ -1527,7 +1532,7 @@ TEST(MessageTest, UnionArmSwitchInPlace) { } TEST(MessageTest, ClearBasic) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.x_.Set(1234); @@ -1553,7 +1558,7 @@ TEST(MessageTest, ClearBasic) { } TEST(MessageTest, ClearRepeated) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.vi32_.Add(1); @@ -1588,10 +1593,10 @@ TEST(MessageTest, ClearRepeated) { } TEST(MessageTest, ClearUnion) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); - msg.u1_.Set<0>(1234); + msg.u1_.Set<0>(1234u); msg.u2_.Set<1>("Hello, world!"); InnerMessage *inner = msg.u3_.Mutable<1, InnerMessage>(); inner->str_.Set("Inner message"); @@ -1608,7 +1613,7 @@ TEST(MessageTest, ClearUnion) { } TEST(MessageTest, ProtobufBasic) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.set_x(1234); @@ -1631,7 +1636,7 @@ TEST(MessageTest, ProtobufBasic) { // Copy message to test reading. { - char *buffer2 = (char *)calloc(4096, 1); + char *buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); @@ -1650,7 +1655,7 @@ TEST(MessageTest, ProtobufBasic) { } TEST(MessageTest, ProtobufSerializationSizeBasic) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.set_x(1); // Tag 100 @@ -1689,7 +1694,7 @@ TEST(MessageTest, ProtobufSerializationSizeBasic) { } TEST(MessageTest, ProtobufSerializationSizeUnion) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.set_u1a(1234); // Tag 107. @@ -1727,7 +1732,7 @@ TEST(MessageTest, ProtobufSerializationSizeUnion) { } TEST(MessageTest, ProtobufSerializationSizeRepeatedPrimitive) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); // Tag 104. @@ -1763,7 +1768,7 @@ TEST(MessageTest, ProtobufSerializationSizeRepeatedPrimitive) { } TEST(MessageTest, ProtobufSerializationBasic) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb; @@ -1790,7 +1795,7 @@ TEST(MessageTest, ProtobufSerializationBasic) { } TEST(MessageTest, ProtobufSerializationRepeated) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb; @@ -1837,7 +1842,7 @@ TEST(MessageTest, ProtobufSerializationRepeated) { } TEST(MessageTest, ProtobufSerializationUnion) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb; @@ -1875,7 +1880,7 @@ TEST(MessageTest, ProtobufDeserializationBasic) { pb_inner->set_f(0xdeadbeef); std::string str = pb_msg.SerializeAsString(); - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb_buffer(str); @@ -1912,7 +1917,7 @@ TEST(MessageTest, ProtobufDeserializationRepeated) { pb_inner2->set_f(0x1234); std::string str = pb_msg.SerializeAsString(); - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb_buffer(str); @@ -1940,7 +1945,7 @@ TEST(MessageTest, ProtobufDeserializationUnion) { pb_inner->set_f(0xdeadbeef); std::string str = pb_msg.SerializeAsString(); - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb_buffer(str); @@ -1989,7 +1994,7 @@ TEST(MessageTest, Print) { inner->e_.Set(EnumTest::BAR); inner->ev_.Add(EnumTest::FOO); inner->ev_.Add(EnumTest::BAR); - inner->uv_.Set<0>(1234); + inner->uv_.Set<0>(1234u); msg.vi32_.Add(1); msg.vi32_.Add(2); @@ -2007,7 +2012,7 @@ TEST(MessageTest, Print) { inner2->f_.Set(0x1234); // Unions. - msg.u1_.Set<0>(1234); + msg.u1_.Set<0>(1234u); msg.u2_.Set<1>("Hello, world!"); InnerMessage *inner3 = msg.u3_.Mutable<1, InnerMessage>(); inner3->str_.Set("Inner message"); @@ -2023,7 +2028,7 @@ TEST(MessageTest, Print) { } TEST(MessageTest, MessageInfo) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); InnerMessage msg = InnerMessage::CreateMutable(buffer, 4096); const ::phaser::MessageInfo *info = msg.GetMessageInfo(); ASSERT_EQ("foo.bar.InnerMessage", info->full_name); @@ -2034,7 +2039,7 @@ TEST(MessageTest, MessageInfo) { } TEST(MessageTest, PhaserBank) { - char *buffer = (char *)calloc(4096, 1); + char *buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); auto status = ::phaser::PhaserBankAllocate( "foo.bar.InnerMessage", msg.runtime); diff --git a/phaser/runtime/runtime.h b/phaser/runtime/runtime.h index e9f623a..ebd56b4 100644 --- a/phaser/runtime/runtime.h +++ b/phaser/runtime/runtime.h @@ -62,9 +62,9 @@ inline std::string StringWithOctalNonPrintables(std::string_view str) { result.push_back('t'); break; default: - result.push_back('0' + ((uc >> 6) & 7)); - result.push_back('0' + ((uc >> 3) & 7)); - result.push_back('0' + (uc & 7)); + result.push_back(static_cast('0' + ((uc >> 6) & 7))); + result.push_back(static_cast('0' + ((uc >> 3) & 7))); + result.push_back(static_cast('0' + (uc & 7))); break; } } diff --git a/phaser/runtime/union.h b/phaser/runtime/union.h index b508638..426e616 100644 --- a/phaser/runtime/union.h +++ b/phaser/runtime/union.h @@ -271,7 +271,8 @@ class UnionStringField : public UnionMemberField { uint32_t abs_offset) const { size_t sz = size(runtime, abs_offset); return ProtoBuffer::TagSize(number, WireType::kLengthDelimited) + - ProtoBuffer::VarintSize(sz) + sz; + ProtoBuffer::VarintSize(static_cast(sz)) + + sz; } absl::Status Serialize(int number, ProtoBuffer &buffer, @@ -493,7 +494,7 @@ template class UnionField : public Field { public: UnionField() = default; UnionField(uint32_t source_offset, uint32_t relative_binary_offset, int id, - int number, std::vector field_numbers) + int number, std::vector field_numbers) : Field(id, number), source_offset_(source_offset), relative_binary_offset_(relative_binary_offset), field_numbers_(field_numbers) {} @@ -505,7 +506,7 @@ template class UnionField : public Field { return std::get(value_).Get(nullptr, 0); } return std::get(value_).Get(GetRuntime(), GetMessageBinaryStart() + - relative_offset + 4); + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } template F GetValue() const { @@ -515,7 +516,7 @@ template class UnionField : public Field { return std::get(value_).Get(nullptr, 0); } return std::get(value_).Get(GetRuntime(), GetMessageBinaryStart() + - relative_offset + 4); + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } template void Print(std::ostream &os) const { @@ -525,19 +526,19 @@ template class UnionField : public Field { return; } int32_t *discrim = GetRuntime()->template ToAddress( - GetMessageBinaryStart() + relative_offset); - if (*discrim != field_numbers_[Id]) { + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset)); + if (*discrim != static_cast(field_numbers_[Id])) { return; } std::get(value_).Print(os, indent_, GetRuntime(), - GetMessageBinaryStart() + relative_offset + 4); + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } template void Set(const U &v) { // Write the field number into the discriminator. int32_t *discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); - *discrim = field_numbers_[Id]; + *discrim = static_cast(field_numbers_[Id]); // Get the variant and set its location. In binary it is // 4 bytes after the discriminator. auto &t = std::get(value_); @@ -549,7 +550,7 @@ template class UnionField : public Field { // Write the field number into the discriminator. int32_t *discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); - *discrim = field_numbers_[Id]; + *discrim = static_cast(field_numbers_[Id]); // Get the variant and set its location. In binary it is // 4 bytes after the discriminator. @@ -563,7 +564,7 @@ template class UnionField : public Field { // Write the field number into the discriminator. int32_t *discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); - *discrim = field_numbers_[Id]; + *discrim = static_cast(field_numbers_[Id]); // Get the variant and set its location. In binary it is // 4 bytes after the discriminator. @@ -594,14 +595,14 @@ template class UnionField : public Field { return 0; // No field present in message (all fields have been removed). } int32_t *discrim = GetRuntime()->template ToAddress( - GetMessageBinaryStart() + relative_offset); + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset)); return *discrim; } template void Clear() { int32_t *discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); - int field_number = field_numbers_[Id]; + int32_t field_number = static_cast(field_numbers_[Id]); if (*discrim != field_number) { return; } @@ -627,7 +628,7 @@ template class UnionField : public Field { } return std::get(value_).SerializedSize(discriminator, GetRuntime(), GetMessageBinaryStart() + - relative_offset + 4); + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } template @@ -639,7 +640,7 @@ template class UnionField : public Field { } return std::get(value_).Serialize(discriminator, buffer, GetRuntime(), GetMessageBinaryStart() + - relative_offset + 4); + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } template @@ -651,14 +652,14 @@ template class UnionField : public Field { } if (absl::Status status = std::get(value_).Deserialize( buffer, GetRuntime(), - GetMessageBinaryStart() + relative_offset + 4); + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); !status.ok()) { return status; } // Set the discriminator. int32_t *discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); - *discrim = field_numbers_[Id]; + *discrim = static_cast(field_numbers_[Id]); return absl::OkStatus(); } @@ -670,10 +671,10 @@ template class UnionField : public Field { } int32_t *discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); - *discrim = field_numbers_[Id]; + *discrim = static_cast(field_numbers_[Id]); // TODO: this isn't right. If the field is a message, it can fail to clone. std::get(value_).Set(other, GetRuntime(), - GetMessageBinaryStart() + relative_offset + 4); + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); return absl::OkStatus(); } @@ -684,14 +685,14 @@ template class UnionField : public Field { return false; } int32_t *discrim = GetRuntime()->template ToAddress( - GetMessageBinaryStart() + relative_offset); - return *discrim == field_numbers_[Id]; + GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset)); + return *discrim == static_cast(field_numbers_[Id]); } template void SetOffset(toolbelt::BufferOffset offset) { int32_t *discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); - *discrim = field_numbers_[Id]; + *discrim = static_cast(field_numbers_[Id]); // Get the variant and set its location. In binary it is // 4 bytes after the discriminator. @@ -718,7 +719,7 @@ template class UnionField : public Field { uint32_t source_offset_; ::toolbelt::BufferOffset relative_binary_offset_; - std::vector field_numbers_; // field number for each tuple type + std::vector field_numbers_; // field number for each tuple type mutable std::tuple value_; }; } // namespace phaser diff --git a/phaser/runtime/vectors.h b/phaser/runtime/vectors.h index 1ecd4be..415cce0 100644 --- a/phaser/runtime/vectors.h +++ b/phaser/runtime/vectors.h @@ -39,17 +39,17 @@ class ProtoBuffer; \ iterator begin() { return iterator(this, BaseOffset()); } \ iterator end() { \ - return iterator(this, BaseOffset() + NumElements() * sizeof(value_type)); \ + return iterator(this, BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type))); \ } \ const_iterator begin() const { return const_iterator(this, BaseOffset()); } \ const_iterator end() const { \ return const_iterator(this, \ - BaseOffset() + NumElements() * sizeof(value_type)); \ + BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type))); \ } \ const_iterator cbegin() const { return const_iterator(this, BaseOffset()); } \ const_iterator cend() const { \ return const_iterator(this, \ - BaseOffset() + NumElements() * sizeof(value_type)); \ + BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type))); \ } \ \ reverse_iterator rbegin() { \ @@ -57,21 +57,21 @@ class ProtoBuffer; } \ reverse_iterator rend() { \ return reverse_iterator( \ - this, BaseOffset() + NumElements() * sizeof(value_type), true); \ + this, BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type)), true); \ } \ const_reverse_iterator rbegin() const { \ return const_reverse_iterator(this, BaseOffset(), true); \ } \ const_reverse_iterator rend() const { \ return const_reverse_iterator( \ - this, BaseOffset() + NumElements() * sizeof(value_type), true); \ + this, BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type)), true); \ } \ const_reverse_iterator crbegin() const { \ return const_reverse_iterator(this, BaseOffset(), true); \ } \ const_reverse_iterator crend() const { \ return const_reverse_iterator( \ - this, BaseOffset() + NumElements() * sizeof(value_type), true); \ + this, BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type)), true); \ } // vtype: value type @@ -141,7 +141,7 @@ class PrimitiveVectorField : public Field { T back() { return (*this)[size() - 1]; } const T back() const { return (*this)[size() - 1]; } - T Get(size_t index) const { return (*this)[index]; } + T Get(size_t index) const { return (*this)[static_cast(index)]; } void Set(size_t index, T v) { T *base = GetRuntime()->template ToAddress(BaseOffset()); @@ -208,7 +208,7 @@ class PrimitiveVectorField : public Field { if (offset < 0) { return absl::Span(); } - toolbelt::VectorHeader *hdr = Header(offset); + toolbelt::VectorHeader *hdr = Header(static_cast(offset)); const T *base = GetRuntime()->template ToAddress(hdr->data); if (base == nullptr) { return absl::Span(); @@ -406,7 +406,7 @@ class PrimitiveVectorField : public Field { if (offset < 0) { return 0; } - return Header(offset)->data; + return Header(static_cast(offset))->data; } size_t NumElements() const { @@ -414,7 +414,7 @@ class PrimitiveVectorField : public Field { if (offset < 0) { return 0; } - return Header(offset)->num_elements; + return Header(static_cast(offset))->num_elements; } ::toolbelt::PayloadBuffer *GetBuffer() const { @@ -478,7 +478,7 @@ class EnumVectorField : public Field { return r; } - Enum Get(size_t index) const { return (*this)[index]; } + Enum Get(size_t index) const { return (*this)[static_cast(index)]; } void Set(size_t index, Enum v) { Enum *base = GetRuntime()->template ToAddress(BaseOffset()); @@ -508,7 +508,7 @@ class EnumVectorField : public Field { if (offset < 0) { return absl::Span(); } - toolbelt::VectorHeader *hdr = Header(offset); + toolbelt::VectorHeader *hdr = Header(static_cast(offset)); const Enum *base = GetRuntime()->template ToAddress(hdr->data); if (base == nullptr) { return absl::Span(); @@ -695,7 +695,7 @@ class EnumVectorField : public Field { if (offset < 0) { return 0; } - return Header(offset)->data; + return Header(static_cast(offset))->data; } size_t NumElements() const { @@ -703,7 +703,7 @@ class EnumVectorField : public Field { if (offset < 0) { return 0; } - return Header(offset)->num_elements; + return Header(static_cast(offset))->num_elements; } ::toolbelt::PayloadBuffer *GetBuffer() const { @@ -741,7 +741,7 @@ template class MessageVectorField : public Field { if (offset == -1) { return empty_; } - auto hdr = Header(offset); + auto hdr = Header(static_cast(offset)); if (static_cast(index) >= hdr->num_elements) { return empty_; } @@ -751,12 +751,12 @@ template class MessageVectorField : public Field { return empty_; } if (static_cast(index) >= msgs_.size()) { - msgs_.resize(index + 1); + msgs_.resize(static_cast(index) + 1); } - if (msgs_[index].empty()) { - msgs_[index] = MessageObject(GetRuntime(), data[index]); + if (msgs_[static_cast(index)].empty()) { + msgs_[static_cast(index)] = MessageObject(GetRuntime(), data[index]); } - return msgs_[index]; + return msgs_[static_cast(index)]; } MessageObject &front() { return msgs_.front(); } @@ -800,16 +800,18 @@ template class MessageVectorField : public Field { return msgs_.back().Mutable(); } - const T &Get(size_t index) const { return (*this)[index].Get(); } + const T &Get(size_t index) const { + return (*this)[static_cast(index)].Get(); + } T *Mutable(int index) { if (static_cast(index) >= msgs_.size()) { ::toolbelt::PayloadBuffer::VectorResize<::toolbelt::BufferOffset>( - GetBufferAddr(), Header(), index + 1); - msgs_.resize(index + 1); + GetBufferAddr(), Header(), static_cast(index) + 1); + msgs_.resize(static_cast(index) + 1); } - if (msgs_[index].IsPlaceholder()) { + if (msgs_[static_cast(index)].IsPlaceholder()) { void *binary = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(), T::BinarySize()); ::toolbelt::BufferOffset absolute_binary_offset = @@ -822,24 +824,24 @@ template class MessageVectorField : public Field { auto obj = MessageObject(GetRuntime(), absolute_binary_offset); obj.InstallMetadata(); - msgs_[index] = std::move(obj); + msgs_[static_cast(index)] = std::move(obj); } - return msgs_[index].Mutable(); + return msgs_[static_cast(index)].Mutable(); } void SetOffset(int index, toolbelt::BufferOffset offset) { if (static_cast(index) >= msgs_.size()) { - msgs_.resize(index + 1); + msgs_.resize(static_cast(index) + 1); } auto hdr = Header(); ::toolbelt::BufferOffset *data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); - if (!msgs_[index].IsPlaceholder() && data[index] != 0) { + if (!msgs_[static_cast(index)].IsPlaceholder() && data[index] != 0) { // Already set, free the current value. - msgs_[index].Clear(); + msgs_[static_cast(index)].Clear(); } data[index] = offset; - msgs_[index] = MessageObject(GetRuntime(), offset); + msgs_[static_cast(index)] = MessageObject(GetRuntime(), offset); } // Allocate a bunch of empty messages. @@ -849,7 +851,7 @@ template class MessageVectorField : public Field { this->resize(n); // Allocate memory for n messages in the payload buffer. std::vector addrs = ::toolbelt::PayloadBuffer::AllocateMany( - GetBufferAddr(), T::BinarySize(), n, true); + GetBufferAddr(), T::BinarySize(), static_cast(n), true); toolbelt::VectorHeader *hdr = Header(); ::toolbelt::BufferOffset *data = @@ -945,7 +947,7 @@ template class MessageVectorField : public Field { if (offset == -1) { return; } - auto hdr = Header(offset); + auto hdr = Header(static_cast(offset)); msgs_.resize(hdr->num_elements); ::toolbelt::BufferOffset *data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); @@ -1018,7 +1020,7 @@ template class MessageVectorField : public Field { if (offset < 0) { return 0; } - return Header(offset)->data; + return Header(static_cast(offset))->data; } size_t NumElements() const { @@ -1026,7 +1028,7 @@ template class MessageVectorField : public Field { if (offset < 0) { return 0; } - return Header(offset)->num_elements; + return Header(static_cast(offset))->num_elements; } ::toolbelt::PayloadBuffer *GetBuffer() const { @@ -1079,7 +1081,7 @@ class StringVectorField : public Field { if (offset == -1) { return empty_; } - auto hdr = Header(offset); + auto hdr = Header(static_cast(offset)); if (static_cast(index) >= hdr->num_elements) { return empty_; } @@ -1089,13 +1091,13 @@ class StringVectorField : public Field { return empty_; } if (static_cast(index) >= strings_.size()) { - strings_.resize(index + 1); + strings_.resize(static_cast(index) + 1); } - if (strings_[index].IsPlaceholder()) { - strings_[index] = NonEmbeddedStringField( + if (strings_[static_cast(index)].IsPlaceholder()) { + strings_[static_cast(index)] = NonEmbeddedStringField( Message::GetMessage(this, source_offset_), data[index]); } - return strings_[index]; + return strings_[static_cast(index)]; } #define RTYPE std::vector @@ -1140,11 +1142,11 @@ class StringVectorField : public Field { template void Set(int index, Str s) { if (static_cast(index) >= strings_.size()) { ::toolbelt::PayloadBuffer::VectorResize<::toolbelt::BufferOffset>( - GetBufferAddr(), Header(), index + 1); - strings_.resize(index + 1); + GetBufferAddr(), Header(), static_cast(index) + 1); + strings_.resize(static_cast(index) + 1); } - if (strings_[index].IsPlaceholder()) { + if (strings_[static_cast(index)].IsPlaceholder()) { // Allocate string header in buffer. void *str_hdr = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(), sizeof(toolbelt::StringHeader)); @@ -1158,9 +1160,9 @@ class StringVectorField : public Field { // Add a source string field. NonEmbeddedStringField field(Message::GetMessage(this, source_offset_), hdr_offset); - strings_[index] = std::move(field); + strings_[static_cast(index)] = std::move(field); } - strings_[index].Set(s); + strings_[static_cast(index)].Set(s); } size_t capacity() const { @@ -1223,7 +1225,7 @@ class StringVectorField : public Field { if (offset == -1) { return; } - auto hdr = Header(offset); + auto hdr = Header(static_cast(offset)); strings_.resize(hdr->num_elements); ::toolbelt::BufferOffset *data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); @@ -1299,7 +1301,7 @@ class StringVectorField : public Field { if (offset < 0) { return 0; } - return Header(offset)->data; + return Header(static_cast(offset))->data; } size_t NumElements() const { @@ -1307,7 +1309,7 @@ class StringVectorField : public Field { if (offset < 0) { return 0; } - return Header(offset)->num_elements; + return Header(static_cast(offset))->num_elements; } ::toolbelt::PayloadBuffer *GetBuffer() const { diff --git a/phaser/runtime/wireformat.h b/phaser/runtime/wireformat.h index c01103c..48ba80c 100644 --- a/phaser/runtime/wireformat.h +++ b/phaser/runtime/wireformat.h @@ -77,7 +77,7 @@ class ProtoBuffer { } } - size_t Size() const { return addr_ - start_; } + size_t Size() const { return static_cast(addr_ - start_); } size_t size() const { return Size(); } @@ -85,10 +85,13 @@ class ProtoBuffer { char *data() { return Data(); } - std::string AsString() const { return std::string(start_, addr_ - start_); } + std::string AsString() const { + return std::string(start_, static_cast(addr_ - start_)); + } template absl::Span AsSpan() const { - return absl::Span(reinterpret_cast(start_), addr_ - start_); + return absl::Span(reinterpret_cast(start_), + static_cast(addr_ - start_)); } bool Eof() const { return addr_ == end_; } @@ -127,7 +130,8 @@ class ProtoBuffer { // Size functions. static size_t TagSize(int field_number, WireType wire_type) { - return VarintSize(MakeTag(field_number, wire_type)); + return VarintSize( + static_cast(MakeTag(field_number, wire_type))); } template static uint64_t ToVarintWire(T value) { @@ -158,7 +162,7 @@ class ProtoBuffer { inline static size_t LengthDelimitedSize(int field_number, size_t length) { return TagSize(field_number, WireType::kLengthDelimited) + - VarintSize(length) + length; + VarintSize(static_cast(length)) + length; } inline static size_t StringSize(int field_number, std::string_view str) { @@ -195,7 +199,7 @@ class ProtoBuffer { absl::Status SerializeTag(int field_number, WireType wire_type) { return SerializeRawVarint( - MakeTag(field_number, wire_type)); + static_cast(MakeTag(field_number, wire_type))); } template absl::Status SerializeFixed(int field_number, T value) { @@ -218,7 +222,8 @@ class ProtoBuffer { !status.ok()) { return status; } - if (absl::Status status = SerializeRawVarint(length); + if (absl::Status status = + SerializeRawVarint(static_cast(length)); !status.ok()) { return status; } @@ -235,7 +240,7 @@ class ProtoBuffer { !status.ok()) { return status; } - return SerializeRawVarint(length); + return SerializeRawVarint(static_cast(length)); } absl::Status SerializeRaw(const void *data, size_t length) { @@ -344,11 +349,12 @@ class ProtoBuffer { if (!length.ok()) { return length.status(); } - if (absl::Status status = Check(*length); !status.ok()) { + const size_t len = static_cast(*length); + if (absl::Status status = Check(len); !status.ok()) { return status; } - absl::Span span(addr_, *length); - addr_ += *length; + absl::Span span(addr_, len); + addr_ += len; return span; } @@ -357,11 +363,12 @@ class ProtoBuffer { if (!length.ok()) { return length.status(); } - if (absl::Status status = Check(*length); !status.ok()) { + const size_t len = static_cast(*length); + if (absl::Status status = Check(len); !status.ok()) { return status; } - std::string_view str(addr_, *length); - addr_ += *length; + std::string_view str(addr_, len); + addr_ += len; return str; } @@ -394,7 +401,7 @@ class ProtoBuffer { } // Zero the newly grown region. memset(new_start + size_, 0, new_size - size_); - size_t curr_length = addr_ - start_; + size_t curr_length = static_cast(addr_ - start_); start_ = new_start; addr_ = start_ + curr_length; end_ = start_ + new_size; diff --git a/phaser/stress_test.cc b/phaser/stress_test.cc index cbd2240..c5c07f6 100644 --- a/phaser/stress_test.cc +++ b/phaser/stress_test.cc @@ -118,7 +118,7 @@ TEST(StressTest, MapManyEntries) { } ASSERT_EQ(500u, msg.values_size()); for (int i = 0; i < 500; i++) { - EXPECT_EQ(i, msg.values(i).value()); + EXPECT_EQ(i, msg.values(static_cast(i)).value()); } } From deeba1263727d842183f31ff5f24682f440f28a7 Mon Sep 17 00:00:00 2001 From: Dave Allison Date: Tue, 2 Jun 2026 09:09:03 -0700 Subject: [PATCH 3/7] Fix pedantic clang warnings --- phaser/compiler/message_gen.cc | 12 ++++++++---- phaser/copts.bzl | 8 -------- phaser/runtime/message_test.cc | 4 ++-- phaser/runtime/vectors.h | 8 +++++--- 4 files changed, 15 insertions(+), 17 deletions(-) diff --git a/phaser/compiler/message_gen.cc b/phaser/compiler/message_gen.cc index 9600b23..b308c06 100644 --- a/phaser/compiler/message_gen.cc +++ b/phaser/compiler/message_gen.cc @@ -899,7 +899,11 @@ void MessageGenerator::GenerateFieldMetadata(std::ostream &os) { uint32_t offset : 24; uint32_t id : 8; )"; - os << " } fields[" << all_fields.size() << "];\n"; + // A message with no fields would otherwise emit `fields[0]`, a zero-length + // array (a non-standard extension). Reserve one (zero-initialized, never read + // because num == 0) element instead so the generated header stays clean. + os << " } fields[" << (all_fields.empty() ? size_t{1} : all_fields.size()) + << "];\n"; os << " };\n"; // Generate the field data. @@ -1451,7 +1455,7 @@ void MessageGenerator::GenerateProtobufSerialization(std::ostream &os) { } void MessageGenerator::GenerateIndent(std::ostream &os) { - os << " void Indent(int indent) const {\n"; + os << " void Indent([[maybe_unused]] int indent) const {\n"; for (auto &field : fields_) { os << " " << field->member_name << ".Indent(indent);\n"; } @@ -1462,7 +1466,7 @@ void MessageGenerator::GenerateIndent(std::ostream &os) { } void MessageGenerator::GenerateStreamer(std::ostream &os) { - os << "inline std::ostream &operator<<(std::ostream &os, const " + os << "inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const " << MessageName(message_) << " &msg) {\n"; // We need to print the fields in the same order as they appear in the // message definition. This is to match the output from the protobuf @@ -1538,7 +1542,7 @@ void MessageGenerator::GenerateCopy(std::ostream &os, bool decl) { // CloneFrom. os << "template \n"; os << "inline absl::Status " << MessageName(message_) - << "::CloneFrom(const T & other) {\n"; + << "::CloneFrom([[maybe_unused]] const T & other) {\n"; for (auto &field : fields_) { if (field->field->is_repeated()) { os << " for (auto& v : other." << field->field->name() << "()) {\n"; diff --git a/phaser/copts.bzl b/phaser/copts.bzl index 2d0d5f9..307d26f 100644 --- a/phaser/copts.bzl +++ b/phaser/copts.bzl @@ -53,14 +53,6 @@ _PHASER_CLANG_COPTS = [ # clang 16/18 only (older clang silently ignores unknown -Wno-* flags). "-Wno-documentation-unknown-command", "-Wno-unsafe-buffer-usage", - - # The zero-copy runtime deliberately interconverts signed indices with - # unsigned 32-bit buffer offsets/sizes, and uses a handful of C-style casts - # when interfacing with the payload buffer. Auditing every such conversion - # is a separate effort; keep these off so the meaningful warnings stand out. - "-Wno-sign-conversion", - "-Wno-shorten-64-to-32", - "-Wno-old-style-cast", ] # GCC has no single -Weverything switch, so we approximate the clang coverage by diff --git a/phaser/runtime/message_test.cc b/phaser/runtime/message_test.cc index 3e71e5c..8f1c407 100644 --- a/phaser/runtime/message_test.cc +++ b/phaser/runtime/message_test.cc @@ -996,7 +996,7 @@ struct TestMessage : public Message { size_t vstr_size() const { return vstr_.size(); } std::string_view vstr(size_t i) const { - return vstr_.Get(static_cast(i)); + return vstr_.Get(i); } template void add_vstr(Str v) { vstr_.Add(v); } template void set_vstr(size_t i, Str v) { vstr_.Set(i, v); } @@ -1009,7 +1009,7 @@ struct TestMessage : public Message { size_t vm_size() const { return vm_.size(); } const InnerMessage &vm(size_t i) const { return vm_.Get(i); } InnerMessage *mutable_vm(size_t i) { - return vm_.Mutable(static_cast(i)); + return vm_.Mutable(i); } InnerMessage *add_vm() { return vm_.Add(); } void clear_vm() { vm_.Clear(); } diff --git a/phaser/runtime/vectors.h b/phaser/runtime/vectors.h index 415cce0..954d66f 100644 --- a/phaser/runtime/vectors.h +++ b/phaser/runtime/vectors.h @@ -804,7 +804,7 @@ template class MessageVectorField : public Field { return (*this)[static_cast(index)].Get(); } - T *Mutable(int index) { + T *Mutable(size_t index) { if (static_cast(index) >= msgs_.size()) { ::toolbelt::PayloadBuffer::VectorResize<::toolbelt::BufferOffset>( GetBufferAddr(), Header(), static_cast(index) + 1); @@ -1137,9 +1137,11 @@ class StringVectorField : public Field { void Add(const char *s, size_t len) { push_back(std::string(s, len)); } template void Add(Str s) { push_back(s); } - std::string_view Get(int index) const { return (*this)[index].Get(); } + std::string_view Get(size_t index) const { + return (*this)[static_cast(index)].Get(); + } - template void Set(int index, Str s) { + template void Set(size_t index, Str s) { if (static_cast(index) >= strings_.size()) { ::toolbelt::PayloadBuffer::VectorResize<::toolbelt::BufferOffset>( GetBufferAddr(), Header(), static_cast(index) + 1); From f1f4c897a2a72e7707d1638baf96d22711ff9097 Mon Sep 17 00:00:00 2001 From: Dave Allison Date: Tue, 2 Jun 2026 10:40:26 -0700 Subject: [PATCH 4/7] Fix some more warnings --- phaser/compiler/message_gen.cc | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/phaser/compiler/message_gen.cc b/phaser/compiler/message_gen.cc index b308c06..5bcff56 100644 --- a/phaser/compiler/message_gen.cc +++ b/phaser/compiler/message_gen.cc @@ -703,7 +703,7 @@ void MessageGenerator::GenerateInternalDefaultConstructor(std::ostream &os, return; } os << MessageName(message_) << "::" << MessageName(message_) - << "(::phaser::InternalDefault d)\n"; + << "(::phaser::InternalDefault)\n"; // Generate field initializers. GenerateFieldInitializers(os); os << "{}\n\n"; @@ -718,9 +718,9 @@ void MessageGenerator::GenerateMainConstructor(std::ostream &os, bool decl) { return; } os << MessageName(message_) << "::" << MessageName(message_) << "("; - os << "std::shared_ptr<::phaser::MessageRuntime> runtime, " + os << "std::shared_ptr<::phaser::MessageRuntime> runtime_ptr, " "::toolbelt::BufferOffset " - "offset) : Message(runtime, offset)\n"; + "offset) : Message(runtime_ptr, offset)\n"; // Generate field initializers. GenerateFieldInitializers(os, ", "); os << "{}\n\n"; @@ -778,7 +778,7 @@ void MessageGenerator::GenerateCreators(std::ostream &os, bool decl) { os << MessageName(message_) << " " << MessageName(message_) << "::CreateMutable(void *addr, size_t size, ::phaser::Tuning tuning) {\n" " ::toolbelt::PayloadBuffer *pb = new (addr) " - "::toolbelt::PayloadBuffer(size, tuning == " + "::toolbelt::PayloadBuffer(static_cast(size), tuning == " "::phaser::Tuning::kPerformance);\n" " ::toolbelt::PayloadBuffer::AllocateMainMessage(&pb, " << MessageName(message_) @@ -843,7 +843,7 @@ void MessageGenerator::GenerateCreators(std::ostream &os, bool decl) { os << " return CreateDynamicMutable(initial_size, [](size_t size) -> " "absl::StatusOr{ return ::malloc(size);}," " ::free," - " [](void* p, size_t old_size, size_t new_size) -> " + " [](void* p, size_t /*old_size*/, size_t new_size) -> " "absl::StatusOr { return ::realloc(p, new_size);}, tuning);\n"; os << "}\n\n"; From cb3a623b720054dda1f3ee5871f906ba8fae8199 Mon Sep 17 00:00:00 2001 From: Dave Allison Date: Tue, 2 Jun 2026 10:40:55 -0700 Subject: [PATCH 5/7] Version 1.1.1 --- MODULE.bazel | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MODULE.bazel b/MODULE.bazel index 85a3c95..8562487 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -1,6 +1,6 @@ module( name = "phaser", - version = "1.1.0" + version = "1.1.1" ) bazel_dep(name = "bazel_skylib", version = "1.9.0") From 910ccd954e75c41c529194c87e40ac1352d96ba3 Mon Sep 17 00:00:00 2001 From: Dave Allison Date: Tue, 2 Jun 2026 11:00:02 -0700 Subject: [PATCH 6/7] Fix valgrind test --- phaser/BUILD.bazel | 1 + 1 file changed, 1 insertion(+) diff --git a/phaser/BUILD.bazel b/phaser/BUILD.bazel index 289661a..c059c2f 100644 --- a/phaser/BUILD.bazel +++ b/phaser/BUILD.bazel @@ -42,6 +42,7 @@ cc_test( name = "active_message_test", srcs = ["active_message_test.cc"], copts = PHASER_COPTS, + data = ["valgrind.supp"], deps = [ "//phaser/runtime:phaser_runtime", "//phaser/testdata:foo_active_message_phaser", From 2cad7003a17cdda938dcdbbcea9c88fcd66ba312 Mon Sep 17 00:00:00 2001 From: Dave Allison Date: Tue, 2 Jun 2026 11:14:03 -0700 Subject: [PATCH 7/7] Just some formatting --- .clang-format | 1 + phaser/active_message_test.cc | 17 +- phaser/all_types_test.cc | 300 ++++---- phaser/compiler/enum_gen.cc | 13 +- phaser/compiler/enum_gen.h | 21 +- phaser/compiler/gen.cc | 83 +-- phaser/compiler/gen.h | 36 +- phaser/compiler/main.cc | 3 +- phaser/compiler/message_gen.cc | 1115 +++++++++++++++-------------- phaser/compiler/message_gen.h | 140 ++-- phaser/perf_test.cc | 22 +- phaser/phaser_test.cc | 38 +- phaser/runtime/any.h | 180 +++-- phaser/runtime/fields.h | 397 +++++----- phaser/runtime/iterators.h | 92 +-- phaser/runtime/message.cc | 42 +- phaser/runtime/message.h | 170 ++--- phaser/runtime/message_test.cc | 970 ++++++++++++------------- phaser/runtime/phaser_bank.cc | 89 +-- phaser/runtime/phaser_bank.h | 127 ++-- phaser/runtime/runtime.h | 71 +- phaser/runtime/union.h | 352 ++++----- phaser/runtime/vectors.h | 377 +++++----- phaser/runtime/wireformat.h | 153 ++-- phaser/runtime/wireformat_test.cc | 30 +- phaser/stress_test.cc | 32 +- phaser/test_helpers.h | 19 +- 27 files changed, 2533 insertions(+), 2357 deletions(-) create mode 100644 .clang-format diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..f6cb8ad --- /dev/null +++ b/.clang-format @@ -0,0 +1 @@ +BasedOnStyle: Google diff --git a/phaser/active_message_test.cc b/phaser/active_message_test.cc index c56a874..2044c55 100644 --- a/phaser/active_message_test.cc +++ b/phaser/active_message_test.cc @@ -2,17 +2,19 @@ // All Rights Reserved // See LICENSE file for licensing information. -#include "phaser/runtime/runtime.h" -#include "phaser/testdata/Foo.phaser.h" -#include #include + +#include #include +#include "phaser/runtime/runtime.h" +#include "phaser/testdata/Foo.phaser.h" + // Verifies the optional `std::any active_message` field that is emitted when a // phaser_library is built with enable_active_message = True (which passes the // active_message=true plugin command-line option). TEST(ActiveMessage, DefaultsToEmpty) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); foo::bar::phaser::Foo msg = foo::bar::phaser::Foo::CreateMutable(buffer, 4096); EXPECT_FALSE(msg.active_message.has_value()); @@ -20,7 +22,7 @@ TEST(ActiveMessage, DefaultsToEmpty) { } TEST(ActiveMessage, HoldsArbitraryPayload) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); foo::bar::phaser::Foo msg = foo::bar::phaser::Foo::CreateMutable(buffer, 4096); @@ -29,8 +31,7 @@ TEST(ActiveMessage, HoldsArbitraryPayload) { msg.active_message = std::string("attached-payload"); ASSERT_TRUE(msg.active_message.has_value()); - EXPECT_EQ("attached-payload", - std::any_cast(msg.active_message)); + EXPECT_EQ("attached-payload", std::any_cast(msg.active_message)); EXPECT_EQ(42, msg.a()); msg.active_message.reset(); @@ -38,7 +39,7 @@ TEST(ActiveMessage, HoldsArbitraryPayload) { free(buffer); } -int main(int argc, char **argv) { +int main(int argc, char** argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } diff --git a/phaser/all_types_test.cc b/phaser/all_types_test.cc index 60f4c5a..87b69cd 100644 --- a/phaser/all_types_test.cc +++ b/phaser/all_types_test.cc @@ -2,19 +2,21 @@ // All Rights Reserved // See LICENSE file for licensing information. -#include "test_helpers.h" +#include + +#include +#include + +#include "google/protobuf/any.pb.h" #include "phaser/runtime/wireformat.h" #include "phaser/testdata/coverage.pb.h" #include "phaser/testdata/coverage.phaser.h" -#include "google/protobuf/any.pb.h" -#include -#include -#include +#include "test_helpers.h" namespace foo::bar::coverage::phaser { namespace { -void FillAllScalars(AllScalars &msg) { +void FillAllScalars(AllScalars& msg) { msg.set_f_int32(-123456); msg.set_f_int64(-9876543210LL); msg.set_f_sint32(-42); @@ -33,7 +35,7 @@ void FillAllScalars(AllScalars &msg) { msg.set_f_enum(COV_BAR); } -void ExpectAllScalars(const AllScalars &msg) { +void ExpectAllScalars(const AllScalars& msg) { EXPECT_EQ(-123456, msg.f_int32()); EXPECT_EQ(-9876543210LL, msg.f_int64()); EXPECT_EQ(-42, msg.f_sint32()); @@ -63,7 +65,7 @@ using PbOneofStress = ::foo::bar::coverage::OneofStress; using PbCoverageInner = ::foo::bar::coverage::CoverageInner; using PbImportsMessage = ::foo::bar::coverage::ImportsMessage; -void ExpectAllScalarsMatch(const AllScalars &a, const AllScalars &b) { +void ExpectAllScalarsMatch(const AllScalars& a, const AllScalars& b) { EXPECT_EQ(a.f_int32(), b.f_int32()); EXPECT_EQ(a.f_int64(), b.f_int64()); EXPECT_EQ(a.f_sint32(), b.f_sint32()); @@ -82,7 +84,7 @@ void ExpectAllScalarsMatch(const AllScalars &a, const AllScalars &b) { EXPECT_EQ(a.f_enum(), b.f_enum()); } -void ExpectAllScalarsMatchPb(const PbAllScalars &pb, const AllScalars &msg) { +void ExpectAllScalarsMatchPb(const PbAllScalars& pb, const AllScalars& msg) { EXPECT_EQ(pb.f_int32(), msg.f_int32()); EXPECT_EQ(pb.f_int64(), msg.f_int64()); EXPECT_EQ(pb.f_sint32(), msg.f_sint32()); @@ -101,7 +103,7 @@ void ExpectAllScalarsMatchPb(const PbAllScalars &pb, const AllScalars &msg) { EXPECT_EQ(pb.f_enum(), static_cast(msg.f_enum())); } -void FillAllScalars(PbAllScalars &msg) { +void FillAllScalars(PbAllScalars& msg) { msg.set_f_int32(-123456); msg.set_f_int64(-9876543210LL); msg.set_f_sint32(-42); @@ -120,14 +122,14 @@ void FillAllScalars(PbAllScalars &msg) { msg.set_f_enum(::foo::bar::coverage::COV_BAR); } -void FillCoverageInner(PbCoverageInner &msg) { +void FillCoverageInner(PbCoverageInner& msg) { msg.set_str("inner"); msg.set_f(0x0123456789abcdefULL); } // Phaser -> protobuf wire -> phaser, then protobuf -> wire -> phaser. -template +template void ExpectBidirectionalWireRoundTrip(FillPhaser fill_phaser, FillPb fill_pb, ExpectPhaserMatch expect_phaser, ExpectPbMatch expect_pb) { @@ -163,16 +165,16 @@ void ExpectBidirectionalWireRoundTrip(FillPhaser fill_phaser, FillPb fill_pb, expect_pb(pb_orig, phaser_roundtrip); } -void FillMapHolder(MapHolder &msg) { - auto *a = msg.add_values(); +void FillMapHolder(MapHolder& msg) { + auto* a = msg.add_values(); a->set_key("alpha"); a->set_value(-7); - auto *b = msg.add_values(); + auto* b = msg.add_values(); b->set_key("beta"); b->set_value(42); } -void ExpectMapHolderMatch(const MapHolder &a, const MapHolder &b) { +void ExpectMapHolderMatch(const MapHolder& a, const MapHolder& b) { ASSERT_EQ(a.values_size(), b.values_size()); for (size_t i = 0; i < a.values_size(); i++) { bool found = false; @@ -187,7 +189,7 @@ void ExpectMapHolderMatch(const MapHolder &a, const MapHolder &b) { } } -void ExpectMapHolderMatchPb(const PbMapHolder &pb, const MapHolder &msg) { +void ExpectMapHolderMatchPb(const PbMapHolder& pb, const MapHolder& msg) { ASSERT_EQ(static_cast(msg.values_size()), pb.values_size()); for (size_t i = 0; i < msg.values_size(); i++) { const auto it = pb.values().find(msg.values(i).key()); @@ -196,7 +198,7 @@ void ExpectMapHolderMatchPb(const PbMapHolder &pb, const MapHolder &msg) { } } -void FillRepeatedPacked(RepeatedPrimitivesPacked &msg) { +void FillRepeatedPacked(RepeatedPrimitivesPacked& msg) { for (int i = -3; i < 10; i++) { msg.add_vi32(i); msg.add_vi64(i * 1000LL); @@ -204,8 +206,8 @@ void FillRepeatedPacked(RepeatedPrimitivesPacked &msg) { } } -void ExpectRepeatedPackedMatch(const RepeatedPrimitivesPacked &a, - const RepeatedPrimitivesPacked &b) { +void ExpectRepeatedPackedMatch(const RepeatedPrimitivesPacked& a, + const RepeatedPrimitivesPacked& b) { ASSERT_EQ(a.vi32_size(), b.vi32_size()); ASSERT_EQ(a.vi64_size(), b.vi64_size()); ASSERT_EQ(a.vf64_size(), b.vf64_size()); @@ -216,8 +218,8 @@ void ExpectRepeatedPackedMatch(const RepeatedPrimitivesPacked &a, } } -void ExpectRepeatedPackedMatchPb(const PbRepeatedPacked &pb, - const RepeatedPrimitivesPacked &msg) { +void ExpectRepeatedPackedMatchPb(const PbRepeatedPacked& pb, + const RepeatedPrimitivesPacked& msg) { ASSERT_EQ(pb.vi32_size(), static_cast(msg.vi32_size())); ASSERT_EQ(pb.vi64_size(), static_cast(msg.vi64_size())); ASSERT_EQ(pb.vf64_size(), static_cast(msg.vf64_size())); @@ -228,126 +230,125 @@ void ExpectRepeatedPackedMatchPb(const PbRepeatedPacked &pb, } } -[[maybe_unused]] void FillRepeatedUnpacked(RepeatedPrimitivesUnpacked &msg) { +[[maybe_unused]] void FillRepeatedUnpacked(RepeatedPrimitivesUnpacked& msg) { for (int i = -5; i < 5; i++) { msg.add_vi32(i * 11); } } -void ExpectRepeatedUnpackedMatch(const RepeatedPrimitivesUnpacked &a, - const RepeatedPrimitivesUnpacked &b) { +void ExpectRepeatedUnpackedMatch(const RepeatedPrimitivesUnpacked& a, + const RepeatedPrimitivesUnpacked& b) { ASSERT_EQ(a.vi32_size(), b.vi32_size()); for (size_t i = 0; i < a.vi32_size(); i++) { EXPECT_EQ(a.vi32(i), b.vi32(i)); } } -void ExpectRepeatedUnpackedMatchPb(const PbRepeatedUnpacked &pb, - const RepeatedPrimitivesUnpacked &msg) { +void ExpectRepeatedUnpackedMatchPb(const PbRepeatedUnpacked& pb, + const RepeatedPrimitivesUnpacked& msg) { ASSERT_EQ(pb.vi32_size(), static_cast(msg.vi32_size())); for (int i = 0; i < pb.vi32_size(); i++) { EXPECT_EQ(pb.vi32(i), msg.vi32(static_cast(i))); } } -[[maybe_unused]] void -ExpectRepeatedUnpackedMatchPb(const PbRepeatedUnpacked &a, - const PbRepeatedUnpacked &b) { +[[maybe_unused]] void ExpectRepeatedUnpackedMatchPb( + const PbRepeatedUnpacked& a, const PbRepeatedUnpacked& b) { ASSERT_EQ(a.vi32_size(), b.vi32_size()); for (int i = 0; i < a.vi32_size(); i++) { EXPECT_EQ(a.vi32(i), b.vi32(i)); } } -void FillRepeatedStrings(RepeatedStrings &msg) { +void FillRepeatedStrings(RepeatedStrings& msg) { msg.add_vstr(""); msg.add_vstr(::phaser::test::MakePatternString(64, 's')); msg.add_vstr("line\nbreak\t"); } -void ExpectRepeatedStringsMatch(const RepeatedStrings &a, - const RepeatedStrings &b) { +void ExpectRepeatedStringsMatch(const RepeatedStrings& a, + const RepeatedStrings& b) { ASSERT_EQ(a.vstr_size(), b.vstr_size()); for (size_t i = 0; i < a.vstr_size(); i++) { EXPECT_EQ(a.vstr(i), b.vstr(i)); } } -void ExpectRepeatedStringsMatchPb(const PbRepeatedStrings &pb, - const RepeatedStrings &msg) { +void ExpectRepeatedStringsMatchPb(const PbRepeatedStrings& pb, + const RepeatedStrings& msg) { ASSERT_EQ(pb.vstr_size(), static_cast(msg.vstr_size())); for (int i = 0; i < pb.vstr_size(); i++) { EXPECT_EQ(pb.vstr(i), msg.vstr(static_cast(i))); } } -void FillRepeatedBytes(RepeatedBytes &msg) { +void FillRepeatedBytes(RepeatedBytes& msg) { msg.add_vbytes(::phaser::test::MakePatternBytes(32)); msg.add_vbytes(std::string("\0\x01\xff", 3)); } -void ExpectRepeatedBytesMatch(const RepeatedBytes &a, const RepeatedBytes &b) { +void ExpectRepeatedBytesMatch(const RepeatedBytes& a, const RepeatedBytes& b) { ASSERT_EQ(a.vbytes_size(), b.vbytes_size()); for (size_t i = 0; i < a.vbytes_size(); i++) { EXPECT_EQ(a.vbytes(i), b.vbytes(i)); } } -void ExpectRepeatedBytesMatchPb(const PbRepeatedBytes &pb, - const RepeatedBytes &msg) { +void ExpectRepeatedBytesMatchPb(const PbRepeatedBytes& pb, + const RepeatedBytes& msg) { ASSERT_EQ(pb.vbytes_size(), static_cast(msg.vbytes_size())); for (int i = 0; i < pb.vbytes_size(); i++) { EXPECT_EQ(pb.vbytes(i), msg.vbytes(static_cast(i))); } } -void FillRepeatedMessages(RepeatedMessages &msg) { - auto *m0 = msg.add_items(); +void FillRepeatedMessages(RepeatedMessages& msg) { + auto* m0 = msg.add_items(); FillAllScalars(*m0); - auto *m1 = msg.add_items(); + auto* m1 = msg.add_items(); m1->set_f_int32(99); m1->set_f_string("nested"); } -void ExpectRepeatedMessagesMatch(const RepeatedMessages &a, - const RepeatedMessages &b) { +void ExpectRepeatedMessagesMatch(const RepeatedMessages& a, + const RepeatedMessages& b) { ASSERT_EQ(a.items_size(), b.items_size()); for (size_t i = 0; i < a.items_size(); i++) { ExpectAllScalarsMatch(a.items(i), b.items(i)); } } -void ExpectRepeatedMessagesMatchPb(const PbRepeatedMessages &pb, - const RepeatedMessages &msg) { +void ExpectRepeatedMessagesMatchPb(const PbRepeatedMessages& pb, + const RepeatedMessages& msg) { ASSERT_EQ(pb.items_size(), static_cast(msg.items_size())); for (int i = 0; i < pb.items_size(); i++) { ExpectAllScalarsMatchPb(pb.items(i), msg.items(static_cast(i))); } } -void FillCoverageInner(CoverageInner &msg) { +void FillCoverageInner(CoverageInner& msg) { msg.set_str("inner"); msg.set_f(0x0123456789abcdefULL); } -void ExpectCoverageInnerMatch(const CoverageInner &a, const CoverageInner &b) { +void ExpectCoverageInnerMatch(const CoverageInner& a, const CoverageInner& b) { EXPECT_EQ(a.str(), b.str()); EXPECT_EQ(a.f(), b.f()); } -void ExpectCoverageInnerMatchPb(const PbCoverageInner &pb, - const CoverageInner &msg) { +void ExpectCoverageInnerMatchPb(const PbCoverageInner& pb, + const CoverageInner& msg) { EXPECT_EQ(pb.str(), msg.str()); EXPECT_EQ(pb.f(), msg.f()); } -void ExpectCoverageInnerMatchPb(const PbCoverageInner &a, - const PbCoverageInner &b) { +void ExpectCoverageInnerMatchPb(const PbCoverageInner& a, + const PbCoverageInner& b) { EXPECT_EQ(a.str(), b.str()); EXPECT_EQ(a.f(), b.f()); } -void FillImportsMessage(ImportsMessage &msg, bool include_any = true) { +void FillImportsMessage(ImportsMessage& msg, bool include_any = true) { msg.mutable_imported_foo()->set_a(-3); msg.mutable_imported_foo()->set_b("wire-foo"); FillCoverageInner(*msg.mutable_inner()); @@ -362,7 +363,7 @@ void FillImportsMessage(ImportsMessage &msg, bool include_any = true) { } } -void FillImportsMessage(PbImportsMessage &msg, bool include_any = true) { +void FillImportsMessage(PbImportsMessage& msg, bool include_any = true) { msg.mutable_imported_foo()->set_a(-3); msg.mutable_imported_foo()->set_b("wire-foo"); FillCoverageInner(*msg.mutable_inner()); @@ -377,12 +378,12 @@ void FillImportsMessage(PbImportsMessage &msg, bool include_any = true) { } } -void FillMapHolder(PbMapHolder &msg) { +void FillMapHolder(PbMapHolder& msg) { (*msg.mutable_values())["alpha"] = -7; (*msg.mutable_values())["beta"] = 42; } -void FillRepeatedPacked(PbRepeatedPacked &msg) { +void FillRepeatedPacked(PbRepeatedPacked& msg) { for (int i = -3; i < 10; i++) { msg.add_vi32(i); msg.add_vi64(i * 1000LL); @@ -390,31 +391,31 @@ void FillRepeatedPacked(PbRepeatedPacked &msg) { } } -void FillRepeatedUnpacked(PbRepeatedUnpacked &msg) { +void FillRepeatedUnpacked(PbRepeatedUnpacked& msg) { for (int i = -5; i < 5; i++) { msg.add_vi32(i * 11); } } -void FillRepeatedStrings(PbRepeatedStrings &msg) { +void FillRepeatedStrings(PbRepeatedStrings& msg) { msg.add_vstr(""); msg.add_vstr(::phaser::test::MakePatternString(64, 's')); msg.add_vstr("line\nbreak\t"); } -void FillRepeatedBytes(PbRepeatedBytes &msg) { +void FillRepeatedBytes(PbRepeatedBytes& msg) { msg.add_vbytes(::phaser::test::MakePatternBytes(32)); msg.add_vbytes(std::string("\0\x01\xff", 3)); } -void FillRepeatedMessages(PbRepeatedMessages &msg) { +void FillRepeatedMessages(PbRepeatedMessages& msg) { FillAllScalars(*msg.add_items()); - auto *m1 = msg.add_items(); + auto* m1 = msg.add_items(); m1->set_f_int32(99); m1->set_f_string("nested"); } -void ExpectImportsMessageMatch(const ImportsMessage &a, const ImportsMessage &b, +void ExpectImportsMessageMatch(const ImportsMessage& a, const ImportsMessage& b, bool check_any = true) { EXPECT_EQ(a.imported_foo().a(), b.imported_foo().a()); EXPECT_EQ(a.imported_foo().b(), b.imported_foo().b()); @@ -432,8 +433,8 @@ void ExpectImportsMessageMatch(const ImportsMessage &a, const ImportsMessage &b, ExpectCoverageInnerMatch(inner_a, inner_b); } -void ExpectImportsMessageMatchPb(const PbImportsMessage &pb, - const ImportsMessage &msg, +void ExpectImportsMessageMatchPb(const PbImportsMessage& pb, + const ImportsMessage& msg, bool check_any = true) { EXPECT_EQ(pb.imported_foo().a(), msg.imported_foo().a()); EXPECT_EQ(pb.imported_foo().b(), msg.imported_foo().b()); @@ -451,9 +452,8 @@ void ExpectImportsMessageMatchPb(const PbImportsMessage &pb, ExpectCoverageInnerMatchPb(inner_pb, inner_msg); } -[[maybe_unused]] void -ExpectImportsMessageMatchPb(const PbImportsMessage &a, - const PbImportsMessage &b) { +[[maybe_unused]] void ExpectImportsMessageMatchPb(const PbImportsMessage& a, + const PbImportsMessage& b) { EXPECT_EQ(a.imported_foo().a(), b.imported_foo().a()); EXPECT_EQ(a.imported_foo().b(), b.imported_foo().b()); EXPECT_EQ(a.inner().str(), b.inner().str()); @@ -486,7 +486,7 @@ void ExpectOneofWireRoundTrip(FillOneof fill, ExpectPhaserOneof expect_phaser, expect_phaser(phaser2); } -} // namespace +} // namespace TEST(AllTypesTest, SetAndGetEveryScalar) { AllScalars msg; @@ -541,12 +541,11 @@ TEST(AllTypesTest, ProtobufRoundTrip) { // the int32 range. Exercise large positive and negative 64-bit values in both // serialization directions to confirm wire compatibility with protobuf. TEST(AllTypesTest, LargeSintWireCompat) { - const int32_t kSint32Values[] = {INT32_MIN, -1000000, -1, 0, 1, 1000000, - INT32_MAX}; + const int32_t kSint32Values[] = {INT32_MIN, -1000000, -1, 0, + 1, 1000000, INT32_MAX}; const int64_t kSint64Values[] = { - INT64_MIN, int64_t(INT32_MIN) - 1, -(int64_t(1) << 40), - -1, 0, 1, - int64_t(1) << 40, int64_t(INT32_MAX) + 1, INT64_MAX}; + INT64_MIN, int64_t(INT32_MIN) - 1, -(int64_t(1) << 40), -1, 0, + 1, int64_t(1) << 40, int64_t(INT32_MAX) + 1, INT64_MAX}; for (int32_t s32 : kSint32Values) { for (int64_t s64 : kSint64Values) { @@ -573,10 +572,10 @@ TEST(AllTypesTest, LargeSintWireCompat) { TEST(AllTypesTest, MapInsertOverwriteAndClear) { MapHolder msg; - auto *e1 = msg.add_values(); + auto* e1 = msg.add_values(); e1->set_key("alpha"); e1->set_value(1); - auto *e2 = msg.add_values(); + auto* e2 = msg.add_values(); e2->set_key("beta"); e2->set_value(2); @@ -592,7 +591,7 @@ TEST(AllTypesTest, MapInsertOverwriteAndClear) { msg.clear_values(); EXPECT_EQ(0u, msg.values_size()); - auto *e3 = msg.add_values(); + auto* e3 = msg.add_values(); e3->set_key("gamma"); e3->set_value(3); EXPECT_EQ(1u, msg.values_size()); @@ -632,11 +631,13 @@ TEST(AllTypesTest, RepeatedStringChurn) { for (int round = 0; round < 10; round++) { msg.clear_vstr(); for (int i = 0; i < 100; i++) { - msg.add_vstr(::phaser::test::MakePatternString(32, static_cast('a' + (i % 26)))); + msg.add_vstr(::phaser::test::MakePatternString( + 32, static_cast('a' + (i % 26)))); } ASSERT_EQ(100u, msg.vstr_size()); for (int i = 0; i < 100; i++) { - EXPECT_EQ(::phaser::test::MakePatternString(32, static_cast('a' + (i % 26))), + EXPECT_EQ(::phaser::test::MakePatternString( + 32, static_cast('a' + (i % 26))), msg.vstr(static_cast(i))); } } @@ -663,9 +664,9 @@ TEST(AllTypesTest, RepeatedBytesWithNulls) { TEST(AllTypesTest, RepeatedMessagesSparseMutable) { RepeatedMessages msg; - auto *m5 = msg.mutable_items(5); + auto* m5 = msg.mutable_items(5); m5->set_f_string("slot-five"); - auto *m0 = msg.mutable_items(0); + auto* m0 = msg.mutable_items(0); m0->set_f_int32(7); EXPECT_EQ(7, msg.items(0).f_int32()); EXPECT_EQ("slot-five", msg.items(5).f_string()); @@ -693,7 +694,7 @@ TEST(AllTypesTest, OneofBytesArm) { TEST(AllTypesTest, OneofNestedMessageArm) { OneofStress msg; - auto *inner = msg.mutable_u_msg(); + auto* inner = msg.mutable_u_msg(); inner->set_f_string("nested"); EXPECT_EQ("nested", msg.u_msg().f_string()); } @@ -744,41 +745,43 @@ TEST(AllTypesTest, AnyPackInnerAndImported) { TEST(AllTypesTest, WireFormatScalarsBidirectional) { ExpectBidirectionalWireRoundTrip( - [](AllScalars &m) { FillAllScalars(m); }, - [](PbAllScalars &m) { FillAllScalars(m); }, - [](const AllScalars &a, const AllScalars &b) { + [](AllScalars& m) { FillAllScalars(m); }, + [](PbAllScalars& m) { FillAllScalars(m); }, + [](const AllScalars& a, const AllScalars& b) { ExpectAllScalarsMatch(a, b); }, - [](const PbAllScalars &pb, const AllScalars &m) { + [](const PbAllScalars& pb, const AllScalars& m) { ExpectAllScalarsMatchPb(pb, m); }); } TEST(AllTypesTest, WireFormatMapBidirectional) { ExpectBidirectionalWireRoundTrip( - [](MapHolder &m) { FillMapHolder(m); }, - [](PbMapHolder &m) { FillMapHolder(m); }, - [](const MapHolder &a, const MapHolder &b) { ExpectMapHolderMatch(a, b); }, - [](const PbMapHolder &pb, const MapHolder &m) { + [](MapHolder& m) { FillMapHolder(m); }, + [](PbMapHolder& m) { FillMapHolder(m); }, + [](const MapHolder& a, const MapHolder& b) { + ExpectMapHolderMatch(a, b); + }, + [](const PbMapHolder& pb, const MapHolder& m) { ExpectMapHolderMatchPb(pb, m); }); } TEST(AllTypesTest, WireFormatRepeatedPackedBidirectional) { ExpectBidirectionalWireRoundTrip( - [](RepeatedPrimitivesPacked &m) { FillRepeatedPacked(m); }, - [](PbRepeatedPacked &m) { FillRepeatedPacked(m); }, - [](const RepeatedPrimitivesPacked &a, const RepeatedPrimitivesPacked &b) { + [](RepeatedPrimitivesPacked& m) { FillRepeatedPacked(m); }, + [](PbRepeatedPacked& m) { FillRepeatedPacked(m); }, + [](const RepeatedPrimitivesPacked& a, const RepeatedPrimitivesPacked& b) { ExpectRepeatedPackedMatch(a, b); }, - [](const PbRepeatedPacked &pb, const RepeatedPrimitivesPacked &m) { + [](const PbRepeatedPacked& pb, const RepeatedPrimitivesPacked& m) { ExpectRepeatedPackedMatchPb(pb, m); }); } -// Proto has [packed=false], but phaser currently emits a length-delimited packed -// payload for scalar repeated fields. Protobuf accepts that wire; verify both -// directions through protobuf bytes. +// Proto has [packed=false], but phaser currently emits a length-delimited +// packed payload for scalar repeated fields. Protobuf accepts that wire; verify +// both directions through protobuf bytes. TEST(AllTypesTest, WireFormatRepeatedUnpackedBidirectional) { PbRepeatedUnpacked pb; FillRepeatedUnpacked(pb); @@ -804,48 +807,48 @@ TEST(AllTypesTest, WireFormatRepeatedUnpackedBidirectional) { TEST(AllTypesTest, WireFormatRepeatedStringsBidirectional) { ExpectBidirectionalWireRoundTrip( - [](RepeatedStrings &m) { FillRepeatedStrings(m); }, - [](PbRepeatedStrings &m) { FillRepeatedStrings(m); }, - [](const RepeatedStrings &a, const RepeatedStrings &b) { + [](RepeatedStrings& m) { FillRepeatedStrings(m); }, + [](PbRepeatedStrings& m) { FillRepeatedStrings(m); }, + [](const RepeatedStrings& a, const RepeatedStrings& b) { ExpectRepeatedStringsMatch(a, b); }, - [](const PbRepeatedStrings &pb, const RepeatedStrings &m) { + [](const PbRepeatedStrings& pb, const RepeatedStrings& m) { ExpectRepeatedStringsMatchPb(pb, m); }); } TEST(AllTypesTest, WireFormatRepeatedBytesBidirectional) { ExpectBidirectionalWireRoundTrip( - [](RepeatedBytes &m) { FillRepeatedBytes(m); }, - [](PbRepeatedBytes &m) { FillRepeatedBytes(m); }, - [](const RepeatedBytes &a, const RepeatedBytes &b) { + [](RepeatedBytes& m) { FillRepeatedBytes(m); }, + [](PbRepeatedBytes& m) { FillRepeatedBytes(m); }, + [](const RepeatedBytes& a, const RepeatedBytes& b) { ExpectRepeatedBytesMatch(a, b); }, - [](const PbRepeatedBytes &pb, const RepeatedBytes &m) { + [](const PbRepeatedBytes& pb, const RepeatedBytes& m) { ExpectRepeatedBytesMatchPb(pb, m); }); } TEST(AllTypesTest, WireFormatRepeatedMessagesBidirectional) { ExpectBidirectionalWireRoundTrip( - [](RepeatedMessages &m) { FillRepeatedMessages(m); }, - [](PbRepeatedMessages &m) { FillRepeatedMessages(m); }, - [](const RepeatedMessages &a, const RepeatedMessages &b) { + [](RepeatedMessages& m) { FillRepeatedMessages(m); }, + [](PbRepeatedMessages& m) { FillRepeatedMessages(m); }, + [](const RepeatedMessages& a, const RepeatedMessages& b) { ExpectRepeatedMessagesMatch(a, b); }, - [](const PbRepeatedMessages &pb, const RepeatedMessages &m) { + [](const PbRepeatedMessages& pb, const RepeatedMessages& m) { ExpectRepeatedMessagesMatchPb(pb, m); }); } TEST(AllTypesTest, WireFormatImportsBidirectional) { ExpectBidirectionalWireRoundTrip( - [](ImportsMessage &m) { FillImportsMessage(m, true); }, - [](PbImportsMessage &m) { FillImportsMessage(m, true); }, - [](const ImportsMessage &a, const ImportsMessage &b) { + [](ImportsMessage& m) { FillImportsMessage(m, true); }, + [](PbImportsMessage& m) { FillImportsMessage(m, true); }, + [](const ImportsMessage& a, const ImportsMessage& b) { ExpectImportsMessageMatch(a, b, true); }, - [](const PbImportsMessage &pb, const ImportsMessage &m) { + [](const PbImportsMessage& pb, const ImportsMessage& m) { ExpectImportsMessageMatchPb(pb, m, true); }); } @@ -899,8 +902,8 @@ TEST(AllTypesTest, WireFormatAnyFieldValueBeforeTypeUrl) { ASSERT_TRUE( buf.SerializeLengthDelimited(2, inner_wire.data(), inner_wire.size()) .ok()); - ASSERT_TRUE(buf.SerializeLengthDelimited(1, type_url.data(), type_url.size()) - .ok()); + ASSERT_TRUE( + buf.SerializeLengthDelimited(1, type_url.data(), type_url.size()).ok()); any_wire = buf.AsString(); } @@ -922,61 +925,56 @@ TEST(AllTypesTest, WireFormatAnyFieldValueBeforeTypeUrl) { } TEST(AllTypesTest, WireFormatOneofIntBidirectional) { - ExpectOneofWireRoundTrip( - [](OneofStress &m) { m.set_u_int(-99); }, - [](const OneofStress &m) { - EXPECT_TRUE(m.has_u_int()); - EXPECT_EQ(-99, m.u_int()); - }, - [](const PbOneofStress &pb) { - EXPECT_TRUE(pb.has_u_int()); - EXPECT_EQ(-99, pb.u_int()); - }); + ExpectOneofWireRoundTrip([](OneofStress& m) { m.set_u_int(-99); }, + [](const OneofStress& m) { + EXPECT_TRUE(m.has_u_int()); + EXPECT_EQ(-99, m.u_int()); + }, + [](const PbOneofStress& pb) { + EXPECT_TRUE(pb.has_u_int()); + EXPECT_EQ(-99, pb.u_int()); + }); } TEST(AllTypesTest, WireFormatOneofStringBidirectional) { - ExpectOneofWireRoundTrip( - [](OneofStress &m) { m.set_u_string("wire-oneof"); }, - [](const OneofStress &m) { - EXPECT_TRUE(m.has_u_string()); - EXPECT_EQ("wire-oneof", m.u_string()); - }, - [](const PbOneofStress &pb) { - EXPECT_TRUE(pb.has_u_string()); - EXPECT_EQ("wire-oneof", pb.u_string()); - }); + ExpectOneofWireRoundTrip([](OneofStress& m) { m.set_u_string("wire-oneof"); }, + [](const OneofStress& m) { + EXPECT_TRUE(m.has_u_string()); + EXPECT_EQ("wire-oneof", m.u_string()); + }, + [](const PbOneofStress& pb) { + EXPECT_TRUE(pb.has_u_string()); + EXPECT_EQ("wire-oneof", pb.u_string()); + }); } TEST(AllTypesTest, WireFormatOneofBytesBidirectional) { const std::string bytes = ::phaser::test::MakePatternBytes(48); - ExpectOneofWireRoundTrip( - [&](OneofStress &m) { m.set_u_bytes(bytes); }, - [&](const OneofStress &m) { - EXPECT_TRUE(m.has_u_bytes()); - EXPECT_EQ(bytes, m.u_bytes()); - }, - [&](const PbOneofStress &pb) { - EXPECT_TRUE(pb.has_u_bytes()); - EXPECT_EQ(bytes, pb.u_bytes()); - }); + ExpectOneofWireRoundTrip([&](OneofStress& m) { m.set_u_bytes(bytes); }, + [&](const OneofStress& m) { + EXPECT_TRUE(m.has_u_bytes()); + EXPECT_EQ(bytes, m.u_bytes()); + }, + [&](const PbOneofStress& pb) { + EXPECT_TRUE(pb.has_u_bytes()); + EXPECT_EQ(bytes, pb.u_bytes()); + }); } TEST(AllTypesTest, WireFormatOneofMessageBidirectional) { ExpectOneofWireRoundTrip( - [](OneofStress &m) { - FillAllScalars(*m.mutable_u_msg()); - }, - [](const OneofStress &m) { + [](OneofStress& m) { FillAllScalars(*m.mutable_u_msg()); }, + [](const OneofStress& m) { EXPECT_TRUE(m.has_u_msg()); AllScalars expected; FillAllScalars(expected); ExpectAllScalarsMatch(m.u_msg(), expected); }, - [](const PbOneofStress &pb) { + [](const PbOneofStress& pb) { EXPECT_TRUE(pb.has_u_msg()); EXPECT_EQ(-123456, pb.u_msg().f_int32()); EXPECT_EQ("scalar-string", pb.u_msg().f_string()); }); } -} // namespace foo::bar::coverage::phaser +} // namespace foo::bar::coverage::phaser diff --git a/phaser/compiler/enum_gen.cc b/phaser/compiler/enum_gen.cc index 368237f..e229ce9 100644 --- a/phaser/compiler/enum_gen.cc +++ b/phaser/compiler/enum_gen.cc @@ -8,14 +8,14 @@ namespace phaser { -void EnumGenerator::GenerateHeader(std::ostream &os) { +void EnumGenerator::GenerateHeader(std::ostream& os) { std::string name(enum_->name()); if (enum_->containing_type() != nullptr) { name = std::string(enum_->containing_type()->name()) + "_" + name; } os << "enum " << name << " : int {\n"; for (int i = 0; i < enum_->value_count(); i++) { - const google::protobuf::EnumValueDescriptor *value = enum_->value(i); + const google::protobuf::EnumValueDescriptor* value = enum_->value(i); std::string const_name(value->name()); if (enum_->containing_type() != nullptr) { const_name = name + "_" + const_name; @@ -29,7 +29,7 @@ void EnumGenerator::GenerateHeader(std::ostream &os) { os << " std::string operator()(" << name << " e) {\n"; os << " switch (e) {\n"; for (int i = 0; i < enum_->value_count(); i++) { - const google::protobuf::EnumValueDescriptor *value = enum_->value(i); + const google::protobuf::EnumValueDescriptor* value = enum_->value(i); std::string const_name(value->name()); if (enum_->containing_type() != nullptr) { const_name = name + "_" + const_name; @@ -46,7 +46,7 @@ void EnumGenerator::GenerateHeader(std::ostream &os) { os << "struct " << name << "Parser {\n"; os << " " << name << " operator()(const std::string &s) {\n"; for (int i = 0; i < enum_->value_count(); i++) { - const google::protobuf::EnumValueDescriptor *value = enum_->value(i); + const google::protobuf::EnumValueDescriptor* value = enum_->value(i); std::string const_name(value->name()); if (enum_->containing_type() != nullptr) { const_name = name + "_" + const_name; @@ -65,10 +65,11 @@ void EnumGenerator::GenerateHeader(std::ostream &os) { os << " return s(static_cast<" << name << ">(e));\n"; os << "}\n\n"; - os << "inline void " << name << "_Parse(const std::string &s, " << name << "* value) {\n"; + os << "inline void " << name << "_Parse(const std::string &s, " << name + << "* value) {\n"; os << " " << name << "Parser p;\n"; os << " *value = p(s);\n"; os << "}\n\n"; } -} // namespace phaser +} // namespace phaser diff --git a/phaser/compiler/enum_gen.h b/phaser/compiler/enum_gen.h index 608002c..0681544 100644 --- a/phaser/compiler/enum_gen.h +++ b/phaser/compiler/enum_gen.h @@ -3,27 +3,28 @@ // See LICENSE file for licensing information. #pragma once -#include "absl/container/flat_hash_map.h" -#include "absl/container/flat_hash_set.h" -#include "absl/status/status.h" -#include "google/protobuf/descriptor.h" #include #include #include #include +#include "absl/container/flat_hash_map.h" +#include "absl/container/flat_hash_set.h" +#include "absl/status/status.h" +#include "google/protobuf/descriptor.h" + namespace phaser { class EnumGenerator { -public: - EnumGenerator(const google::protobuf::EnumDescriptor *e) : enum_(e) {} + public: + EnumGenerator(const google::protobuf::EnumDescriptor* e) : enum_(e) {} - void GenerateHeader(std::ostream &os); + void GenerateHeader(std::ostream& os); -private: + private: friend class MessageGenerator; - const google::protobuf::EnumDescriptor *enum_; + const google::protobuf::EnumDescriptor* enum_; std::vector> nested_enum_gens_; }; -} // namespace phaser +} // namespace phaser diff --git a/phaser/compiler/gen.cc b/phaser/compiler/gen.cc index 92f080b..4a1f38b 100644 --- a/phaser/compiler/gen.cc +++ b/phaser/compiler/gen.cc @@ -3,18 +3,20 @@ // See LICENSE file for licensing information. #include "phaser/compiler/gen.h" -#include "absl/strings/str_format.h" -#include "absl/strings/str_split.h" + #include #include +#include "absl/strings/str_format.h" +#include "absl/strings/str_split.h" + namespace phaser { -static void -WriteToZeroCopyStream(const std::string &data, - google::protobuf::io::ZeroCopyOutputStream *stream) { +static void WriteToZeroCopyStream( + const std::string& data, + google::protobuf::io::ZeroCopyOutputStream* stream) { // Write to the stream that protobuf wants - void *data_buffer; + void* data_buffer; int size; size_t offset = 0; while (offset < data.size()) { @@ -29,7 +31,9 @@ WriteToZeroCopyStream(const std::string &data, } } -static std::string GeneratedFilename(const std::filesystem::path& package_name, const std::filesystem::path& target_name, std::string filename) { +static std::string GeneratedFilename(const std::filesystem::path& package_name, + const std::filesystem::path& target_name, + std::string filename) { size_t virtual_imports = filename.find("_virtual_imports/"); if (virtual_imports != std::string::npos) { // This is something like: @@ -38,14 +42,13 @@ static std::string GeneratedFilename(const std::filesystem::path& package_name, // Remove the first directory. filename = filename.substr(filename.find('/') + 1); } - return package_name / target_name / filename; + return package_name / target_name / filename; } bool CodeGenerator::Generate( - const google::protobuf::FileDescriptor *file, const std::string ¶meter, - google::protobuf::compiler::GeneratorContext *generator_context, - std::string *error) const { - + const google::protobuf::FileDescriptor* file, const std::string& parameter, + google::protobuf::compiler::GeneratorContext* generator_context, + std::string* error) const { // The options for the compiler are passed in the --phaser_out parameter // as a comma separated list of key=value pairs, followed by a colon // and then the output directory. @@ -61,10 +64,10 @@ bool CodeGenerator::Generate( target_name_ = option.second; } else if (option.first == "active_message") { // Bare flag or explicit truthy value enables the field. - generate_active_message_ = - option.second.empty() || option.second == "true" || - option.second == "1"; - } + generate_active_message_ = option.second.empty() || + option.second == "true" || + option.second == "1"; + } } Generator gen(file, added_namespace_, package_name_, target_name_, @@ -85,7 +88,7 @@ bool CodeGenerator::Generate( generator_context->Open(hp.string())); std::filesystem::create_directories(hp.parent_path()); - + if (header_output == nullptr) { std::cerr << "Failed to open " << hp << " for writing\n"; *error = absl::StrFormat("Failed to open %s for writing", hp.string()); @@ -112,10 +115,9 @@ bool CodeGenerator::Generate( return true; } - -void Generator::OpenNamespace(std::ostream &os) { +void Generator::OpenNamespace(std::ostream& os) { std::vector parts = absl::StrSplit(file_->package(), '.'); - for (const auto &part : parts) { + for (const auto& part : parts) { os << "namespace " << part << " {\n"; } if (!added_namespace_.empty()) { @@ -123,26 +125,28 @@ void Generator::OpenNamespace(std::ostream &os) { } } -void Generator::CloseNamespace(std::ostream &os) { +void Generator::CloseNamespace(std::ostream& os) { if (!added_namespace_.empty()) { os << "} // namespace " << added_namespace_ << "\n"; } std::vector parts = absl::StrSplit(file_->package(), '.'); - for (const auto &part : parts) { + for (const auto& part : parts) { os << "} // namespace " << part << "\n"; } } -Generator::Generator(const google::protobuf::FileDescriptor *file, - const std::string &ns, const std::string& pn, +Generator::Generator(const google::protobuf::FileDescriptor* file, + const std::string& ns, const std::string& pn, const std::string& tn, bool generate_active_message) - : file_(file), added_namespace_(ns), package_name_(pn), target_name_(tn), + : file_(file), + added_namespace_(ns), + package_name_(pn), + target_name_(tn), generate_active_message_(generate_active_message) { for (int i = 0; i < file->message_type_count(); i++) { - message_gens_.push_back( - std::make_unique( - file->message_type(i), added_namespace_, - std::string(file->package()), generate_active_message_)); + message_gens_.push_back(std::make_unique( + file->message_type(i), added_namespace_, std::string(file->package()), + generate_active_message_)); } // Enums for (int i = 0; i < file->enum_type_count(); i++) { @@ -150,7 +154,7 @@ Generator::Generator(const google::protobuf::FileDescriptor *file, } } -void Generator::GenerateHeaders(std::ostream &os) { +void Generator::GenerateHeaders(std::ostream& os) { os << "#pragma once\n"; os << "#include \"phaser/runtime/runtime.h\"\n"; if (generate_active_message_) { @@ -158,8 +162,7 @@ void Generator::GenerateHeaders(std::ostream &os) { } for (int i = 0; i < file_->dependency_count(); i++) { std::string base = GeneratedFilename( - package_name_, target_name_, - std::string(file_->dependency(i)->name())); + package_name_, target_name_, std::string(file_->dependency(i)->name())); std::filesystem::path p(base); p.replace_extension(".phaser.h"); os << "#include \"" << p.string() << "\"\n"; @@ -168,33 +171,33 @@ void Generator::GenerateHeaders(std::ostream &os) { OpenNamespace(os); // Enums - for (auto &enum_gen : enum_gens_) { + for (auto& enum_gen : enum_gens_) { enum_gen->GenerateHeader(os); } - for (auto &msg_gen : message_gens_) { + for (auto& msg_gen : message_gens_) { msg_gen->GenerateEnums(os); } - for (auto &msg_gen : message_gens_) { + for (auto& msg_gen : message_gens_) { msg_gen->GenerateHeader(os); } CloseNamespace(os); } -void Generator::GenerateSources(std::ostream &os) { - std::filesystem::path p(GeneratedFilename( - package_name_, target_name_, std::string(file_->name()))); +void Generator::GenerateSources(std::ostream& os) { + std::filesystem::path p(GeneratedFilename(package_name_, target_name_, + std::string(file_->name()))); p.replace_extension(".phaser.h"); os << "#include \"" << p.string() << "\"\n"; OpenNamespace(os); - for (auto &msg_gen : message_gens_) { + for (auto& msg_gen : message_gens_) { msg_gen->GenerateSource(os); } CloseNamespace(os); } -} // namespace phaser +} // namespace phaser diff --git a/phaser/compiler/gen.h b/phaser/compiler/gen.h index ccc53f5..b885940 100644 --- a/phaser/compiler/gen.h +++ b/phaser/compiler/gen.h @@ -4,28 +4,27 @@ #pragma once +#include +#include +#include + +#include "absl/status/status.h" #include "google/protobuf/compiler/code_generator.h" #include "google/protobuf/compiler/plugin.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/io/zero_copy_stream.h" -#include "absl/status/status.h" - -#include "phaser/compiler/message_gen.h" #include "phaser/compiler/enum_gen.h" - -#include -#include -#include +#include "phaser/compiler/message_gen.h" namespace phaser { class CodeGenerator : public google::protobuf::compiler::CodeGenerator { -public: + public: CodeGenerator() = default; - bool Generate(const google::protobuf::FileDescriptor *file, - const std::string ¶meter, - google::protobuf::compiler::GeneratorContext *generator_context, - std::string *error) const override; + bool Generate(const google::protobuf::FileDescriptor* file, + const std::string& parameter, + google::protobuf::compiler::GeneratorContext* generator_context, + std::string* error) const override; uint64_t GetSupportedFeatures() const override { return FEATURE_PROTO3_OPTIONAL; @@ -39,19 +38,20 @@ class CodeGenerator : public google::protobuf::compiler::CodeGenerator { mutable bool generate_active_message_ = false; }; - class Generator { -public: - Generator(const google::protobuf::FileDescriptor *file, const std::string& ns, const std::string& pn, const std::string& tn, bool generate_active_message = false); + public: + Generator(const google::protobuf::FileDescriptor* file, const std::string& ns, + const std::string& pn, const std::string& tn, + bool generate_active_message = false); void GenerateHeaders(std::ostream& os); void GenerateSources(std::ostream& os); -private: + private: void OpenNamespace(std::ostream& os); void CloseNamespace(std::ostream& os); - const google::protobuf::FileDescriptor *file_; + const google::protobuf::FileDescriptor* file_; std::vector> message_gens_; std::vector> enum_gens_; const std::string& added_namespace_; @@ -60,4 +60,4 @@ class Generator { bool generate_active_message_; }; -} // namespace phaser +} // namespace phaser diff --git a/phaser/compiler/main.cc b/phaser/compiler/main.cc index 4f97137..e18bdf4 100644 --- a/phaser/compiler/main.cc +++ b/phaser/compiler/main.cc @@ -6,8 +6,7 @@ #include "google/protobuf/compiler/plugin.h" #include "phaser/compiler/gen.h" - -int main(int argc, char *argv[]) { +int main(int argc, char* argv[]) { phaser::CodeGenerator generator; return google::protobuf::compiler::PluginMain(argc, argv, &generator); } diff --git a/phaser/compiler/message_gen.cc b/phaser/compiler/message_gen.cc index 5bcff56..f0a72f0 100644 --- a/phaser/compiler/message_gen.cc +++ b/phaser/compiler/message_gen.cc @@ -3,16 +3,19 @@ // See LICENSE file for licensing information. #include "phaser/compiler/message_gen.h" -#include "absl/strings/str_format.h" -#include "absl/strings/str_replace.h" + +#include + #include #include #include -#include + +#include "absl/strings/str_format.h" +#include "absl/strings/str_replace.h" namespace phaser { -static bool IsCppReservedWord(const std::string &s) { +static bool IsCppReservedWord(const std::string& s) { static absl::flat_hash_set reserved_words = { "alignas", "alignof", @@ -115,8 +118,8 @@ static bool IsCppReservedWord(const std::string &s) { return reserved_words.contains(s); } -std::string -MessageGenerator::EnumName(const google::protobuf::EnumDescriptor *desc) { +std::string MessageGenerator::EnumName( + const google::protobuf::EnumDescriptor* desc) { std::string name(desc->name()); if (desc->containing_type() != nullptr) { name = std::string(desc->containing_type()->name()) + "_" + name; @@ -124,9 +127,8 @@ MessageGenerator::EnumName(const google::protobuf::EnumDescriptor *desc) { return name; } -std::string -MessageGenerator::MessageName(const google::protobuf::Descriptor *desc, - bool is_ref) { +std::string MessageGenerator::MessageName( + const google::protobuf::Descriptor* desc, bool is_ref) { if (is_ref && IsAny(desc)) { return "::phaser::AnyMessage"; } @@ -151,286 +153,286 @@ MessageGenerator::MessageName(const google::protobuf::Descriptor *desc, } std::string MessageGenerator::FieldCFieldType( - const google::protobuf::FieldDescriptor *field) { + const google::protobuf::FieldDescriptor* field) { switch (field->type()) { - case google::protobuf::FieldDescriptor::TYPE_INT32: - return "Int32Field"; - case google::protobuf::FieldDescriptor::TYPE_SINT32: - return "Int32Field"; - case google::protobuf::FieldDescriptor::TYPE_SFIXED32: - return "Int32Field"; - case google::protobuf::FieldDescriptor::TYPE_INT64: - return "Int64Field"; - case google::protobuf::FieldDescriptor::TYPE_SINT64: - return "Int64Field"; - case google::protobuf::FieldDescriptor::TYPE_SFIXED64: - return "Int64Field"; - case google::protobuf::FieldDescriptor::TYPE_UINT32: - return "Uint32Field"; - case google::protobuf::FieldDescriptor::TYPE_FIXED32: - return "Uint32Field"; - case google::protobuf::FieldDescriptor::TYPE_UINT64: - return "Uint64Field"; - case google::protobuf::FieldDescriptor::TYPE_FIXED64: - return "Uint64Field"; - case google::protobuf::FieldDescriptor::TYPE_DOUBLE: - return "DoubleField"; - case google::protobuf::FieldDescriptor::TYPE_FLOAT: - return "FloatField"; - case google::protobuf::FieldDescriptor::TYPE_BOOL: - return "BoolField"; - case google::protobuf::FieldDescriptor::TYPE_ENUM: - return "EnumField<" + EnumName(field->enum_type()) + ", " + - EnumName(field->enum_type()) + "Stringizer, " + - EnumName(field->enum_type()) + "Parser>"; - case google::protobuf::FieldDescriptor::TYPE_STRING: - case google::protobuf::FieldDescriptor::TYPE_BYTES: - return "StringField"; - case google::protobuf::FieldDescriptor::TYPE_MESSAGE: - if (IsAny(field)) { - return "AnyField"; - } - return "IndirectMessageField<" + MessageName(field->message_type(), true) + - ">"; + case google::protobuf::FieldDescriptor::TYPE_INT32: + return "Int32Field"; + case google::protobuf::FieldDescriptor::TYPE_SINT32: + return "Int32Field"; + case google::protobuf::FieldDescriptor::TYPE_SFIXED32: + return "Int32Field"; + case google::protobuf::FieldDescriptor::TYPE_INT64: + return "Int64Field"; + case google::protobuf::FieldDescriptor::TYPE_SINT64: + return "Int64Field"; + case google::protobuf::FieldDescriptor::TYPE_SFIXED64: + return "Int64Field"; + case google::protobuf::FieldDescriptor::TYPE_UINT32: + return "Uint32Field"; + case google::protobuf::FieldDescriptor::TYPE_FIXED32: + return "Uint32Field"; + case google::protobuf::FieldDescriptor::TYPE_UINT64: + return "Uint64Field"; + case google::protobuf::FieldDescriptor::TYPE_FIXED64: + return "Uint64Field"; + case google::protobuf::FieldDescriptor::TYPE_DOUBLE: + return "DoubleField"; + case google::protobuf::FieldDescriptor::TYPE_FLOAT: + return "FloatField"; + case google::protobuf::FieldDescriptor::TYPE_BOOL: + return "BoolField"; + case google::protobuf::FieldDescriptor::TYPE_ENUM: + return "EnumField<" + EnumName(field->enum_type()) + ", " + + EnumName(field->enum_type()) + "Stringizer, " + + EnumName(field->enum_type()) + "Parser>"; + case google::protobuf::FieldDescriptor::TYPE_STRING: + case google::protobuf::FieldDescriptor::TYPE_BYTES: + return "StringField"; + case google::protobuf::FieldDescriptor::TYPE_MESSAGE: + if (IsAny(field)) { + return "AnyField"; + } + return "IndirectMessageField<" + + MessageName(field->message_type(), true) + ">"; - case google::protobuf::FieldDescriptor::TYPE_GROUP: - std::cerr << "Groups are not supported\n"; - exit(1); + case google::protobuf::FieldDescriptor::TYPE_GROUP: + std::cerr << "Groups are not supported\n"; + exit(1); } // Unreachable: every protobuf field type is handled above and GROUP exits. abort(); } std::string MessageGenerator::FieldInfoType( - const google::protobuf::FieldDescriptor *field) { + const google::protobuf::FieldDescriptor* field) { switch (field->type()) { - case google::protobuf::FieldDescriptor::TYPE_INT32: - return "::phaser::FieldType::kFieldInt32"; - case google::protobuf::FieldDescriptor::TYPE_SINT32: - return "::phaser::FieldType::kFieldInt32"; - case google::protobuf::FieldDescriptor::TYPE_SFIXED32: - return "::phaser::FieldType::kFieldInt32"; - case google::protobuf::FieldDescriptor::TYPE_INT64: - return "::phaser::FieldType::kFieldInt64"; - case google::protobuf::FieldDescriptor::TYPE_SINT64: - return "::phaser::FieldType::kFieldInt64"; - case google::protobuf::FieldDescriptor::TYPE_SFIXED64: - return "::phaser::FieldType::kFieldInt64"; - case google::protobuf::FieldDescriptor::TYPE_UINT32: - return "::phaser::FieldType::kFieldInt32"; - case google::protobuf::FieldDescriptor::TYPE_FIXED32: - return "::phaser::FieldType::kFieldInt32"; - case google::protobuf::FieldDescriptor::TYPE_UINT64: - return "::phaser::FieldType::kFieldInt64"; - case google::protobuf::FieldDescriptor::TYPE_FIXED64: - return "::phaser::FieldType::kFieldInt64"; - case google::protobuf::FieldDescriptor::TYPE_DOUBLE: - return "::phaser::FieldType::kFieldDouble"; - case google::protobuf::FieldDescriptor::TYPE_FLOAT: - return "::phaser::FieldType::kFieldFloat"; - case google::protobuf::FieldDescriptor::TYPE_BOOL: - return "::phaser::FieldType::kFieldBool"; - case google::protobuf::FieldDescriptor::TYPE_ENUM: - return "::phaser::FieldType::kFieldEnum"; - case google::protobuf::FieldDescriptor::TYPE_STRING: - return "::phaser::FieldType::kFieldString"; - case google::protobuf::FieldDescriptor::TYPE_BYTES: - return "::phaser::FieldType::kFieldBytes"; - case google::protobuf::FieldDescriptor::TYPE_MESSAGE: - return "::phaser::FieldType::kFieldMessage"; - - case google::protobuf::FieldDescriptor::TYPE_GROUP: - std::cerr << "Groups are not supported\n"; - exit(1); + case google::protobuf::FieldDescriptor::TYPE_INT32: + return "::phaser::FieldType::kFieldInt32"; + case google::protobuf::FieldDescriptor::TYPE_SINT32: + return "::phaser::FieldType::kFieldInt32"; + case google::protobuf::FieldDescriptor::TYPE_SFIXED32: + return "::phaser::FieldType::kFieldInt32"; + case google::protobuf::FieldDescriptor::TYPE_INT64: + return "::phaser::FieldType::kFieldInt64"; + case google::protobuf::FieldDescriptor::TYPE_SINT64: + return "::phaser::FieldType::kFieldInt64"; + case google::protobuf::FieldDescriptor::TYPE_SFIXED64: + return "::phaser::FieldType::kFieldInt64"; + case google::protobuf::FieldDescriptor::TYPE_UINT32: + return "::phaser::FieldType::kFieldInt32"; + case google::protobuf::FieldDescriptor::TYPE_FIXED32: + return "::phaser::FieldType::kFieldInt32"; + case google::protobuf::FieldDescriptor::TYPE_UINT64: + return "::phaser::FieldType::kFieldInt64"; + case google::protobuf::FieldDescriptor::TYPE_FIXED64: + return "::phaser::FieldType::kFieldInt64"; + case google::protobuf::FieldDescriptor::TYPE_DOUBLE: + return "::phaser::FieldType::kFieldDouble"; + case google::protobuf::FieldDescriptor::TYPE_FLOAT: + return "::phaser::FieldType::kFieldFloat"; + case google::protobuf::FieldDescriptor::TYPE_BOOL: + return "::phaser::FieldType::kFieldBool"; + case google::protobuf::FieldDescriptor::TYPE_ENUM: + return "::phaser::FieldType::kFieldEnum"; + case google::protobuf::FieldDescriptor::TYPE_STRING: + return "::phaser::FieldType::kFieldString"; + case google::protobuf::FieldDescriptor::TYPE_BYTES: + return "::phaser::FieldType::kFieldBytes"; + case google::protobuf::FieldDescriptor::TYPE_MESSAGE: + return "::phaser::FieldType::kFieldMessage"; + + case google::protobuf::FieldDescriptor::TYPE_GROUP: + std::cerr << "Groups are not supported\n"; + exit(1); } // Unreachable: every protobuf field type is handled above and GROUP exits. abort(); } -std::string -MessageGenerator::FieldCType(const google::protobuf::FieldDescriptor *field) { +std::string MessageGenerator::FieldCType( + const google::protobuf::FieldDescriptor* field) { switch (field->type()) { - case google::protobuf::FieldDescriptor::TYPE_INT32: - case google::protobuf::FieldDescriptor::TYPE_SINT32: - case google::protobuf::FieldDescriptor::TYPE_SFIXED32: - return "int32_t"; - case google::protobuf::FieldDescriptor::TYPE_INT64: - case google::protobuf::FieldDescriptor::TYPE_SINT64: - case google::protobuf::FieldDescriptor::TYPE_SFIXED64: - return "int64_t"; - case google::protobuf::FieldDescriptor::TYPE_UINT32: - case google::protobuf::FieldDescriptor::TYPE_FIXED32: - return "uint32_t"; - case google::protobuf::FieldDescriptor::TYPE_UINT64: - case google::protobuf::FieldDescriptor::TYPE_FIXED64: - return "uint64_t"; - case google::protobuf::FieldDescriptor::TYPE_DOUBLE: - return "double"; - case google::protobuf::FieldDescriptor::TYPE_FLOAT: - return "float"; - case google::protobuf::FieldDescriptor::TYPE_BOOL: - return "bool"; - case google::protobuf::FieldDescriptor::TYPE_ENUM: - return EnumName(field->enum_type()); - case google::protobuf::FieldDescriptor::TYPE_STRING: - case google::protobuf::FieldDescriptor::TYPE_BYTES: - return "std::string_view"; - case google::protobuf::FieldDescriptor::TYPE_MESSAGE: - return MessageName(field->message_type(), true); - case google::protobuf::FieldDescriptor::TYPE_GROUP: - std::cerr << "Groups are not supported\n"; - exit(1); + case google::protobuf::FieldDescriptor::TYPE_INT32: + case google::protobuf::FieldDescriptor::TYPE_SINT32: + case google::protobuf::FieldDescriptor::TYPE_SFIXED32: + return "int32_t"; + case google::protobuf::FieldDescriptor::TYPE_INT64: + case google::protobuf::FieldDescriptor::TYPE_SINT64: + case google::protobuf::FieldDescriptor::TYPE_SFIXED64: + return "int64_t"; + case google::protobuf::FieldDescriptor::TYPE_UINT32: + case google::protobuf::FieldDescriptor::TYPE_FIXED32: + return "uint32_t"; + case google::protobuf::FieldDescriptor::TYPE_UINT64: + case google::protobuf::FieldDescriptor::TYPE_FIXED64: + return "uint64_t"; + case google::protobuf::FieldDescriptor::TYPE_DOUBLE: + return "double"; + case google::protobuf::FieldDescriptor::TYPE_FLOAT: + return "float"; + case google::protobuf::FieldDescriptor::TYPE_BOOL: + return "bool"; + case google::protobuf::FieldDescriptor::TYPE_ENUM: + return EnumName(field->enum_type()); + case google::protobuf::FieldDescriptor::TYPE_STRING: + case google::protobuf::FieldDescriptor::TYPE_BYTES: + return "std::string_view"; + case google::protobuf::FieldDescriptor::TYPE_MESSAGE: + return MessageName(field->message_type(), true); + case google::protobuf::FieldDescriptor::TYPE_GROUP: + std::cerr << "Groups are not supported\n"; + exit(1); } // Unreachable: every protobuf field type is handled above and GROUP exits. abort(); } std::string MessageGenerator::FieldRepeatedCType( - const google::protobuf::FieldDescriptor *field) { + const google::protobuf::FieldDescriptor* field) { std::string packed = field->is_packed() ? ", true>" : ", false>"; switch (field->type()) { - case google::protobuf::FieldDescriptor::TYPE_INT32: - return "PrimitiveVectorFieldenum_type()) + ", " + - EnumName(field->enum_type()) + "Stringizer, " + - EnumName(field->enum_type()) + "Parser" + packed; - case google::protobuf::FieldDescriptor::TYPE_STRING: - case google::protobuf::FieldDescriptor::TYPE_BYTES: - return "StringVectorField"; - case google::protobuf::FieldDescriptor::TYPE_MESSAGE: - return "MessageVectorField<" + MessageName(field->message_type(), true) + - ">"; - case google::protobuf::FieldDescriptor::TYPE_GROUP: - std::cerr << "Groups are not supported\n"; - exit(1); + case google::protobuf::FieldDescriptor::TYPE_INT32: + return "PrimitiveVectorFieldenum_type()) + ", " + + EnumName(field->enum_type()) + "Stringizer, " + + EnumName(field->enum_type()) + "Parser" + packed; + case google::protobuf::FieldDescriptor::TYPE_STRING: + case google::protobuf::FieldDescriptor::TYPE_BYTES: + return "StringVectorField"; + case google::protobuf::FieldDescriptor::TYPE_MESSAGE: + return "MessageVectorField<" + MessageName(field->message_type(), true) + + ">"; + case google::protobuf::FieldDescriptor::TYPE_GROUP: + std::cerr << "Groups are not supported\n"; + exit(1); } // Unreachable: every protobuf field type is handled above and GROUP exits. abort(); } std::string MessageGenerator::FieldUnionCType( - const google::protobuf::FieldDescriptor *field) { + const google::protobuf::FieldDescriptor* field) { switch (field->type()) { - case google::protobuf::FieldDescriptor::TYPE_INT32: - return "UnionInt32Field"; - case google::protobuf::FieldDescriptor::TYPE_SINT32: - return "UnionInt32Field"; - case google::protobuf::FieldDescriptor::TYPE_SFIXED32: - return "UnionInt32Field"; - case google::protobuf::FieldDescriptor::TYPE_INT64: - return "UnionInt64Field"; - case google::protobuf::FieldDescriptor::TYPE_SINT64: - return "UnionInt64Field"; - case google::protobuf::FieldDescriptor::TYPE_SFIXED64: - return "UnionInt64Field"; - case google::protobuf::FieldDescriptor::TYPE_UINT32: - return "UnionUint32Field"; - case google::protobuf::FieldDescriptor::TYPE_FIXED32: - return "UnionUint32Field"; - case google::protobuf::FieldDescriptor::TYPE_UINT64: - return "UnionUint64Field"; - case google::protobuf::FieldDescriptor::TYPE_FIXED64: - return "UnionUint64Field"; - case google::protobuf::FieldDescriptor::TYPE_DOUBLE: - return "UnionDoubleField"; - case google::protobuf::FieldDescriptor::TYPE_FLOAT: - return "UnionFloatField"; - case google::protobuf::FieldDescriptor::TYPE_BOOL: - return "UnionBoolField"; - case google::protobuf::FieldDescriptor::TYPE_ENUM: - return "UnionEnumField<" + EnumName(field->enum_type()) + ", " + - EnumName(field->enum_type()) + "Stringizer, " + - EnumName(field->enum_type()) + "Parser>"; - case google::protobuf::FieldDescriptor::TYPE_STRING: - case google::protobuf::FieldDescriptor::TYPE_BYTES: - return "UnionStringField"; - case google::protobuf::FieldDescriptor::TYPE_MESSAGE: - return "UnionMessageField<" + MessageName(field->message_type(), true) + - ">"; - case google::protobuf::FieldDescriptor::TYPE_GROUP: - std::cerr << "Groups are not supported\n"; - exit(1); + case google::protobuf::FieldDescriptor::TYPE_INT32: + return "UnionInt32Field"; + case google::protobuf::FieldDescriptor::TYPE_SINT32: + return "UnionInt32Field"; + case google::protobuf::FieldDescriptor::TYPE_SFIXED32: + return "UnionInt32Field"; + case google::protobuf::FieldDescriptor::TYPE_INT64: + return "UnionInt64Field"; + case google::protobuf::FieldDescriptor::TYPE_SINT64: + return "UnionInt64Field"; + case google::protobuf::FieldDescriptor::TYPE_SFIXED64: + return "UnionInt64Field"; + case google::protobuf::FieldDescriptor::TYPE_UINT32: + return "UnionUint32Field"; + case google::protobuf::FieldDescriptor::TYPE_FIXED32: + return "UnionUint32Field"; + case google::protobuf::FieldDescriptor::TYPE_UINT64: + return "UnionUint64Field"; + case google::protobuf::FieldDescriptor::TYPE_FIXED64: + return "UnionUint64Field"; + case google::protobuf::FieldDescriptor::TYPE_DOUBLE: + return "UnionDoubleField"; + case google::protobuf::FieldDescriptor::TYPE_FLOAT: + return "UnionFloatField"; + case google::protobuf::FieldDescriptor::TYPE_BOOL: + return "UnionBoolField"; + case google::protobuf::FieldDescriptor::TYPE_ENUM: + return "UnionEnumField<" + EnumName(field->enum_type()) + ", " + + EnumName(field->enum_type()) + "Stringizer, " + + EnumName(field->enum_type()) + "Parser>"; + case google::protobuf::FieldDescriptor::TYPE_STRING: + case google::protobuf::FieldDescriptor::TYPE_BYTES: + return "UnionStringField"; + case google::protobuf::FieldDescriptor::TYPE_MESSAGE: + return "UnionMessageField<" + MessageName(field->message_type(), true) + + ">"; + case google::protobuf::FieldDescriptor::TYPE_GROUP: + std::cerr << "Groups are not supported\n"; + exit(1); } // Unreachable: every protobuf field type is handled above and GROUP exits. abort(); } uint32_t MessageGenerator::FieldBinarySize( - const google::protobuf::FieldDescriptor *field) { + const google::protobuf::FieldDescriptor* field) { switch (field->type()) { - case google::protobuf::FieldDescriptor::TYPE_INT32: - case google::protobuf::FieldDescriptor::TYPE_SINT32: - case google::protobuf::FieldDescriptor::TYPE_SFIXED32: - return 4; - case google::protobuf::FieldDescriptor::TYPE_INT64: - case google::protobuf::FieldDescriptor::TYPE_SINT64: - case google::protobuf::FieldDescriptor::TYPE_SFIXED64: - return 8; - case google::protobuf::FieldDescriptor::TYPE_UINT32: - case google::protobuf::FieldDescriptor::TYPE_FIXED32: - return 4; - case google::protobuf::FieldDescriptor::TYPE_UINT64: - case google::protobuf::FieldDescriptor::TYPE_FIXED64: - return 8; - case google::protobuf::FieldDescriptor::TYPE_DOUBLE: - return 8; - case google::protobuf::FieldDescriptor::TYPE_FLOAT: - return 4; - case google::protobuf::FieldDescriptor::TYPE_BOOL: - return 1; - case google::protobuf::FieldDescriptor::TYPE_ENUM: - return 4; - case google::protobuf::FieldDescriptor::TYPE_STRING: - case google::protobuf::FieldDescriptor::TYPE_BYTES: - return 4; - case google::protobuf::FieldDescriptor::TYPE_MESSAGE: - return 4; - case google::protobuf::FieldDescriptor::TYPE_GROUP: - std::cerr << "Groups are not supported\n"; - exit(1); + case google::protobuf::FieldDescriptor::TYPE_INT32: + case google::protobuf::FieldDescriptor::TYPE_SINT32: + case google::protobuf::FieldDescriptor::TYPE_SFIXED32: + return 4; + case google::protobuf::FieldDescriptor::TYPE_INT64: + case google::protobuf::FieldDescriptor::TYPE_SINT64: + case google::protobuf::FieldDescriptor::TYPE_SFIXED64: + return 8; + case google::protobuf::FieldDescriptor::TYPE_UINT32: + case google::protobuf::FieldDescriptor::TYPE_FIXED32: + return 4; + case google::protobuf::FieldDescriptor::TYPE_UINT64: + case google::protobuf::FieldDescriptor::TYPE_FIXED64: + return 8; + case google::protobuf::FieldDescriptor::TYPE_DOUBLE: + return 8; + case google::protobuf::FieldDescriptor::TYPE_FLOAT: + return 4; + case google::protobuf::FieldDescriptor::TYPE_BOOL: + return 1; + case google::protobuf::FieldDescriptor::TYPE_ENUM: + return 4; + case google::protobuf::FieldDescriptor::TYPE_STRING: + case google::protobuf::FieldDescriptor::TYPE_BYTES: + return 4; + case google::protobuf::FieldDescriptor::TYPE_MESSAGE: + return 4; + case google::protobuf::FieldDescriptor::TYPE_GROUP: + std::cerr << "Groups are not supported\n"; + exit(1); } // Unreachable: every protobuf field type is handled above and GROUP exits. abort(); } -bool MessageGenerator::IsAny(const google::protobuf::Descriptor *desc) { +bool MessageGenerator::IsAny(const google::protobuf::Descriptor* desc) { return desc->full_name() == "google.protobuf.Any"; } -bool MessageGenerator::IsAny(const google::protobuf::FieldDescriptor *field) { +bool MessageGenerator::IsAny(const google::protobuf::FieldDescriptor* field) { return field->type() == google::protobuf::FieldDescriptor::TYPE_MESSAGE && field->message_type()->full_name() == "google.protobuf.Any"; } void MessageGenerator::CompileUnions() { for (int i = 0; i < message_->field_count(); i++) { - const auto &field = message_->field(i); - const google::protobuf::OneofDescriptor *oneof = field->containing_oneof(); + const auto& field = message_->field(i); + const google::protobuf::OneofDescriptor* oneof = field->containing_oneof(); if (oneof == nullptr) { // Not a oneof, already handled in CompileFields. continue; @@ -456,7 +458,7 @@ void MessageGenerator::CompileUnions() { union_info->binary_size = std::max(union_info->binary_size, 4 + field_size); union_info->id++; } - for (auto & [ oneof, union_info ] : unions_) { + for (auto& [oneof, union_info] : unions_) { union_info->member_type += ">"; } } @@ -466,9 +468,9 @@ void MessageGenerator::CompileFields() { uint32_t id = 0; fields_.reserve(static_cast(message_->field_count())); for (int i = 0; i < message_->field_count(); i++) { - const auto &field = message_->field(i); + const auto& field = message_->field(i); std::string field_type; - const google::protobuf::OneofDescriptor *oneof = field->containing_oneof(); + const google::protobuf::OneofDescriptor* oneof = field->containing_oneof(); uint32_t field_size; uint32_t next_id = id; if (oneof != nullptr) { @@ -502,10 +504,9 @@ void MessageGenerator::CompileFields() { } } offset = (offset + (field_size - 1)) & ~(field_size - 1); - fields_.push_back( - std::make_shared(field, offset, id, - std::string(field->name()) + "_", - field_type, FieldCType(field), field_size)); + fields_.push_back(std::make_shared( + field, offset, id, std::string(field->name()) + "_", field_type, + FieldCType(field), field_size)); fields_in_order_.push_back(fields_.back()); offset += field_size; id = next_id; @@ -517,7 +518,7 @@ void MessageGenerator::FinalizeOffsetsAndSizes() { // Find the max field id. This will determine the number of 32-bit words we // need for the presence mask. int32_t max_id = -1; - for (auto &field : fields_) { + for (auto& field : fields_) { max_id = std::max(max_id, int32_t(field->id)); } presence_mask_size_ = @@ -525,7 +526,7 @@ void MessageGenerator::FinalizeOffsetsAndSizes() { size += presence_mask_size_; // Finalize the offsets in the fields vector now that we know the header size. - for (auto &field : fields_) { + for (auto& field : fields_) { field->offset += size; } @@ -538,9 +539,9 @@ void MessageGenerator::FinalizeOffsetsAndSizes() { size = offset; // Add the offset to the unions. - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { u->offset = offset; - for (auto &field : u->members) { + for (auto& field : u->members) { field->offset += offset; } offset += u->binary_size; @@ -549,8 +550,8 @@ void MessageGenerator::FinalizeOffsetsAndSizes() { binary_size_ = size; } -void MessageGenerator::GenerateHeader(std::ostream &os) { - for (const auto &nested : nested_message_gens_) { +void MessageGenerator::GenerateHeader(std::ostream& os) { + for (const auto& nested : nested_message_gens_) { nested->GenerateHeader(os); } CompileFields(); @@ -622,8 +623,8 @@ void MessageGenerator::GenerateHeader(std::ostream &os) { GenerateCopy(os, false); } -void MessageGenerator::GenerateSource(std::ostream &os) { - for (const auto &nested : nested_message_gens_) { +void MessageGenerator::GenerateSource(std::ostream& os) { + for (const auto& nested : nested_message_gens_) { nested->GenerateSource(os); } @@ -647,27 +648,27 @@ void MessageGenerator::GenerateSource(std::ostream &os) { GeneratePhaserBank(os); } -void MessageGenerator::GenerateFieldDeclarations(std::ostream &os) { - for (auto &field : fields_) { +void MessageGenerator::GenerateFieldDeclarations(std::ostream& os) { + for (auto& field : fields_) { os << " ::phaser::" << field->member_type << " " << field->member_name << ";\n"; } - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { os << " ::phaser::" << u->member_type << " " << u->member_name << ";\n"; } } -void MessageGenerator::GenerateEnums(std::ostream &os) { +void MessageGenerator::GenerateEnums(std::ostream& os) { // Nested enums. - for (auto &msg : nested_message_gens_) { + for (auto& msg : nested_message_gens_) { msg->GenerateEnums(os); } - for (auto &enum_gen : enum_gens_) { + for (auto& enum_gen : enum_gens_) { enum_gen->GenerateHeader(os); } } -void MessageGenerator::GenerateConstructors(std::ostream &os, bool decl) { +void MessageGenerator::GenerateConstructors(std::ostream& os, bool decl) { // Generate default constructor. GenerateDefaultConstructor(os, decl); GenerateInternalDefaultConstructor(os, decl); @@ -675,7 +676,7 @@ void MessageGenerator::GenerateConstructors(std::ostream &os, bool decl) { GenerateMainConstructor(os, decl); } -void MessageGenerator::GenerateDefaultConstructor(std::ostream &os, bool decl) { +void MessageGenerator::GenerateDefaultConstructor(std::ostream& os, bool decl) { if (decl) { os << " " << MessageName(message_) << "(size_t initial_size = 8192, ::phaser::Tuning tuning = " @@ -696,7 +697,7 @@ void MessageGenerator::GenerateDefaultConstructor(std::ostream &os, bool decl) { )XXX"; } -void MessageGenerator::GenerateInternalDefaultConstructor(std::ostream &os, +void MessageGenerator::GenerateInternalDefaultConstructor(std::ostream& os, bool decl) { if (decl) { os << " " << MessageName(message_) << "(::phaser::InternalDefault d);\n"; @@ -709,7 +710,7 @@ void MessageGenerator::GenerateInternalDefaultConstructor(std::ostream &os, os << "{}\n\n"; } -void MessageGenerator::GenerateMainConstructor(std::ostream &os, bool decl) { +void MessageGenerator::GenerateMainConstructor(std::ostream& os, bool decl) { if (decl) { os << " " << MessageName(message_) << "(std::shared_ptr<::phaser::MessageRuntime> runtime, " @@ -726,24 +727,24 @@ void MessageGenerator::GenerateMainConstructor(std::ostream &os, bool decl) { os << "{}\n\n"; } -void MessageGenerator::GenerateFieldInitializers(std::ostream &os, - const char *sep) { +void MessageGenerator::GenerateFieldInitializers(std::ostream& os, + const char* sep) { if (fields_.empty() && unions_.empty()) { return; } os << "#pragma clang diagnostic push\n"; os << "#pragma clang diagnostic ignored \"-Winvalid-offsetof\"\n"; - for (auto &field : fields_) { + for (auto& field : fields_) { os << sep << field->member_name << "(offsetof(" << MessageName(message_) << ", " << field->member_name << "), " << field->offset << ", " << field->id << ", " << field->field->number() << ")\n"; sep = ", "; } - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { os << sep << u->member_name << "(offsetof(" << MessageName(message_) << ", " << u->member_name << "), " << u->offset << ", 0, 0, {"; - const char *num_sep = ""; - for (auto &field : u->members) { + const char* num_sep = ""; + for (auto& field : u->members) { os << num_sep << field->field->number(); num_sep = ","; } @@ -753,7 +754,7 @@ void MessageGenerator::GenerateFieldInitializers(std::ostream &os, os << "#pragma clang diagnostic pop\n\n"; } -void MessageGenerator::GenerateCreators(std::ostream &os, bool decl) { +void MessageGenerator::GenerateCreators(std::ostream& os, bool decl) { if (decl) { os << " static " << MessageName(message_) << " CreateMutable(void *addr, size_t size, ::phaser::Tuning tuning = " @@ -865,7 +866,7 @@ void MessageGenerator::GenerateCreators(std::ostream &os, bool decl) { "}\n\n"; } -void MessageGenerator::GenerateSizeFunctions(std::ostream &os) { +void MessageGenerator::GenerateSizeFunctions(std::ostream& os) { os << " static constexpr size_t BinarySize() { return HeaderSize() + " << binary_size_ << "; }\n"; os << " static constexpr size_t PresenceMaskSize() { return " @@ -874,20 +875,20 @@ void MessageGenerator::GenerateSizeFunctions(std::ostream &os) { "PresenceMaskSize(); }\n"; } -void MessageGenerator::GenerateFieldMetadata(std::ostream &os) { +void MessageGenerator::GenerateFieldMetadata(std::ostream& os) { // Build a vector of fields from the fields an unions, sorted by field number. std::vector> all_fields; - for (auto &field : fields_) { + for (auto& field : fields_) { all_fields.push_back(field); } - for (auto & [ oneof, u ] : unions_) { - for (auto &field : u->members) { + for (auto& [oneof, u] : unions_) { + for (auto& field : u->members) { all_fields.push_back(field); } } std::sort(all_fields.begin(), all_fields.end(), - [](const auto &a, const auto &b) { + [](const auto& a, const auto& b) { return a->field->number() < b->field->number(); }); @@ -911,7 +912,7 @@ void MessageGenerator::GenerateFieldMetadata(std::ostream &os) { << "FieldData field_data = {\n"; os << " .num = " << all_fields.size() << ",\n"; os << " .fields = {\n"; - for (auto &field : all_fields) { + for (auto& field : all_fields) { os << " { .number = " << field->field->number() << ", .offset = " << field->offset << ", .id = " << field->id << " },\n"; } @@ -919,16 +920,16 @@ void MessageGenerator::GenerateFieldMetadata(std::ostream &os) { os << " };\n"; } -void MessageGenerator::GenerateClear(std::ostream &os, bool decl) { +void MessageGenerator::GenerateClear(std::ostream& os, bool decl) { if (decl) { os << " void Clear() override;\n"; return; } os << "void " << MessageName(message_) << "::Clear() {\n"; - for (auto &field : fields_) { + for (auto& field : fields_) { os << " " << field->member_name << ".Clear();\n"; } - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { for (size_t i = 0; i < u->members.size(); i++) { os << " " << u->member_name << ".Clear<" << i << ">();\n"; } @@ -936,22 +937,22 @@ void MessageGenerator::GenerateClear(std::ostream &os, bool decl) { os << "}\n\n"; } -void MessageGenerator::GenerateProtobufAccessors(std::ostream &os) { +void MessageGenerator::GenerateProtobufAccessors(std::ostream& os) { // Generate field accessors. GenerateFieldProtobufAccessors(os); // Union accessors. GenerateUnionProtobufAccessors(os); } -void MessageGenerator::GenerateFieldProtobufAccessors(std::ostream &os) { - for (auto &field : fields_) { +void MessageGenerator::GenerateFieldProtobufAccessors(std::ostream& os) { + for (auto& field : fields_) { GenerateFieldProtobufAccessors(field, nullptr, -1, os); } } void MessageGenerator::GenerateFieldProtobufAccessors( std::shared_ptr field, std::shared_ptr union_field, - int union_index, std::ostream &os) { + int union_index, std::ostream& os) { std::string field_name(field->field->name()); std::string sanitized_field_name = field_name + +(IsCppReservedWord(field_name) ? "_" : ""); @@ -993,290 +994,292 @@ void MessageGenerator::GenerateFieldProtobufAccessors( if (field->field->is_repeated()) { // Generate repeated accessor. switch (field->field->type()) { - case google::protobuf::FieldDescriptor::TYPE_INT32: - case google::protobuf::FieldDescriptor::TYPE_SINT32: - case google::protobuf::FieldDescriptor::TYPE_SFIXED32: - case google::protobuf::FieldDescriptor::TYPE_INT64: - case google::protobuf::FieldDescriptor::TYPE_SINT64: - case google::protobuf::FieldDescriptor::TYPE_SFIXED64: - case google::protobuf::FieldDescriptor::TYPE_UINT32: - case google::protobuf::FieldDescriptor::TYPE_FIXED32: - case google::protobuf::FieldDescriptor::TYPE_UINT64: - case google::protobuf::FieldDescriptor::TYPE_FIXED64: - case google::protobuf::FieldDescriptor::TYPE_DOUBLE: - case google::protobuf::FieldDescriptor::TYPE_FLOAT: - case google::protobuf::FieldDescriptor::TYPE_BOOL: - case google::protobuf::FieldDescriptor::TYPE_ENUM: - case google::protobuf::FieldDescriptor::TYPE_STRING: - case google::protobuf::FieldDescriptor::TYPE_BYTES: - os << " " << field->c_type << " " << sanitized_field_name - << "(size_t index) const {\n"; - os << " return " << member_name << ".Get(index);\n"; - os << " }\n"; - os << " size_t " << field_name << "_size() const {\n"; - os << " return " << member_name << ".Size();\n"; - os << " }\n"; - os << " void clear_" << field_name << "() {\n"; - os << " " << member_name << ".Clear();\n"; - os << " }\n"; - os << " void reserve_" << field_name << "(size_t num) {\n"; - os << " " << member_name << ".reserve(num);\n"; - os << " }\n"; - os << " void resize_" << field_name << "(size_t num) {\n"; - os << " " << member_name << ".resize(num);\n"; - os << " }\n"; - - // Strings have different accessors from primitive fields. - if (field->field->type() == - google::protobuf::FieldDescriptor::TYPE_STRING || - field->field->type() == - google::protobuf::FieldDescriptor::TYPE_BYTES) { - os << " template \n"; - os << " void add_" << field_name << "(Str value) {\n"; - os << " " << member_name << ".Add(value);\n"; + case google::protobuf::FieldDescriptor::TYPE_INT32: + case google::protobuf::FieldDescriptor::TYPE_SINT32: + case google::protobuf::FieldDescriptor::TYPE_SFIXED32: + case google::protobuf::FieldDescriptor::TYPE_INT64: + case google::protobuf::FieldDescriptor::TYPE_SINT64: + case google::protobuf::FieldDescriptor::TYPE_SFIXED64: + case google::protobuf::FieldDescriptor::TYPE_UINT32: + case google::protobuf::FieldDescriptor::TYPE_FIXED32: + case google::protobuf::FieldDescriptor::TYPE_UINT64: + case google::protobuf::FieldDescriptor::TYPE_FIXED64: + case google::protobuf::FieldDescriptor::TYPE_DOUBLE: + case google::protobuf::FieldDescriptor::TYPE_FLOAT: + case google::protobuf::FieldDescriptor::TYPE_BOOL: + case google::protobuf::FieldDescriptor::TYPE_ENUM: + case google::protobuf::FieldDescriptor::TYPE_STRING: + case google::protobuf::FieldDescriptor::TYPE_BYTES: + os << " " << field->c_type << " " << sanitized_field_name + << "(size_t index) const {\n"; + os << " return " << member_name << ".Get(index);\n"; os << " }\n"; - os << " template \n"; - os << " void set_" << field_name << "(size_t index, Str value) {\n"; - os << " " << member_name << ".Set(index, value);\n"; + os << " size_t " << field_name << "_size() const {\n"; + os << " return " << member_name << ".Size();\n"; os << " }\n"; - os << " const ::phaser::StringVectorField& " << sanitized_field_name - << "() const {\n"; - os << " " << member_name << ".Populate();\n"; - os << " return " << member_name << ";\n"; + os << " void clear_" << field_name << "() {\n"; + os << " " << member_name << ".Clear();\n"; os << " }\n"; - } else { - os << " void add_" << field_name << "(" << field->c_type - << " value) {\n"; - os << " " << member_name << ".Add(value);\n"; - os << " }\n"; - os << " void set_" << field_name << "(size_t index, " << field->c_type - << " value) {\n"; - os << " " << member_name << ".Set(index, value);\n"; + os << " void reserve_" << field_name << "(size_t num) {\n"; + os << " " << member_name << ".reserve(num);\n"; os << " }\n"; - os << " absl::Span<" << field->c_type << ">" << field_name - << "_as_mutable_span() {\n"; - os << " return " << member_name << ".AsMutableSpan();\n"; - os << " }\n"; - os << " absl::Spanc_type << ">" << field_name - << "_as_span() const {\n"; - os << " return " << member_name << ".AsSpan();\n"; + os << " void resize_" << field_name << "(size_t num) {\n"; + os << " " << member_name << ".resize(num);\n"; os << " }\n"; + + // Strings have different accessors from primitive fields. if (field->field->type() == - google::protobuf::FieldDescriptor::TYPE_ENUM) { - os << " const ::phaser::EnumVectorField<" << field->c_type << ", " - << EnumName(field->field->enum_type()) << "Stringizer, " - << EnumName(field->field->enum_type()) << "Parser" << packed_string - << ">& " << sanitized_field_name << "() const {\n"; + google::protobuf::FieldDescriptor::TYPE_STRING || + field->field->type() == + google::protobuf::FieldDescriptor::TYPE_BYTES) { + os << " template \n"; + os << " void add_" << field_name << "(Str value) {\n"; + os << " " << member_name << ".Add(value);\n"; + os << " }\n"; + os << " template \n"; + os << " void set_" << field_name << "(size_t index, Str value) {\n"; + os << " " << member_name << ".Set(index, value);\n"; + os << " }\n"; + os << " const ::phaser::StringVectorField& " << sanitized_field_name + << "() const {\n"; + os << " " << member_name << ".Populate();\n"; os << " return " << member_name << ";\n"; os << " }\n"; } else { - os << " const ::phaser::PrimitiveVectorField<" << field->c_type - << fixed_size_string << signed_string << packed_string << ">& " - << sanitized_field_name << "() const {\n"; - os << " return " << member_name << ";\n"; + os << " void add_" << field_name << "(" << field->c_type + << " value) {\n"; + os << " " << member_name << ".Add(value);\n"; + os << " }\n"; + os << " void set_" << field_name << "(size_t index, " + << field->c_type << " value) {\n"; + os << " " << member_name << ".Set(index, value);\n"; os << " }\n"; + os << " absl::Span<" << field->c_type << ">" << field_name + << "_as_mutable_span() {\n"; + os << " return " << member_name << ".AsMutableSpan();\n"; + os << " }\n"; + os << " absl::Spanc_type << ">" << field_name + << "_as_span() const {\n"; + os << " return " << member_name << ".AsSpan();\n"; + os << " }\n"; + if (field->field->type() == + google::protobuf::FieldDescriptor::TYPE_ENUM) { + os << " const ::phaser::EnumVectorField<" << field->c_type << ", " + << EnumName(field->field->enum_type()) << "Stringizer, " + << EnumName(field->field->enum_type()) << "Parser" + << packed_string << ">& " << sanitized_field_name + << "() const {\n"; + os << " return " << member_name << ";\n"; + os << " }\n"; + } else { + os << " const ::phaser::PrimitiveVectorField<" << field->c_type + << fixed_size_string << signed_string << packed_string << ">& " + << sanitized_field_name << "() const {\n"; + os << " return " << member_name << ";\n"; + os << " }\n"; + } } - } - break; - case google::protobuf::FieldDescriptor::TYPE_MESSAGE: - os << " size_t " << field_name << "_size() const {\n"; - os << " return " << member_name << ".Size();\n"; - os << " }\n"; - os << " void clear_" << field_name << "() {\n"; - os << " " << member_name << ".Clear();\n"; - os << " }\n"; - os << " const " << field->c_type << "& " << sanitized_field_name - << "(size_t index) const {\n"; - os << " return " << member_name << ".Get(index);\n"; - os << " }\n"; - os << " " << field->c_type << "* mutable_" << field_name - << "(size_t index) {\n"; - os << " return " << member_name << ".Mutable(index);\n"; - os << " }\n"; - os << " " << field->c_type << "* add_" << field_name << "() {\n"; - os << " return " << member_name << ".Add();\n"; - os << " }\n"; - os << " const ::phaser::MessageVectorField<" << field->c_type << ">& " - << sanitized_field_name << "() const {\n"; - os << " " << member_name << ".Populate();\n"; - os << " return " << member_name << ";\n"; - os << " }\n"; - os << " void reserve_" << field_name << "(size_t num) {\n"; - os << " " << member_name << ".reserve(num);\n"; - os << " }\n"; - os << " void resize_" << field_name << "(size_t num) {\n"; - os << " " << member_name << ".resize(num);\n"; - os << " }\n"; - os << " std::vector<" << field->c_type << "*> allocate_" << field_name - << "(size_t n) {\n"; - os << " return " << member_name << ".Allocate(n);\n"; - os << " }\n"; - break; - case google::protobuf::FieldDescriptor::TYPE_GROUP: - std::cerr << "Groups are not supported\n"; - exit(1); + break; + case google::protobuf::FieldDescriptor::TYPE_MESSAGE: + os << " size_t " << field_name << "_size() const {\n"; + os << " return " << member_name << ".Size();\n"; + os << " }\n"; + os << " void clear_" << field_name << "() {\n"; + os << " " << member_name << ".Clear();\n"; + os << " }\n"; + os << " const " << field->c_type << "& " << sanitized_field_name + << "(size_t index) const {\n"; + os << " return " << member_name << ".Get(index);\n"; + os << " }\n"; + os << " " << field->c_type << "* mutable_" << field_name + << "(size_t index) {\n"; + os << " return " << member_name << ".Mutable(index);\n"; + os << " }\n"; + os << " " << field->c_type << "* add_" << field_name << "() {\n"; + os << " return " << member_name << ".Add();\n"; + os << " }\n"; + os << " const ::phaser::MessageVectorField<" << field->c_type << ">& " + << sanitized_field_name << "() const {\n"; + os << " " << member_name << ".Populate();\n"; + os << " return " << member_name << ";\n"; + os << " }\n"; + os << " void reserve_" << field_name << "(size_t num) {\n"; + os << " " << member_name << ".reserve(num);\n"; + os << " }\n"; + os << " void resize_" << field_name << "(size_t num) {\n"; + os << " " << member_name << ".resize(num);\n"; + os << " }\n"; + os << " std::vector<" << field->c_type << "*> allocate_" << field_name + << "(size_t n) {\n"; + os << " return " << member_name << ".Allocate(n);\n"; + os << " }\n"; + break; + case google::protobuf::FieldDescriptor::TYPE_GROUP: + std::cerr << "Groups are not supported\n"; + exit(1); } } else { // Non-repeated fields. switch (field->field->type()) { - case google::protobuf::FieldDescriptor::TYPE_INT32: - case google::protobuf::FieldDescriptor::TYPE_SINT32: - case google::protobuf::FieldDescriptor::TYPE_SFIXED32: - case google::protobuf::FieldDescriptor::TYPE_INT64: - case google::protobuf::FieldDescriptor::TYPE_SINT64: - case google::protobuf::FieldDescriptor::TYPE_SFIXED64: - case google::protobuf::FieldDescriptor::TYPE_UINT32: - case google::protobuf::FieldDescriptor::TYPE_FIXED32: - case google::protobuf::FieldDescriptor::TYPE_UINT64: - case google::protobuf::FieldDescriptor::TYPE_FIXED64: - case google::protobuf::FieldDescriptor::TYPE_DOUBLE: - case google::protobuf::FieldDescriptor::TYPE_FLOAT: - case google::protobuf::FieldDescriptor::TYPE_BOOL: - case google::protobuf::FieldDescriptor::TYPE_ENUM: - case google::protobuf::FieldDescriptor::TYPE_STRING: - case google::protobuf::FieldDescriptor::TYPE_BYTES: - os << " " << field->c_type << " " << sanitized_field_name - << "() const {\n"; - if (union_index == -1) { - os << " return " << member_name << ".Get();\n"; - } else { - os << " return " << member_name << ".template GetValue<" - << std::to_string(union_index) << ", " << field->c_type << ">();\n"; - } - os << " }\n"; - if (union_index == -1) { - os << " bool has_" << field_name << "() const {\n"; - os << " return " << member_name << ".IsPresent();\n"; + case google::protobuf::FieldDescriptor::TYPE_INT32: + case google::protobuf::FieldDescriptor::TYPE_SINT32: + case google::protobuf::FieldDescriptor::TYPE_SFIXED32: + case google::protobuf::FieldDescriptor::TYPE_INT64: + case google::protobuf::FieldDescriptor::TYPE_SINT64: + case google::protobuf::FieldDescriptor::TYPE_SFIXED64: + case google::protobuf::FieldDescriptor::TYPE_UINT32: + case google::protobuf::FieldDescriptor::TYPE_FIXED32: + case google::protobuf::FieldDescriptor::TYPE_UINT64: + case google::protobuf::FieldDescriptor::TYPE_FIXED64: + case google::protobuf::FieldDescriptor::TYPE_DOUBLE: + case google::protobuf::FieldDescriptor::TYPE_FLOAT: + case google::protobuf::FieldDescriptor::TYPE_BOOL: + case google::protobuf::FieldDescriptor::TYPE_ENUM: + case google::protobuf::FieldDescriptor::TYPE_STRING: + case google::protobuf::FieldDescriptor::TYPE_BYTES: + os << " " << field->c_type << " " << sanitized_field_name + << "() const {\n"; + if (union_index == -1) { + os << " return " << member_name << ".Get();\n"; + } else { + os << " return " << member_name << ".template GetValue<" + << std::to_string(union_index) << ", " << field->c_type + << ">();\n"; + } os << " }\n"; - } else { - os << " bool has_" << field_name << "() const {\n"; - os << " return " << member_name << ".template IsPresent<" - << std::to_string(union_index) << ">();\n"; + if (union_index == -1) { + os << " bool has_" << field_name << "() const {\n"; + os << " return " << member_name << ".IsPresent();\n"; + os << " }\n"; + } else { + os << " bool has_" << field_name << "() const {\n"; + os << " return " << member_name << ".template IsPresent<" + << std::to_string(union_index) << ">();\n"; + os << " }\n"; + } + os << " void clear_" << field_name << "() {\n"; + os << " " << member_name << ".Clear" << suffix << "();\n"; os << " }\n"; - } - os << " void clear_" << field_name << "() {\n"; - os << " " << member_name << ".Clear" << suffix << "();\n"; - os << " }\n"; - if (field->field->type() == - google::protobuf::FieldDescriptor::TYPE_STRING || - field->field->type() == - google::protobuf::FieldDescriptor::TYPE_BYTES) { - os << " template \n"; - os << " void set_" << field_name << "(Str value) {\n"; - if (union_index != -1) { - // Clear all other union members. - for (size_t i = 0; i < union_field->members.size(); i++) { - if (i != size_t(union_index)) { - os << " " << member_name << ".Clear<" << i << ">();\n"; + if (field->field->type() == + google::protobuf::FieldDescriptor::TYPE_STRING || + field->field->type() == + google::protobuf::FieldDescriptor::TYPE_BYTES) { + os << " template \n"; + os << " void set_" << field_name << "(Str value) {\n"; + if (union_index != -1) { + // Clear all other union members. + for (size_t i = 0; i < union_field->members.size(); i++) { + if (i != size_t(union_index)) { + os << " " << member_name << ".Clear<" << i << ">();\n"; + } } } + os << " " << member_name << ".Set" << suffix << "(value);\n"; + os << " }\n"; + os << " absl::Span allocate_" << field_name + << "(size_t len) {\n"; + os << " return " << member_name << ".Allocate" << suffix + << "(len);\n"; + os << " }\n"; + } else { + os << " void set_" << field_name << "(" << field->c_type + << " value) {\n"; + if (union_index != -1) { + // Clear all other union members. + for (size_t i = 0; i < union_field->members.size(); i++) { + if (i != size_t(union_index)) { + os << " " << member_name << ".Clear<" << i << ">();\n"; + } + } + } + os << " " << member_name << ".Set" << suffix << "(value);\n"; + os << " }\n"; } - os << " " << member_name << ".Set" << suffix << "(value);\n"; + break; + + case google::protobuf::FieldDescriptor::TYPE_MESSAGE: + os << " void clear_" << field_name << "() {\n"; + os << " " << member_name << ".Clear" << suffix << "();\n"; os << " }\n"; - os << " absl::Span allocate_" << field_name - << "(size_t len) {\n"; - os << " return " << member_name << ".Allocate" << suffix - << "(len);\n"; + os << " void set_" << field_name + << "(toolbelt::BufferOffset offset) {\n"; + os << " " << member_name << ".SetOffset" << suffix << "(offset);\n"; os << " }\n"; - } else { - os << " void set_" << field_name << "(" << field->c_type - << " value) {\n"; - if (union_index != -1) { + + if (union_index == -1) { + os << " const " << field->c_type << "& " << sanitized_field_name + << "() const {\n"; + os << " return " << member_name << ".Get();\n"; + os << " }\n"; + os << " bool has_" << field_name << "() const {\n"; + os << " return " << member_name << ".IsPresent();\n"; + os << " }\n"; + os << " " << field->c_type << "* mutable_" << field_name << "() {\n"; + os << " return " << member_name << ".Mutable();\n"; + os << " }\n"; + } else { + // Union members need to be accessed by index and type. + os << " const " << field->c_type << "& " << sanitized_field_name + << "() const {\n"; + os << " return " << member_name << ".template GetReference<" + << std::to_string(union_index) << ", " + << MessageName(field->field->message_type()) << ">();\n"; + os << " }\n"; + os << " " << field->c_type << "* mutable_" << field_name << "() {\n"; // Clear all other union members. for (size_t i = 0; i < union_field->members.size(); i++) { if (i != size_t(union_index)) { os << " " << member_name << ".Clear<" << i << ">();\n"; } } - } - os << " " << member_name << ".Set" << suffix << "(value);\n"; - os << " }\n"; - } - break; - - case google::protobuf::FieldDescriptor::TYPE_MESSAGE: - os << " void clear_" << field_name << "() {\n"; - os << " " << member_name << ".Clear" << suffix << "();\n"; - os << " }\n"; - os << " void set_" << field_name - << "(toolbelt::BufferOffset offset) {\n"; - os << " " << member_name << ".SetOffset" << suffix << "(offset);\n"; - os << " }\n"; + os << " return " << member_name << ".Mutable<" + << std::to_string(union_index) << ", " + << MessageName(field->field->message_type()) << ">();\n"; + os << " }\n"; - if (union_index == -1) { - os << " const " << field->c_type << "& " << sanitized_field_name - << "() const {\n"; - os << " return " << member_name << ".Get();\n"; - os << " }\n"; - os << " bool has_" << field_name << "() const {\n"; - os << " return " << member_name << ".IsPresent();\n"; - os << " }\n"; - os << " " << field->c_type << "* mutable_" << field_name << "() {\n"; - os << " return " << member_name << ".Mutable();\n"; - os << " }\n"; - } else { - // Union members need to be accessed by index and type. - os << " const " << field->c_type << "& " << sanitized_field_name - << "() const {\n"; - os << " return " << member_name << ".template GetReference<" - << std::to_string(union_index) << ", " - << MessageName(field->field->message_type()) << ">();\n"; - os << " }\n"; - os << " " << field->c_type << "* mutable_" << field_name << "() {\n"; - // Clear all other union members. - for (size_t i = 0; i < union_field->members.size(); i++) { - if (i != size_t(union_index)) { - os << " " << member_name << ".Clear<" << i << ">();\n"; - } + os << " bool has_" << field_name << "() const {\n"; + os << " return " << member_name << ".template IsPresent<" + << std::to_string(union_index) << ">();\n"; + os << " }\n"; } - os << " return " << member_name << ".Mutable<" - << std::to_string(union_index) << ", " - << MessageName(field->field->message_type()) << ">();\n"; - os << " }\n"; - - os << " bool has_" << field_name << "() const {\n"; - os << " return " << member_name << ".template IsPresent<" - << std::to_string(union_index) << ">();\n"; - os << " }\n"; - } - // Any-typed message fields reuse the standard message accessors above - // (mutable_X() returns a phaser::AnyMessage, which exposes the full Any - // API: PackFrom/UnpackTo/Is/etc.), so no field-specific generation is - // needed here. - - break; - case google::protobuf::FieldDescriptor::TYPE_GROUP: - std::cerr << "Groups are not supported\n"; - exit(1); + // Any-typed message fields reuse the standard message accessors above + // (mutable_X() returns a phaser::AnyMessage, which exposes the full Any + // API: PackFrom/UnpackTo/Is/etc.), so no field-specific generation is + // needed here. + + break; + case google::protobuf::FieldDescriptor::TYPE_GROUP: + std::cerr << "Groups are not supported\n"; + exit(1); } } } -void MessageGenerator::GenerateUnionProtobufAccessors(std::ostream &os) { - for (auto & [ oneof, u ] : unions_) { +void MessageGenerator::GenerateUnionProtobufAccessors(std::ostream& os) { + for (auto& [oneof, u] : unions_) { os << "\n // Oneof " << oneof->name() << "\n"; os << " int " << oneof->name() << "_case() const {\n"; os << " return " << u->member_name << ".Discriminator();\n"; os << " }\n"; for (size_t i = 0; i < u->members.size(); i++) { - auto &field = u->members[i]; + auto& field = u->members[i]; GenerateFieldProtobufAccessors(field, u, int(i), os); } } } -void MessageGenerator::GenerateNestedTypes(std::ostream &os) { - for (auto &msg : nested_message_gens_) { +void MessageGenerator::GenerateNestedTypes(std::ostream& os) { + for (auto& msg : nested_message_gens_) { os << " using " << msg->message_->name() << " = " << MessageName(msg->message_) << ";\n"; } - for (auto &enum_gen : enum_gens_) { + for (auto& enum_gen : enum_gens_) { os << " using " << enum_gen->enum_->name() << " = " << EnumName(enum_gen->enum_) << ";\n"; // Generate enum constant aliases. for (int i = 0; i < enum_gen->enum_->value_count(); i++) { - const google::protobuf::EnumValueDescriptor *value = + const google::protobuf::EnumValueDescriptor* value = enum_gen->enum_->value(i); os << " static constexpr " << enum_gen->enum_->name() << " " << value->name() << " = " << EnumName(enum_gen->enum_) << "_" @@ -1285,15 +1288,15 @@ void MessageGenerator::GenerateNestedTypes(std::ostream &os) { } } -void MessageGenerator::GenerateFieldNumbers(std::ostream &os) { - for (auto &field : fields_) { +void MessageGenerator::GenerateFieldNumbers(std::ostream& os) { + for (auto& field : fields_) { std::string name(field->field->camelcase_name()); name = absl::StrFormat("k%c%s", toupper(name[0]), name.substr(1)); os << " static constexpr int " << name << "FieldNumber = " << field->field->number() << ";\n"; } - for (auto & [ oneof, u ] : unions_) { - for (auto &field : u->members) { + for (auto& [oneof, u] : unions_) { + for (auto& field : u->members) { std::string name(field->field->camelcase_name()); name = absl::StrFormat("k%c%s", toupper(name[0]), name.substr(1)); os << " static constexpr int " << name @@ -1302,14 +1305,14 @@ void MessageGenerator::GenerateFieldNumbers(std::ostream &os) { } } -void MessageGenerator::GenerateSerializedSize(std::ostream &os, bool decl) { +void MessageGenerator::GenerateSerializedSize(std::ostream& os, bool decl) { if (decl) { os << " size_t SerializedSize() const;\n"; return; } os << "size_t " << MessageName(message_) << "::SerializedSize() const {\n"; os << " size_t size = 0;\n"; - for (auto &field : fields_) { + for (auto& field : fields_) { if (field->field->is_repeated()) { os << " size += " << field->member_name << ".SerializedSize();\n"; } else { @@ -1318,10 +1321,10 @@ void MessageGenerator::GenerateSerializedSize(std::ostream &os, bool decl) { os << " }\n"; } } - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { os << " switch (" << u->member_name << ".Discriminator()) {\n"; for (size_t i = 0; i < u->members.size(); i++) { - auto &field = u->members[i]; + auto& field = u->members[i]; os << " case " << field->field->number() << ":\n"; os << " size += " << u->member_name << ".SerializedSize<" << i << ">(" << field->field->number() << ");\n"; @@ -1333,14 +1336,14 @@ void MessageGenerator::GenerateSerializedSize(std::ostream &os, bool decl) { os << "}\n\n"; } -void MessageGenerator::GenerateSerializer(std::ostream &os, bool decl) { +void MessageGenerator::GenerateSerializer(std::ostream& os, bool decl) { if (decl) { os << " absl::Status Serialize(::phaser::ProtoBuffer &buffer) const;\n"; return; } os << "absl::Status " << MessageName(message_) << "::Serialize(::phaser::ProtoBuffer &buffer) const {\n"; - for (auto &field : fields_) { + for (auto& field : fields_) { if (field->field->is_repeated()) { os << " if (absl::Status status = " << field->member_name << ".Serialize(buffer); !status.ok()) return status;\n"; @@ -1351,10 +1354,10 @@ void MessageGenerator::GenerateSerializer(std::ostream &os, bool decl) { os << " }\n"; } } - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { os << " switch (" << u->member_name << ".Discriminator()) {\n"; for (size_t i = 0; i < u->members.size(); i++) { - auto &field = u->members[i]; + auto& field = u->members[i]; os << " case " << field->field->number() << ":\n"; os << " if (absl::Status status = " << u->member_name << ".Serialize<" << i << ">(" << field->field->number() @@ -1367,7 +1370,7 @@ void MessageGenerator::GenerateSerializer(std::ostream &os, bool decl) { os << "}\n\n"; } -void MessageGenerator::GenerateDeserializer(std::ostream &os, bool decl) { +void MessageGenerator::GenerateDeserializer(std::ostream& os, bool decl) { if (decl) { os << " absl::Status Deserialize(::phaser::ProtoBuffer &buffer);\n"; return; @@ -1384,15 +1387,15 @@ void MessageGenerator::GenerateDeserializer(std::ostream &os, bool decl) { uint32_t field_number = *tag >> ::phaser::ProtoBuffer::kFieldIdShift; switch (field_number) { )XXX"; - for (auto &field : fields_) { + for (auto& field : fields_) { os << " case " << field->field->number() << ":\n"; os << " if (absl::Status status = " << field->member_name << ".Deserialize(buffer); !status.ok()) return status;\n"; os << " break;\n"; } - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { for (size_t i = 0; i < u->members.size(); i++) { - auto &field = u->members[i]; + auto& field = u->members[i]; os << " case " << field->field->number() << ":\n"; os << " if (absl::Status status = " << u->member_name << ".Deserialize<" << i << ">(" << field->field->number() @@ -1412,7 +1415,7 @@ void MessageGenerator::GenerateDeserializer(std::ostream &os, bool decl) { os << "}\n\n"; } -void MessageGenerator::GenerateProtobufSerialization(std::ostream &os) { +void MessageGenerator::GenerateProtobufSerialization(std::ostream& os) { os << R"XXX( // This is the size of the message on the wire. It is not the serialized protobuf size. size_t ByteSizeLong() const { @@ -1454,36 +1457,36 @@ void MessageGenerator::GenerateProtobufSerialization(std::ostream &os) { )XXX"; } -void MessageGenerator::GenerateIndent(std::ostream &os) { +void MessageGenerator::GenerateIndent(std::ostream& os) { os << " void Indent([[maybe_unused]] int indent) const {\n"; - for (auto &field : fields_) { + for (auto& field : fields_) { os << " " << field->member_name << ".Indent(indent);\n"; } - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { os << " " << u->member_name << ".Indent(indent);\n"; } os << " }\n\n"; } -void MessageGenerator::GenerateStreamer(std::ostream &os) { - os << "inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] const " +void MessageGenerator::GenerateStreamer(std::ostream& os) { + os << "inline std::ostream &operator<<(std::ostream &os, [[maybe_unused]] " + "const " << MessageName(message_) << " &msg) {\n"; // We need to print the fields in the same order as they appear in the // message definition. This is to match the output from the protobuf // printer. - for (auto &field : fields_in_order_) { + for (auto& field : fields_in_order_) { if (field->IsUnion()) { auto u = std::static_pointer_cast(field); os << " switch (msg." << u->member_name << ".Discriminator()) {\n"; for (size_t i = 0; i < u->members.size(); i++) { - auto &member = u->members[i]; + auto& member = u->members[i]; os << " case " << member->field->number() << ":\n"; os << " msg." << u->member_name << ".PrintIndent(os);\n"; if (member->field->type() == google::protobuf::FieldDescriptor::TYPE_MESSAGE) { os << " os << \"" << member->field->name() << " \";\n"; } else { - os << " os << \"" << member->field->name() << ": \";\n"; } os << " msg." << u->member_name << ".Print<" << i << ">(os);\n"; @@ -1527,7 +1530,7 @@ void MessageGenerator::GenerateStreamer(std::ostream &os) { os << "}\n\n"; } -void MessageGenerator::GenerateCopy(std::ostream &os, bool decl) { +void MessageGenerator::GenerateCopy(std::ostream& os, bool decl) { if (decl) { os << " template \n"; os << " absl::Status CloneFrom(const T & other);\n\n"; @@ -1543,7 +1546,7 @@ void MessageGenerator::GenerateCopy(std::ostream &os, bool decl) { os << "template \n"; os << "inline absl::Status " << MessageName(message_) << "::CloneFrom([[maybe_unused]] const T & other) {\n"; - for (auto &field : fields_) { + for (auto& field : fields_) { if (field->field->is_repeated()) { os << " for (auto& v : other." << field->field->name() << "()) {\n"; if (field->field->type() == @@ -1571,10 +1574,10 @@ void MessageGenerator::GenerateCopy(std::ostream &os, bool decl) { } } if (!unions_.empty()) { - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { os << " switch (other." << u->member_name << ".Discriminator()) {\n"; for (size_t i = 0; i < u->members.size(); i++) { - auto &field = u->members[i]; + auto& field = u->members[i]; os << " case " << field->field->number() << ":\n"; os << " if (absl::Status s = " << u->member_name << ".template CloneFrom<" << i << ">(other." << field->field->name() @@ -1589,7 +1592,7 @@ void MessageGenerator::GenerateCopy(std::ostream &os, bool decl) { } // DebugString -void MessageGenerator::GenerateDebugString(std::ostream &os) { +void MessageGenerator::GenerateDebugString(std::ostream& os) { os << R"XXX( std::string DebugString() const { std::ostringstream os; @@ -1600,7 +1603,7 @@ void MessageGenerator::GenerateDebugString(std::ostream &os) { )XXX"; } -void MessageGenerator::GeneratePhaserBank(std::ostream &os) { +void MessageGenerator::GeneratePhaserBank(std::ostream& os) { os << "static void " << MessageName(message_) << "StreamTo(const ::phaser::Message& msg, std::ostream& os, int indent) " "{\n"; @@ -1684,7 +1687,7 @@ void MessageGenerator::GeneratePhaserBank(std::ostream &os) { os << " [[maybe_unused]] const " << MessageName(message_) << " *m = static_cast(&msg);\n"; os << " switch (number) {\n"; - for (auto &field : fields_) { + for (auto& field : fields_) { os << " case " << field->field->number() << ":\n"; if (field->field->is_repeated()) { os << " return m->" << field->field->name() << "_size() > 0;\n"; @@ -1692,9 +1695,9 @@ void MessageGenerator::GeneratePhaserBank(std::ostream &os) { os << " return m->has_" << field->field->name() << "();\n"; } } - for (auto & [ oneof, u ] : unions_) { + for (auto& [oneof, u] : unions_) { for (size_t i = 0; i < u->members.size(); i++) { - auto &field = u->members[i]; + auto& field = u->members[i]; os << " case " << field->field->number() << ":\n"; os << " return m->" << oneof->name() << "_case() == " << field->field->number() << ";\n"; @@ -1776,7 +1779,7 @@ void MessageGenerator::GeneratePhaserBank(std::ostream &os) { void MessageGenerator::GenerateFieldInfo(int index, std::shared_ptr field, std::shared_ptr union_field, - int union_index, std::ostream &os) { + int union_index, std::ostream& os) { std::string field_type = FieldInfoType(field->field); std::string fixed_size_string = field->field->type() == @@ -1838,7 +1841,7 @@ void MessageGenerator::GenerateFieldInfo(int index, os << ");\n"; } -void MessageGenerator::GenerateMessageInfo(std::ostream &os, bool decl) { +void MessageGenerator::GenerateMessageInfo(std::ostream& os, bool decl) { if (decl) { os << " static const ::phaser::MessageInfo* GetMessageInfoStatic();\n"; os << " const ::phaser::MessageInfo* GetMessageInfo() const override {\n"; @@ -1859,7 +1862,7 @@ void MessageGenerator::GenerateMessageInfo(std::ostream &os, bool decl) { // Generate fields_in_order. int index = 0; os << " info.fields_in_order.resize(" << fields_in_order_.size() << ");\n"; - for (auto &field : fields_in_order_) { + for (auto& field : fields_in_order_) { if (field->IsUnion()) { auto u = std::static_pointer_cast(field); os << " info.fields_in_order[" << index++ @@ -1878,7 +1881,7 @@ void MessageGenerator::GenerateMessageInfo(std::ostream &os, bool decl) { )XXX"; // Generate oneof fields. index = 0; - for (auto &field : fields_in_order_) { + for (auto& field : fields_in_order_) { if (field->IsUnion()) { auto u = std::static_pointer_cast(field); os << " {\n"; @@ -1888,7 +1891,7 @@ void MessageGenerator::GenerateMessageInfo(std::ostream &os, bool decl) { << index << "]);\n"; os << " u->fields_in_order.resize(" << u->members.size() << ");\n"; for (size_t i = 0; i < u->members.size(); i++) { - auto &member = u->members[i]; + auto& member = u->members[i]; GenerateFieldInfo(static_cast(i), member, u, static_cast(i), os); } @@ -1907,4 +1910,4 @@ void MessageGenerator::GenerateMessageInfo(std::ostream &os, bool decl) { os << "#pragma clang diagnostic pop\n"; } -} // namespace phaser +} // namespace phaser diff --git a/phaser/compiler/message_gen.h b/phaser/compiler/message_gen.h index 5c004b7..97f8dc3 100644 --- a/phaser/compiler/message_gen.h +++ b/phaser/compiler/message_gen.h @@ -3,28 +3,34 @@ // See LICENSE file for licensing information. #pragma once +#include +#include +#include +#include + #include "absl/container/flat_hash_map.h" #include "absl/container/flat_hash_set.h" #include "absl/status/status.h" #include "google/protobuf/descriptor.h" #include "phaser/compiler/enum_gen.h" -#include -#include -#include -#include namespace phaser { struct FieldInfo { // Constructor. - FieldInfo(const google::protobuf::FieldDescriptor *f, uint32_t o, uint32_t i, - const std::string &name, const std::string &mtype, - const std::string &ctype, uint32_t size) - : field(f), offset(o), id(i), member_name(name), member_type(mtype), - c_type(ctype), binary_size(size) {} + FieldInfo(const google::protobuf::FieldDescriptor* f, uint32_t o, uint32_t i, + const std::string& name, const std::string& mtype, + const std::string& ctype, uint32_t size) + : field(f), + offset(o), + id(i), + member_name(name), + member_type(mtype), + c_type(ctype), + binary_size(size) {} virtual ~FieldInfo() = default; virtual bool IsUnion() const { return false; } - const google::protobuf::FieldDescriptor *field; + const google::protobuf::FieldDescriptor* field; uint32_t offset; uint32_t id; std::string member_name; @@ -35,21 +41,22 @@ struct FieldInfo { struct UnionInfo : public FieldInfo { // Constructor - UnionInfo(const google::protobuf::OneofDescriptor *o, uint32_t size, - const std::string &name, const std::string &type) + UnionInfo(const google::protobuf::OneofDescriptor* o, uint32_t size, + const std::string& name, const std::string& type) : FieldInfo(nullptr, 0, 0, name, type, "", size), oneof(o) {} bool IsUnion() const override { return true; } - const google::protobuf::OneofDescriptor *oneof; + const google::protobuf::OneofDescriptor* oneof; std::vector> members; }; class MessageGenerator { -public: - MessageGenerator(const google::protobuf::Descriptor *message, - const std::string &added_namespace, - const std::string &package_name, + public: + MessageGenerator(const google::protobuf::Descriptor* message, + const std::string& added_namespace, + const std::string& package_name, bool generate_active_message = false) - : message_(message), added_namespace_(added_namespace), + : message_(message), + added_namespace_(added_namespace), package_name_(package_name), generate_active_message_(generate_active_message) { for (int i = 0; i < message_->nested_type_count(); i++) { @@ -64,73 +71,72 @@ class MessageGenerator { } } - void GenerateHeader(std::ostream &os); - void GenerateSource(std::ostream &os); + void GenerateHeader(std::ostream& os); + void GenerateSource(std::ostream& os); - void GenerateFieldDeclarations(std::ostream &os); + void GenerateFieldDeclarations(std::ostream& os); - void GenerateEnums(std::ostream &os); + void GenerateEnums(std::ostream& os); -private: + private: void CompileFields(); void CompileUnions(); void FinalizeOffsetsAndSizes(); - void GenerateDefaultConstructor(std::ostream &os, bool decl); - void GenerateInternalDefaultConstructor(std::ostream &os, bool decl); - void GenerateMainConstructor(std::ostream &os, bool decl); - void GenerateConstructors(std::ostream &os, bool decl); - void GenerateFieldInitializers(std::ostream &os, const char *sep = ": "); - void GenerateSizeFunctions(std::ostream &os); - void GenerateFieldMetadata(std::ostream &os); - void GenerateCreators(std::ostream &os, bool decl); - void GenerateClear(std::ostream &os, bool decl); - - void GenerateProtobufAccessors(std::ostream &os); - void GenerateFieldProtobufAccessors(std::ostream &os); + void GenerateDefaultConstructor(std::ostream& os, bool decl); + void GenerateInternalDefaultConstructor(std::ostream& os, bool decl); + void GenerateMainConstructor(std::ostream& os, bool decl); + void GenerateConstructors(std::ostream& os, bool decl); + void GenerateFieldInitializers(std::ostream& os, const char* sep = ": "); + void GenerateSizeFunctions(std::ostream& os); + void GenerateFieldMetadata(std::ostream& os); + void GenerateCreators(std::ostream& os, bool decl); + void GenerateClear(std::ostream& os, bool decl); + + void GenerateProtobufAccessors(std::ostream& os); + void GenerateFieldProtobufAccessors(std::ostream& os); void GenerateFieldProtobufAccessors(std::shared_ptr field, std::shared_ptr union_field, - int union_index, std::ostream &os); - void GenerateUnionProtobufAccessors(std::ostream &os); - void GenerateNestedTypes(std::ostream &os); - void GenerateFieldNumbers(std::ostream &os); - void GenerateSerializedSize(std::ostream &os, bool decl); - void GenerateSerializer(std::ostream &os, bool decl); - void GenerateDeserializer(std::ostream &os, bool decl); - - void GenerateProtobufSerialization(std::ostream &os); - void GenerateIndent(std::ostream &os); - void GenerateStreamer(std::ostream &os); - bool IsAny(const google::protobuf::Descriptor *desc); - bool IsAny(const google::protobuf::FieldDescriptor *field); - void GenerateCopy(std::ostream &os, bool decl); - void GenerateDebugString(std::ostream &os); - void GeneratePhaserBank(std::ostream &os); - void GenerateMessageInfo(std::ostream &os, bool decl); + int union_index, std::ostream& os); + void GenerateUnionProtobufAccessors(std::ostream& os); + void GenerateNestedTypes(std::ostream& os); + void GenerateFieldNumbers(std::ostream& os); + void GenerateSerializedSize(std::ostream& os, bool decl); + void GenerateSerializer(std::ostream& os, bool decl); + void GenerateDeserializer(std::ostream& os, bool decl); + + void GenerateProtobufSerialization(std::ostream& os); + void GenerateIndent(std::ostream& os); + void GenerateStreamer(std::ostream& os); + bool IsAny(const google::protobuf::Descriptor* desc); + bool IsAny(const google::protobuf::FieldDescriptor* field); + void GenerateCopy(std::ostream& os, bool decl); + void GenerateDebugString(std::ostream& os); + void GeneratePhaserBank(std::ostream& os); + void GenerateMessageInfo(std::ostream& os, bool decl); void GenerateFieldInfo(int index, std::shared_ptr field, std::shared_ptr union_field, - int union_index, std::ostream &os); + int union_index, std::ostream& os); - std::string EnumName(const google::protobuf::EnumDescriptor *desc); + std::string EnumName(const google::protobuf::EnumDescriptor* desc); // If is_ref is true, it changes how the generator treats google.protobuf.Any. // For a reference to a google.protobuf.Any, we use an internal // ::phaser::AnyMessage type. - std::string MessageName(const google::protobuf::Descriptor *desc, + std::string MessageName(const google::protobuf::Descriptor* desc, bool is_ref = false); - std::string FieldCFieldType(const google::protobuf::FieldDescriptor *field); - std::string FieldCType(const google::protobuf::FieldDescriptor *field); - std::string - FieldRepeatedCType(const google::protobuf::FieldDescriptor *field); - std::string FieldUnionCType(const google::protobuf::FieldDescriptor *field); - uint32_t FieldBinarySize(const google::protobuf::FieldDescriptor *field); - std::string FieldInfoType(const google::protobuf::FieldDescriptor *field); - - const google::protobuf::Descriptor *message_; + std::string FieldCFieldType(const google::protobuf::FieldDescriptor* field); + std::string FieldCType(const google::protobuf::FieldDescriptor* field); + std::string FieldRepeatedCType( + const google::protobuf::FieldDescriptor* field); + std::string FieldUnionCType(const google::protobuf::FieldDescriptor* field); + uint32_t FieldBinarySize(const google::protobuf::FieldDescriptor* field); + std::string FieldInfoType(const google::protobuf::FieldDescriptor* field); + + const google::protobuf::Descriptor* message_; std::vector> nested_message_gens_; std::vector> enum_gens_; std::vector> fields_; - std::map> + std::map> unions_; std::vector> fields_in_order_; uint32_t binary_size_ = 4; @@ -140,4 +146,4 @@ class MessageGenerator { bool generate_active_message_ = false; }; -} // namespace phaser +} // namespace phaser diff --git a/phaser/perf_test.cc b/phaser/perf_test.cc index b7cbb90..6fdb6fc 100644 --- a/phaser/perf_test.cc +++ b/phaser/perf_test.cc @@ -5,6 +5,10 @@ // It would be in your interests to build this optimized or you will be // waiting a while... +#include + +#include + #include "absl/strings/str_format.h" #include "phaser/runtime/runtime.h" #include "phaser/testdata/vision.pb.h" @@ -12,8 +16,6 @@ #include "toolbelt/clock.h" #include "toolbelt/hexdump.h" #include "toolbelt/payload_buffer.h" -#include -#include // This test builds a camera image in a fixed size buffer. The protobuf version // has to serialize it into the buffer, but with phaser we build it directly in @@ -264,7 +266,7 @@ TEST(PerfTest, ProtobufAllLidars) { constexpr int kNumLidars = 100; constexpr int kNumBeams = 100000; for (int j = 0; j < kNumLidars; ++j) { - robot::LidarScan *scan = lidars.add_scans(); + robot::LidarScan* scan = lidars.add_scans(); scan->mutable_header()->set_timestamp(1234567890); for (int k = 0; k < kNumBeams; ++k) { @@ -280,7 +282,7 @@ TEST(PerfTest, ProtobufAllLidars) { ASSERT_EQ(lidars2.header().timestamp(), 1234567890); ASSERT_EQ(lidars2.scans_size(), kNumLidars); for (int j = 0; j < kNumLidars; ++j) { - const robot::LidarScan &scan = lidars2.scans(j); + const robot::LidarScan& scan = lidars2.scans(j); ASSERT_EQ(scan.header().timestamp(), 1234567890); ASSERT_EQ(scan.beams_size(), kNumBeams); for (int k = 0; k < kNumBeams; ++k) { @@ -310,7 +312,7 @@ TEST(PerfTest, PhaserAllLidarsPush) { constexpr int kNumBeams = 100000; lidars.reserve_scans(kNumLidars); for (int j = 0; j < kNumLidars; ++j) { - robot::phaser::LidarScan *scan = lidars.add_scans(); + robot::phaser::LidarScan* scan = lidars.add_scans(); scan->mutable_header()->set_timestamp(1234567890); scan->reserve_beams(kNumBeams); @@ -325,7 +327,7 @@ TEST(PerfTest, PhaserAllLidarsPush) { ASSERT_EQ(lidars2.header().timestamp(), 1234567890); ASSERT_EQ(lidars2.scans_size(), kNumLidars); for (int j = 0; j < kNumLidars; ++j) { - const robot::phaser::LidarScan &scan = lidars2.scans(j); + const robot::phaser::LidarScan& scan = lidars2.scans(j); ASSERT_EQ(scan.header().timestamp(), 1234567890); ASSERT_EQ(scan.beams_size(), kNumBeams); for (int k = 0; k < kNumBeams; ++k) { @@ -355,7 +357,7 @@ TEST(PerfTest, PhaserAllLidarsZeroCopy) { constexpr int kNumBeams = 100000; // Allocate all the scans at once. - std::vector lidar_scans = + std::vector lidar_scans = lidars.allocate_scans(kNumLidars); for (auto scan : lidar_scans) { scan->mutable_header()->set_timestamp(1234567890); @@ -371,9 +373,9 @@ TEST(PerfTest, PhaserAllLidarsZeroCopy) { robot::phaser::AllLidars::CreateReadonly(buffer.data(), lidars.Size()); ASSERT_EQ(lidars2.header().timestamp(), 1234567890); ASSERT_EQ(lidars2.scans_size(), kNumLidars); - auto &scans = lidars2.scans(); + auto& scans = lidars2.scans(); for (int j = 0; j < kNumLidars; ++j) { - const robot::phaser::LidarScan &scan = *(scans[j]); + const robot::phaser::LidarScan& scan = *(scans[j]); ASSERT_EQ(scan.header().timestamp(), 1234567890); ASSERT_EQ(scan.beams_size(), kNumBeams); absl::Span beams = scan.beams_as_span(); @@ -387,7 +389,7 @@ TEST(PerfTest, PhaserAllLidarsZeroCopy) { std::cout << absl::StrFormat("Phaser zero-copy: %d ns\n", end - start); } -int main(int argc, char **argv) { +int main(int argc, char** argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); diff --git a/phaser/phaser_test.cc b/phaser/phaser_test.cc index 9bb710b..f78c1ef 100644 --- a/phaser/phaser_test.cc +++ b/phaser/phaser_test.cc @@ -3,15 +3,17 @@ // All Rights Reserved // See LICENSE file for licensing information. -#include "test_helpers.h" +#include + +#include + #include "absl/strings/str_format.h" #include "phaser/runtime/runtime.h" #include "phaser/testdata/TestMessage.pb.h" #include "phaser/testdata/TestMessage.phaser.h" +#include "test_helpers.h" #include "toolbelt/hexdump.h" #include "toolbelt/payload_buffer.h" -#include -#include TEST(PhaserTest, ProtobufCompat) { foo::bar::phaser::TestMessage msg; @@ -93,7 +95,7 @@ TEST(PhaserTest, ProtobufCompat) { } TEST(PhaserTest, Expansion) { - foo::bar::phaser::TestMessage msg; // 1K buffer by default. + foo::bar::phaser::TestMessage msg; // 1K buffer by default. msg.set_x(1234); msg.set_y(5678); msg.set_s("hello world"); @@ -385,7 +387,7 @@ TEST(PhaserTest, GarbageWithValidMagic) { buffer[i] = static_cast(rand() & 0xff); } // Set the magic. - *reinterpret_cast(buffer) = ::toolbelt::kFixedBufferMagic; + *reinterpret_cast(buffer) = ::toolbelt::kFixedBufferMagic; auto msg = foo::bar::phaser::TestMessage::CreateReadonly(buffer, sizeof(buffer)); @@ -424,11 +426,11 @@ TEST(PhaserTest, GarbageWithTailoring) { buffer[i] = static_cast(rand() & 0xff); } // Set the magic and the header fields. - *reinterpret_cast(buffer) = ::toolbelt::kFixedBufferMagic; - *reinterpret_cast(buffer + 4) = 0x1c; // message location. - *reinterpret_cast(buffer + 8) = 1024; // hwm. - *reinterpret_cast(buffer + 12) = 1000; // full_size - *reinterpret_cast(buffer + 16) = 50; // free list + *reinterpret_cast(buffer) = ::toolbelt::kFixedBufferMagic; + *reinterpret_cast(buffer + 4) = 0x1c; // message location. + *reinterpret_cast(buffer + 8) = 1024; // hwm. + *reinterpret_cast(buffer + 12) = 1000; // full_size + *reinterpret_cast(buffer + 16) = 50; // free list auto msg = foo::bar::phaser::TestMessage::CreateReadonly(buffer, sizeof(buffer)); @@ -481,7 +483,7 @@ TEST(PhaserTest, Reflection) { msg.set_u1a(4321); msg.set_u2a(8765); - absl::StatusOr info = + absl::StatusOr info = ::phaser::PhaserBankMessageInfo("foo.bar.TestMessage"); ASSERT_TRUE(info.ok()); ASSERT_NE(nullptr, *info); @@ -492,8 +494,8 @@ TEST(PhaserTest, Reflection) { ASSERT_EQ(100, field_x->number); ASSERT_EQ(::phaser::FieldType::kFieldInt32, field_x->type); - ::phaser::PrimitiveFieldInfo *pf_x = - static_cast<::phaser::PrimitiveFieldInfo *>(field_x.get()); + ::phaser::PrimitiveFieldInfo* pf_x = + static_cast<::phaser::PrimitiveFieldInfo*>(field_x.get()); ASSERT_NE(nullptr, pf_x); ASSERT_FALSE(pf_x->is_repeated); ASSERT_FALSE(pf_x->is_packed); @@ -508,7 +510,7 @@ TEST(PhaserTest, Reflection) { int x_number = it->second->number; // Let's print all the fields. - for (const auto &field : (*info)->fields_in_order) { + for (const auto& field : (*info)->fields_in_order) { std::cout << field->name << " " << field->number << " " << static_cast(field->type) << " " << field->offset << std::endl; @@ -517,7 +519,7 @@ TEST(PhaserTest, Reflection) { ::phaser::PhaserBankHasField("foo.bar.TestMessage", msg, x_number); ASSERT_TRUE(has_x.ok()); - absl::StatusOr<::phaser::Int32Field<> *> x = + absl::StatusOr<::phaser::Int32Field<>*> x = ::phaser::PhaserBankGetFieldByNumber<::phaser::Int32Field<>>( "foo.bar.TestMessage", msg, 100); ASSERT_TRUE(x.ok()); @@ -534,11 +536,11 @@ TEST(PhaserTest, Reflection) { ASSERT_TRUE(vi32.ok()); ASSERT_NE(nullptr, *vi32); - ::phaser::PrimitiveVectorField &vi32r = **vi32; + ::phaser::PrimitiveVectorField& vi32r = **vi32; ASSERT_EQ(3, vi32r.Size()); ASSERT_EQ(1, vi32r[0]); - for (auto &v : vi32r) { + for (auto& v : vi32r) { std::cout << v << std::endl; } } @@ -571,7 +573,7 @@ TEST(DebugRedaction, DoesNotStripMidContentMarker) { ASSERT_EQ(original, s); } -int main(int argc, char **argv) { +int main(int argc, char** argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); diff --git a/phaser/runtime/any.h b/phaser/runtime/any.h index f683fe1..81e0873 100644 --- a/phaser/runtime/any.h +++ b/phaser/runtime/any.h @@ -9,18 +9,20 @@ // 1. A string called 'type_url' that specifies the type of the message // 2. A bytes field called 'value' that contains a message. // -// In memory, `value` holds phaser binary (zero-copy via PackFrom / As / MutableAny). -// On protobuf wire, `value` is length-delimited *protobuf* bytes of the inner -// message; Serialize/Deserialize transcode at this boundary. +// In memory, `value` holds phaser binary (zero-copy via PackFrom / As / +// MutableAny). On protobuf wire, `value` is length-delimited *protobuf* bytes +// of the inner message; Serialize/Deserialize transcode at this boundary. // -#include "phaser/runtime/fields.h" -#include "phaser/runtime/phaser_bank.h" -#include "toolbelt/hexdump.h" #include + #include #include #include +#include "phaser/runtime/fields.h" +#include "phaser/runtime/phaser_bank.h" +#include "toolbelt/hexdump.h" + namespace phaser { #pragma clang diagnostic push @@ -28,7 +30,7 @@ namespace phaser { // Hand-coded message class that represents a google.protobuf.Any message. class AnyMessage : public Message { -public: + public: AnyMessage(phaser::InternalDefault /*d*/) : type_url_(offsetof(AnyMessage, type_url_), HeaderSize() + 0, 0, 1), value_(offsetof(AnyMessage, value_), HeaderSize() + 4, 1, 2) {} @@ -61,26 +63,32 @@ class AnyMessage : public Message { std::string GetName() const override { return Name(); } std::string GetFullName() const override { return FullName(); } - friend std::ostream &operator<<(std::ostream &os, const AnyMessage &msg); + friend std::ostream& operator<<(std::ostream& os, const AnyMessage& msg); void Indent(int indent) { type_url_.Indent(indent); value_.Indent(indent); } - const MessageInfo *GetMessageInfo() const override { - return nullptr; // Implement this. + const MessageInfo* GetMessageInfo() const override { + return nullptr; // Implement this. } // Protobuf accessors. std::string_view type_url() const { return type_url_.Get(); } - template void set_type_url(Str str) { type_url_.Set(str); } + template + void set_type_url(Str str) { + type_url_.Set(str); + } void clear_type_url() { type_url_.Clear(); } bool has_type_url() const { return type_url_.IsPresent(); } std::string_view value() const { return value_.Get(); } - template void set_value(Str str) { value_.Set(str); } - void set_value(const char *data, size_t size) { value_.Set(data, size); } + template + void set_value(Str str) { + value_.Set(str); + } + void set_value(const char* data, size_t size) { value_.Set(data, size); } void clear_value() { value_.Clear(); } bool has_value() const { return value_.IsPresent(); } @@ -89,10 +97,10 @@ class AnyMessage : public Message { value_.Clear(); } - bool operator==(const AnyMessage &other) const { + bool operator==(const AnyMessage& other) const { return type_url_ == other.type_url_ && value_ == other.value_; } - bool operator!=(const AnyMessage &other) const { + bool operator!=(const AnyMessage& other) const { return type_url_ != other.type_url_ || value_ != other.value_; } size_t SerializedSize() const { @@ -101,7 +109,7 @@ class AnyMessage : public Message { size += type_url_.SerializedSize(); } if (value_.IsPresent()) { - absl::StatusOr embedded = EmbeddedMessageForWire(); + absl::StatusOr embedded = EmbeddedMessageForWire(); if (!embedded.ok()) { return 0; } @@ -116,14 +124,14 @@ class AnyMessage : public Message { return size; } - absl::Status Serialize(phaser::ProtoBuffer &buffer) const { + absl::Status Serialize(phaser::ProtoBuffer& buffer) const { if (type_url_.IsPresent()) { if (absl::Status status = type_url_.Serialize(buffer); !status.ok()) { return status; } } if (value_.IsPresent()) { - absl::StatusOr embedded = EmbeddedMessageForWire(); + absl::StatusOr embedded = EmbeddedMessageForWire(); if (!embedded.ok()) { return embedded.status(); } @@ -148,7 +156,7 @@ class AnyMessage : public Message { return absl::OkStatus(); } - absl::Status Deserialize(phaser::ProtoBuffer &buffer) { + absl::Status Deserialize(phaser::ProtoBuffer& buffer) { clear_type_url(); clear_value(); @@ -163,28 +171,28 @@ class AnyMessage : public Message { } uint32_t field_number = *tag >> phaser::ProtoBuffer::kFieldIdShift; switch (field_number) { - case 1: { - absl::StatusOr url = buffer.DeserializeString(); - if (!url.ok()) { - return url.status(); - } - pending_type_url = std::string(*url); - break; - } - case 2: { - absl::StatusOr> wire = - buffer.DeserializeLengthDelimited(); - if (!wire.ok()) { - return wire.status(); + case 1: { + absl::StatusOr url = buffer.DeserializeString(); + if (!url.ok()) { + return url.status(); + } + pending_type_url = std::string(*url); + break; } - pending_wire_value = - std::string(wire->data(), wire->data() + wire->size()); - break; - } - default: - if (absl::Status status = buffer.SkipTag(*tag); !status.ok()) { - return status; + case 2: { + absl::StatusOr> wire = + buffer.DeserializeLengthDelimited(); + if (!wire.ok()) { + return wire.status(); + } + pending_wire_value = + std::string(wire->data(), wire->data() + wire->size()); + break; } + default: + if (absl::Status status = buffer.SkipTag(*tag); !status.ok()) { + return status; + } } } @@ -206,7 +214,7 @@ class AnyMessage : public Message { return type; } - absl::Status CloneFrom(const AnyMessage &msg) { + absl::Status CloneFrom(const AnyMessage& msg) { if (msg.has_type_url()) { type_url_.Set(msg.type_url()); } @@ -216,12 +224,12 @@ class AnyMessage : public Message { "Any value without type_url cannot be cloned"); } const std::string type = msg.MessageTypeName(); - absl::StatusOr dest = AllocateEmbeddedMessage(type); + absl::StatusOr dest = AllocateEmbeddedMessage(type); if (!dest.ok()) { return dest.status(); } std::unique_ptr dest_owner(*dest); - absl::StatusOr src = + absl::StatusOr src = PhaserBankMakeExisting(type, msg.runtime, msg.value().data()); if (!src.ok()) { return src.status(); @@ -232,15 +240,16 @@ class AnyMessage : public Message { return absl::OkStatus(); } - void CopyFrom(const Message &m) override { - const AnyMessage &msg = static_cast(m); + void CopyFrom(const Message& m) override { + const AnyMessage& msg = static_cast(m); (void)CloneFrom(msg); } // Create an instance of message T in the value field. Returns // a message whose storage is in the payload buffer inside // the value. - template T MutableAny() { + template + T MutableAny() { set_type_url("type.googleapis.com/" + T::FullName()); size_t size = T::BinarySize(); absl::Span memory = value_.Allocate(size, true); @@ -251,32 +260,37 @@ class AnyMessage : public Message { // In phaser the embedded message isn't serialized so this is just a // copy from msg into the value field. - template bool PackFrom(const T &msg) { + template + bool PackFrom(const T& msg) { T m = MutableAny(); return m.CloneFrom(msg).ok(); } - template absl::Status PackFromOrStatus(const T &msg) { + template + absl::Status PackFromOrStatus(const T& msg) { T m = MutableAny(); return m.CloneFrom(msg); } - template bool UnpackTo(T *msg) const { - const char *addr = value().data(); + template + bool UnpackTo(T* msg) const { + const char* addr = value().data(); std::unique_ptr embedded_msg = std::make_unique( - runtime, runtime->ToOffset(const_cast(addr))); + runtime, runtime->ToOffset(const_cast(addr))); return msg->CloneFrom(*embedded_msg).ok(); } - template absl::Status UnpackToOrStatus(T *msg) const { - const char *addr = value().data(); + template + absl::Status UnpackToOrStatus(T* msg) const { + const char* addr = value().data(); std::unique_ptr embedded_msg = std::make_unique( - runtime, runtime->ToOffset(const_cast(addr))); + runtime, runtime->ToOffset(const_cast(addr))); return msg->CloneFrom(*embedded_msg); } - template bool Is() const { - const std::string &msg_type = T::FullName(); + template + bool Is() const { + const std::string& msg_type = T::FullName(); std::string t = MessageTypeName(); return t == msg_type; } @@ -284,12 +298,13 @@ class AnyMessage : public Message { // Gets the value of the any field as a message of type T. This does not // check that the message is actually of type T, so it's up to you to call // the Is() method first. Caveat programmer. - template const T As() const { - const T msg(runtime, runtime->ToOffset(const_cast(value().data()))); + template + const T As() const { + const T msg(runtime, runtime->ToOffset(const_cast(value().data()))); return msg; } - bool ParseFromArray(const char *array, size_t size) { + bool ParseFromArray(const char* array, size_t size) { ProtoBuffer buffer(array, size); if (absl::Status status = Deserialize(buffer); !status.ok()) { return false; @@ -297,11 +312,11 @@ class AnyMessage : public Message { return true; } - bool ParseFromString(const std::string &str) { + bool ParseFromString(const std::string& str) { return ParseFromArray(str.data(), str.size()); } - bool SerializeToString(std::string *str) const { + bool SerializeToString(std::string* str) const { size_t size = SerializedSize(); str->resize(size); if (size == 0) { @@ -317,7 +332,7 @@ class AnyMessage : public Message { return str; } - bool SerializeToArray(char *array, size_t size) const { + bool SerializeToArray(char* array, size_t size) const { ProtoBuffer buffer(array, size); if (absl::Status status = Serialize(buffer); !status.ok()) { return false; @@ -325,10 +340,10 @@ class AnyMessage : public Message { return true; } -private: + private: static constexpr int kValueFieldNumber = 2; - absl::StatusOr EmbeddedMessageForWire() const { + absl::StatusOr EmbeddedMessageForWire() const { if (!has_type_url() || !has_value()) { return absl::FailedPreconditionError( "Any is missing type_url or embedded value"); @@ -337,7 +352,7 @@ class AnyMessage : public Message { return PhaserBankMakeExisting(type, runtime, value().data()); } - absl::StatusOr AllocateEmbeddedMessage(const std::string &type) { + absl::StatusOr AllocateEmbeddedMessage(const std::string& type) { absl::StatusOr binary_size = PhaserBankBinarySize(type); if (!binary_size.ok()) { return binary_size.status(); @@ -347,13 +362,12 @@ class AnyMessage : public Message { runtime->ToOffset(memory.data())); } - absl::Status MaterializeValueFromProtobufWire(const std::string &wire) { + absl::Status MaterializeValueFromProtobufWire(const std::string& wire) { if (!has_type_url()) { - return absl::InvalidArgumentError( - "Any value on wire requires type_url"); + return absl::InvalidArgumentError("Any value on wire requires type_url"); } const std::string type = MessageTypeName(); - absl::StatusOr embedded = AllocateEmbeddedMessage(type); + absl::StatusOr embedded = AllocateEmbeddedMessage(type); if (!embedded.ok()) { return embedded.status(); } @@ -369,34 +383,44 @@ class AnyMessage : public Message { #pragma clang diagnostic pop class AnyField : public IndirectMessageField { -public: + public: AnyField(uint32_t boff, uint32_t offset, int id, int number) : IndirectMessageField(boff, offset, id, number) {} - bool operator==(const AnyField &other) const { + bool operator==(const AnyField& other) const { return IndirectMessageField::operator==(other); } - bool operator!=(const AnyField &other) const { + bool operator!=(const AnyField& other) const { return IndirectMessageField::operator!=(other); } - template bool PackFrom(const T &msg) { + template + bool PackFrom(const T& msg) { return msg_.PackFrom(msg); } - template bool UnpackTo(T *msg) const { + template + bool UnpackTo(T* msg) const { return msg_.UnpackTo(msg); } - bool ParseFromString(const std::string &str) { return msg_.ParseFromString(str); } + bool ParseFromString(const std::string& str) { + return msg_.ParseFromString(str); + } - bool SerializeToString(std::string *str) const { + bool SerializeToString(std::string* str) const { return msg_.SerializeToString(str); } - template bool Is() const { return msg_.Is(); } + template + bool Is() const { + return msg_.Is(); + } - template void CloneFrom(const T &msg) { msg_.CloneFrom(msg); } + template + void CloneFrom(const T& msg) { + msg_.CloneFrom(msg); + } bool has_type_url() const { return msg_.has_type_url(); } bool has_value() const { return msg_.has_value(); } @@ -404,4 +428,4 @@ class AnyField : public IndirectMessageField { std::string_view value() const { return msg_.value(); } }; -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/fields.h b/phaser/runtime/fields.h index 51fdf49..af250c1 100644 --- a/phaser/runtime/fields.h +++ b/phaser/runtime/fields.h @@ -6,6 +6,13 @@ // Single value fields. +#include +#include + +#include +#include +#include + #include "absl/container/flat_hash_map.h" #include "absl/status/status.h" #include "absl/status/statusor.h" @@ -13,38 +20,34 @@ #include "phaser/runtime/message.h" #include "phaser/runtime/wireformat.h" #include "toolbelt/payload_buffer.h" -#include -#include -#include -#include -#include namespace phaser { -template constexpr size_t AlignedOffset(size_t offset) { +template +constexpr size_t AlignedOffset(size_t offset) { return (offset + sizeof(T) - 1) & ~(sizeof(T) - 1); } class Field { -public: + public: Field() = default; Field(int id, int number) : id_(id), number_(number) {} - Field(const Field &) = default; - Field &operator=(const Field &) = default; + Field(const Field&) = default; + Field& operator=(const Field&) = default; virtual ~Field() = default; // The presence bit is in a set of words immediately after // the metadata at the start of the message. - void SetPresence(::toolbelt::PayloadBuffer *buffer, uint32_t binary_offset) { + void SetPresence(::toolbelt::PayloadBuffer* buffer, uint32_t binary_offset) { buffer->SetPresenceBit(static_cast(id_), binary_offset); } - void ClearPresence(::toolbelt::PayloadBuffer *buffer, + void ClearPresence(::toolbelt::PayloadBuffer* buffer, uint32_t binary_offset) { buffer->ClearPresenceBit(static_cast(id_), binary_offset); } - bool IsPresent(uint32_t field_id, ::toolbelt::PayloadBuffer *buffer, + bool IsPresent(uint32_t field_id, ::toolbelt::PayloadBuffer* buffer, uint32_t binary_offset) const { if (field_id == static_cast(-1)) { return false; @@ -74,7 +77,7 @@ class Field { // For printing. void Indent(int indent) const { indent_ += indent; } - void PrintIndent(std::ostream &os) const { + void PrintIndent(std::ostream& os) const { for (int i = 0; i < indent_; i++) { os << " "; } @@ -82,7 +85,7 @@ class Field { int GetIndent() const { return indent_; } -protected: + protected: int id_ = 0; int number_ = 0; mutable ::toolbelt::BufferOffset cached_offset_ = 0xffffffff; @@ -90,84 +93,86 @@ class Field { mutable int indent_ = 0; }; -#define DEFINE_PRIMITIVE_FIELD(cname, type) \ - template \ - class cname##Field : public Field { \ - public: \ - cname##Field() = default; \ - explicit cname##Field(uint32_t boff, uint32_t offset, int id, int number) \ - : Field(id, number), source_offset_(boff), \ - relative_binary_offset_(offset) {} \ - type Get() const { \ - int32_t offset = FindFieldOffset(source_offset_); \ - if (offset < 0) { \ - return type(); \ - } \ - return GetBuffer()->template Get( \ - GetMessageBinaryStart() + \ - static_cast<::toolbelt::BufferOffset>(offset)); \ - } \ - type GetForPrinting() const { return Get(); } \ - bool IsPresent() const { \ - return Field::IsPresent(static_cast(FindFieldId(source_offset_)), GetBuffer(), \ - GetPresenceMaskStart()); \ - } \ - \ - void Set(type v) { \ - GetBuffer()->Set(GetMessageBinaryStart() + relative_binary_offset_, v); \ - SetPresence(GetBuffer(), GetPresenceMaskStart()); \ - } \ - void Clear() { ClearPresence(GetBuffer(), GetPresenceMaskStart()); } \ - bool operator==(const cname##Field &other) const { \ - return Get() == other.Get(); \ - } \ - bool operator!=(const cname##Field &other) const { \ - return !(*this == other); \ - } \ - size_t SerializedSize() const { \ - if constexpr (FixedSize) { \ - return ProtoBuffer::TagSize(Number(), \ - ProtoBuffer::FixedWireType()) + \ - sizeof(type); \ - } else { \ - return ProtoBuffer::TagSize(Number(), WireType::kVarint) + \ - ProtoBuffer::VarintSize(Get()); \ - } \ - } \ - absl::Status Serialize(ProtoBuffer &buffer) const { \ - if constexpr (FixedSize) { \ - return buffer.SerializeFixed(Number(), Get()); \ - } else { \ - return buffer.SerializeVarint(Number(), Get()); \ - } \ - } \ - \ - absl::Status Deserialize(ProtoBuffer &buffer) { \ - absl::StatusOr v; \ - if constexpr (FixedSize) { \ - v = buffer.DeserializeFixed(); \ - } else { \ - v = buffer.DeserializeVarint(); \ - } \ - if (!v.ok()) { \ - return v.status(); \ - } \ - Set(*v); \ - return absl::OkStatus(); \ - } \ - \ - private: \ - ::toolbelt::PayloadBuffer *GetBuffer() const { \ - return Message::GetBuffer(this, source_offset_); \ - } \ - ::toolbelt::BufferOffset GetMessageBinaryStart() const { \ - return Message::GetMessageBinaryStart(this, source_offset_); \ - } \ - ::toolbelt::BufferOffset GetPresenceMaskStart() const { \ - return Message::GetMessageBinaryStart(this, source_offset_) + 4; \ - } \ - uint32_t source_offset_; \ - ::toolbelt::BufferOffset relative_binary_offset_; \ +#define DEFINE_PRIMITIVE_FIELD(cname, type) \ + template \ + class cname##Field : public Field { \ + public: \ + cname##Field() = default; \ + explicit cname##Field(uint32_t boff, uint32_t offset, int id, int number) \ + : Field(id, number), \ + source_offset_(boff), \ + relative_binary_offset_(offset) {} \ + type Get() const { \ + int32_t offset = FindFieldOffset(source_offset_); \ + if (offset < 0) { \ + return type(); \ + } \ + return GetBuffer()->template Get( \ + GetMessageBinaryStart() + \ + static_cast<::toolbelt::BufferOffset>(offset)); \ + } \ + type GetForPrinting() const { return Get(); } \ + bool IsPresent() const { \ + return Field::IsPresent( \ + static_cast(FindFieldId(source_offset_)), GetBuffer(), \ + GetPresenceMaskStart()); \ + } \ + \ + void Set(type v) { \ + GetBuffer()->Set(GetMessageBinaryStart() + relative_binary_offset_, v); \ + SetPresence(GetBuffer(), GetPresenceMaskStart()); \ + } \ + void Clear() { ClearPresence(GetBuffer(), GetPresenceMaskStart()); } \ + bool operator==(const cname##Field& other) const { \ + return Get() == other.Get(); \ + } \ + bool operator!=(const cname##Field& other) const { \ + return !(*this == other); \ + } \ + size_t SerializedSize() const { \ + if constexpr (FixedSize) { \ + return ProtoBuffer::TagSize(Number(), \ + ProtoBuffer::FixedWireType()) + \ + sizeof(type); \ + } else { \ + return ProtoBuffer::TagSize(Number(), WireType::kVarint) + \ + ProtoBuffer::VarintSize(Get()); \ + } \ + } \ + absl::Status Serialize(ProtoBuffer& buffer) const { \ + if constexpr (FixedSize) { \ + return buffer.SerializeFixed(Number(), Get()); \ + } else { \ + return buffer.SerializeVarint(Number(), Get()); \ + } \ + } \ + \ + absl::Status Deserialize(ProtoBuffer& buffer) { \ + absl::StatusOr v; \ + if constexpr (FixedSize) { \ + v = buffer.DeserializeFixed(); \ + } else { \ + v = buffer.DeserializeVarint(); \ + } \ + if (!v.ok()) { \ + return v.status(); \ + } \ + Set(*v); \ + return absl::OkStatus(); \ + } \ + \ + private: \ + ::toolbelt::PayloadBuffer* GetBuffer() const { \ + return Message::GetBuffer(this, source_offset_); \ + } \ + ::toolbelt::BufferOffset GetMessageBinaryStart() const { \ + return Message::GetMessageBinaryStart(this, source_offset_); \ + } \ + ::toolbelt::BufferOffset GetPresenceMaskStart() const { \ + return Message::GetMessageBinaryStart(this, source_offset_) + 4; \ + } \ + uint32_t source_offset_; \ + ::toolbelt::BufferOffset relative_binary_offset_; \ }; DEFINE_PRIMITIVE_FIELD(Int32, int32_t) @@ -185,17 +190,18 @@ struct InternalIntStringizer { }; struct InternalIntParser { - int operator()(const std::string &s) const { return std::stoi(s); } + int operator()(const std::string& s) const { return std::stoi(s); } }; template class EnumField : public Field { -public: + public: using T = typename std::underlying_type::type; EnumField() = default; explicit EnumField(uint32_t boff, uint32_t offset, int id, int number) - : Field(id, number), source_offset_(boff), + : Field(id, number), + source_offset_(boff), relative_binary_offset_(offset) {} Enum Get() const { @@ -205,19 +211,20 @@ class EnumField : public Field { } return static_cast( GetBuffer()->template Get::type>( - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset))); + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(offset))); } std::string GetForPrinting() const { return ToString(); } bool IsPresent() const { - return Field::IsPresent(static_cast(FindFieldId(source_offset_)), GetBuffer(), - GetPresenceMaskStart()); + return Field::IsPresent(static_cast(FindFieldId(source_offset_)), + GetBuffer(), GetPresenceMaskStart()); } std::string ToString() const { return Stringizer()(Get()); } - Enum ParseFromString(const std::string &s) { Set(Parser(s)); } + Enum ParseFromString(const std::string& s) { Set(Parser(s)); } T GetUnderlying() const { int32_t offset = FindFieldOffset(source_offset_); @@ -225,7 +232,8 @@ class EnumField : public Field { return 0; } return GetBuffer()->template Get::type>( - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(offset)); } void Set(Enum e) { @@ -241,10 +249,10 @@ class EnumField : public Field { void Clear() { ClearPresence(GetBuffer(), GetPresenceMaskStart()); } - bool operator==(const EnumField &other) const { + bool operator==(const EnumField& other) const { return static_cast(*this) == static_cast(other); } - bool operator!=(const EnumField &other) const { return !(*this == other); } + bool operator!=(const EnumField& other) const { return !(*this == other); } size_t SerializedSize() const { return ProtoBuffer::TagSize(Number(), WireType::kVarint) + @@ -252,12 +260,12 @@ class EnumField : public Field { static_cast(GetUnderlying())); } - absl::Status Serialize(ProtoBuffer &buffer) const { + absl::Status Serialize(ProtoBuffer& buffer) const { return buffer.SerializeVarint( Number(), static_cast(GetUnderlying())); } - absl::Status Deserialize(ProtoBuffer &buffer) { + absl::Status Deserialize(ProtoBuffer& buffer) { absl::StatusOr v = buffer.DeserializeVarint(); if (!v.ok()) { return v.status(); @@ -266,8 +274,8 @@ class EnumField : public Field { return absl::OkStatus(); } -private: - ::toolbelt::PayloadBuffer *GetBuffer() const { + private: + ::toolbelt::PayloadBuffer* GetBuffer() const { return Message::GetBuffer(this, source_offset_); } ::toolbelt::BufferOffset GetMessageBinaryStart() const { @@ -283,11 +291,12 @@ class EnumField : public Field { // String field with an offset inline in the message. class StringField : public Field { -public: + public: StringField() = default; explicit StringField(uint32_t source_offset, uint32_t relative_binary_offset, int id, int number) - : Field(id, number), source_offset_(source_offset), + : Field(id, number), + source_offset_(source_offset), relative_binary_offset_(relative_binary_offset) {} std::string_view Get() const { @@ -295,7 +304,9 @@ class StringField : public Field { if (offset < 0) { return std::string_view(); } - return GetBuffer()->GetStringView(GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); + return GetBuffer()->GetStringView( + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(offset)); } bool IsPresent() const { @@ -303,25 +314,27 @@ class StringField : public Field { if (offset < 0) { return false; } - const ::toolbelt::BufferOffset *addr = + const ::toolbelt::BufferOffset* addr = GetRuntime()->ToAddress( - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(offset)); return *addr != 0; } - template void Set(Str s) { + template + void Set(Str s) { ::toolbelt::PayloadBuffer::SetString( GetBufferAddr(), s, GetMessageBinaryStart() + relative_binary_offset_); } - void Set(const char *data, size_t size) { + void Set(const char* data, size_t size) { ::toolbelt::PayloadBuffer::SetString( GetBufferAddr(), std::string_view(data, size), GetMessageBinaryStart() + relative_binary_offset_); } - void SetNoCopy(const void *data) { - toolbelt::StringHeader *header = + void SetNoCopy(const void* data) { + toolbelt::StringHeader* header = GetRuntime()->ToAddress( GetMessageBinaryStart() + relative_binary_offset_); *header = GetRuntime()->ToOffset(data); @@ -340,25 +353,29 @@ class StringField : public Field { GetMessageBinaryStart() + relative_binary_offset_, clear); } - bool operator==(const StringField &other) const { + bool operator==(const StringField& other) const { return Get() == other.Get(); } - bool operator!=(const StringField &other) const { return !(*this == other); } + bool operator!=(const StringField& other) const { return !(*this == other); } size_t size() const { int32_t offset = FindFieldOffset(source_offset_); if (offset < 0) { return 0; } - return GetBuffer()->StringSize(GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); + return GetBuffer()->StringSize( + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(offset)); } - const char *data() const { + const char* data() const { int32_t offset = FindFieldOffset(source_offset_); if (offset < 0) { return nullptr; } - return GetBuffer()->StringData(GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(offset)); + return GetBuffer()->StringData( + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(offset)); } size_t SerializedSize() const { @@ -366,12 +383,12 @@ class StringField : public Field { return ProtoBuffer::LengthDelimitedSize(Number(), s); } - absl::Status Serialize(ProtoBuffer &buffer) const { + absl::Status Serialize(ProtoBuffer& buffer) const { size_t s = size(); return buffer.ProtoBuffer::SerializeLengthDelimited(Number(), data(), s); } - absl::Status Deserialize(ProtoBuffer &buffer) { + absl::Status Deserialize(ProtoBuffer& buffer) { absl::StatusOr s = buffer.DeserializeString(); if (!s.ok()) { return s.status(); @@ -381,18 +398,19 @@ class StringField : public Field { return absl::OkStatus(); } -private: - template friend class StringArrayField; + private: + template + friend class StringArrayField; - const std::shared_ptr &GetRuntime() const { + const std::shared_ptr& GetRuntime() const { return Message::GetRuntime(this, source_offset_); } - ::toolbelt::PayloadBuffer *GetBuffer() const { + ::toolbelt::PayloadBuffer* GetBuffer() const { return Message::GetBuffer(this, source_offset_); } - ::toolbelt::PayloadBuffer **GetBufferAddr() const { + ::toolbelt::PayloadBuffer** GetBufferAddr() const { return Message::GetBufferAddr(this, source_offset_); } ::toolbelt::BufferOffset GetMessageBinaryStart() const { @@ -407,9 +425,9 @@ class StringField : public Field { // store the std::shared_ptr to the phaser::Runtime pointer instead of // an offset to the start of the message. class NonEmbeddedStringField { -public: + public: NonEmbeddedStringField() = default; - explicit NonEmbeddedStringField(const Message *msg, + explicit NonEmbeddedStringField(const Message* msg, uint32_t absolute_binary_offset) : msg_(msg), absolute_binary_offset_(absolute_binary_offset) {} @@ -417,7 +435,8 @@ class NonEmbeddedStringField { return GetBuffer()->GetStringView(absolute_binary_offset_); } - template void Set(Str s) { + template + void Set(Str s) { ::toolbelt::PayloadBuffer::SetString(GetBufferAddr(), s, absolute_binary_offset_); } @@ -427,10 +446,10 @@ class NonEmbeddedStringField { absolute_binary_offset_); } - bool operator==(const NonEmbeddedStringField &other) const { + bool operator==(const NonEmbeddedStringField& other) const { return Get() == other.Get(); } - bool operator!=(const NonEmbeddedStringField &other) const { + bool operator!=(const NonEmbeddedStringField& other) const { return !(*this == other); } @@ -438,7 +457,7 @@ class NonEmbeddedStringField { return GetBuffer()->StringSize(absolute_binary_offset_); } - const char *data() const { + const char* data() const { return GetBuffer()->StringData(absolute_binary_offset_); } bool empty() const { return size() == 0; } @@ -451,18 +470,18 @@ class NonEmbeddedStringField { // type intentionally has no standalone Serialize() of its own. size_t SerializedSize() const { return size(); } -private: - ::toolbelt::PayloadBuffer *GetBuffer() const { return msg_->runtime->pb; } + private: + ::toolbelt::PayloadBuffer* GetBuffer() const { return msg_->runtime->pb; } - ::toolbelt::PayloadBuffer **GetBufferAddr() const { + ::toolbelt::PayloadBuffer** GetBufferAddr() const { return &msg_->runtime->pb; } - const Message *msg_; + const Message* msg_; ::toolbelt::BufferOffset - absolute_binary_offset_; // Offset into - // ::toolbelt::PayloadBuffer of - // toolbelt::StringHeader + absolute_binary_offset_; // Offset into + // ::toolbelt::PayloadBuffer of + // toolbelt::StringHeader }; // This is a buffer offset containing the absolute offset of a message in the @@ -478,25 +497,28 @@ class NonEmbeddedStringField { // | | // +------------+ -template class IndirectMessageField : public Field { -public: +template +class IndirectMessageField : public Field { + public: IndirectMessageField() = default; explicit IndirectMessageField(uint32_t source_offset, uint32_t relative_binary_offset, int id, int number) - : Field(id, number), source_offset_(source_offset), + : Field(id, number), + source_offset_(source_offset), relative_binary_offset_(relative_binary_offset), msg_(InternalDefault{}) {} - const MessageType &Msg() const { return msg_; } - MessageType &MutableMsg() { return msg_; } + const MessageType& Msg() const { return msg_; } + MessageType& MutableMsg() { return msg_; } - const MessageType &Get() const { + const MessageType& Get() const { int32_t offset = FindFieldOffset(source_offset_); if (offset < 0) { return msg_; } - ::toolbelt::BufferOffset *addr = GetIndirectAddress(static_cast(offset)); + ::toolbelt::BufferOffset* addr = + GetIndirectAddress(static_cast(offset)); if (*addr != 0) { // Load up the message if it's already been allocated. msg_.runtime = GetRuntime(); @@ -510,19 +532,20 @@ template class IndirectMessageField : public Field { if (offset < 0) { return false; } - ::toolbelt::BufferOffset *addr = GetIndirectAddress(static_cast(offset)); + ::toolbelt::BufferOffset* addr = + GetIndirectAddress(static_cast(offset)); return *addr != 0; } - MessageType *Mutable() { - ::toolbelt::BufferOffset *addr = + MessageType* Mutable() { + ::toolbelt::BufferOffset* addr = GetIndirectAddress(relative_binary_offset_); if (*addr != 0) { // Already allocated. return &msg_; } // Allocate a new message. - void *msg_addr = ::toolbelt::PayloadBuffer::Allocate( + void* msg_addr = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(), MessageType::BinarySize()); ::toolbelt::BufferOffset msg_offset = GetRuntime()->ToOffset(msg_addr); // Assign to the message. @@ -531,7 +554,7 @@ template class IndirectMessageField : public Field { // Buffer might have moved, get address of indirect again. addr = GetIndirectAddress(relative_binary_offset_); - *addr = msg_offset; // Put message field offset into message. + *addr = msg_offset; // Put message field offset into message. // Install the metadata into the binary message. msg_.template InstallMetadata(); @@ -539,7 +562,7 @@ template class IndirectMessageField : public Field { } void SetOffset(toolbelt::BufferOffset offset) { - ::toolbelt::BufferOffset *addr = + ::toolbelt::BufferOffset* addr = GetIndirectAddress(relative_binary_offset_); if (*addr != 0) { // Already set, clear the exising message @@ -551,7 +574,7 @@ template class IndirectMessageField : public Field { } void Clear() { - ::toolbelt::BufferOffset *addr = + ::toolbelt::BufferOffset* addr = GetIndirectAddress(relative_binary_offset_); if (*addr == 0) { return; @@ -564,10 +587,10 @@ template class IndirectMessageField : public Field { *addr = 0; } - bool operator==(const IndirectMessageField &other) const { + bool operator==(const IndirectMessageField& other) const { return msg_ != other.msg_; } - bool operator!=(const IndirectMessageField &other) const { + bool operator!=(const IndirectMessageField& other) const { return !(*this == other); } @@ -576,7 +599,8 @@ template class IndirectMessageField : public Field { if (offset < 0) { return 0; } - ::toolbelt::BufferOffset *addr = GetIndirectAddress(static_cast(offset)); + ::toolbelt::BufferOffset* addr = + GetIndirectAddress(static_cast(offset)); if (*addr != 0) { // Load up the message if it's already been allocated. msg_.runtime = GetRuntime(); @@ -585,12 +609,13 @@ template class IndirectMessageField : public Field { return ProtoBuffer::LengthDelimitedSize(Number(), msg_.SerializedSize()); } - absl::Status Serialize(ProtoBuffer &buffer) const { + absl::Status Serialize(ProtoBuffer& buffer) const { int32_t offset = FindFieldOffset(source_offset_); if (offset < 0) { return absl::OkStatus(); } - ::toolbelt::BufferOffset *addr = GetIndirectAddress(static_cast(offset)); + ::toolbelt::BufferOffset* addr = + GetIndirectAddress(static_cast(offset)); if (*addr != 0) { // Load up the message if it's already been allocated. msg_.runtime = GetRuntime(); @@ -607,13 +632,13 @@ template class IndirectMessageField : public Field { return msg_.Serialize(buffer); } - absl::Status Deserialize(ProtoBuffer &buffer) { + absl::Status Deserialize(ProtoBuffer& buffer) { absl::StatusOr> s = buffer.DeserializeLengthDelimited(); if (!s.ok()) { return s.status(); } // Allocate a new message. - void *msg_addr = ::toolbelt::PayloadBuffer::Allocate( + void* msg_addr = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(), MessageType::BinarySize()); ::toolbelt::BufferOffset msg_offset = GetRuntime()->ToOffset(msg_addr); // Assign to the message. @@ -621,9 +646,9 @@ template class IndirectMessageField : public Field { msg_.absolute_binary_offset = msg_offset; // Buffer might have moved, get address of indirect again. - ::toolbelt::BufferOffset *addr = + ::toolbelt::BufferOffset* addr = GetIndirectAddress(relative_binary_offset_); - *addr = msg_offset; // Put message field offset into message. + *addr = msg_offset; // Put message field offset into message. // Install the metadata into the binary message. msg_.template InstallMetadata(); @@ -637,21 +662,21 @@ template class IndirectMessageField : public Field { msg_.Indent(indent); } -protected: - ::toolbelt::PayloadBuffer *GetBuffer() const { + protected: + ::toolbelt::PayloadBuffer* GetBuffer() const { return Message::GetBuffer(this, source_offset_); } - ::toolbelt::BufferOffset *GetIndirectAddress(uint32_t abs_offset) const { + ::toolbelt::BufferOffset* GetIndirectAddress(uint32_t abs_offset) const { return GetBuffer()->template ToAddress<::toolbelt::BufferOffset>( GetMessageBinaryStart() + abs_offset); } - ::toolbelt::PayloadBuffer **GetBufferAddr() const { + ::toolbelt::PayloadBuffer** GetBufferAddr() const { return Message::GetBufferAddr(this, source_offset_); } - const std::shared_ptr &GetRuntime() const { + const std::shared_ptr& GetRuntime() const { return Message::GetRuntime(this, source_offset_); } @@ -664,25 +689,26 @@ template class IndirectMessageField : public Field { mutable MessageType msg_; }; -template class MessageObject { -public: +template +class MessageObject { + public: MessageObject() : msg_(InternalDefault{}) {} explicit MessageObject(std::shared_ptr runtime, uint32_t absolute_binary_offset) : msg_(runtime, absolute_binary_offset) {} - const MessageType &Get() const { return msg_; } + const MessageType& Get() const { return msg_; } - const MessageType &operator*() const { return msg_; } - MessageType &operator*() { return msg_; } - MessageType *operator->() { return &msg_; } + const MessageType& operator*() const { return msg_; } + MessageType& operator*() { return msg_; } + MessageType* operator->() { return &msg_; } - MessageType *Mutable() { return &msg_; } + MessageType* Mutable() { return &msg_; } - bool operator==(const MessageObject &other) const { + bool operator==(const MessageObject& other) const { return msg_ != other.msg_; } - bool operator!=(const MessageObject &other) const { + bool operator!=(const MessageObject& other) const { return !(*this == other); } @@ -699,20 +725,21 @@ template class MessageObject { msg_.Clear(); } - const MessageType &Msg() const { return msg_; } - MessageType &MutableMsg() { return msg_; } + const MessageType& Msg() const { return msg_; } + MessageType& MutableMsg() { return msg_; } - template absl::Status CloneFrom(const T &other) { + template + absl::Status CloneFrom(const T& other) { return msg_.CloneFrom(other.msg_); } size_t SerializedSize() const { return msg_.SerializedSize(); } - absl::Status Serialize(ProtoBuffer &buffer) const { + absl::Status Serialize(ProtoBuffer& buffer) const { return msg_.Serialize(buffer); } - absl::Status Deserialize(ProtoBuffer &buffer) { + absl::Status Deserialize(ProtoBuffer& buffer) { absl::StatusOr> s = buffer.DeserializeLengthDelimited(); if (!s.ok()) { return s.status(); @@ -726,15 +753,15 @@ template class MessageObject { msg_.Indent(indent); } - void PrintIndent(std::ostream &os) const { + void PrintIndent(std::ostream& os) const { for (int i = 0; i < indent_; i++) { os << " "; } } -private: + private: mutable MessageType msg_; mutable int indent_ = 0; }; -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/iterators.h b/phaser/runtime/iterators.h index b515b0b..715907f 100644 --- a/phaser/runtime/iterators.h +++ b/phaser/runtime/iterators.h @@ -6,23 +6,26 @@ // Array and vector iterators. -#include "absl/status/status.h" -#include "absl/status/statusor.h" -#include "phaser/runtime/message.h" -#include "toolbelt/payload_buffer.h" #include #include + #include #include #include +#include "absl/status/status.h" +#include "absl/status/statusor.h" +#include "phaser/runtime/message.h" +#include "toolbelt/payload_buffer.h" + namespace phaser { -template struct FieldIterator { - FieldIterator(const Field *f, ::toolbelt::BufferOffset o, bool r = false) +template +struct FieldIterator { + FieldIterator(const Field* f, ::toolbelt::BufferOffset o, bool r = false) : field(f), offset(o), reverse(r) {} - FieldIterator &operator++() { + FieldIterator& operator++() { if (reverse) { offset -= static_cast<::toolbelt::BufferOffset>(sizeof(T)); } else { @@ -30,7 +33,7 @@ template struct FieldIterator { } return *this; } - FieldIterator &operator--() { + FieldIterator& operator--() { if (reverse) { offset += static_cast<::toolbelt::BufferOffset>(sizeof(T)); } else { @@ -50,26 +53,28 @@ template struct FieldIterator { } return FieldIterator(field, field->BaseOffset() - i * sizeof(T)); } - T &operator*() const { - T *addr = field->GetBuffer()->template ToAddress(offset); + T& operator*() const { + T* addr = field->GetBuffer()->template ToAddress(offset); return *addr; } - bool operator==(const FieldIterator &it) const { + bool operator==(const FieldIterator& it) const { return field == it.field && offset == it.offset; } - bool operator!=(const FieldIterator &it) const { return !operator==(it); } + bool operator!=(const FieldIterator& it) const { return !operator==(it); } - const Field *field; + const Field* field; ::toolbelt::BufferOffset offset; bool reverse; }; -template struct StringFieldIterator { - StringFieldIterator(const Field *f, ::toolbelt::BufferOffset o, bool r = false) +template +struct StringFieldIterator { + StringFieldIterator(const Field* f, ::toolbelt::BufferOffset o, + bool r = false) : field(f), offset(o), reverse(r) {} - StringFieldIterator &operator++() { + StringFieldIterator& operator++() { if (reverse) { offset -= sizeof(::toolbelt::BufferOffset); } else { @@ -77,7 +82,7 @@ template struct StringFieldIterator { } return *this; } - StringFieldIterator &operator--() { + StringFieldIterator& operator--() { if (reverse) { offset += sizeof(::toolbelt::BufferOffset); } else { @@ -91,8 +96,8 @@ template struct StringFieldIterator { field, field->BaseOffset() - i * sizeof(::toolbelt::BufferOffset), true); } - return StringFieldIterator(field, field->BaseOffset() + - i * sizeof(::toolbelt::BufferOffset)); + return StringFieldIterator( + field, field->BaseOffset() + i * sizeof(::toolbelt::BufferOffset)); } StringFieldIterator operator-(size_t i) { if (reverse) { @@ -100,30 +105,31 @@ template struct StringFieldIterator { field, field->BaseOffset() + i * sizeof(::toolbelt::BufferOffset), true); } - return StringFieldIterator(field, field->BaseOffset() - - i * sizeof(::toolbelt::BufferOffset)); + return StringFieldIterator( + field, field->BaseOffset() - i * sizeof(::toolbelt::BufferOffset)); } std::string_view operator*() const { return field->GetBuffer()->GetStringView(field->BaseOffset() + offset); } - bool operator==(const StringFieldIterator &it) const { + bool operator==(const StringFieldIterator& it) const { return field == it.field && offset == it.offset; } - bool operator!=(const StringFieldIterator &it) const { + bool operator!=(const StringFieldIterator& it) const { return !operator==(it); } - const Field *field; + const Field* field; ::toolbelt::BufferOffset offset; bool reverse; }; -template struct EnumFieldIterator { - EnumFieldIterator(const Field *f, ::toolbelt::BufferOffset o, bool r = false) +template +struct EnumFieldIterator { + EnumFieldIterator(const Field* f, ::toolbelt::BufferOffset o, bool r = false) : field(f), offset(o), reverse(r) {} - EnumFieldIterator &operator++() { + EnumFieldIterator& operator++() { if (reverse) { offset -= static_cast<::toolbelt::BufferOffset>(sizeof(T)); } else { @@ -131,7 +137,7 @@ template struct EnumFieldIterator { } return *this; } - EnumFieldIterator &operator--() { + EnumFieldIterator& operator--() { if (reverse) { offset += static_cast<::toolbelt::BufferOffset>(sizeof(T)); } else { @@ -141,42 +147,42 @@ template struct EnumFieldIterator { } EnumFieldIterator operator+(size_t i) { if (reverse) { - return EnumFieldIterator(field, - field->BaseOffset() - - i * sizeof(std::underlying_type::type), - true); + return EnumFieldIterator( + field, + field->BaseOffset() - i * sizeof(std::underlying_type::type), + true); } return EnumFieldIterator( field, field->BaseOffset() + i * sizeof(std::underlying_type::type)); } EnumFieldIterator operator-(size_t i) { if (reverse) { - return EnumFieldIterator(field, - field->BaseOffset() + - i * sizeof(std::underlying_type::type), - true); + return EnumFieldIterator( + field, + field->BaseOffset() + i * sizeof(std::underlying_type::type), + true); } return EnumFieldIterator( field, field->BaseOffset() - i * sizeof(std::underlying_type::type)); } - T &operator*() const { + T& operator*() const { using U = typename std::underlying_type::type; - U *addr = field->GetBuffer()->template ToAddress(offset); + U* addr = field->GetBuffer()->template ToAddress(offset); // An enum and its fixed underlying type share representation; route the // cast through void* so it is not flagged as a dereference of an unrelated // reinterpret_cast. - return *static_cast(static_cast(addr)); + return *static_cast(static_cast(addr)); } - bool operator==(const EnumFieldIterator &it) const { + bool operator==(const EnumFieldIterator& it) const { return field == it.field && offset == it.offset; } - bool operator!=(const EnumFieldIterator &it) const { return !operator==(it); } + bool operator!=(const EnumFieldIterator& it) const { return !operator==(it); } - const Field *field; + const Field* field; ::toolbelt::BufferOffset offset; bool reverse; }; -} // namespace phasdr +} // namespace phaser diff --git a/phaser/runtime/message.cc b/phaser/runtime/message.cc index a32eb38..a11ddec 100644 --- a/phaser/runtime/message.cc +++ b/phaser/runtime/message.cc @@ -3,9 +3,11 @@ // See LICENSE file for licensing information. #include "phaser/runtime/message.h" -#include "toolbelt/hexdump.h" + #include +#include "toolbelt/hexdump.h" + namespace phaser { int32_t Message::FindFieldOffset(uint32_t field_number) const { @@ -13,14 +15,14 @@ int32_t Message::FindFieldOffset(uint32_t field_number) const { return -1; } // First 4 bytes of message are the the offset to the field data. - ::toolbelt::BufferOffset *field_data = + ::toolbelt::BufferOffset* field_data = runtime->ToAddress<::toolbelt::BufferOffset>(absolute_binary_offset); if (field_data == nullptr) { return -1; } // Dereference offset to get a pointer to the field data (in the payload // buffer)l - FieldData *fd = runtime->ToAddress(*field_data); + FieldData* fd = runtime->ToAddress(*field_data); if (fd == nullptr) { return -1; } @@ -46,7 +48,7 @@ int32_t Message::FindFieldId(uint32_t field_number) const { return -1; } // First 4 bytes of message are the the offset to the field data. - ::toolbelt::BufferOffset *field_data = + ::toolbelt::BufferOffset* field_data = runtime->ToAddress<::toolbelt::BufferOffset>(absolute_binary_offset); if (field_data == nullptr) { @@ -54,7 +56,7 @@ int32_t Message::FindFieldId(uint32_t field_number) const { } // Dereference offset to get a pointer to the field data (in the payload // buffer)l - FieldData *fd = runtime->ToAddress(*field_data); + FieldData* fd = runtime->ToAddress(*field_data); if (fd == nullptr) { return -1; } @@ -75,11 +77,11 @@ int32_t Message::FindFieldId(uint32_t field_number) const { return -1; } -::toolbelt::PayloadBuffer *NewDynamicBuffer(size_t initial_size, +::toolbelt::PayloadBuffer* NewDynamicBuffer(size_t initial_size, Tuning tuning) { - absl::StatusOr<::toolbelt::PayloadBuffer *> r = NewDynamicBuffer( - initial_size, [](size_t size) -> void * { return ::malloc(size); }, - [](void *p, size_t /*old_size*/, size_t new_size) -> void * { + absl::StatusOr<::toolbelt::PayloadBuffer*> r = NewDynamicBuffer( + initial_size, [](size_t size) -> void* { return ::malloc(size); }, + [](void* p, size_t /*old_size*/, size_t new_size) -> void* { return ::realloc(p, new_size); }, tuning); @@ -91,11 +93,11 @@ ::toolbelt::PayloadBuffer *NewDynamicBuffer(size_t initial_size, return *r; } -absl::StatusOr<::toolbelt::PayloadBuffer *> NewDynamicBuffer( - size_t initial_size, std::function(size_t)> alloc, - std::function(void *, size_t, size_t)> realloc, +absl::StatusOr<::toolbelt::PayloadBuffer*> NewDynamicBuffer( + size_t initial_size, std::function(size_t)> alloc, + std::function(void*, size_t, size_t)> realloc, Tuning tuning) { - absl::StatusOr buffer = alloc(initial_size); + absl::StatusOr buffer = alloc(initial_size); if (!buffer.ok()) { return buffer.status(); } @@ -103,11 +105,11 @@ absl::StatusOr<::toolbelt::PayloadBuffer *> NewDynamicBuffer( // initialized. This avoids spurious "uninitialised value" reports from tools // like valgrind when the allocator scans or copies free space. memset(*buffer, 0, initial_size); - ::toolbelt::PayloadBuffer *pb = new (*buffer)::toolbelt::PayloadBuffer( + ::toolbelt::PayloadBuffer* pb = new (*buffer)::toolbelt::PayloadBuffer( static_cast(initial_size), - [ initial_size, realloc_fn = std::move(realloc) ]( - ::toolbelt::PayloadBuffer * *p, size_t old_size, size_t new_size) { - absl::StatusOr r = realloc_fn(*p, old_size, new_size); + [initial_size, realloc_fn = std::move(realloc)]( + ::toolbelt::PayloadBuffer** p, size_t old_size, size_t new_size) { + absl::StatusOr r = realloc_fn(*p, old_size, new_size); if (!r.ok()) { std::cerr << "Failed to resize PayloadBuffer from " << initial_size << " to " << new_size << std::endl; @@ -115,12 +117,12 @@ absl::StatusOr<::toolbelt::PayloadBuffer *> NewDynamicBuffer( } // Zero the newly grown region for the same reason as above. if (new_size > old_size) { - memset(reinterpret_cast(*r) + old_size, 0, + memset(reinterpret_cast(*r) + old_size, 0, new_size - old_size); } - *p = reinterpret_cast<::toolbelt::PayloadBuffer *>(*r); + *p = reinterpret_cast<::toolbelt::PayloadBuffer*>(*r); }, tuning == Tuning::kPerformance); return pb; } -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/message.h b/phaser/runtime/message.h index b29d603..5f72ddc 100644 --- a/phaser/runtime/message.h +++ b/phaser/runtime/message.h @@ -4,16 +4,18 @@ #pragma once +#include + +#include +#include +#include +#include + #include "absl/container/flat_hash_map.h" #include "absl/status/status.h" #include "absl/status/statusor.h" #include "toolbelt/hexdump.h" #include "toolbelt/payload_buffer.h" -#include -#include -#include -#include -#include namespace phaser { @@ -32,9 +34,9 @@ struct FieldData { uint32_t num; struct { uint32_t number; - uint32_t offset : 24; // Offset into message. - uint32_t id : 8; // Field id for presence bit mask. - } fields[]; // Flexible array member; data lives in the payload buffer. + uint32_t offset : 24; // Offset into message. + uint32_t id : 8; // Field id for presence bit mask. + } fields[]; // Flexible array member; data lives in the payload buffer. }; #pragma clang diagnostic pop @@ -54,22 +56,24 @@ enum class FieldType { }; struct FieldInfo { - FieldInfo(const std::string &n, FieldType t, int num, off_t off) + FieldInfo(const std::string& n, FieldType t, int num, off_t off) : name(n), type(t), number(num), offset(off) {} std::string name; FieldType type; int number; - off_t offset; // Offset into source message (not binary). + off_t offset; // Offset into source message (not binary). }; struct PrimitiveFieldInfo : public FieldInfo { - PrimitiveFieldInfo(const std::string &n, FieldType t, int num, off_t off, + PrimitiveFieldInfo(const std::string& n, FieldType t, int num, off_t off, bool f = false, bool /*s*/ = false, bool r = false, bool p = false) : FieldInfo(n, t, num, off), is_fixed(f), is_repeated(r), is_packed(p) {} - PrimitiveFieldInfo(const std::string &n, FieldType t, int num, off_t off, - const std::string &m, bool r = false, bool p = false) - : FieldInfo(n, t, num, off), is_repeated(r), is_packed(p), + PrimitiveFieldInfo(const std::string& n, FieldType t, int num, off_t off, + const std::string& m, bool r = false, bool p = false) + : FieldInfo(n, t, num, off), + is_repeated(r), + is_packed(p), message_or_enum_name(m) {} bool is_fixed = false; @@ -80,17 +84,17 @@ struct PrimitiveFieldInfo : public FieldInfo { }; struct UnionFieldInfo : public PrimitiveFieldInfo { - UnionFieldInfo(const std::string &n, FieldType t, int num, off_t off, int i, - const std::string &m) + UnionFieldInfo(const std::string& n, FieldType t, int num, off_t off, int i, + const std::string& m) : PrimitiveFieldInfo(n, t, num, off, m), id(i) {} - UnionFieldInfo(const std::string &n, FieldType t, int num, off_t off, int i, + UnionFieldInfo(const std::string& n, FieldType t, int num, off_t off, int i, bool f = false, bool s = false) : PrimitiveFieldInfo(n, t, num, off, f, s), id(i) {} - int id; // Field id within union. + int id; // Field id within union. }; struct UnionInfo : public FieldInfo { - UnionInfo(const std::string &n, off_t off) + UnionInfo(const std::string& n, off_t off) : FieldInfo(n, FieldType::kFieldOneof, 0, off) {} std::vector> fields_in_order; }; @@ -107,11 +111,11 @@ struct MessageInfo { // so that we know where the metadata for each message is stored. The // metadata offset is held in the message header. struct MessageRuntime { - MessageRuntime(::toolbelt::PayloadBuffer *p) : pb(p) {} - MessageRuntime(::toolbelt::PayloadBuffer *p, size_t size) + MessageRuntime(::toolbelt::PayloadBuffer* p) : pb(p) {} + MessageRuntime(::toolbelt::PayloadBuffer* p, size_t size) : pb(p), buffer_size(size) {} virtual ~MessageRuntime() = default; - ::toolbelt::PayloadBuffer *pb; + ::toolbelt::PayloadBuffer* pb; // This is the size of the buffer. If it is zero, the size is inside // the payload buffer. If it's non-zero, it's the size of the received @@ -120,27 +124,29 @@ struct MessageRuntime { // have no way to check it's valid). size_t buffer_size = 0; - virtual void AddMetadata(const std::string & /*name*/, + virtual void AddMetadata(const std::string& /*name*/, ::toolbelt::BufferOffset /*offset*/) {} - virtual ::toolbelt::BufferOffset GetMetadata(const std::string & /*name*/) { + virtual ::toolbelt::BufferOffset GetMetadata(const std::string& /*name*/) { return 0; } - template T *ToAddress(toolbelt::BufferOffset offset) { + template + T* ToAddress(toolbelt::BufferOffset offset) { return pb->ToAddress(offset, buffer_size); } template - const T *ToAddress(toolbelt::BufferOffset offset) const { + const T* ToAddress(toolbelt::BufferOffset offset) const { return pb->ToAddress(offset, buffer_size); } template - toolbelt::BufferOffset ToOffset(const T *addr) const { + toolbelt::BufferOffset ToOffset(const T* addr) const { return pb->ToOffset(addr, buffer_size); } - template toolbelt::BufferOffset ToOffset(T *addr) { + template + toolbelt::BufferOffset ToOffset(T* addr) { return pb->ToOffset(addr, buffer_size); } }; @@ -148,15 +154,15 @@ struct MessageRuntime { // This is a message runtime for a message that is mutable. It holds a mapping // for each message name to the offset of the metadata in the payload buffer. struct MutableMessageRuntime : public MessageRuntime { - MutableMessageRuntime(::toolbelt::PayloadBuffer *p) : MessageRuntime(p) {} + MutableMessageRuntime(::toolbelt::PayloadBuffer* p) : MessageRuntime(p) {} absl::flat_hash_map metadata_offsets; - void AddMetadata(const std::string &name, + void AddMetadata(const std::string& name, ::toolbelt::BufferOffset offset) override { metadata_offsets[name] = offset; } - ::toolbelt::BufferOffset GetMetadata(const std::string &name) override { + ::toolbelt::BufferOffset GetMetadata(const std::string& name) override { auto it = metadata_offsets.find(name); if (it == metadata_offsets.end()) { return 0; @@ -168,8 +174,8 @@ struct MutableMessageRuntime : public MessageRuntime { // Dynamically allocated payload buffer. Must be allocated in memory // from malloc using the NewDynamicBuffer function. struct DynamicMutableMessageRuntime : public MutableMessageRuntime { - DynamicMutableMessageRuntime(::toolbelt::PayloadBuffer *p, - std::function free) + DynamicMutableMessageRuntime(::toolbelt::PayloadBuffer* p, + std::function free) : MutableMessageRuntime(p), free_(std::move(free)) {} ~DynamicMutableMessageRuntime() override { if (free_ != nullptr) { @@ -177,7 +183,7 @@ struct DynamicMutableMessageRuntime : public MutableMessageRuntime { free_(pb); } } - std::function free_; + std::function free_; }; struct InternalDefault {}; @@ -189,8 +195,8 @@ struct InternalDefault {}; // If you are sending messages over a network, then you can sacrifice // allocation peformance for size and use kSize. enum class Tuning { - kPerformance, // Use a bitmap allocator for small blocks - kSize, // Use a simple allocator for small blocks + kPerformance, // Use a bitmap allocator for small blocks + kSize, // Use a simple allocator for small blocks }; // Payload buffers can move. All messages in a message tree must all use the @@ -228,15 +234,15 @@ struct Message { Message() = default; Message(std::shared_ptr rt, ::toolbelt::BufferOffset start) : runtime(rt), absolute_binary_offset(start) {} - Message(const Message &) = default; - Message &operator=(const Message &) = default; + Message(const Message&) = default; + Message& operator=(const Message&) = default; virtual ~Message() = default; - virtual const MessageInfo *GetMessageInfo() const { return nullptr; } + virtual const MessageInfo* GetMessageInfo() const { return nullptr; } virtual std::string GetName() const { return "Message"; } virtual std::string GetFullName() const { return "phaser.Message"; } virtual void Clear() {} - virtual void CopyFrom(const Message & /*src*/) {} + virtual void CopyFrom(const Message& /*src*/) {} std::shared_ptr runtime; ::toolbelt::BufferOffset absolute_binary_offset; @@ -244,50 +250,50 @@ struct Message { // 'field' is the offset from the start of the message to the field (positive) // Subtract the field offset from the field to get the address of the // std::shared_ptr to the pointer to the ::toolbelt::PayloadBuffer. - static ::toolbelt::PayloadBuffer *GetBuffer(const void *field, + static ::toolbelt::PayloadBuffer* GetBuffer(const void* field, uint32_t offset) { - const Message *msg = reinterpret_cast( - reinterpret_cast(field) - offset); + const Message* msg = reinterpret_cast( + reinterpret_cast(field) - offset); return msg->runtime->pb; } - static ::toolbelt::PayloadBuffer **GetBufferAddr(const void *field, + static ::toolbelt::PayloadBuffer** GetBufferAddr(const void* field, uint32_t offset) { - const Message *msg = reinterpret_cast( - reinterpret_cast(field) - offset); + const Message* msg = reinterpret_cast( + reinterpret_cast(field) - offset); return &msg->runtime->pb; } - static std::shared_ptr &GetRuntime(void *field, + static std::shared_ptr& GetRuntime(void* field, uint32_t offset) { - Message *msg = - reinterpret_cast(reinterpret_cast(field) - offset); + Message* msg = + reinterpret_cast(reinterpret_cast(field) - offset); return msg->runtime; } - static const std::shared_ptr &GetRuntime(const void *field, + static const std::shared_ptr& GetRuntime(const void* field, uint32_t offset) { - const Message *msg = reinterpret_cast( - reinterpret_cast(field) - offset); + const Message* msg = reinterpret_cast( + reinterpret_cast(field) - offset); return msg->runtime; } - static const Message *GetMessage(const void *field, uint32_t offset) { - const Message *msg = reinterpret_cast( - reinterpret_cast(field) - offset); + static const Message* GetMessage(const void* field, uint32_t offset) { + const Message* msg = reinterpret_cast( + reinterpret_cast(field) - offset); return msg; } - static Message *GetMessage(void *field, uint32_t offset) { - Message *msg = - reinterpret_cast(reinterpret_cast(field) - offset); + static Message* GetMessage(void* field, uint32_t offset) { + Message* msg = + reinterpret_cast(reinterpret_cast(field) - offset); return msg; } - static ::toolbelt::BufferOffset GetMessageBinaryStart(const void *field, + static ::toolbelt::BufferOffset GetMessageBinaryStart(const void* field, uint32_t offset) { - const Message *msg = reinterpret_cast( - reinterpret_cast(field) - offset); + const Message* msg = reinterpret_cast( + reinterpret_cast(field) - offset); return msg->absolute_binary_offset; } @@ -299,37 +305,39 @@ struct Message { return absl::OkStatus(); } - void *GetUserMetadata() { + void* GetUserMetadata() { return runtime->pb->ToAddress(runtime->pb->metadata); } - void *Allocate(size_t size, size_t alignment = 4, bool clear = true) { + void* Allocate(size_t size, size_t alignment = 4, bool clear = true) { (void)alignment; return toolbelt::PayloadBuffer::Allocate( &runtime->pb, static_cast(size), clear); } - void Free(void *ptr) { runtime->pb->Free(ptr); } + void Free(void* ptr) { runtime->pb->Free(ptr); } - void *Realloc(void *ptr, size_t size, size_t alignment = 4, + void* Realloc(void* ptr, size_t size, size_t alignment = 4, bool clear = true) { (void)alignment; - return toolbelt::PayloadBuffer::Realloc( - &runtime->pb, ptr, static_cast(size), clear); + return toolbelt::PayloadBuffer::Realloc(&runtime->pb, ptr, + static_cast(size), clear); } - toolbelt::BufferOffset ToOffset(void *addr) { + toolbelt::BufferOffset ToOffset(void* addr) { return runtime->pb->ToOffset(addr); } - template T *ToAddress(toolbelt::BufferOffset offset) { + template + T* ToAddress(toolbelt::BufferOffset offset) { return runtime->pb->ToAddress(offset); } - template void InstallMetadata() { + template + void InstallMetadata() { auto metadata = runtime->GetMetadata(MessageType::FullName()); if (metadata != 0) { - ::toolbelt::BufferOffset *header = + ::toolbelt::BufferOffset* header = runtime->pb->ToAddress<::toolbelt::BufferOffset>( absolute_binary_offset); *header = metadata; @@ -337,10 +345,10 @@ struct Message { } // Allocate space for field data in the payload buffer and copy it in. - void *fields = ::toolbelt::PayloadBuffer::Allocate( + void* fields = ::toolbelt::PayloadBuffer::Allocate( &runtime->pb, sizeof(MessageType::field_data), false); memcpy(fields, &MessageType::field_data, sizeof(MessageType::field_data)); - ::toolbelt::BufferOffset *header = + ::toolbelt::BufferOffset* header = runtime->pb->ToAddress<::toolbelt::BufferOffset>( absolute_binary_offset); *header = runtime->pb->ToOffset(fields); @@ -354,22 +362,22 @@ struct Message { // Similar for field id for presence bit mask. int32_t FindFieldId(uint32_t field_number) const; - void *BinaryData() const { + void* BinaryData() const { return runtime->pb->ToAddress(absolute_binary_offset); } - void *Data() const { return reinterpret_cast(runtime->pb); } + void* Data() const { return reinterpret_cast(runtime->pb); } size_t Size() const { return runtime->pb->Size(); } size_t ZeroCopySize() const { return runtime->pb->Size(); } }; -::toolbelt::PayloadBuffer * -NewDynamicBuffer(size_t initial_size, Tuning tuning = Tuning::kPerformance); +::toolbelt::PayloadBuffer* NewDynamicBuffer( + size_t initial_size, Tuning tuning = Tuning::kPerformance); -absl::StatusOr<::toolbelt::PayloadBuffer *> NewDynamicBuffer( - size_t initial_size, std::function(size_t)> alloc, - std::function(void *, size_t, size_t)> realloc, +absl::StatusOr<::toolbelt::PayloadBuffer*> NewDynamicBuffer( + size_t initial_size, std::function(size_t)> alloc, + std::function(void*, size_t, size_t)> realloc, Tuning tuning = Tuning::kPerformance); -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/message_test.cc b/phaser/runtime/message_test.cc index 8f1c407..eefa7de 100644 --- a/phaser/runtime/message_test.cc +++ b/phaser/runtime/message_test.cc @@ -2,14 +2,16 @@ // All Rights Reserved // See LICENSE file for licensing information. +#include + +#include + #include "absl/strings/str_format.h" #include "phaser/runtime/phaser_bank.h" #include "phaser/runtime/runtime.h" #include "phaser/testdata/TestMessage.pb.h" #include "toolbelt/hexdump.h" #include "toolbelt/payload_buffer.h" -#include -#include using PayloadBuffer = ::toolbelt::PayloadBuffer; using BufferOffset = ::toolbelt::BufferOffset; @@ -25,12 +27,12 @@ enum class EnumTest : uint16_t { UNSET = 0, FOO = 0xda, BAR = 0xad }; struct EnumTestStringizer { std::string operator()(EnumTest e) const { switch (e) { - case EnumTest::FOO: - return "FOO"; - case EnumTest::BAR: - return "BAR"; - case EnumTest::UNSET: - return "UNSET"; + case EnumTest::FOO: + return "FOO"; + case EnumTest::BAR: + return "BAR"; + case EnumTest::UNSET: + return "UNSET"; } return "UNKNOWN"; } @@ -93,13 +95,13 @@ struct InnerMessage : public Message { std::string GetName() const override { return Name(); } std::string GetFullName() const override { return FullName(); } - friend std::ostream &operator<<(std::ostream &os, const InnerMessage &msg); + friend std::ostream& operator<<(std::ostream& os, const InnerMessage& msg); - const ::phaser::MessageInfo *GetMessageInfo() const override { + const ::phaser::MessageInfo* GetMessageInfo() const override { return InnerMessage::GetMessageInfoStatic(); } - static const ::phaser::MessageInfo *GetMessageInfoStatic() { + static const ::phaser::MessageInfo* GetMessageInfoStatic() { static phaser::MessageInfo info; if (!info.full_name.empty()) { return &info; @@ -121,7 +123,7 @@ struct InnerMessage : public Message { std::make_shared("uv", offsetof(InnerMessage, uv_)); // Add to fields maps. - for (auto &f : info.fields_in_order) { + for (auto& f : info.fields_in_order) { info.fields_by_number[f->number] = f; info.fields_by_name[f->name] = f; } @@ -135,7 +137,7 @@ struct InnerMessage : public Message { u->fields_in_order[1] = std::make_shared( "uvb", phaser::FieldType::kFieldEnum, 60, u->offset, 1); // Add to fields map. - for (auto &f : u->fields_in_order) { + for (auto& f : u->fields_in_order) { info.fields_by_number[f->number] = f; info.fields_by_name[f->name] = f; } @@ -144,8 +146,9 @@ struct InnerMessage : public Message { return &info; } - static InnerMessage CreateMutable(void *addr, size_t size) { - ::toolbelt::PayloadBuffer *pb = new (addr)::toolbelt::PayloadBuffer(static_cast(size)); + static InnerMessage CreateMutable(void* addr, size_t size) { + ::toolbelt::PayloadBuffer* pb = + new (addr)::toolbelt::PayloadBuffer(static_cast(size)); ::toolbelt::PayloadBuffer::AllocateMainMessage(&pb, InnerMessage::BinarySize()); auto runtime = std::make_shared(pb); @@ -168,12 +171,12 @@ struct InnerMessage : public Message { return os.str(); } - void CopyFrom(const Message &m) override { - const InnerMessage &other = static_cast(m); + void CopyFrom(const Message& m) override { + const InnerMessage& other = static_cast(m); (void)CloneFrom(other); } - absl::Status CloneFrom(const InnerMessage &other) { + absl::Status CloneFrom(const InnerMessage& other) { if (other.str_.IsPresent()) { str_.Set(other.str_.Get()); } @@ -183,29 +186,34 @@ struct InnerMessage : public Message { if (other.e_.IsPresent()) { e_.Set(other.e_.Get()); } - for (auto &v : other.ev_) { + for (auto& v : other.ev_) { ev_.Add(v); } switch (other.uv_.Discriminator()) { - case 50: - if (absl::Status s = uv_.CloneFrom<0>(other.uv_.GetValue<0, uint32_t>()); - !s.ok()) { - return s; - } - break; - case 60: - if (absl::Status s = uv_.CloneFrom<1>(other.uv_.GetValue<1, EnumTest>()); - !s.ok()) { - return s; - } - break; + case 50: + if (absl::Status s = + uv_.CloneFrom<0>(other.uv_.GetValue<0, uint32_t>()); + !s.ok()) { + return s; + } + break; + case 60: + if (absl::Status s = + uv_.CloneFrom<1>(other.uv_.GetValue<1, EnumTest>()); + !s.ok()) { + return s; + } + break; } return absl::OkStatus(); } // Protobuf accessors. std::string_view str() const { return str_.Get(); } - template void set_str(Str str) { str_.Set(str); } + template + void set_str(Str str) { + str_.Set(str); + } void clear_str() { str_.Clear(); } bool has_str() const { return str_.IsPresent(); } @@ -242,17 +250,17 @@ struct InnerMessage : public Message { } size += ev_.SerializedSize(); switch (uv_.Discriminator()) { - case 50: - size += uv_.SerializedSize<0>(50); - break; - case 60: - size += uv_.SerializedSize<1>(60); - break; + case 50: + size += uv_.SerializedSize<0>(50); + break; + case 60: + size += uv_.SerializedSize<1>(60); + break; } return size; } - absl::Status Serialize(phaser::ProtoBuffer &buffer) const { + absl::Status Serialize(phaser::ProtoBuffer& buffer) const { if (str_.IsPresent()) { if (absl::Status status = str_.Serialize(buffer); !status.ok()) { return status; @@ -273,22 +281,22 @@ struct InnerMessage : public Message { } switch (uv_.Discriminator()) { - case 50: - if (absl::Status status = uv_.Serialize<0>(50, buffer); !status.ok()) { - return status; - } - break; - case 60: - if (absl::Status status = uv_.Serialize<1>(60, buffer); !status.ok()) { - return status; - } - break; + case 50: + if (absl::Status status = uv_.Serialize<0>(50, buffer); !status.ok()) { + return status; + } + break; + case 60: + if (absl::Status status = uv_.Serialize<1>(60, buffer); !status.ok()) { + return status; + } + break; } return absl::OkStatus(); } - absl::Status Deserialize(phaser::ProtoBuffer &buffer) { + absl::Status Deserialize(phaser::ProtoBuffer& buffer) { while (!buffer.Eof()) { absl::StatusOr tag = buffer.DeserializeVarint(); @@ -297,49 +305,49 @@ struct InnerMessage : public Message { } uint32_t field_number = *tag >> phaser::ProtoBuffer::kFieldIdShift; switch (field_number) { - case 10: - if (absl::Status status = str_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 20: - if (absl::Status status = f_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 30: - if (absl::Status status = e_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 40: - if (absl::Status status = ev_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 50: - if (absl::Status status = uv_.Deserialize<0>(50, buffer); - !status.ok()) { - return status; - } - break; - case 60: - if (absl::Status status = uv_.Deserialize<1>(60, buffer); - !status.ok()) { - return status; - } - break; - default: - if (absl::Status status = buffer.SkipTag(*tag); !status.ok()) { - return status; - } + case 10: + if (absl::Status status = str_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 20: + if (absl::Status status = f_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 30: + if (absl::Status status = e_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 40: + if (absl::Status status = ev_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 50: + if (absl::Status status = uv_.Deserialize<0>(50, buffer); + !status.ok()) { + return status; + } + break; + case 60: + if (absl::Status status = uv_.Deserialize<1>(60, buffer); + !status.ok()) { + return status; + } + break; + default: + if (absl::Status status = buffer.SkipTag(*tag); !status.ok()) { + return status; + } } } return absl::OkStatus(); } phaser::StringField str_; - phaser::Uint64Field f_; // Fixed size. + phaser::Uint64Field f_; // Fixed size. phaser::EnumField e_; phaser::EnumVectorField ev_; @@ -349,7 +357,7 @@ struct InnerMessage : public Message { uv_; }; -inline std::ostream &operator<<(std::ostream &os, const InnerMessage &msg) { +inline std::ostream& operator<<(std::ostream& os, const InnerMessage& msg) { if (msg.str_.IsPresent()) { msg.str_.PrintIndent(os); os << "str: " << msg.str_ << std::endl; @@ -362,133 +370,132 @@ inline std::ostream &operator<<(std::ostream &os, const InnerMessage &msg) { msg.e_.PrintIndent(os); os << "e: " << msg.e_ << std::endl; } - for (auto &v : msg.ev_) { + for (auto& v : msg.ev_) { msg.ev_.PrintIndent(os); os << "ev: " << EnumTestStringizer()(v) << std::endl; } switch (msg.uv_.Discriminator()) { - case 50: - msg.uv_.PrintIndent(os); - os << "uva: "; - msg.uv_.Print<0>(os); - os << std::endl; - break; - case 60: - msg.uv_.PrintIndent(os); - os << "uvb: "; - msg.uv_.Print<1>(os); - os << std::endl; - break; + case 50: + msg.uv_.PrintIndent(os); + os << "uva: "; + msg.uv_.Print<0>(os); + os << std::endl; + break; + case 60: + msg.uv_.PrintIndent(os); + os << "uvb: "; + msg.uv_.Print<1>(os); + os << std::endl; + break; } return os; } -static void InnerMessageStreamTo(const Message &msg, std::ostream &os, +static void InnerMessageStreamTo(const Message& msg, std::ostream& os, int /*indent*/) { - const InnerMessage *m = static_cast(&msg); + const InnerMessage* m = static_cast(&msg); os << *m; } -static absl::Status InnerMessageSerializeToBuffer(const Message &msg, - phaser::ProtoBuffer &buffer) { - const InnerMessage *m = static_cast(&msg); +static absl::Status InnerMessageSerializeToBuffer(const Message& msg, + phaser::ProtoBuffer& buffer) { + const InnerMessage* m = static_cast(&msg); return m->Serialize(buffer); } -static absl::Status -InnerMessageDeserializeFromBuffer(Message &msg, phaser::ProtoBuffer &buffer) { - InnerMessage *m = static_cast(&msg); +static absl::Status InnerMessageDeserializeFromBuffer( + Message& msg, phaser::ProtoBuffer& buffer) { + InnerMessage* m = static_cast(&msg); return m->Deserialize(buffer); } -static size_t InnerMessageSerializedSize(const Message &msg) { - const InnerMessage *m = static_cast(&msg); +static size_t InnerMessageSerializedSize(const Message& msg) { + const InnerMessage* m = static_cast(&msg); return m->SerializedSize(); } -static Message * -InnerMessageAllocateAtOffset(std::shared_ptr<::phaser::MessageRuntime> runtime, - toolbelt::BufferOffset offset) { +static Message* InnerMessageAllocateAtOffset( + std::shared_ptr<::phaser::MessageRuntime> runtime, + toolbelt::BufferOffset offset) { auto msg = new InnerMessage(runtime, offset); msg->InstallMetadata(); return msg; } -static std::pair -InnerMessageAllocate(std::shared_ptr<::phaser::MessageRuntime> runtime) { - void *addr = toolbelt::PayloadBuffer::Allocate( - &runtime->pb, InnerMessage::BinarySize()); +static std::pair InnerMessageAllocate( + std::shared_ptr<::phaser::MessageRuntime> runtime) { + void* addr = toolbelt::PayloadBuffer::Allocate(&runtime->pb, + InnerMessage::BinarySize()); toolbelt::BufferOffset offset = runtime->pb->ToOffset(addr); auto msg = new InnerMessage(runtime, offset); msg->InstallMetadata(); return std::make_pair(msg, offset); } -static void InnerMessageClear(Message &msg) { - InnerMessage *m = static_cast(&msg); +static void InnerMessageClear(Message& msg) { + InnerMessage* m = static_cast(&msg); m->Clear(); } -static absl::Status InnerMessageCopy(const Message &src, Message &dst) { - const InnerMessage *src_m = static_cast(&src); - InnerMessage *dst_m = static_cast(&dst); +static absl::Status InnerMessageCopy(const Message& src, Message& dst) { + const InnerMessage* src_m = static_cast(&src); + InnerMessage* dst_m = static_cast(&dst); return dst_m->CloneFrom(*src_m); } -static const Message * -InnerMessageMakeExisting(std::shared_ptr<::phaser::MessageRuntime> runtime, - const void *data) { +static const Message* InnerMessageMakeExisting( + std::shared_ptr<::phaser::MessageRuntime> runtime, const void* data) { return new InnerMessage(runtime, runtime->pb->ToOffset(data)); } static size_t InnerMessageBinarySize() { return InnerMessage::BinarySize(); } -static const phaser::MessageInfo *InnerMessageMessageInfo() { +static const phaser::MessageInfo* InnerMessageMessageInfo() { return InnerMessage::GetMessageInfoStatic(); } -static bool InnerMessageHasField(const phaser::Message &msg, int number) { - const InnerMessage *m = static_cast(&msg); +static bool InnerMessageHasField(const phaser::Message& msg, int number) { + const InnerMessage* m = static_cast(&msg); switch (number) { - case 10: - return m->str_.IsPresent(); - case 20: - return m->f_.IsPresent(); - case 30: - return m->e_.IsPresent(); - case 40: - return m->ev_.size() > 0; - case 50: - return m->uv_.Discriminator() == 50; - case 60: - return m->uv_.Discriminator() == 60; + case 10: + return m->str_.IsPresent(); + case 20: + return m->f_.IsPresent(); + case 30: + return m->e_.IsPresent(); + case 40: + return m->ev_.size() > 0; + case 50: + return m->uv_.Discriminator() == 50; + case 60: + return m->uv_.Discriminator() == 60; } return false; } -static void *InnerMessageFindFieldByNumber(Message &msg, int number) { +static void* InnerMessageFindFieldByNumber(Message& msg, int number) { if (!InnerMessageHasField(msg, number)) { return nullptr; } - const phaser::MessageInfo *info = InnerMessage::GetMessageInfoStatic(); + const phaser::MessageInfo* info = InnerMessage::GetMessageInfoStatic(); auto it = info->fields_by_number.find(number); if (it != info->fields_by_number.end()) { - char *m = reinterpret_cast(&msg); + char* m = reinterpret_cast(&msg); return m + it->second->offset; } return nullptr; } -static void *InnerMessageFindFieldByName(Message &msg, - const std::string &name) { - const phaser::MessageInfo *info = InnerMessage::GetMessageInfoStatic(); +static void* InnerMessageFindFieldByName(Message& msg, + const std::string& name) { + const phaser::MessageInfo* info = InnerMessage::GetMessageInfoStatic(); auto it = info->fields_by_name.find(name); if (it != info->fields_by_name.end()) { if (!InnerMessageHasField(msg, it->second->number)) { return nullptr; } - char *m = reinterpret_cast(&msg); + char* m = reinterpret_cast(&msg); return m + it->second->offset; } return nullptr; @@ -548,8 +555,9 @@ struct TestMessage : public Message { u2_(offsetof(TestMessage, u2_), HeaderSize() + 56, 0, 0, {109, 110}), u3_(offsetof(TestMessage, u3_), HeaderSize() + 64, 0, 0, {111, 112}) {} - static TestMessage CreateMutable(void *addr, size_t size) { - ::toolbelt::PayloadBuffer *pb = new (addr)::toolbelt::PayloadBuffer(static_cast(size)); + static TestMessage CreateMutable(void* addr, size_t size) { + ::toolbelt::PayloadBuffer* pb = + new (addr)::toolbelt::PayloadBuffer(static_cast(size)); ::toolbelt::PayloadBuffer::AllocateMainMessage(&pb, TestMessage::BinarySize()); auto runtime = std::make_shared(pb); @@ -558,28 +566,30 @@ struct TestMessage : public Message { return msg; } - static TestMessage CreateReadonly(void *addr) { - ::toolbelt::PayloadBuffer *pb = - reinterpret_cast<::toolbelt::PayloadBuffer *>(addr); + static TestMessage CreateReadonly(void* addr) { + ::toolbelt::PayloadBuffer* pb = + reinterpret_cast<::toolbelt::PayloadBuffer*>(addr); auto runtime = std::make_shared(pb); return TestMessage(runtime, pb->message); } static TestMessage CreateDynamicMutable(size_t initial_size = 1024) { - ::toolbelt::PayloadBuffer *pb = phaser::NewDynamicBuffer(initial_size); + ::toolbelt::PayloadBuffer* pb = phaser::NewDynamicBuffer(initial_size); ::toolbelt::PayloadBuffer::AllocateMainMessage(&pb, TestMessage::BinarySize()); - auto runtime = std::make_shared(pb, ::free); + auto runtime = + std::make_shared(pb, ::free); auto msg = TestMessage(runtime, pb->message); msg.InstallMetadata(); return msg; } void InitDynamicMutable(size_t initial_size = 1024) { - ::toolbelt::PayloadBuffer *pb = phaser::NewDynamicBuffer(initial_size); + ::toolbelt::PayloadBuffer* pb = phaser::NewDynamicBuffer(initial_size); ::toolbelt::PayloadBuffer::AllocateMainMessage(&pb, TestMessage::BinarySize()); - auto rt = std::make_shared(pb, ::free); + auto rt = + std::make_shared(pb, ::free); this->runtime = rt; this->absolute_binary_offset = pb->message; this->InstallMetadata(); @@ -630,8 +640,8 @@ struct TestMessage : public Message { std::string GetName() const override { return Name(); } std::string GetFullName() const override { return FullName(); } - void CopyFrom(const Message &m) override { - const TestMessage &other = static_cast(m); + void CopyFrom(const Message& m) override { + const TestMessage& other = static_cast(m); (void)CloneFrom(other); } @@ -651,7 +661,7 @@ struct TestMessage : public Message { u3_.Clear<1>(); } - const ::phaser::MessageInfo *GetMessageInfo() const override { + const ::phaser::MessageInfo* GetMessageInfo() const override { return nullptr; } @@ -679,35 +689,35 @@ struct TestMessage : public Message { size += vstr_.SerializedSize(); size += vm_.SerializedSize(); switch (u1_.Discriminator()) { - case 107: - size += u1_.SerializedSize<0>(107); - break; - case 108: - size += u1_.SerializedSize<1>(108); - break; + case 107: + size += u1_.SerializedSize<0>(107); + break; + case 108: + size += u1_.SerializedSize<1>(108); + break; } switch (u2_.Discriminator()) { - case 109: - size += u2_.SerializedSize<0>(109); - break; - case 110: - size += u2_.SerializedSize<1>(110); - break; + case 109: + size += u2_.SerializedSize<0>(109); + break; + case 110: + size += u2_.SerializedSize<1>(110); + break; } switch (u3_.Discriminator()) { - case 111: - size += u3_.SerializedSize<0>(111); - break; - case 112: - size += u3_.SerializedSize<1>(112); - break; + case 111: + size += u3_.SerializedSize<0>(111); + break; + case 112: + size += u3_.SerializedSize<1>(112); + break; } return size; } - absl::Status Serialize(phaser::ProtoBuffer &buffer) const { + absl::Status Serialize(phaser::ProtoBuffer& buffer) const { if (x_.IsPresent()) { if (absl::Status status = x_.Serialize(buffer); !status.ok()) { return status; @@ -740,139 +750,139 @@ struct TestMessage : public Message { } // Union fields. switch (u1_.Discriminator()) { - case 107: - if (absl::Status status = u1_.Serialize<0>(107, buffer); !status.ok()) { - return status; - } - break; - case 108: - if (absl::Status status = u1_.Serialize<1>(108, buffer); !status.ok()) { - return status; - } - break; - } - - // u2. - switch (u2_.Discriminator()) { - case 109: - if (absl::Status status = u2_.Serialize<0>(109, buffer); !status.ok()) { - return status; - } - break; - case 110: - if (absl::Status status = u2_.Serialize<1>(110, buffer); !status.ok()) { - return status; - } - break; - } - - // u3. - switch (u3_.Discriminator()) { - case 111: - if (absl::Status status = u3_.Serialize<0>(111, buffer); !status.ok()) { - return status; - } - break; - case 112: - if (absl::Status status = u3_.Serialize<1>(112, buffer); !status.ok()) { - return status; - } - break; - } - - return absl::OkStatus(); - } - - absl::Status Deserialize(phaser::ProtoBuffer &buffer) { - while (!buffer.Eof()) { - absl::StatusOr tag = - buffer.DeserializeVarint(); - if (!tag.ok()) { - return tag.status(); - } - uint32_t field_number = *tag >> phaser::ProtoBuffer::kFieldIdShift; - switch (field_number) { - case 100: - if (absl::Status status = x_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 101: - if (absl::Status status = y_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 102: - if (absl::Status status = s_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 103: - if (absl::Status status = m_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 104: - if (absl::Status status = vi32_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 105: - if (absl::Status status = vstr_.Deserialize(buffer); !status.ok()) { - return status; - } - break; - case 106: - if (absl::Status status = vm_.Deserialize(buffer); !status.ok()) { - return status; - } - break; case 107: - if (absl::Status status = u1_.Deserialize<0>(107, buffer); - !status.ok()) { + if (absl::Status status = u1_.Serialize<0>(107, buffer); !status.ok()) { return status; } break; case 108: - if (absl::Status status = u1_.Deserialize<1>(108, buffer); - !status.ok()) { + if (absl::Status status = u1_.Serialize<1>(108, buffer); !status.ok()) { return status; } break; + } + + // u2. + switch (u2_.Discriminator()) { case 109: - if (absl::Status status = u2_.Deserialize<0>(109, buffer); - !status.ok()) { + if (absl::Status status = u2_.Serialize<0>(109, buffer); !status.ok()) { return status; } break; case 110: - if (absl::Status status = u2_.Deserialize<1>(110, buffer); - !status.ok()) { + if (absl::Status status = u2_.Serialize<1>(110, buffer); !status.ok()) { return status; } break; + } + + // u3. + switch (u3_.Discriminator()) { case 111: - if (absl::Status status = u3_.Deserialize<0>(111, buffer); - !status.ok()) { + if (absl::Status status = u3_.Serialize<0>(111, buffer); !status.ok()) { return status; } break; case 112: - if (absl::Status status = u3_.Deserialize<1>(112, buffer); - !status.ok()) { + if (absl::Status status = u3_.Serialize<1>(112, buffer); !status.ok()) { return status; } break; - default: - if (absl::Status status = buffer.SkipTag(*tag); !status.ok()) { - return status; - } + } + + return absl::OkStatus(); + } + + absl::Status Deserialize(phaser::ProtoBuffer& buffer) { + while (!buffer.Eof()) { + absl::StatusOr tag = + buffer.DeserializeVarint(); + if (!tag.ok()) { + return tag.status(); + } + uint32_t field_number = *tag >> phaser::ProtoBuffer::kFieldIdShift; + switch (field_number) { + case 100: + if (absl::Status status = x_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 101: + if (absl::Status status = y_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 102: + if (absl::Status status = s_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 103: + if (absl::Status status = m_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 104: + if (absl::Status status = vi32_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 105: + if (absl::Status status = vstr_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 106: + if (absl::Status status = vm_.Deserialize(buffer); !status.ok()) { + return status; + } + break; + case 107: + if (absl::Status status = u1_.Deserialize<0>(107, buffer); + !status.ok()) { + return status; + } + break; + case 108: + if (absl::Status status = u1_.Deserialize<1>(108, buffer); + !status.ok()) { + return status; + } + break; + case 109: + if (absl::Status status = u2_.Deserialize<0>(109, buffer); + !status.ok()) { + return status; + } + break; + case 110: + if (absl::Status status = u2_.Deserialize<1>(110, buffer); + !status.ok()) { + return status; + } + break; + case 111: + if (absl::Status status = u3_.Deserialize<0>(111, buffer); + !status.ok()) { + return status; + } + break; + case 112: + if (absl::Status status = u3_.Deserialize<1>(112, buffer); + !status.ok()) { + return status; + } + break; + default: + if (absl::Status status = buffer.SkipTag(*tag); !status.ok()) { + return status; + } } } return absl::OkStatus(); } - friend std::ostream &operator<<(std::ostream &os, const TestMessage &msg); + friend std::ostream& operator<<(std::ostream& os, const TestMessage& msg); void Indent(int indent) { x_.Indent(indent); @@ -887,7 +897,7 @@ struct TestMessage : public Message { u3_.Indent(indent); } - absl::Status CloneFrom(const TestMessage &src) { + absl::Status CloneFrom(const TestMessage& src) { if (src.x_.IsPresent()) { x_.Set(src.x_.Get()); } else { @@ -904,7 +914,7 @@ struct TestMessage : public Message { s_.Clear(); } if (src.m_.IsPresent()) { - auto *m = mutable_m(); + auto* m = mutable_m(); if (absl::Status s = m->CloneFrom(src.m()); !s.ok()) { return s; } @@ -916,48 +926,49 @@ struct TestMessage : public Message { add_vstr(src.vstr(i)); } for (size_t i = 0; i < src.vm_size(); ++i) { - auto *m = add_vm(); + auto* m = add_vm(); if (absl::Status s = m->CloneFrom(src.vm(i)); !s.ok()) { return s; } } switch (src.u1_.Discriminator()) { - case 107: - if (absl::Status status = u1_.CloneFrom<0, uint32_t>(src.u1a()); - !status.ok()) { - return status; - } - break; - case 108: - if (absl::Status s = u1_.CloneFrom<1, uint64_t>(src.u1b()); !s.ok()) { - return s; - } - break; + case 107: + if (absl::Status status = u1_.CloneFrom<0, uint32_t>(src.u1a()); + !status.ok()) { + return status; + } + break; + case 108: + if (absl::Status s = u1_.CloneFrom<1, uint64_t>(src.u1b()); !s.ok()) { + return s; + } + break; } switch (src.u2_.Discriminator()) { - case 109: - if (absl::Status s = u2_.CloneFrom<0, int64_t>(src.u2a()); !s.ok()) { - return s; - } - break; - case 110: - if (absl::Status s = u2_.CloneFrom<1, std::string_view>(src.u2b()); - !s.ok()) { - return s; - } - break; + case 109: + if (absl::Status s = u2_.CloneFrom<0, int64_t>(src.u2a()); !s.ok()) { + return s; + } + break; + case 110: + if (absl::Status s = u2_.CloneFrom<1, std::string_view>(src.u2b()); + !s.ok()) { + return s; + } + break; } switch (src.u3_.Discriminator()) { - case 111: - if (absl::Status s = u3_.CloneFrom<0, int64_t>(src.u3a()); !s.ok()) { - return s; - } - break; - case 112: - if (absl::Status s = u3_.CloneFrom<1, InnerMessage>(src.u3b()); !s.ok()) { - return s; - } - break; + case 111: + if (absl::Status s = u3_.CloneFrom<0, int64_t>(src.u3a()); !s.ok()) { + return s; + } + break; + case 112: + if (absl::Status s = u3_.CloneFrom<1, InnerMessage>(src.u3b()); + !s.ok()) { + return s; + } + break; } return absl::OkStatus(); } @@ -974,13 +985,13 @@ struct TestMessage : public Message { bool has_y() const { return y_.IsPresent(); } std::string_view s() const { return s_.Get(); } - void set_s(const std::string &s) { s_.Set(s); } + void set_s(const std::string& s) { s_.Set(s); } void clear_s() { s_.Clear(); } bool has_s() const { return s_.IsPresent(); } absl::Span allocate_s(size_t len) { return s_.Allocate(len); } - const InnerMessage &m() const { return m_.Get(); } - InnerMessage *mutable_m() { return m_.Mutable(); } + const InnerMessage& m() const { return m_.Get(); } + InnerMessage* mutable_m() { return m_.Mutable(); } void clear_m() { m_.Clear(); } bool has_m() const { return m_.IsPresent(); } void set_m(toolbelt::BufferOffset offset) { m_.SetOffset(offset); } @@ -990,30 +1001,32 @@ struct TestMessage : public Message { void add_vi32(int32_t v) { vi32_.Add(v); } void set_vi32(size_t i, int32_t v) { vi32_.Set(i, v); } void clear_vi32() { vi32_.Clear(); } - phaser::PrimitiveVectorField &vi32() { + phaser::PrimitiveVectorField& vi32() { return vi32_; } size_t vstr_size() const { return vstr_.size(); } - std::string_view vstr(size_t i) const { - return vstr_.Get(i); + std::string_view vstr(size_t i) const { return vstr_.Get(i); } + template + void add_vstr(Str v) { + vstr_.Add(v); + } + template + void set_vstr(size_t i, Str v) { + vstr_.Set(i, v); } - template void add_vstr(Str v) { vstr_.Add(v); } - template void set_vstr(size_t i, Str v) { vstr_.Set(i, v); } void clear_vstr() { vstr_.Clear(); } - phaser::StringVectorField &vstr() { + phaser::StringVectorField& vstr() { vstr_.Populate(); return vstr_; } size_t vm_size() const { return vm_.size(); } - const InnerMessage &vm(size_t i) const { return vm_.Get(i); } - InnerMessage *mutable_vm(size_t i) { - return vm_.Mutable(i); - } - InnerMessage *add_vm() { return vm_.Add(); } + const InnerMessage& vm(size_t i) const { return vm_.Get(i); } + InnerMessage* mutable_vm(size_t i) { return vm_.Mutable(i); } + InnerMessage* add_vm() { return vm_.Add(); } void clear_vm() { vm_.Clear(); } - phaser::MessageVectorField &vm() { + phaser::MessageVectorField& vm() { vm_.Populate(); return vm_; } @@ -1045,7 +1058,7 @@ struct TestMessage : public Message { void clear_u2a() { u2_.Clear<0>(); } std::string_view u2b() const { return u2_.GetValue<1, std::string_view>(); } - void set_u2b(const std::string &v) { + void set_u2b(const std::string& v) { u2_.Clear<0>(); u2_.Set<1>(v); } @@ -1060,10 +1073,10 @@ struct TestMessage : public Message { } void clear_u3a() { u3_.Clear<0>(); } - const InnerMessage &u3b() const { + const InnerMessage& u3b() const { return u3_.GetReference<1, InnerMessage>(); } - InnerMessage *mutable_u3b() { + InnerMessage* mutable_u3b() { u3_.Clear<0>(); return u3_.Mutable<1, InnerMessage>(); } @@ -1090,14 +1103,12 @@ struct TestMessage : public Message { phaser::UnionMessageField> u3_; - void DebugDump() { - runtime->pb->Dump(std::cout); - } + void DebugDump() { runtime->pb->Dump(std::cout); } }; #pragma clang diagnostic pop -inline std::ostream &operator<<(std::ostream &os, const TestMessage &msg) { +inline std::ostream& operator<<(std::ostream& os, const TestMessage& msg) { if (msg.x_.IsPresent()) { msg.x_.PrintIndent(os); os << "x: " << msg.x_ << std::endl; @@ -1119,125 +1130,124 @@ inline std::ostream &operator<<(std::ostream &os, const TestMessage &msg) { } // Repeated Fields. - for (auto &v : msg.vi32_) { + for (auto& v : msg.vi32_) { msg.vi32_.PrintIndent(os); os << "vi32: " << v << std::endl; } - for (auto &v : msg.vstr_) { + for (auto& v : msg.vstr_) { msg.vstr_.PrintIndent(os); os << "vstr: " << v << std::endl; } - for (auto &v : msg.vm_) { + for (auto& v : msg.vm_) { msg.vm_.PrintIndent(os); os << "vm: " << v << std::endl; } // Unions switch (msg.u1_.Discriminator()) { - case 107: - msg.u1_.PrintIndent(os); - os << "u1a: "; - msg.u1_.Print<0>(os); - os << std::endl; - break; - case 108: - msg.u1_.PrintIndent(os); - os << "u1b: "; - msg.u1_.Print<1>(os); - os << std::endl; - break; + case 107: + msg.u1_.PrintIndent(os); + os << "u1a: "; + msg.u1_.Print<0>(os); + os << std::endl; + break; + case 108: + msg.u1_.PrintIndent(os); + os << "u1b: "; + msg.u1_.Print<1>(os); + os << std::endl; + break; } switch (msg.u2_.Discriminator()) { - case 109: - msg.u2_.PrintIndent(os); - os << "u2a: "; - msg.u2_.Print<0>(os); - os << std::endl; - break; - case 110: - msg.u2_.PrintIndent(os); - os << "u2b: "; - msg.u2_.Print<1>(os); - os << std::endl; - break; + case 109: + msg.u2_.PrintIndent(os); + os << "u2a: "; + msg.u2_.Print<0>(os); + os << std::endl; + break; + case 110: + msg.u2_.PrintIndent(os); + os << "u2b: "; + msg.u2_.Print<1>(os); + os << std::endl; + break; } switch (msg.u3_.Discriminator()) { - case 111: - msg.u3_.PrintIndent(os); - os << "u3a: "; - msg.u3_.Print<0>(os); - os << std::endl; - break; - case 112: - msg.u3_.PrintIndent(os); - os << "u3b: "; - msg.u3_.Print<1>(os); - os << std::endl; - break; + case 111: + msg.u3_.PrintIndent(os); + os << "u3a: "; + msg.u3_.Print<0>(os); + os << std::endl; + break; + case 112: + msg.u3_.PrintIndent(os); + os << "u3b: "; + msg.u3_.Print<1>(os); + os << std::endl; + break; } return os; } -static void TestMessageStreamTo(const Message &msg, std::ostream &os, +static void TestMessageStreamTo(const Message& msg, std::ostream& os, int /*indent*/) { - const TestMessage *m = static_cast(&msg); + const TestMessage* m = static_cast(&msg); os << *m; } -static absl::Status TestMessageSerializeToBuffer(const Message &msg, - phaser::ProtoBuffer &buffer) { - const TestMessage *m = static_cast(&msg); +static absl::Status TestMessageSerializeToBuffer(const Message& msg, + phaser::ProtoBuffer& buffer) { + const TestMessage* m = static_cast(&msg); return m->Serialize(buffer); } -static absl::Status -TestMessageDeserializeFromBuffer(Message &msg, phaser::ProtoBuffer &buffer) { - TestMessage *m = static_cast(&msg); +static absl::Status TestMessageDeserializeFromBuffer( + Message& msg, phaser::ProtoBuffer& buffer) { + TestMessage* m = static_cast(&msg); return m->Deserialize(buffer); } -static size_t TestMessageSerializedSize(const Message &msg) { - const TestMessage *m = static_cast(&msg); +static size_t TestMessageSerializedSize(const Message& msg) { + const TestMessage* m = static_cast(&msg); return m->SerializedSize(); } -static Message * -TestMessageAllocateAtOffset(std::shared_ptr<::phaser::MessageRuntime> runtime, - toolbelt::BufferOffset offset) { +static Message* TestMessageAllocateAtOffset( + std::shared_ptr<::phaser::MessageRuntime> runtime, + toolbelt::BufferOffset offset) { auto msg = new TestMessage(runtime, offset); msg->InstallMetadata(); return msg; } -static std::pair -TestMessageAllocate(std::shared_ptr<::phaser::MessageRuntime> runtime) { - void *addr = toolbelt::PayloadBuffer::Allocate( - &runtime->pb, TestMessage::BinarySize()); +static std::pair TestMessageAllocate( + std::shared_ptr<::phaser::MessageRuntime> runtime) { + void* addr = toolbelt::PayloadBuffer::Allocate(&runtime->pb, + TestMessage::BinarySize()); toolbelt::BufferOffset offset = runtime->pb->ToOffset(addr); auto msg = new TestMessage(runtime, offset); msg->InstallMetadata(); return std::make_pair(msg, offset); } -static void TestMessageClear(Message &msg) { - TestMessage *m = static_cast(&msg); +static void TestMessageClear(Message& msg) { + TestMessage* m = static_cast(&msg); m->Clear(); } -static absl::Status TestMessageCopy(const Message &src, Message &dst) { - const TestMessage *src_m = static_cast(&src); - TestMessage *dst_m = static_cast(&dst); +static absl::Status TestMessageCopy(const Message& src, Message& dst) { + const TestMessage* src_m = static_cast(&src); + TestMessage* dst_m = static_cast(&dst); return dst_m->CloneFrom(*src_m); } -static const Message * -TestMessageMakeExisting(std::shared_ptr<::phaser::MessageRuntime> runtime, - const void *data) { +static const Message* TestMessageMakeExisting( + std::shared_ptr<::phaser::MessageRuntime> runtime, const void* data) { return new TestMessage(runtime, runtime->pb->ToOffset(data)); } @@ -1269,7 +1279,7 @@ static struct TestMessageBankRegister { } TestMessage_bank_register; TEST(MessageTest, Basic) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.DebugDump(); @@ -1295,13 +1305,13 @@ TEST(MessageTest, Basic) { ASSERT_EQ("Hello, world!", s); ASSERT_TRUE(msg.m_.IsPresent()); - auto &inner2 = msg.m_.Get(); + auto& inner2 = msg.m_.Get(); ASSERT_EQ("Inner message", inner2.str_.Get()); ASSERT_EQ(0xdeadbeef, inner2.f_.Get()); // Copy message to test reading. { - char *buffer2 = static_cast(calloc(4096, 1)); + char* buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); @@ -1318,7 +1328,7 @@ TEST(MessageTest, Basic) { ASSERT_EQ("Hello, world!", ro_s); ASSERT_TRUE(ro_msg.m_.IsPresent()); - auto &ro_inner = ro_msg.m_.Get(); + auto& ro_inner = ro_msg.m_.Get(); ASSERT_EQ("Inner message", ro_inner.str_.Get()); ASSERT_EQ(0xdeadbeef, ro_inner.f_.Get()); free(buffer2); @@ -1327,7 +1337,7 @@ TEST(MessageTest, Basic) { } TEST(MessageTest, RepeatedPrimitive) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); // This field is absent. @@ -1338,7 +1348,7 @@ TEST(MessageTest, RepeatedPrimitive) { msg.DebugDump(); int i = 1; - for (auto &v : msg.vi32_) { + for (auto& v : msg.vi32_) { ASSERT_EQ(i, v); i++; } @@ -1347,12 +1357,12 @@ TEST(MessageTest, RepeatedPrimitive) { // Copy message to test reading. { - char *buffer2 = static_cast(calloc(4096, 1)); + char* buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); int ro_i = 1; - for (auto &v : ro_msg.vi32_) { + for (auto& v : ro_msg.vi32_) { ASSERT_EQ(ro_i, v); ro_i++; } @@ -1364,7 +1374,7 @@ TEST(MessageTest, RepeatedPrimitive) { } TEST(MessageTest, RepeatedString) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.DebugDump(); @@ -1374,9 +1384,9 @@ TEST(MessageTest, RepeatedString) { msg.DebugDump(); - const char *strings[] = {"one", "two", "three", "four"}; + const char* strings[] = {"one", "two", "three", "four"}; int i = 0; - for (auto &v : msg.vstr_) { + for (auto& v : msg.vstr_) { ASSERT_EQ(strings[i], v.Get()); i++; } @@ -1390,12 +1400,12 @@ TEST(MessageTest, RepeatedString) { // Copy message to test reading. { - char *buffer2 = static_cast(calloc(4096, 1)); + char* buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); int ro_i = 0; - for (auto &v : ro_msg.vstr_) { + for (auto& v : ro_msg.vstr_) { ASSERT_EQ(strings[ro_i], v.Get()); ro_i++; } @@ -1409,40 +1419,40 @@ TEST(MessageTest, RepeatedString) { } TEST(MessageTest, RepeatedMessage) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); - InnerMessage *inner1 = msg.vm_.Add(); + InnerMessage* inner1 = msg.vm_.Add(); inner1->str_.Set("one"); inner1->f_.Set(0xdeadbeef); - InnerMessage *inner2 = msg.vm_.Mutable(2); + InnerMessage* inner2 = msg.vm_.Mutable(2); inner2->str_.Set("two"); inner2->f_.Set(0x1234); msg.DebugDump(); { - auto &ro_inner1 = msg.vm_.Get(0); + auto& ro_inner1 = msg.vm_.Get(0); ASSERT_EQ("one", ro_inner1.str_.Get()); ASSERT_EQ(0xdeadbeef, ro_inner1.f_.Get()); - auto &ro_inner2 = msg.vm_.Get(2); + auto& ro_inner2 = msg.vm_.Get(2); ASSERT_EQ("two", ro_inner2.str_.Get()); ASSERT_EQ(0x1234, ro_inner2.f_.Get()); } // Copy message to test reading. { - char *buffer2 = static_cast(calloc(4096, 1)); + char* buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); - auto &ro_inner1 = ro_msg.vm_.Get(0); + auto& ro_inner1 = ro_msg.vm_.Get(0); ASSERT_EQ("one", ro_inner1.str_.Get()); ASSERT_EQ(0xdeadbeef, ro_inner1.f_.Get()); - auto &ro_inner2 = ro_msg.vm_.Get(2); + auto& ro_inner2 = ro_msg.vm_.Get(2); ASSERT_EQ("two", ro_inner2.str_.Get()); ASSERT_EQ(0x1234, ro_inner2.f_.Get()); free(buffer2); @@ -1451,12 +1461,12 @@ TEST(MessageTest, RepeatedMessage) { } TEST(MessageTest, UnionField) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.u1_.Set<0>(1234u); msg.u2_.Set<1>("Hello, world!"); - InnerMessage *inner = msg.u3_.Mutable<1, InnerMessage>(); + InnerMessage* inner = msg.u3_.Mutable<1, InnerMessage>(); inner->str_.Set("Inner message"); inner->f_.Set(0xdeadbeef); @@ -1479,7 +1489,7 @@ TEST(MessageTest, UnionField) { // in-buffer storage to a smaller block, which drives toolbelt's // PayloadBuffer::Realloc -> ShrinkBlock path. TEST(MessageTest, UnionArmSwitchInPlace) { - char *buffer = static_cast(calloc(8192, 1)); + char* buffer = static_cast(calloc(8192, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 8192); // Grow then repeatedly shrink the string arm on the same message. Each shrink @@ -1506,7 +1516,7 @@ TEST(MessageTest, UnionArmSwitchInPlace) { // Message arm: populate it, switch to the scalar arm, then back again. { - InnerMessage *inner = msg.mutable_u3b(); + InnerMessage* inner = msg.mutable_u3b(); inner->str_.Set("an inner message with a reasonably long string payload"); inner->f_.Set(0xfeedface); } @@ -1520,7 +1530,7 @@ TEST(MessageTest, UnionArmSwitchInPlace) { // Back to the message arm, then shrink the inner string in place. { - InnerMessage *inner = msg.mutable_u3b(); + InnerMessage* inner = msg.mutable_u3b(); inner->str_.Set("longer inner string to allocate a sizeable block here"); inner->str_.Set("short"); } @@ -1532,7 +1542,7 @@ TEST(MessageTest, UnionArmSwitchInPlace) { } TEST(MessageTest, ClearBasic) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.x_.Set(1234); @@ -1558,7 +1568,7 @@ TEST(MessageTest, ClearBasic) { } TEST(MessageTest, ClearRepeated) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.vi32_.Add(1); @@ -1568,11 +1578,11 @@ TEST(MessageTest, ClearRepeated) { msg.vstr_.Add("one"); msg.vstr_.Add("two"); - auto *inner1 = msg.vm_.Add(); + auto* inner1 = msg.vm_.Add(); inner1->str_.Set("one"); inner1->f_.Set(0xdeadbeef); - auto *inner2 = msg.vm_.Add(); + auto* inner2 = msg.vm_.Add(); inner2->str_.Set("two"); inner2->f_.Set(0x1234); @@ -1593,12 +1603,12 @@ TEST(MessageTest, ClearRepeated) { } TEST(MessageTest, ClearUnion) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.u1_.Set<0>(1234u); msg.u2_.Set<1>("Hello, world!"); - InnerMessage *inner = msg.u3_.Mutable<1, InnerMessage>(); + InnerMessage* inner = msg.u3_.Mutable<1, InnerMessage>(); inner->str_.Set("Inner message"); inner->f_.Set(0xdeadbeef); @@ -1613,7 +1623,7 @@ TEST(MessageTest, ClearUnion) { } TEST(MessageTest, ProtobufBasic) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); msg.set_x(1234); @@ -1636,7 +1646,7 @@ TEST(MessageTest, ProtobufBasic) { // Copy message to test reading. { - char *buffer2 = static_cast(calloc(4096, 1)); + char* buffer2 = static_cast(calloc(4096, 1)); memcpy(buffer2, buffer, 4096); TestMessage ro_msg = TestMessage::CreateReadonly(buffer2); @@ -1655,25 +1665,25 @@ TEST(MessageTest, ProtobufBasic) { } TEST(MessageTest, ProtobufSerializationSizeBasic) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); - msg.set_x(1); // Tag 100 + msg.set_x(1); // Tag 100 ASSERT_EQ(3, msg.x_.SerializedSize()); msg.set_x(0x80); ASSERT_EQ(4, msg.x_.SerializedSize()); - msg.set_x(0x3fff); // Max can fit into 2 bytes for the value. + msg.set_x(0x3fff); // Max can fit into 2 bytes for the value. ASSERT_EQ(4, msg.x_.SerializedSize()); - msg.set_x(0x4000); // One more than can fit into 2 bytes for the value. + msg.set_x(0x4000); // One more than can fit into 2 bytes for the value. ASSERT_EQ(5, msg.x_.SerializedSize()); msg.set_s("Hello, world!"); ASSERT_EQ(16, msg.s_.SerializedSize()); auto inner = msg.mutable_m(); - inner->set_str("Inner message"); // Tag 10, size: 15 - inner->set_f(0xdeadbeef); // Tag 20, size: 10 - ASSERT_EQ(25, inner->SerializedSize()); // 25 bytes + inner->set_str("Inner message"); // Tag 10, size: 15 + inner->set_f(0xdeadbeef); // Tag 20, size: 10 + ASSERT_EQ(25, inner->SerializedSize()); // 25 bytes size_t m_size = msg.m_.SerializedSize(); size_t expected_size = 5 + 16 + m_size; @@ -1683,7 +1693,7 @@ TEST(MessageTest, ProtobufSerializationSizeBasic) { foo::bar::TestMessage pb_msg; pb_msg.set_x(0x4000); pb_msg.set_s("Hello, world!"); - auto *pb_inner = pb_msg.mutable_m(); + auto* pb_inner = pb_msg.mutable_m(); pb_inner->set_str("Inner message"); pb_inner->set_f(0xdeadbeef); @@ -1694,24 +1704,24 @@ TEST(MessageTest, ProtobufSerializationSizeBasic) { } TEST(MessageTest, ProtobufSerializationSizeUnion) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); - msg.set_u1a(1234); // Tag 107. + msg.set_u1a(1234); // Tag 107. ASSERT_EQ(4, msg.u1_.SerializedSize<0>(107)); - msg.set_u1b(0xdeadbeef); // Tag 108. + msg.set_u1b(0xdeadbeef); // Tag 108. ASSERT_EQ(10, msg.u1_.SerializedSize<1>(108)); - msg.set_u2a(1234); // Tag 109. + msg.set_u2a(1234); // Tag 109. ASSERT_EQ(4, msg.u2_.SerializedSize<0>(109)); - msg.set_u2b("Hello, world!"); // Tag 110. + msg.set_u2b("Hello, world!"); // Tag 110. ASSERT_EQ(16, msg.u2_.SerializedSize<1>(110)); // u3 auto inner = msg.mutable_u3b(); - inner->set_str("Inner message"); // Tag 10, size: 15 - inner->set_f(0xdeadbeef); // Tag 20, size: 10 - ASSERT_EQ(25, inner->SerializedSize()); // 25 bytes + inner->set_str("Inner message"); // Tag 10, size: 15 + inner->set_f(0xdeadbeef); // Tag 20, size: 10 + ASSERT_EQ(25, inner->SerializedSize()); // 25 bytes size_t m_size = msg.u3_.SerializedSize<1>(112); size_t expected_size = 10 + 16 + m_size; @@ -1721,7 +1731,7 @@ TEST(MessageTest, ProtobufSerializationSizeUnion) { foo::bar::TestMessage pb_msg; pb_msg.set_u1b(0xdeadbeef); pb_msg.set_u2b("Hello, world!"); - auto *pb_inner = pb_msg.mutable_u3b(); + auto* pb_inner = pb_msg.mutable_u3b(); pb_inner->set_str("Inner message"); pb_inner->set_f(0xdeadbeef); @@ -1732,7 +1742,7 @@ TEST(MessageTest, ProtobufSerializationSizeUnion) { } TEST(MessageTest, ProtobufSerializationSizeRepeatedPrimitive) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); // Tag 104. @@ -1768,7 +1778,7 @@ TEST(MessageTest, ProtobufSerializationSizeRepeatedPrimitive) { } TEST(MessageTest, ProtobufSerializationBasic) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb; @@ -1784,7 +1794,7 @@ TEST(MessageTest, ProtobufSerializationBasic) { pb_msg.set_x(1); pb_msg.set_y(0xffff); pb_msg.set_s("Hello, world!"); - auto *pb_inner = pb_msg.mutable_m(); + auto* pb_inner = pb_msg.mutable_m(); pb_inner->set_str("Inner message"); pb_inner->set_f(0xdeadbeef); @@ -1795,7 +1805,7 @@ TEST(MessageTest, ProtobufSerializationBasic) { } TEST(MessageTest, ProtobufSerializationRepeated) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb; @@ -1808,11 +1818,11 @@ TEST(MessageTest, ProtobufSerializationRepeated) { msg.add_vstr("two"); msg.add_vstr("three"); - auto *inner1 = msg.vm_.Add(); + auto* inner1 = msg.vm_.Add(); inner1->set_str("one"); inner1->set_f(0xdeadbeef); - auto *inner2 = msg.vm_.Add(); + auto* inner2 = msg.vm_.Add(); inner2->set_str("two"); inner2->set_f(0x1234); @@ -1827,11 +1837,11 @@ TEST(MessageTest, ProtobufSerializationRepeated) { pb_msg.add_vstr("two"); pb_msg.add_vstr("three"); - auto *pb_inner1 = pb_msg.add_vm(); + auto* pb_inner1 = pb_msg.add_vm(); pb_inner1->set_str("one"); pb_inner1->set_f(0xdeadbeef); - auto *pb_inner2 = pb_msg.add_vm(); + auto* pb_inner2 = pb_msg.add_vm(); pb_inner2->set_str("two"); pb_inner2->set_f(0x1234); @@ -1842,7 +1852,7 @@ TEST(MessageTest, ProtobufSerializationRepeated) { } TEST(MessageTest, ProtobufSerializationUnion) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb; @@ -1858,7 +1868,7 @@ TEST(MessageTest, ProtobufSerializationUnion) { pb_msg.set_u1a(1234); pb_msg.set_u2b("Hello, world!"); - auto *pb_inner = pb_msg.mutable_u3b(); + auto* pb_inner = pb_msg.mutable_u3b(); pb_inner->set_str("Inner message"); pb_inner->set_f(0xdeadbeef); @@ -1875,12 +1885,12 @@ TEST(MessageTest, ProtobufDeserializationBasic) { pb_msg.set_y(0xffff); pb_msg.set_s("Hello, world!"); - auto *pb_inner = pb_msg.mutable_m(); + auto* pb_inner = pb_msg.mutable_m(); pb_inner->set_str("Inner message"); pb_inner->set_f(0xdeadbeef); std::string str = pb_msg.SerializeAsString(); - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb_buffer(str); @@ -1908,16 +1918,16 @@ TEST(MessageTest, ProtobufDeserializationRepeated) { pb_msg.add_vstr("two"); pb_msg.add_vstr("three"); - auto *pb_inner1 = pb_msg.add_vm(); + auto* pb_inner1 = pb_msg.add_vm(); pb_inner1->set_str("one"); pb_inner1->set_f(0xdeadbeef); - auto *pb_inner2 = pb_msg.add_vm(); + auto* pb_inner2 = pb_msg.add_vm(); pb_inner2->set_str("two"); pb_inner2->set_f(0x1234); std::string str = pb_msg.SerializeAsString(); - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb_buffer(str); @@ -1940,12 +1950,12 @@ TEST(MessageTest, ProtobufDeserializationUnion) { pb_msg.set_u1a(1234); pb_msg.set_u2b("Hello, world!"); - auto *pb_inner = pb_msg.mutable_u3b(); + auto* pb_inner = pb_msg.mutable_u3b(); pb_inner->set_str("Inner message"); pb_inner->set_f(0xdeadbeef); std::string str = pb_msg.SerializeAsString(); - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); phaser::ProtoBuffer pb_buffer(str); @@ -2003,18 +2013,18 @@ TEST(MessageTest, Print) { msg.vstr_.Add("one"); msg.vstr_.Add("two"); - auto *inner1 = msg.vm_.Add(); + auto* inner1 = msg.vm_.Add(); inner1->str_.Set("one"); inner1->f_.Set(0xdeadbeef); - auto *inner2 = msg.vm_.Add(); + auto* inner2 = msg.vm_.Add(); inner2->str_.Set("two"); inner2->f_.Set(0x1234); // Unions. msg.u1_.Set<0>(1234u); msg.u2_.Set<1>("Hello, world!"); - InnerMessage *inner3 = msg.u3_.Mutable<1, InnerMessage>(); + InnerMessage* inner3 = msg.u3_.Mutable<1, InnerMessage>(); inner3->str_.Set("Inner message"); inner3->f_.Set(0xdeadbeef); @@ -2028,9 +2038,9 @@ TEST(MessageTest, Print) { } TEST(MessageTest, MessageInfo) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); InnerMessage msg = InnerMessage::CreateMutable(buffer, 4096); - const ::phaser::MessageInfo *info = msg.GetMessageInfo(); + const ::phaser::MessageInfo* info = msg.GetMessageInfo(); ASSERT_EQ("foo.bar.InnerMessage", info->full_name); ASSERT_EQ(5, info->fields_in_order.size()); ASSERT_EQ("str", info->fields_in_order[0]->name); @@ -2039,12 +2049,12 @@ TEST(MessageTest, MessageInfo) { } TEST(MessageTest, PhaserBank) { - char *buffer = static_cast(calloc(4096, 1)); + char* buffer = static_cast(calloc(4096, 1)); TestMessage msg = TestMessage::CreateMutable(buffer, 4096); auto status = ::phaser::PhaserBankAllocate( "foo.bar.InnerMessage", msg.runtime); ASSERT_TRUE(status.ok()); - auto[inner, offset] = *status; + auto [inner, offset] = *status; msg.set_m(offset); inner->set_str("Inner message"); @@ -2053,7 +2063,7 @@ TEST(MessageTest, PhaserBank) { free(buffer); } -int main(int argc, char **argv) { +int main(int argc, char** argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); diff --git a/phaser/runtime/phaser_bank.cc b/phaser/runtime/phaser_bank.cc index aa8c8a9..e2df153 100644 --- a/phaser/runtime/phaser_bank.cc +++ b/phaser/runtime/phaser_bank.cc @@ -3,14 +3,16 @@ // See LICENSE file for licensing information. #include "phaser/runtime/phaser_bank.h" -#include "absl/strings/str_format.h" + #include +#include "absl/strings/str_format.h" + namespace phaser { std::unique_ptr> phaser_banks_; -absl::StatusOr GetPhaserBankInfo(std::string message_type) { +absl::StatusOr GetPhaserBankInfo(std::string message_type) { auto it = phaser_banks_->find(message_type); if (it == phaser_banks_->end()) { return absl::InternalError( @@ -19,7 +21,7 @@ absl::StatusOr GetPhaserBankInfo(std::string message_type) { return &it->second; } -void PhaserBankRegisterMessage(const std::string &name, const BankInfo &info) { +void PhaserBankRegisterMessage(const std::string& name, const BankInfo& info) { if (!phaser_banks_) { // Lazy init because we can't guarantee the order of static initialization. phaser_banks_ = @@ -28,9 +30,9 @@ void PhaserBankRegisterMessage(const std::string &name, const BankInfo &info) { (*phaser_banks_)[name] = info; } -absl::Status PhaserStreamTo(const std::string &message_type, const Message &msg, - std::ostream &os, int indent) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::Status PhaserStreamTo(const std::string& message_type, const Message& msg, + std::ostream& os, int indent) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } @@ -38,9 +40,9 @@ absl::Status PhaserStreamTo(const std::string &message_type, const Message &msg, return absl::OkStatus(); } -absl::StatusOr -PhaserBankDebugString(const std::string &message_type, const Message &msg) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr PhaserBankDebugString( + const std::string& message_type, const Message& msg) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } @@ -49,48 +51,48 @@ PhaserBankDebugString(const std::string &message_type, const Message &msg) { return os.str(); } -absl::Status PhaserBankSerializeToBuffer(const std::string &message_type, - const Message &msg, - ProtoBuffer &buffer) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::Status PhaserBankSerializeToBuffer(const std::string& message_type, + const Message& msg, + ProtoBuffer& buffer) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->serialize_to_buffer(msg, buffer); } -absl::Status PhaserBankDeserializeFromBuffer(const std::string &message_type, - Message &msg, - ProtoBuffer &buffer) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::Status PhaserBankDeserializeFromBuffer(const std::string& message_type, + Message& msg, + ProtoBuffer& buffer) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->deserialize_from_buffer(msg, buffer); } -absl::StatusOr PhaserBankSerializedSize(const std::string &message_type, - const Message &msg) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr PhaserBankSerializedSize(const std::string& message_type, + const Message& msg) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->serialized_size(msg); } -absl::StatusOr -PhaserBankAllocateAtOffset(const std::string &message_type, - std::shared_ptr<::phaser::MessageRuntime> runtime, - toolbelt::BufferOffset offset) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr PhaserBankAllocateAtOffset( + const std::string& message_type, + std::shared_ptr<::phaser::MessageRuntime> runtime, + toolbelt::BufferOffset offset) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->allocate_at_offset(runtime, offset); } -absl::Status PhaserBankClear(const std::string &message_type, Message &msg) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::Status PhaserBankClear(const std::string& message_type, Message& msg) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } @@ -98,49 +100,48 @@ absl::Status PhaserBankClear(const std::string &message_type, Message &msg) { return absl::OkStatus(); } -absl::Status PhaserBankCopy(const std::string &message_type, const Message &src, - Message &dst) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::Status PhaserBankCopy(const std::string& message_type, const Message& src, + Message& dst) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->copy(src, dst); } -absl::StatusOr -PhaserBankMakeExisting(const std::string &message_type, - std::shared_ptr<::phaser::MessageRuntime> runtime, - const void *data) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr PhaserBankMakeExisting( + const std::string& message_type, + std::shared_ptr<::phaser::MessageRuntime> runtime, const void* data) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->make_existing(runtime, data); } -absl::StatusOr PhaserBankBinarySize(const std::string &message_type) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr PhaserBankBinarySize(const std::string& message_type) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->binary_size(); } -absl::StatusOr -PhaserBankMessageInfo(const std::string &message_type) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr PhaserBankMessageInfo( + const std::string& message_type) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->message_info(); } -absl::StatusOr PhaserBankHasField(const std::string &message_type, - const Message &msg, int number) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr PhaserBankHasField(const std::string& message_type, + const Message& msg, int number) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->has_field(msg, number); } -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/phaser_bank.h b/phaser/runtime/phaser_bank.h index 3253674..0995dde 100644 --- a/phaser/runtime/phaser_bank.h +++ b/phaser/runtime/phaser_bank.h @@ -11,120 +11,117 @@ namespace phaser { struct BankInfo { - void (*stream_to)(const Message &msg, std::ostream &os, int indent); - absl::Status (*serialize_to_buffer)(const Message &msg, ProtoBuffer &buffer); - absl::Status (*deserialize_from_buffer)(Message &msg, ProtoBuffer &buffer); - size_t (*serialized_size)(const Message &msg); - Message *(*allocate_at_offset)( + void (*stream_to)(const Message& msg, std::ostream& os, int indent); + absl::Status (*serialize_to_buffer)(const Message& msg, ProtoBuffer& buffer); + absl::Status (*deserialize_from_buffer)(Message& msg, ProtoBuffer& buffer); + size_t (*serialized_size)(const Message& msg); + Message* (*allocate_at_offset)( std::shared_ptr<::phaser::MessageRuntime> runtime, toolbelt::BufferOffset offset); - std::pair (*allocate)( + std::pair (*allocate)( std::shared_ptr<::phaser::MessageRuntime> runtime); - void (*clear)(Message &msg); - absl::Status (*copy)(const Message &src, Message &dst); - const Message *(*make_existing)( - std::shared_ptr<::phaser::MessageRuntime> runtime, const void *data); + void (*clear)(Message& msg); + absl::Status (*copy)(const Message& src, Message& dst); + const Message* (*make_existing)( + std::shared_ptr<::phaser::MessageRuntime> runtime, const void* data); size_t (*binary_size)(); - const MessageInfo *(*message_info)(); - bool (*has_field)(const Message &msg, int number); - void *(*get_field_by_name)(Message &msg, const std::string &name); - void *(*get_field_by_number)(Message &msg, int number); + const MessageInfo* (*message_info)(); + bool (*has_field)(const Message& msg, int number); + void* (*get_field_by_name)(Message& msg, const std::string& name); + void* (*get_field_by_number)(Message& msg, int number); }; extern std::unique_ptr> phaser_banks_; -absl::StatusOr GetPhaserBankInfo(std::string message_type); +absl::StatusOr GetPhaserBankInfo(std::string message_type); -void PhaserBankRegisterMessage(const std::string &name, const BankInfo &info); +void PhaserBankRegisterMessage(const std::string& name, const BankInfo& info); -absl::Status PhaserStreamTo(const std::string &message_type, const Message &msg, - std::ostream &os, int indent); -absl::StatusOr -PhaserBankDebugString(const std::string &message_type, const Message &msg); +absl::Status PhaserStreamTo(const std::string& message_type, const Message& msg, + std::ostream& os, int indent); +absl::StatusOr PhaserBankDebugString( + const std::string& message_type, const Message& msg); -absl::Status PhaserBankSerializeToBuffer(const std::string &message_type, - const Message &msg, - ProtoBuffer &buffer); -absl::Status PhaserBankDeserializeFromBuffer(const std::string &message_type, - Message &msg, ProtoBuffer &buffer); -absl::StatusOr PhaserBankSerializedSize(const std::string &message_type, - const Message &msg); +absl::Status PhaserBankSerializeToBuffer(const std::string& message_type, + const Message& msg, + ProtoBuffer& buffer); +absl::Status PhaserBankDeserializeFromBuffer(const std::string& message_type, + Message& msg, ProtoBuffer& buffer); +absl::StatusOr PhaserBankSerializedSize(const std::string& message_type, + const Message& msg); // This allocates a message from the heap (using new) with its storage in the // payload buffer. The ownership of the heap memory is passed back to the // caller, so you can make a std::unique_ptr from the result or // otherwise manage the memory. -absl::StatusOr -PhaserBankAllocateAtOffset(const std::string &message_type, - std::shared_ptr<::phaser::MessageRuntime> runtime, - toolbelt::BufferOffset offset); +absl::StatusOr PhaserBankAllocateAtOffset( + const std::string& message_type, + std::shared_ptr<::phaser::MessageRuntime> runtime, + toolbelt::BufferOffset offset); template -inline absl::StatusOr> -PhaserBankAllocate(const std::string &message_type, - std::shared_ptr<::phaser::MessageRuntime> runtime) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +inline absl::StatusOr> PhaserBankAllocate( + const std::string& message_type, + std::shared_ptr<::phaser::MessageRuntime> runtime) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } - auto[msg, offset] = (*bank_info)->allocate(runtime); - return std::make_pair(static_cast(msg), offset); + auto [msg, offset] = (*bank_info)->allocate(runtime); + return std::make_pair(static_cast(msg), offset); } template <> -inline absl::StatusOr> -PhaserBankAllocate(const std::string &message_type, +inline absl::StatusOr> +PhaserBankAllocate(const std::string& message_type, std::shared_ptr<::phaser::MessageRuntime> runtime) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } return (*bank_info)->allocate(runtime); } -absl::Status PhaserBankClear(const std::string &message_type, Message &msg); +absl::Status PhaserBankClear(const std::string& message_type, Message& msg); -absl::Status PhaserBankCopy(const std::string &message_type, const Message &src, - Message &dst); +absl::Status PhaserBankCopy(const std::string& message_type, const Message& src, + Message& dst); -absl::StatusOr -PhaserBankMakeExisting(const std::string &message_type, - std::shared_ptr<::phaser::MessageRuntime> runtime, - const void *data); +absl::StatusOr PhaserBankMakeExisting( + const std::string& message_type, + std::shared_ptr<::phaser::MessageRuntime> runtime, const void* data); -absl::StatusOr PhaserBankBinarySize(const std::string &message_type); +absl::StatusOr PhaserBankBinarySize(const std::string& message_type); -absl::StatusOr -PhaserBankMessageInfo(const std::string &message_type); +absl::StatusOr PhaserBankMessageInfo( + const std::string& message_type); -absl::StatusOr PhaserBankHasField(const std::string &message_type, - const Message &msg, int number); +absl::StatusOr PhaserBankHasField(const std::string& message_type, + const Message& msg, int number); template -absl::StatusOr -inline PhaserBankGetFieldByName(const std::string &message_type, Message &msg, - const std::string &name) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr inline PhaserBankGetFieldByName( + const std::string& message_type, Message& msg, const std::string& name) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } - Field *result = - reinterpret_cast((*bank_info)->get_field_by_name(msg, name)); + Field* result = + reinterpret_cast((*bank_info)->get_field_by_name(msg, name)); return result; } template -absl::StatusOr -inline PhaserBankGetFieldByNumber(const std::string &message_type, Message &msg, - int number) { - absl::StatusOr bank_info = GetPhaserBankInfo(message_type); +absl::StatusOr inline PhaserBankGetFieldByNumber( + const std::string& message_type, Message& msg, int number) { + absl::StatusOr bank_info = GetPhaserBankInfo(message_type); if (!bank_info.ok()) { return bank_info.status(); } - Field *result = - reinterpret_cast((*bank_info)->get_field_by_number(msg, number)); + Field* result = + reinterpret_cast((*bank_info)->get_field_by_number(msg, number)); return result; } -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/runtime.h b/phaser/runtime/runtime.h index ebd56b4..c930038 100644 --- a/phaser/runtime/runtime.h +++ b/phaser/runtime/runtime.h @@ -5,11 +5,10 @@ #pragma once #include -#include "phaser/runtime/message.h" - #include "phaser/runtime/any.h" #include "phaser/runtime/fields.h" #include "phaser/runtime/iterators.h" +#include "phaser/runtime/message.h" #include "phaser/runtime/phaser_bank.h" #include "phaser/runtime/union.h" #include "phaser/runtime/vectors.h" @@ -17,12 +16,12 @@ #include "toolbelt/payload_buffer.h" namespace phaser { -#define DEFINE_PRIMITIVE_FIELD_STREAMER(cname) \ - template \ - inline std::ostream &operator<<( \ - std::ostream &os, const cname##Field &field) { \ - os << field.GetForPrinting(); \ - return os; \ +#define DEFINE_PRIMITIVE_FIELD_STREAMER(cname) \ + template \ + inline std::ostream& operator<<( \ + std::ostream& os, const cname##Field& field) { \ + os << field.GetForPrinting(); \ + return os; \ } DEFINE_PRIMITIVE_FIELD_STREAMER(Int32) @@ -52,47 +51,47 @@ inline std::string StringWithOctalNonPrintables(std::string_view str) { // \n and \t). Everything else is printed as octal (3 digits). result.push_back('\\'); switch (uc) { - case '\n': - result.push_back('n'); - break; - case '\r': - result.push_back('r'); - break; - case '\t': - result.push_back('t'); - break; - default: - result.push_back(static_cast('0' + ((uc >> 6) & 7))); - result.push_back(static_cast('0' + ((uc >> 3) & 7))); - result.push_back(static_cast('0' + (uc & 7))); - break; + case '\n': + result.push_back('n'); + break; + case '\r': + result.push_back('r'); + break; + case '\t': + result.push_back('t'); + break; + default: + result.push_back(static_cast('0' + ((uc >> 6) & 7))); + result.push_back(static_cast('0' + ((uc >> 3) & 7))); + result.push_back(static_cast('0' + (uc & 7))); + break; } } } return result; } -inline std::ostream &operator<<(std::ostream &os, const StringField &field) { +inline std::ostream& operator<<(std::ostream& os, const StringField& field) { os << "\"" << StringWithOctalNonPrintables(field.Get()) << "\""; return os; } -inline std::ostream &operator<<(std::ostream &os, - const NonEmbeddedStringField &field) { +inline std::ostream& operator<<(std::ostream& os, + const NonEmbeddedStringField& field) { os << "\"" << StringWithOctalNonPrintables(field.Get()) << "\""; return os; } template -inline std::ostream & -operator<<(std::ostream &os, const EnumField &field) { +inline std::ostream& operator<<( + std::ostream& os, const EnumField& field) { os << field.GetForPrinting(); return os; } template -inline std::ostream &operator<<(std::ostream &os, - const IndirectMessageField &field) { +inline std::ostream& operator<<(std::ostream& os, + const IndirectMessageField& field) { os << "{\n"; field.Indent(2); os << field.Get(); @@ -103,8 +102,8 @@ inline std::ostream &operator<<(std::ostream &os, } template -inline std::ostream &operator<<(std::ostream &os, - const MessageObject &field) { +inline std::ostream& operator<<(std::ostream& os, + const MessageObject& field) { os << "{\n"; field.Indent(2); os << field.Get(); @@ -114,7 +113,7 @@ inline std::ostream &operator<<(std::ostream &os, return os; } -inline std::ostream &operator<<(std::ostream &os, const AnyField &field) { +inline std::ostream& operator<<(std::ostream& os, const AnyField& field) { // If the any field hasn't been set, don't print anything. if (!field.has_type_url() || !field.has_value()) { return os; @@ -126,18 +125,18 @@ inline std::ostream &operator<<(std::ostream &os, const AnyField &field) { return os; } -inline std::ostream &operator<<(std::ostream &os, const AnyMessage &msg) { +inline std::ostream& operator<<(std::ostream& os, const AnyMessage& msg) { if (msg.value_.IsPresent()) { // The value contains a message. We use the phaser bank to stream // actual message contents. - const char *addr = msg.value().data(); + const char* addr = msg.value().data(); os << "{\n"; msg.value_.Indent(2); msg.value_.PrintIndent(os); std::string type = msg.MessageTypeName(); os << "[" << msg.type_url() << "] {\n"; msg.value_.Indent(2); - absl::StatusOr s = + absl::StatusOr s = PhaserBankMakeExisting(type, msg.runtime, addr); if (!s.ok()) { os << "Error: " << s.status() << std::endl; @@ -161,4 +160,4 @@ inline std::ostream &operator<<(std::ostream &os, const AnyMessage &msg) { } return os; } -} +} // namespace phaser diff --git a/phaser/runtime/union.h b/phaser/runtime/union.h index 426e616..1be4a93 100644 --- a/phaser/runtime/union.h +++ b/phaser/runtime/union.h @@ -5,30 +5,32 @@ #pragma once // Union fields. -#include "absl/container/flat_hash_map.h" -#include "absl/status/status.h" -#include "absl/status/statusor.h" -#include "phaser/runtime/iterators.h" -#include "phaser/runtime/message.h" -#include "toolbelt/payload_buffer.h" #include #include + #include #include #include #include +#include "absl/container/flat_hash_map.h" +#include "absl/status/status.h" +#include "absl/status/statusor.h" +#include "phaser/runtime/iterators.h" +#include "phaser/runtime/message.h" +#include "toolbelt/payload_buffer.h" + namespace phaser { class UnionMemberField { -protected: - ::toolbelt::PayloadBuffer * - GetBuffer(const std::shared_ptr &runtime) const { + protected: + ::toolbelt::PayloadBuffer* GetBuffer( + const std::shared_ptr& runtime) const { return runtime->pb; } - ::toolbelt::PayloadBuffer ** - GetBufferAddr(const std::shared_ptr &runtime) const { + ::toolbelt::PayloadBuffer** GetBufferAddr( + const std::shared_ptr& runtime) const { return &runtime->pb; } }; @@ -36,37 +38,37 @@ class UnionMemberField { #define DEFINE_PRIMITIVE_UNION_FIELD(cname, type) \ template \ class Union##cname##Field : public UnionMemberField { \ - public: \ + public: \ Union##cname##Field() = default; \ - type Get(const std::shared_ptr &runtime, \ + type Get(const std::shared_ptr& runtime, \ uint32_t abs_offset) const { \ if (runtime == nullptr) { \ return type(); \ } \ return GetBuffer(runtime)->template Get(abs_offset); \ } \ - void Print(std::ostream &os, int /*indent*/, \ - const std::shared_ptr &runtime, \ + void Print(std::ostream& os, int /*indent*/, \ + const std::shared_ptr& runtime, \ uint32_t abs_offset) const { \ os << Get(runtime, abs_offset); \ } \ - void Set(type v, const std::shared_ptr &runtime, \ + void Set(type v, const std::shared_ptr& runtime, \ uint32_t abs_offset) { \ GetBuffer(runtime)->Set(abs_offset, v); \ } \ - void SetOffset(const std::shared_ptr & /*runtime*/, \ - uint32_t /*abs_offset*/, \ + void SetOffset(const std::shared_ptr& /*runtime*/, \ + uint32_t /*abs_offset*/, \ toolbelt::BufferOffset /*msg_offset*/) {} \ \ - bool Equal(const Union##cname##Field &other, \ - const std::shared_ptr &runtime, \ + bool Equal(const Union##cname##Field& other, \ + const std::shared_ptr& runtime, \ uint32_t abs_offset) { \ return Get(runtime, abs_offset) == other.Get(runtime, abs_offset); \ } \ - void Clear(const std::shared_ptr & /*runtime*/, \ + void Clear(const std::shared_ptr& /*runtime*/, \ uint32_t /*abs_offset*/) {} \ size_t SerializedSize(int number, \ - const std::shared_ptr &runtime, \ + const std::shared_ptr& runtime, \ uint32_t abs_offset) const { \ if constexpr (FixedSize) { \ return ProtoBuffer::TagSize(number, \ @@ -78,8 +80,8 @@ class UnionMemberField { Get(runtime, abs_offset)); \ } \ } \ - absl::Status Serialize(int number, ProtoBuffer &buffer, \ - const std::shared_ptr &runtime, \ + absl::Status Serialize(int number, ProtoBuffer& buffer, \ + const std::shared_ptr& runtime, \ uint32_t abs_offset) const { \ if constexpr (FixedSize) { \ return buffer.SerializeFixed(number, Get(runtime, abs_offset)); \ @@ -88,8 +90,8 @@ class UnionMemberField { Get(runtime, abs_offset)); \ } \ } \ - absl::Status Deserialize(ProtoBuffer &buffer, \ - const std::shared_ptr &runtime, \ + absl::Status Deserialize(ProtoBuffer& buffer, \ + const std::shared_ptr& runtime, \ uint32_t abs_offset) { \ absl::StatusOr v; \ if constexpr (FixedSize) { \ @@ -125,11 +127,11 @@ DEFINE_PRIMITIVE_UNION_FIELD(Bool, bool) template class UnionEnumField : public UnionMemberField { -public: + public: using T = typename std::underlying_type::type; UnionEnumField() = default; - Enum Get(const std::shared_ptr &runtime, + Enum Get(const std::shared_ptr& runtime, uint32_t abs_offset) const { if (runtime == nullptr) { return static_cast(0); @@ -140,58 +142,58 @@ class UnionEnumField : public UnionMemberField { abs_offset)); } - void Print(std::ostream &os, int /*indent*/, - const std::shared_ptr &runtime, + void Print(std::ostream& os, int /*indent*/, + const std::shared_ptr& runtime, uint32_t abs_offset) const { os << Stringizer()(Get(runtime, abs_offset)); } - T GetUnderlying(const std::shared_ptr &runtime, + T GetUnderlying(const std::shared_ptr& runtime, uint32_t abs_offset) const { return GetBuffer(runtime) ->template Get::type>(abs_offset); } - void SetOffset(const std::shared_ptr & /*runtime*/, + void SetOffset(const std::shared_ptr& /*runtime*/, uint32_t /*abs_offset*/, toolbelt::BufferOffset /*msg_offset*/) {} - void Set(Enum e, const std::shared_ptr &runtime, + void Set(Enum e, const std::shared_ptr& runtime, uint32_t abs_offset) { GetBuffer(runtime)->Set( abs_offset, static_cast::type>(e)); } - void Set(T e, const std::shared_ptr &runtime, + void Set(T e, const std::shared_ptr& runtime, uint32_t abs_offset) { GetBuffer(runtime)->Set(abs_offset, e); } - bool Equal(const UnionEnumField &other, - const std::shared_ptr &runtime, + bool Equal(const UnionEnumField& other, + const std::shared_ptr& runtime, uint32_t abs_offset) { return Get(runtime, abs_offset) == other.Get(runtime, abs_offset); } - void Clear(const std::shared_ptr & /*runtime*/, + void Clear(const std::shared_ptr& /*runtime*/, uint32_t /*abs_offset*/) {} size_t SerializedSize(int number, - const std::shared_ptr &runtime, + const std::shared_ptr& runtime, uint32_t abs_offset) const { return ProtoBuffer::TagSize(number, WireType::kVarint) + ProtoBuffer::VarintSize( GetUnderlying(runtime, abs_offset)); } - absl::Status Serialize(int number, ProtoBuffer &buffer, - const std::shared_ptr &runtime, + absl::Status Serialize(int number, ProtoBuffer& buffer, + const std::shared_ptr& runtime, uint32_t abs_offset) const { return buffer.SerializeVarint(number, GetUnderlying(runtime, abs_offset)); } - absl::Status Deserialize(ProtoBuffer &buffer, - const std::shared_ptr &runtime, + absl::Status Deserialize(ProtoBuffer& buffer, + const std::shared_ptr& runtime, uint32_t abs_offset) { absl::StatusOr v = buffer.DeserializeVarint(); if (!v.ok()) { @@ -205,10 +207,10 @@ class UnionEnumField : public UnionMemberField { // The union contains an offset to the string data (length and bytes). class UnionStringField : public UnionMemberField { -public: + public: UnionStringField() = default; - std::string_view Get(const std::shared_ptr &runtime, + std::string_view Get(const std::shared_ptr& runtime, uint32_t abs_offset) const { if (runtime == nullptr) { return ""; @@ -216,58 +218,58 @@ class UnionStringField : public UnionMemberField { return GetBuffer(runtime)->GetStringView(abs_offset); } - void Print(std::ostream &os, int /*indent*/, - const std::shared_ptr &runtime, + void Print(std::ostream& os, int /*indent*/, + const std::shared_ptr& runtime, uint32_t abs_offset) const { os << "\"" << std::string(Get(runtime, abs_offset)) << "\""; } - bool IsPresent(const std::shared_ptr &runtime, + bool IsPresent(const std::shared_ptr& runtime, uint32_t abs_offset) const { - const ::toolbelt::BufferOffset *addr = + const ::toolbelt::BufferOffset* addr = runtime->ToAddress(abs_offset); return *addr != 0; } - void SetOffset(const std::shared_ptr & /*runtime*/, + void SetOffset(const std::shared_ptr& /*runtime*/, uint32_t /*abs_offset*/, toolbelt::BufferOffset /*msg_offset*/) {} template - void Set(Str s, const std::shared_ptr &runtime, + void Set(Str s, const std::shared_ptr& runtime, uint32_t abs_offset) { ::toolbelt::PayloadBuffer::SetString(GetBufferAddr(runtime), s, abs_offset); } absl::Span Allocate(size_t size, - const std::shared_ptr &runtime, + const std::shared_ptr& runtime, uint32_t abs_offset) { return ::toolbelt::PayloadBuffer::AllocateString(GetBufferAddr(runtime), size, abs_offset); } - bool Equal(const UnionStringField &other, - const std::shared_ptr &runtime, + bool Equal(const UnionStringField& other, + const std::shared_ptr& runtime, uint32_t abs_offset) { return Get(runtime, abs_offset) == other.Get(runtime, abs_offset); } - size_t size(const std::shared_ptr &runtime, + size_t size(const std::shared_ptr& runtime, uint32_t abs_offset) const { return GetBuffer(runtime)->StringSize(abs_offset); } - const char *data(const std::shared_ptr &runtime, + const char* data(const std::shared_ptr& runtime, uint32_t abs_offset) const { return GetBuffer(runtime)->StringData(abs_offset); } - void Clear(const std::shared_ptr &runtime, + void Clear(const std::shared_ptr& runtime, uint32_t abs_offset) { ::toolbelt::PayloadBuffer::ClearString(GetBufferAddr(runtime), abs_offset); } size_t SerializedSize(int number, - const std::shared_ptr &runtime, + const std::shared_ptr& runtime, uint32_t abs_offset) const { size_t sz = size(runtime, abs_offset); return ProtoBuffer::TagSize(number, WireType::kLengthDelimited) + @@ -275,15 +277,15 @@ class UnionStringField : public UnionMemberField { sz; } - absl::Status Serialize(int number, ProtoBuffer &buffer, - const std::shared_ptr &runtime, + absl::Status Serialize(int number, ProtoBuffer& buffer, + const std::shared_ptr& runtime, uint32_t abs_offset) const { return buffer.SerializeLengthDelimited(number, data(runtime, abs_offset), size(runtime, abs_offset)); } - absl::Status Deserialize(ProtoBuffer &buffer, - const std::shared_ptr &runtime, + absl::Status Deserialize(ProtoBuffer& buffer, + const std::shared_ptr& runtime, uint32_t abs_offset) { absl::StatusOr v = buffer.DeserializeString(); if (!v.ok()) { @@ -299,12 +301,12 @@ class UnionStringField : public UnionMemberField { template class UnionMessageField : public UnionMemberField { -public: + public: UnionMessageField() : msg_(InternalDefault{}) {} - const MessageType &Get(const std::shared_ptr &runtime, + const MessageType& Get(const std::shared_ptr& runtime, uint32_t abs_offset) const { - ::toolbelt::BufferOffset *addr = GetIndirectAddress(runtime, abs_offset); + ::toolbelt::BufferOffset* addr = GetIndirectAddress(runtime, abs_offset); if (addr == nullptr || *addr == 0) { return msg_; } @@ -314,8 +316,8 @@ class UnionMessageField : public UnionMemberField { return msg_; } - void Print(std::ostream &os, int indent, - const std::shared_ptr &runtime, + void Print(std::ostream& os, int indent, + const std::shared_ptr& runtime, uint32_t abs_offset) const { os << "{\n"; auto msg = Get(runtime, abs_offset); @@ -328,21 +330,21 @@ class UnionMessageField : public UnionMemberField { os << "}"; } - bool IsPresent(const std::shared_ptr &runtime, + bool IsPresent(const std::shared_ptr& runtime, uint32_t abs_offset) const { - ::toolbelt::BufferOffset *addr = GetIndirectAddress(runtime, abs_offset); + ::toolbelt::BufferOffset* addr = GetIndirectAddress(runtime, abs_offset); return addr == nullptr || *addr != 0; } - MessageType *Mutable(const std::shared_ptr &runtime, + MessageType* Mutable(const std::shared_ptr& runtime, uint32_t abs_offset) { - ::toolbelt::BufferOffset *addr = GetIndirectAddress(runtime, abs_offset); + ::toolbelt::BufferOffset* addr = GetIndirectAddress(runtime, abs_offset); if (addr == nullptr || *addr != 0) { // Already allocated. return &msg_; } // Allocate a new message. - void *msg_addr = ::toolbelt::PayloadBuffer::Allocate( + void* msg_addr = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(runtime), MessageType::BinarySize()); ::toolbelt::BufferOffset msg_offset = GetBuffer(runtime)->ToOffset(msg_addr); @@ -354,14 +356,14 @@ class UnionMessageField : public UnionMemberField { // Buffer might have moved, get address of indirect again. addr = GetIndirectAddress(runtime, abs_offset); if (addr != nullptr) { - *addr = msg_offset; // Put message field offset into message. + *addr = msg_offset; // Put message field offset into message. } return &msg_; } - void SetOffset(const std::shared_ptr &runtime, uint32_t abs_offset, - toolbelt::BufferOffset msg_offset) { - ::toolbelt::BufferOffset *addr = GetIndirectAddress(runtime, abs_offset); + void SetOffset(const std::shared_ptr& runtime, + uint32_t abs_offset, toolbelt::BufferOffset msg_offset) { + ::toolbelt::BufferOffset* addr = GetIndirectAddress(runtime, abs_offset); if (addr == nullptr) { return; } @@ -370,18 +372,18 @@ class UnionMessageField : public UnionMemberField { msg_.absolute_binary_offset = msg_offset; } - absl::Status SerializeToBuffer(ProtoBuffer &buffer) const { + absl::Status SerializeToBuffer(ProtoBuffer& buffer) const { return msg_.SerializeToBuffer(buffer); } - absl::Status DeserializeFromBuffer(ProtoBuffer &buffer) { + absl::Status DeserializeFromBuffer(ProtoBuffer& buffer) { return msg_.DeserializeFromBuffer(buffer); } - void Set(const MessageType &msg, - const std::shared_ptr &runtime, + void Set(const MessageType& msg, + const std::shared_ptr& runtime, uint32_t abs_offset) { - ::toolbelt::BufferOffset *addr = GetIndirectAddress(runtime, abs_offset); + ::toolbelt::BufferOffset* addr = GetIndirectAddress(runtime, abs_offset); if (addr == nullptr) { return; } @@ -390,7 +392,7 @@ class UnionMessageField : public UnionMemberField { GetBuffer(runtime)->Free(runtime->ToAddress(*addr)); } // Allocate a new message. - void *msg_addr = ::toolbelt::PayloadBuffer::Allocate( + void* msg_addr = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(runtime), MessageType::BinarySize()); ::toolbelt::BufferOffset msg_offset = GetBuffer(runtime)->ToOffset(msg_addr); @@ -404,15 +406,15 @@ class UnionMessageField : public UnionMemberField { if (addr == nullptr) { return; } - *addr = msg_offset; // Put message field offset into message. + *addr = msg_offset; // Put message field offset into message. // TODO: what to do here if this fails? (void)msg_.CloneFrom(msg); } - void Clear(const std::shared_ptr &runtime, + void Clear(const std::shared_ptr& runtime, uint32_t abs_offset) { - ::toolbelt::BufferOffset *addr = GetIndirectAddress(runtime, abs_offset); + ::toolbelt::BufferOffset* addr = GetIndirectAddress(runtime, abs_offset); if (addr == nullptr) { return; } @@ -426,14 +428,14 @@ class UnionMessageField : public UnionMemberField { constexpr WireType GetWireType() { return WireType::kLengthDelimited; } size_t SerializedSize(int number, - const std::shared_ptr &runtime, + const std::shared_ptr& runtime, uint32_t abs_offset) const { return ProtoBuffer::LengthDelimitedSize( number, Get(runtime, abs_offset).SerializedSize()); } - absl::Status Serialize(int number, ProtoBuffer &buffer, - const std::shared_ptr &runtime, + absl::Status Serialize(int number, ProtoBuffer& buffer, + const std::shared_ptr& runtime, uint32_t abs_offset) const { if (absl::Status status = buffer.SerializeLengthDelimitedHeader( number, Get(runtime, abs_offset).SerializedSize()); @@ -443,14 +445,14 @@ class UnionMessageField : public UnionMemberField { return Get(runtime, abs_offset).Serialize(buffer); } - absl::Status Deserialize(ProtoBuffer &buffer, - const std::shared_ptr &runtime, + absl::Status Deserialize(ProtoBuffer& buffer, + const std::shared_ptr& runtime, uint32_t abs_offset) { absl::StatusOr> s = buffer.DeserializeLengthDelimited(); if (!s.ok()) { return s.status(); } - void *msg_addr = ::toolbelt::PayloadBuffer::Allocate( + void* msg_addr = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(runtime), MessageType::BinarySize()); ::toolbelt::BufferOffset msg_offset = GetBuffer(runtime)->ToOffset(msg_addr); @@ -460,19 +462,19 @@ class UnionMessageField : public UnionMemberField { msg_.template InstallMetadata(); // Buffer might have moved, get address of indirect again. - ::toolbelt::BufferOffset *addr = GetIndirectAddress(runtime, abs_offset); + ::toolbelt::BufferOffset* addr = GetIndirectAddress(runtime, abs_offset); if (addr == nullptr) { return absl::OkStatus(); } - *addr = msg_offset; // Put message field offset into message. + *addr = msg_offset; // Put message field offset into message. ProtoBuffer sub_buffer(s.value()); return msg_.Deserialize(sub_buffer); } -private: - ::toolbelt::BufferOffset * - GetIndirectAddress(const std::shared_ptr &runtime, - uint32_t abs_offset) const { + private: + ::toolbelt::BufferOffset* GetIndirectAddress( + const std::shared_ptr& runtime, + uint32_t abs_offset) const { if (runtime == nullptr) { return nullptr; } @@ -480,7 +482,7 @@ class UnionMessageField : public UnionMemberField { } mutable MessageType msg_; -}; // namespace phaser +}; // namespace phaser // All member of the tuple must be union fields. These are stored in a // std::tuple which does not store them inline so they need to contain the @@ -490,85 +492,100 @@ class UnionMessageField : public UnionMemberField { // (the field number of the tuple) followed by the binary data for the // field itself. The size of the field data is the max of all the fields // in the union. -template class UnionField : public Field { -public: +template +class UnionField : public Field { + public: UnionField() = default; UnionField(uint32_t source_offset, uint32_t relative_binary_offset, int id, int number, std::vector field_numbers) - : Field(id, number), source_offset_(source_offset), + : Field(id, number), + source_offset_(source_offset), relative_binary_offset_(relative_binary_offset), field_numbers_(field_numbers) {} - template const F &GetReference() const { + template + const F& GetReference() const { int32_t relative_offset = Message::GetMessage(this, source_offset_) ->FindFieldOffset(field_numbers_[Id]); if (relative_offset < 0) { return std::get(value_).Get(nullptr, 0); } - return std::get(value_).Get(GetRuntime(), GetMessageBinaryStart() + - static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); + return std::get(value_).Get( + GetRuntime(), + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } - template F GetValue() const { + template + F GetValue() const { int32_t relative_offset = Message::GetMessage(this, source_offset_) ->FindFieldOffset(field_numbers_[Id]); if (relative_offset < 0) { return std::get(value_).Get(nullptr, 0); } - return std::get(value_).Get(GetRuntime(), GetMessageBinaryStart() + - static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); + return std::get(value_).Get( + GetRuntime(), + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } - template void Print(std::ostream &os) const { + template + void Print(std::ostream& os) const { int32_t relative_offset = Message::GetMessage(this, source_offset_) ->FindFieldOffset(field_numbers_[Id]); if (relative_offset < 0) { return; } - int32_t *discrim = GetRuntime()->template ToAddress( - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset)); + int32_t* discrim = GetRuntime()->template ToAddress( + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset)); if (*discrim != static_cast(field_numbers_[Id])) { return; } - std::get(value_).Print(os, indent_, GetRuntime(), - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); + std::get(value_).Print( + os, indent_, GetRuntime(), + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } - template void Set(const U &v) { + template + void Set(const U& v) { // Write the field number into the discriminator. - int32_t *discrim = GetRuntime()->template ToAddress( + int32_t* discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); *discrim = static_cast(field_numbers_[Id]); // Get the variant and set its location. In binary it is // 4 bytes after the discriminator. - auto &t = std::get(value_); + auto& t = std::get(value_); t.Set(v, GetRuntime(), GetMessageBinaryStart() + relative_binary_offset_ + 4); } - template U *Mutable() { + template + U* Mutable() { // Write the field number into the discriminator. - int32_t *discrim = GetRuntime()->template ToAddress( + int32_t* discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); *discrim = static_cast(field_numbers_[Id]); // Get the variant and set its location. In binary it is // 4 bytes after the discriminator. - auto &t = std::get(value_); + auto& t = std::get(value_); return t.Mutable(GetRuntime(), GetMessageBinaryStart() + relative_binary_offset_ + 4); } // Only valid for strings and bytes. - template absl::Span Allocate(size_t size) { + template + absl::Span Allocate(size_t size) { // Write the field number into the discriminator. - int32_t *discrim = GetRuntime()->template ToAddress( + int32_t* discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); *discrim = static_cast(field_numbers_[Id]); // Get the variant and set its location. In binary it is // 4 bytes after the discriminator. - auto &t = std::get(value_); + auto& t = std::get(value_); return t.Allocate(size, GetRuntime(), GetMessageBinaryStart() + relative_binary_offset_ + 4); } @@ -583,30 +600,32 @@ template class UnionField : public Field { // present as they will only be absent if the message definition has been // changed and the field removed. In the worst case, the complete union // has been removed and none of the fields are present. - const Message *msg = Message::GetMessage(this, source_offset_); + const Message* msg = Message::GetMessage(this, source_offset_); int32_t relative_offset = -1; - for (auto &field_number : field_numbers_) { + for (auto& field_number : field_numbers_) { relative_offset = msg->FindFieldOffset(field_number); if (relative_offset >= 0) { break; } } if (relative_offset < 0) { - return 0; // No field present in message (all fields have been removed). + return 0; // No field present in message (all fields have been removed). } - int32_t *discrim = GetRuntime()->template ToAddress( - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset)); + int32_t* discrim = GetRuntime()->template ToAddress( + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset)); return *discrim; } - template void Clear() { - int32_t *discrim = GetRuntime()->template ToAddress( + template + void Clear() { + int32_t* discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); int32_t field_number = static_cast(field_numbers_[Id]); if (*discrim != field_number) { return; } - auto &t = std::get(value_); + auto& t = std::get(value_); t.Clear(GetRuntime(), GetMessageBinaryStart() + relative_binary_offset_ + 4); *discrim = 0; @@ -614,112 +633,123 @@ template class UnionField : public Field { // store their value inline here and their Clear() is a no-op, so without // this a later switch to a variable-length arm (string/message) would // misread the leftover scalar bytes as an allocated buffer offset. - ::toolbelt::BufferOffset *slot = + ::toolbelt::BufferOffset* slot = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>( GetMessageBinaryStart() + relative_binary_offset_ + 4); *slot = 0; } - template size_t SerializedSize(int discriminator) const { + template + size_t SerializedSize(int discriminator) const { int32_t relative_offset = Message::GetMessage(this, source_offset_) ->FindFieldOffset(field_numbers_[Id]); - if (relative_offset < 0) { // Field not present. + if (relative_offset < 0) { // Field not present. return 0; } - return std::get(value_).SerializedSize(discriminator, GetRuntime(), - GetMessageBinaryStart() + - static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); + return std::get(value_).SerializedSize( + discriminator, GetRuntime(), + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } template - absl::Status Serialize(int discriminator, ProtoBuffer &buffer) const { + absl::Status Serialize(int discriminator, ProtoBuffer& buffer) const { int32_t relative_offset = Message::GetMessage(this, source_offset_) ->FindFieldOffset(field_numbers_[Id]); - if (relative_offset < 0) { // Field not present. + if (relative_offset < 0) { // Field not present. return absl::OkStatus(); } - return std::get(value_).Serialize(discriminator, buffer, GetRuntime(), - GetMessageBinaryStart() + - static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); + return std::get(value_).Serialize( + discriminator, buffer, GetRuntime(), + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); } template - absl::Status Deserialize(int /*discriminator*/, ProtoBuffer &buffer) { + absl::Status Deserialize(int /*discriminator*/, ProtoBuffer& buffer) { int32_t relative_offset = Message::GetMessage(this, source_offset_) ->FindFieldOffset(field_numbers_[Id]); - if (relative_offset < 0) { // Field not present. + if (relative_offset < 0) { // Field not present. return absl::OkStatus(); } if (absl::Status status = std::get(value_).Deserialize( buffer, GetRuntime(), - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); !status.ok()) { return status; } // Set the discriminator. - int32_t *discrim = GetRuntime()->template ToAddress( + int32_t* discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); *discrim = static_cast(field_numbers_[Id]); return absl::OkStatus(); } - template absl::Status CloneFrom(const M &other) { + template + absl::Status CloneFrom(const M& other) { int32_t relative_offset = Message::GetMessage(this, source_offset_) ->FindFieldOffset(field_numbers_[Id]); - if (relative_offset < 0) { // Field not present. + if (relative_offset < 0) { // Field not present. return absl::OkStatus(); } - int32_t *discrim = GetRuntime()->template ToAddress( + int32_t* discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); *discrim = static_cast(field_numbers_[Id]); // TODO: this isn't right. If the field is a message, it can fail to clone. - std::get(value_).Set(other, GetRuntime(), - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); + std::get(value_).Set( + other, GetRuntime(), + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset) + 4); return absl::OkStatus(); } - template bool IsPresent() const { + template + bool IsPresent() const { int32_t relative_offset = Message::GetMessage(this, source_offset_) ->FindFieldOffset(field_numbers_[Id]); if (relative_offset < 0) { return false; } - int32_t *discrim = GetRuntime()->template ToAddress( - GetMessageBinaryStart() + static_cast<::toolbelt::BufferOffset>(relative_offset)); + int32_t* discrim = GetRuntime()->template ToAddress( + GetMessageBinaryStart() + + static_cast<::toolbelt::BufferOffset>(relative_offset)); return *discrim == static_cast(field_numbers_[Id]); } - template void SetOffset(toolbelt::BufferOffset offset) { - int32_t *discrim = GetRuntime()->template ToAddress( + template + void SetOffset(toolbelt::BufferOffset offset) { + int32_t* discrim = GetRuntime()->template ToAddress( GetMessageBinaryStart() + relative_binary_offset_); *discrim = static_cast(field_numbers_[Id]); // Get the variant and set its location. In binary it is // 4 bytes after the discriminator. - auto &t = std::get(value_); + auto& t = std::get(value_); return t.SetOffset(GetRuntime(), - GetMessageBinaryStart() + relative_binary_offset_ + 4, offset); + GetMessageBinaryStart() + relative_binary_offset_ + 4, + offset); } -private: - ::toolbelt::PayloadBuffer *GetBuffer() const { + private: + ::toolbelt::PayloadBuffer* GetBuffer() const { return Message::GetBuffer(this, source_offset_); } - ::toolbelt::PayloadBuffer **GetBufferAddr() const { + ::toolbelt::PayloadBuffer** GetBufferAddr() const { return Message::GetBufferAddr(this, source_offset_); } ::toolbelt::BufferOffset GetMessageBinaryStart() const { return Message::GetMessageBinaryStart(this, source_offset_); } - const std::shared_ptr &GetRuntime() const { + const std::shared_ptr& GetRuntime() const { return Message::GetRuntime(this, source_offset_); } uint32_t source_offset_; ::toolbelt::BufferOffset relative_binary_offset_; - std::vector field_numbers_; // field number for each tuple type + std::vector field_numbers_; // field number for each tuple type mutable std::tuple value_; }; -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/vectors.h b/phaser/runtime/vectors.h index 954d66f..c593c17 100644 --- a/phaser/runtime/vectors.h +++ b/phaser/runtime/vectors.h @@ -6,6 +6,13 @@ // Vector fields (repeated fields). +#include +#include + +#include +#include +#include + #include "absl/container/flat_hash_map.h" #include "absl/status/status.h" #include "absl/status/statusor.h" @@ -13,11 +20,6 @@ #include "phaser/runtime/message.h" #include "phaser/runtime/wireformat.h" #include "toolbelt/payload_buffer.h" -#include -#include -#include -#include -#include namespace phaser { @@ -25,10 +27,10 @@ class ProtoBuffer; #define DECLARE_ZERO_COPY_VECTOR_BITS(vtype, itype, ctype, utype) \ using value_type = vtype; \ - using reference = value_type &; \ - using const_reference = value_type &; \ - using pointer = value_type *; \ - using const_pointer = const value_type *; \ + using reference = value_type&; \ + using const_reference = value_type&; \ + using pointer = value_type*; \ + using const_pointer = const value_type*; \ using size_type = size_t; \ using difference_type = ptrdiff_t; \ \ @@ -39,17 +41,21 @@ class ProtoBuffer; \ iterator begin() { return iterator(this, BaseOffset()); } \ iterator end() { \ - return iterator(this, BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type))); \ + return iterator(this, \ + BaseOffset() + static_cast<::toolbelt::BufferOffset>( \ + NumElements() * sizeof(value_type))); \ } \ const_iterator begin() const { return const_iterator(this, BaseOffset()); } \ const_iterator end() const { \ - return const_iterator(this, \ - BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type))); \ + return const_iterator( \ + this, BaseOffset() + static_cast<::toolbelt::BufferOffset>( \ + NumElements() * sizeof(value_type))); \ } \ const_iterator cbegin() const { return const_iterator(this, BaseOffset()); } \ const_iterator cend() const { \ - return const_iterator(this, \ - BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type))); \ + return const_iterator( \ + this, BaseOffset() + static_cast<::toolbelt::BufferOffset>( \ + NumElements() * sizeof(value_type))); \ } \ \ reverse_iterator rbegin() { \ @@ -57,51 +63,60 @@ class ProtoBuffer; } \ reverse_iterator rend() { \ return reverse_iterator( \ - this, BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type)), true); \ + this, \ + BaseOffset() + static_cast<::toolbelt::BufferOffset>( \ + NumElements() * sizeof(value_type)), \ + true); \ } \ const_reverse_iterator rbegin() const { \ return const_reverse_iterator(this, BaseOffset(), true); \ } \ const_reverse_iterator rend() const { \ return const_reverse_iterator( \ - this, BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type)), true); \ + this, \ + BaseOffset() + static_cast<::toolbelt::BufferOffset>( \ + NumElements() * sizeof(value_type)), \ + true); \ } \ const_reverse_iterator crbegin() const { \ return const_reverse_iterator(this, BaseOffset(), true); \ } \ const_reverse_iterator crend() const { \ return const_reverse_iterator( \ - this, BaseOffset() + static_cast<::toolbelt::BufferOffset>(NumElements() * sizeof(value_type)), true); \ + this, \ + BaseOffset() + static_cast<::toolbelt::BufferOffset>( \ + NumElements() * sizeof(value_type)), \ + true); \ } // vtype: value type // rtype: relay type (like std::array) // relay: member to relay through -#define DECLARE_RELAY_VECTOR_BITS(vtype, rtype, relay) \ - using value_type = vtype; \ - using reference = value_type &; \ - using const_reference = value_type &; \ - using pointer = value_type *; \ - using const_pointer = const value_type *; \ - using size_type = size_t; \ - using difference_type = ptrdiff_t; \ - \ - using iterator = typename rtype::iterator; \ - using const_iterator = typename rtype::const_iterator; \ - using reverse_iterator = typename rtype::reverse_iterator; \ - using const_reverse_iterator = typename rtype::const_reverse_iterator; \ - \ - iterator begin() { return relay.begin(); } \ - iterator end() { return relay.end(); } \ - reverse_iterator rbegin() { return relay.rbegin(); } \ - reverse_iterator rend() { return relay.rend(); } \ - const_iterator begin() const { return relay.begin(); } \ - const_iterator end() const { return relay.end(); } \ - const_iterator cbegin() const { return relay.begin(); } \ - const_iterator cend() const { return relay.end(); } \ - const_reverse_iterator rbegin() const { return relay.rbegin(); } \ - const_reverse_iterator rend() const { return relay.rend(); } \ - const_reverse_iterator crbegin() const { return relay.crbegin(); } \ +#define DECLARE_RELAY_VECTOR_BITS(vtype, rtype, relay) \ + using value_type = vtype; \ + using reference = value_type&; \ + using const_reference = value_type&; \ + using pointer = value_type*; \ + using const_pointer = const value_type*; \ + using size_type = size_t; \ + using difference_type = ptrdiff_t; \ + \ + using iterator = typename rtype::iterator; \ + using const_iterator = typename rtype::const_iterator; \ + using reverse_iterator = typename rtype::reverse_iterator; \ + using const_reverse_iterator = typename rtype::const_reverse_iterator; \ + \ + iterator begin() { return relay.begin(); } \ + iterator end() { return relay.end(); } \ + reverse_iterator rbegin() { return relay.rbegin(); } \ + reverse_iterator rend() { return relay.rend(); } \ + const_iterator begin() const { return relay.begin(); } \ + const_iterator end() const { return relay.end(); } \ + const_iterator cbegin() const { return relay.begin(); } \ + const_iterator cend() const { return relay.end(); } \ + const_reverse_iterator rbegin() const { return relay.rbegin(); } \ + const_reverse_iterator rend() const { return relay.rend(); } \ + const_reverse_iterator crbegin() const { return relay.crbegin(); } \ const_reverse_iterator crend() const { return relay.crend(); } // This is a variable length vector of T. It looks like a std::vector. @@ -110,17 +125,18 @@ class ProtoBuffer; template class PrimitiveVectorField : public Field { -public: + public: PrimitiveVectorField() = default; explicit PrimitiveVectorField(uint32_t source_offset, uint32_t relative_binary_offset, int id, int number) - : Field(id, number), source_offset_(source_offset), + : Field(id, number), + source_offset_(source_offset), relative_binary_offset_(relative_binary_offset) {} - const T &operator[](int index) { + const T& operator[](int index) { static T empty; - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return empty; } @@ -129,7 +145,7 @@ class PrimitiveVectorField : public Field { T operator[](int index) const { static T empty; - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return empty; } @@ -144,7 +160,7 @@ class PrimitiveVectorField : public Field { T Get(size_t index) const { return (*this)[static_cast(index)]; } void Set(size_t index, T v) { - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return; } @@ -168,7 +184,7 @@ class PrimitiveVectorField : public Field { #undef ITYPE #undef CTYPE - void push_back(const T &v) { + void push_back(const T& v) { ::toolbelt::PayloadBuffer::VectorPush( GetBufferAddr(), Header(relative_binary_offset_), v); } @@ -187,15 +203,15 @@ class PrimitiveVectorField : public Field { ::toolbelt::PayloadBuffer::VectorClear(GetBufferAddr(), Header(relative_binary_offset_)); } - void clear() { Clear(); } // STL compatibility. + void clear() { Clear(); } // STL compatibility. size_t size() const { return NumElements(); } - T *data() const { return GetRuntime()->template ToAddress(BaseOffset()); } + T* data() const { return GetRuntime()->template ToAddress(BaseOffset()); } size_t Size() const { return NumElements(); } absl::Span AsMutableSpan() { - toolbelt::VectorHeader *hdr = Header(relative_binary_offset_); - T *base = GetRuntime()->template ToAddress(hdr->data); + toolbelt::VectorHeader* hdr = Header(relative_binary_offset_); + T* base = GetRuntime()->template ToAddress(hdr->data); if (base == nullptr) { return absl::Span(); } @@ -208,8 +224,8 @@ class PrimitiveVectorField : public Field { if (offset < 0) { return absl::Span(); } - toolbelt::VectorHeader *hdr = Header(static_cast(offset)); - const T *base = GetRuntime()->template ToAddress(hdr->data); + toolbelt::VectorHeader* hdr = Header(static_cast(offset)); + const T* base = GetRuntime()->template ToAddress(hdr->data); if (base == nullptr) { return absl::Span(); } @@ -220,7 +236,7 @@ class PrimitiveVectorField : public Field { bool empty() const { return size() == 0; } size_t capacity() const { - ::toolbelt::BufferOffset *addr = BaseOffset(); + ::toolbelt::BufferOffset* addr = BaseOffset(); if (addr == nullptr) { return 0; } @@ -236,7 +252,7 @@ class PrimitiveVectorField : public Field { } bool operator==( - const PrimitiveVectorField &other) const { + const PrimitiveVectorField& other) const { size_t n = size(); for (size_t i = 0; i < n; i++) { if ((*this)[i] != other[i]) { @@ -246,7 +262,7 @@ class PrimitiveVectorField : public Field { return true; } bool operator!=( - const PrimitiveVectorField &other) const { + const PrimitiveVectorField& other) const { return !(*this == other); } @@ -262,7 +278,7 @@ class PrimitiveVectorField : public Field { if constexpr (FixedSize) { return ProtoBuffer::LengthDelimitedSize(Number(), sz * sizeof(T)); } else { - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return 0; } @@ -280,7 +296,7 @@ class PrimitiveVectorField : public Field { ProtoBuffer::FixedWireType()) + sizeof(T)); } else { - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return 0; } @@ -293,13 +309,13 @@ class PrimitiveVectorField : public Field { return ProtoBuffer::LengthDelimitedSize(Number(), length); } - absl::Status Serialize(ProtoBuffer &buffer) const { + absl::Status Serialize(ProtoBuffer& buffer) const { size_t sz = size(); if (sz == 0) { return absl::OkStatus(); } - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return absl::OkStatus(); } @@ -307,7 +323,7 @@ class PrimitiveVectorField : public Field { if constexpr (Packed) { if constexpr (FixedSize) { return buffer.SerializeLengthDelimited( - Number(), reinterpret_cast(base), sz * sizeof(T)); + Number(), reinterpret_cast(base), sz * sizeof(T)); } else { size_t length = 0; for (size_t i = 0; i < sz; i++) { @@ -353,7 +369,7 @@ class PrimitiveVectorField : public Field { return absl::OkStatus(); } - absl::Status Deserialize(ProtoBuffer &buffer) { + absl::Status Deserialize(ProtoBuffer& buffer) { if constexpr (Packed) { absl::StatusOr> data = buffer.DeserializeLengthDelimited(); @@ -362,7 +378,7 @@ class PrimitiveVectorField : public Field { } if constexpr (FixedSize) { resize(data->size() / sizeof(T)); - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); memcpy(base, data->data(), data->size()); return absl::OkStatus(); } else { @@ -393,10 +409,10 @@ class PrimitiveVectorField : public Field { return absl::OkStatus(); } -private: + private: friend FieldIterator; friend FieldIterator; - toolbelt::VectorHeader *Header(uint32_t offset) const { + toolbelt::VectorHeader* Header(uint32_t offset) const { return GetRuntime()->template ToAddress( Message::GetMessageBinaryStart(this, source_offset_) + offset); } @@ -417,18 +433,18 @@ class PrimitiveVectorField : public Field { return Header(static_cast(offset))->num_elements; } - ::toolbelt::PayloadBuffer *GetBuffer() const { + ::toolbelt::PayloadBuffer* GetBuffer() const { return Message::GetBuffer(this, source_offset_); } - ::toolbelt::PayloadBuffer **GetBufferAddr() const { + ::toolbelt::PayloadBuffer** GetBufferAddr() const { return Message::GetBufferAddr(this, source_offset_); } ::toolbelt::BufferOffset GetMessageBinaryStart() const { return Message::GetMessageBinaryStart(this, source_offset_); } - const std::shared_ptr &GetRuntime() const { + const std::shared_ptr& GetRuntime() const { return Message::GetRuntime(this, source_offset_); } @@ -439,29 +455,30 @@ class PrimitiveVectorField : public Field { template class EnumVectorField : public Field { -public: + public: EnumVectorField() = default; explicit EnumVectorField(uint32_t source_offset, uint32_t relative_binary_offset, int id, int number) - : Field(id, number), source_offset_(source_offset), + : Field(id, number), + source_offset_(source_offset), relative_binary_offset_(relative_binary_offset) {} using T = typename std::underlying_type::type; Enum operator[](int index) { - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return static_cast(0); } - return *reinterpret_cast(&base[index]); + return *reinterpret_cast(&base[index]); } const Enum operator[](int index) const { - const T *base = GetRuntime()->template ToAddress(BaseOffset()); + const T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return static_cast(0); } - return *reinterpret_cast(&base[index]); + return *reinterpret_cast(&base[index]); } Enum front() { return (*this)[0]; } @@ -481,7 +498,7 @@ class EnumVectorField : public Field { Enum Get(size_t index) const { return (*this)[static_cast(index)]; } void Set(size_t index, Enum v) { - Enum *base = GetRuntime()->template ToAddress(BaseOffset()); + Enum* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return; } @@ -494,8 +511,8 @@ class EnumVectorField : public Field { #undef CTYPE absl::Span AsMutableSpan() { - toolbelt::VectorHeader *hdr = Header(relative_binary_offset_); - Enum *base = GetRuntime()->template ToAddress(hdr->data); + toolbelt::VectorHeader* hdr = Header(relative_binary_offset_); + Enum* base = GetRuntime()->template ToAddress(hdr->data); if (base == nullptr) { return absl::Span(); } @@ -508,8 +525,8 @@ class EnumVectorField : public Field { if (offset < 0) { return absl::Span(); } - toolbelt::VectorHeader *hdr = Header(static_cast(offset)); - const Enum *base = GetRuntime()->template ToAddress(hdr->data); + toolbelt::VectorHeader* hdr = Header(static_cast(offset)); + const Enum* base = GetRuntime()->template ToAddress(hdr->data); if (base == nullptr) { return absl::Span(); } @@ -517,7 +534,7 @@ class EnumVectorField : public Field { return absl::Span(base, hdr->num_elements); } - void push_back(const Enum &v) { + void push_back(const Enum& v) { ::toolbelt::PayloadBuffer::VectorPush( GetBufferAddr(), Header(relative_binary_offset_), static_cast(v)); } @@ -538,16 +555,16 @@ class EnumVectorField : public Field { ::toolbelt::PayloadBuffer::VectorClear(GetBufferAddr(), Header(relative_binary_offset_)); } - void clear() { Clear(); } // STL compatibility. + void clear() { Clear(); } // STL compatibility. size_t size() const { return NumElements(); } - Enum *data() const { GetRuntime()->template ToAddress(BaseOffset()); } + Enum* data() const { GetRuntime()->template ToAddress(BaseOffset()); } bool empty() const { return size() == 0; } size_t Size() const { return NumElements(); } size_t capacity() const { - toolbelt::VectorHeader *hdr = Header(); - ::toolbelt::BufferOffset *addr = + toolbelt::VectorHeader* hdr = Header(); + ::toolbelt::BufferOffset* addr = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); if (addr == nullptr) { return 0; @@ -564,7 +581,7 @@ class EnumVectorField : public Field { } bool operator==( - const EnumVectorField &other) const { + const EnumVectorField& other) const { size_t n = size(); for (size_t i = 0; i < n; i++) { if ((*this)[i] != other[i]) { @@ -574,7 +591,7 @@ class EnumVectorField : public Field { return true; } bool operator!=( - const EnumVectorField &other) const { + const EnumVectorField& other) const { return !(*this == other); } @@ -587,7 +604,7 @@ class EnumVectorField : public Field { // Packed is default in proto3 but optional in proto2. if constexpr (Packed) { - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return 0; } @@ -599,7 +616,7 @@ class EnumVectorField : public Field { // Not packed, just a sequence of individual fields, all with the same // tag. - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return 0; } @@ -611,13 +628,13 @@ class EnumVectorField : public Field { return ProtoBuffer::LengthDelimitedSize(Number(), length); } - absl::Status Serialize(ProtoBuffer &buffer) const { + absl::Status Serialize(ProtoBuffer& buffer) const { size_t sz = size(); if (sz == 0) { return absl::OkStatus(); } - T *base = GetRuntime()->template ToAddress(BaseOffset()); + T* base = GetRuntime()->template ToAddress(BaseOffset()); if (base == nullptr) { return absl::OkStatus(); } @@ -657,7 +674,7 @@ class EnumVectorField : public Field { return absl::OkStatus(); } - absl::Status Deserialize(ProtoBuffer &buffer) { + absl::Status Deserialize(ProtoBuffer& buffer) { if constexpr (Packed) { absl::StatusOr> data = buffer.DeserializeLengthDelimited(); @@ -682,10 +699,10 @@ class EnumVectorField : public Field { return absl::OkStatus(); } -private: + private: friend EnumFieldIterator; friend EnumFieldIterator; - toolbelt::VectorHeader *Header(::toolbelt::BufferOffset offset) const { + toolbelt::VectorHeader* Header(::toolbelt::BufferOffset offset) const { return GetRuntime()->template ToAddress( Message::GetMessageBinaryStart(this, source_offset_) + offset); } @@ -706,15 +723,15 @@ class EnumVectorField : public Field { return Header(static_cast(offset))->num_elements; } - ::toolbelt::PayloadBuffer *GetBuffer() const { + ::toolbelt::PayloadBuffer* GetBuffer() const { return Message::GetBuffer(this, source_offset_); } - const std::shared_ptr &GetRuntime() const { + const std::shared_ptr& GetRuntime() const { return Message::GetRuntime(this, source_offset_); } - ::toolbelt::PayloadBuffer **GetBufferAddr() const { + ::toolbelt::PayloadBuffer** GetBufferAddr() const { return Message::GetBufferAddr(this, source_offset_); } ::toolbelt::BufferOffset GetMessageBinaryStart() const { @@ -727,16 +744,18 @@ class EnumVectorField : public Field { // The vector contains a set of ::toolbelt::BufferOffsets allocated in the // buffer, each of which contains the absolute offset of the message. -template class MessageVectorField : public Field { -public: +template +class MessageVectorField : public Field { + public: MessageVectorField() = default; explicit MessageVectorField(uint32_t source_offset, uint32_t relative_binary_offset, int id, int number) - : Field(id, number), source_offset_(source_offset), + : Field(id, number), + source_offset_(source_offset), relative_binary_offset_(relative_binary_offset) {} - const MessageObject &operator[](int index) const { + const MessageObject& operator[](int index) const { int32_t offset = FindFieldOffset(source_offset_); if (offset == -1) { return empty_; @@ -745,7 +764,7 @@ template class MessageVectorField : public Field { if (static_cast(index) >= hdr->num_elements) { return empty_; } - ::toolbelt::BufferOffset *data = + ::toolbelt::BufferOffset* data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); if (data[index] == 0) { return empty_; @@ -754,21 +773,22 @@ template class MessageVectorField : public Field { msgs_.resize(static_cast(index) + 1); } if (msgs_[static_cast(index)].empty()) { - msgs_[static_cast(index)] = MessageObject(GetRuntime(), data[index]); + msgs_[static_cast(index)] = + MessageObject(GetRuntime(), data[index]); } return msgs_[static_cast(index)]; } - MessageObject &front() { return msgs_.front(); } - const MessageObject &front() const { return msgs_.front(); } - MessageObject &back() { return msgs_.back(); } - const MessageObject &back() const { return msgs_.back(); } + MessageObject& front() { return msgs_.front(); } + const MessageObject& front() const { return msgs_.front(); } + MessageObject& back() { return msgs_.back(); } + const MessageObject& back() const { return msgs_.back(); } #define RTYPE std::vector> DECLARE_RELAY_VECTOR_BITS(MessageObject, RTYPE, msgs_) #undef RTYPE - void push_back(const T &v) { + void push_back(const T& v) { ::toolbelt::BufferOffset offset = v.absolute_binary_offset; ::toolbelt::PayloadBuffer::VectorPush<::toolbelt::BufferOffset>( GetBufferAddr(), Header(), offset); @@ -777,7 +797,7 @@ template class MessageVectorField : public Field { msgs_.push_back(std::move(obj)); } - void push_back(T &&v) { + void push_back(T&& v) { ::toolbelt::BufferOffset offset = v.absolute_binary_offset; ::toolbelt::PayloadBuffer::VectorPush<::toolbelt::BufferOffset>( GetBufferAddr(), Header(), offset); @@ -786,10 +806,10 @@ template class MessageVectorField : public Field { msgs_.push_back(std::move(obj)); } - T *Add() { + T* Add() { // Allocate a new message. - void *binary = ::toolbelt::PayloadBuffer::Allocate( - GetBufferAddr(), T::BinarySize()); + void* binary = + ::toolbelt::PayloadBuffer::Allocate(GetBufferAddr(), T::BinarySize()); ::toolbelt::BufferOffset absolute_binary_offset = GetRuntime()->ToOffset(binary); ::toolbelt::PayloadBuffer::VectorPush<::toolbelt::BufferOffset>( @@ -800,11 +820,11 @@ template class MessageVectorField : public Field { return msgs_.back().Mutable(); } - const T &Get(size_t index) const { + const T& Get(size_t index) const { return (*this)[static_cast(index)].Get(); } - T *Mutable(size_t index) { + T* Mutable(size_t index) { if (static_cast(index) >= msgs_.size()) { ::toolbelt::PayloadBuffer::VectorResize<::toolbelt::BufferOffset>( GetBufferAddr(), Header(), static_cast(index) + 1); @@ -812,13 +832,13 @@ template class MessageVectorField : public Field { } if (msgs_[static_cast(index)].IsPlaceholder()) { - void *binary = ::toolbelt::PayloadBuffer::Allocate( - GetBufferAddr(), T::BinarySize()); + void* binary = + ::toolbelt::PayloadBuffer::Allocate(GetBufferAddr(), T::BinarySize()); ::toolbelt::BufferOffset absolute_binary_offset = GetRuntime()->ToOffset(binary); auto hdr = Header(); - ::toolbelt::BufferOffset *data = + ::toolbelt::BufferOffset* data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); data[index] = absolute_binary_offset; @@ -834,9 +854,10 @@ template class MessageVectorField : public Field { msgs_.resize(static_cast(index) + 1); } auto hdr = Header(); - ::toolbelt::BufferOffset *data = + ::toolbelt::BufferOffset* data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); - if (!msgs_[static_cast(index)].IsPlaceholder() && data[index] != 0) { + if (!msgs_[static_cast(index)].IsPlaceholder() && + data[index] != 0) { // Already set, free the current value. msgs_[static_cast(index)].Clear(); } @@ -845,22 +866,22 @@ template class MessageVectorField : public Field { } // Allocate a bunch of empty messages. - std::vector Allocate(size_t n) { - std::vector result; + std::vector Allocate(size_t n) { + std::vector result; result.resize(n); this->resize(n); // Allocate memory for n messages in the payload buffer. - std::vector addrs = ::toolbelt::PayloadBuffer::AllocateMany( + std::vector addrs = ::toolbelt::PayloadBuffer::AllocateMany( GetBufferAddr(), T::BinarySize(), static_cast(n), true); - toolbelt::VectorHeader *hdr = Header(); - ::toolbelt::BufferOffset *data = + toolbelt::VectorHeader* hdr = Header(); + ::toolbelt::BufferOffset* data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); // Fill in the msgs_ vector with MessageObject objects referring to the // allocated memory. for (size_t i = 0; i < n; i++) { - auto &msg = msgs_[i].MutableMsg(); + auto& msg = msgs_[i].MutableMsg(); msg.runtime = GetRuntime(); toolbelt::BufferOffset offset = GetRuntime()->ToOffset(addrs[i]); msg.absolute_binary_offset = offset; @@ -872,7 +893,7 @@ template class MessageVectorField : public Field { } size_t capacity() const { - ::toolbelt::BufferOffset *base = + ::toolbelt::BufferOffset* base = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>( BaseOffset()); @@ -926,16 +947,16 @@ template class MessageVectorField : public Field { return relative_binary_offset_; } - bool operator==(const MessageVectorField &other) const { + bool operator==(const MessageVectorField& other) const { return msgs_ != other.msgs_; } - bool operator!=(const MessageVectorField &other) const { + bool operator!=(const MessageVectorField& other) const { return !(*this == other); } - std::vector> &Get() { return msgs_; } + std::vector>& Get() { return msgs_; } - const std::vector> &Get() const { return msgs_; } + const std::vector>& Get() const { return msgs_; } void Populate() const { if (!msgs_.empty()) { @@ -949,7 +970,7 @@ template class MessageVectorField : public Field { } auto hdr = Header(static_cast(offset)); msgs_.resize(hdr->num_elements); - ::toolbelt::BufferOffset *data = + ::toolbelt::BufferOffset* data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); for (uint32_t i = 0; i < hdr->num_elements; i++) { if (data[i] == 0) { @@ -970,14 +991,14 @@ template class MessageVectorField : public Field { return length; } - absl::Status Serialize(ProtoBuffer &buffer) const { + absl::Status Serialize(ProtoBuffer& buffer) const { Populate(); size_t sz = size(); if (sz == 0) { return absl::OkStatus(); } - for (const auto &msg : msgs_) { + for (const auto& msg : msgs_) { if (absl::Status status = buffer.SerializeLengthDelimitedHeader( Number(), msg.SerializedSize()); !status.ok()) { @@ -990,24 +1011,24 @@ template class MessageVectorField : public Field { return absl::OkStatus(); } - absl::Status Deserialize(ProtoBuffer &buffer) { + absl::Status Deserialize(ProtoBuffer& buffer) { absl::StatusOr> v = buffer.DeserializeLengthDelimited(); if (!v.ok()) { return v.status(); } ProtoBuffer msg_buffer(*v); - T *msg = Add(); + T* msg = Add(); if (absl::Status status = msg->Deserialize(msg_buffer); !status.ok()) { return status; } return absl::OkStatus(); } -private: + private: friend FieldIterator; friend FieldIterator; - toolbelt::VectorHeader * - Header(::toolbelt::BufferOffset relative_offset = 0) const { + toolbelt::VectorHeader* Header( + ::toolbelt::BufferOffset relative_offset = 0) const { if (relative_offset == 0) { relative_offset = relative_binary_offset_; } @@ -1031,18 +1052,18 @@ template class MessageVectorField : public Field { return Header(static_cast(offset))->num_elements; } - ::toolbelt::PayloadBuffer *GetBuffer() const { + ::toolbelt::PayloadBuffer* GetBuffer() const { return Message::GetBuffer(this, source_offset_); } - ::toolbelt::PayloadBuffer **GetBufferAddr() const { + ::toolbelt::PayloadBuffer** GetBufferAddr() const { return Message::GetBufferAddr(this, source_offset_); } ::toolbelt::BufferOffset GetMessageBinaryStart() const { return Message::GetMessageBinaryStart(this, source_offset_); } - const std::shared_ptr &GetRuntime() const { + const std::shared_ptr& GetRuntime() const { return Message::GetRuntime(this, source_offset_); } @@ -1068,15 +1089,16 @@ template class MessageVectorField : public Field { // | | | "data" | // +-----------+ +-------------+ class StringVectorField : public Field { -public: + public: StringVectorField() = default; explicit StringVectorField(uint32_t source_offset, uint32_t relative_binary_offset, int id, int number) - : Field(id, number), source_offset_(source_offset), + : Field(id, number), + source_offset_(source_offset), relative_binary_offset_(relative_binary_offset) {} - const NonEmbeddedStringField &operator[](int index) const { + const NonEmbeddedStringField& operator[](int index) const { int32_t offset = FindFieldOffset(source_offset_); if (offset == -1) { return empty_; @@ -1085,7 +1107,7 @@ class StringVectorField : public Field { if (static_cast(index) >= hdr->num_elements) { return empty_; } - ::toolbelt::BufferOffset *data = + ::toolbelt::BufferOffset* data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); if (data[index] == 0) { return empty_; @@ -1105,21 +1127,22 @@ class StringVectorField : public Field { #undef RTYPE size_t size() const { return NumElements(); } - NonEmbeddedStringField *data() { + NonEmbeddedStringField* data() { Populate(); return strings_.data(); } bool empty() const { return size() == 0; } size_t Size() const { return NumElements(); } - NonEmbeddedStringField &front() { return strings_.front(); } - const NonEmbeddedStringField &front() const { return strings_.front(); } - NonEmbeddedStringField &back() { return strings_.back(); } - const NonEmbeddedStringField &back() const { return strings_.back(); } + NonEmbeddedStringField& front() { return strings_.front(); } + const NonEmbeddedStringField& front() const { return strings_.front(); } + NonEmbeddedStringField& back() { return strings_.back(); } + const NonEmbeddedStringField& back() const { return strings_.back(); } - template void push_back(Str s) { + template + void push_back(Str s) { // Allocate string header in buffer. - void *str_hdr = ::toolbelt::PayloadBuffer::Allocate( + void* str_hdr = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(), sizeof(toolbelt::StringHeader)); ::toolbelt::BufferOffset hdr_offset = GetRuntime()->ToOffset(str_hdr); ::toolbelt::PayloadBuffer::SetString(GetBufferAddr(), s, hdr_offset); @@ -1134,14 +1157,18 @@ class StringVectorField : public Field { strings_.push_back(std::move(field)); } - void Add(const char *s, size_t len) { push_back(std::string(s, len)); } - template void Add(Str s) { push_back(s); } + void Add(const char* s, size_t len) { push_back(std::string(s, len)); } + template + void Add(Str s) { + push_back(s); + } std::string_view Get(size_t index) const { return (*this)[static_cast(index)].Get(); } - template void Set(size_t index, Str s) { + template + void Set(size_t index, Str s) { if (static_cast(index) >= strings_.size()) { ::toolbelt::PayloadBuffer::VectorResize<::toolbelt::BufferOffset>( GetBufferAddr(), Header(), static_cast(index) + 1); @@ -1150,12 +1177,12 @@ class StringVectorField : public Field { if (strings_[static_cast(index)].IsPlaceholder()) { // Allocate string header in buffer. - void *str_hdr = ::toolbelt::PayloadBuffer::Allocate( + void* str_hdr = ::toolbelt::PayloadBuffer::Allocate( GetBufferAddr(), sizeof(toolbelt::StringHeader)); ::toolbelt::BufferOffset hdr_offset = GetRuntime()->ToOffset(str_hdr); auto hdr = Header(); - ::toolbelt::BufferOffset *data = + ::toolbelt::BufferOffset* data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); data[index] = hdr_offset; @@ -1168,7 +1195,7 @@ class StringVectorField : public Field { } size_t capacity() const { - ::toolbelt::BufferOffset *base = + ::toolbelt::BufferOffset* base = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>( BaseOffset()); @@ -1193,7 +1220,7 @@ class StringVectorField : public Field { } void Clear() { - for (auto &s : strings_) { + for (auto& s : strings_) { s.Clear(); } strings_.clear(); @@ -1201,7 +1228,7 @@ class StringVectorField : public Field { GetBufferAddr(), Header()); } - void clear() { Clear(); } // STL compatibility. + void clear() { Clear(); } // STL compatibility. ::toolbelt::BufferOffset BinaryEndOffset() const { return relative_binary_offset_ + sizeof(toolbelt::VectorHeader); @@ -1210,10 +1237,10 @@ class StringVectorField : public Field { return relative_binary_offset_; } - bool operator==(const StringVectorField &other) const { + bool operator==(const StringVectorField& other) const { return strings_ == other.strings_; } - bool operator!=(const StringVectorField &other) const { + bool operator!=(const StringVectorField& other) const { return !(*this == other); } @@ -1229,7 +1256,7 @@ class StringVectorField : public Field { } auto hdr = Header(static_cast(offset)); strings_.resize(hdr->num_elements); - ::toolbelt::BufferOffset *data = + ::toolbelt::BufferOffset* data = GetRuntime()->template ToAddress<::toolbelt::BufferOffset>(hdr->data); for (uint32_t i = 0; i < hdr->num_elements; i++) { if (data[i] == 0) { @@ -1242,7 +1269,7 @@ class StringVectorField : public Field { std::vector Get() const { std::vector r; - for (const auto &s : strings_) { + for (const auto& s : strings_) { r.push_back(s.Get()); } return r; @@ -1258,14 +1285,14 @@ class StringVectorField : public Field { return length; } - absl::Status Serialize(ProtoBuffer &buffer) const { + absl::Status Serialize(ProtoBuffer& buffer) const { Populate(); size_t sz = size(); if (sz == 0) { return absl::OkStatus(); } - for (const auto &s : strings_) { + for (const auto& s : strings_) { if (absl::Status status = buffer.SerializeLengthDelimited(Number(), s.data(), s.size()); !status.ok()) { @@ -1275,7 +1302,7 @@ class StringVectorField : public Field { return absl::OkStatus(); } - absl::Status Deserialize(ProtoBuffer &buffer) { + absl::Status Deserialize(ProtoBuffer& buffer) { absl::StatusOr v = buffer.DeserializeString(); if (!v.ok()) { return v.status(); @@ -1284,9 +1311,9 @@ class StringVectorField : public Field { return absl::OkStatus(); } -private: - toolbelt::VectorHeader * - Header(::toolbelt::BufferOffset relative_offset = 0) const { + private: + toolbelt::VectorHeader* Header( + ::toolbelt::BufferOffset relative_offset = 0) const { if (relative_offset == 0) { relative_offset = relative_binary_offset_; } @@ -1294,7 +1321,7 @@ class StringVectorField : public Field { GetMessageBinaryStart() + relative_offset); } - const std::shared_ptr &GetRuntime() const { + const std::shared_ptr& GetRuntime() const { return Message::GetRuntime(this, source_offset_); } @@ -1314,11 +1341,11 @@ class StringVectorField : public Field { return Header(static_cast(offset))->num_elements; } - ::toolbelt::PayloadBuffer *GetBuffer() const { + ::toolbelt::PayloadBuffer* GetBuffer() const { return Message::GetBuffer(this, source_offset_); } - ::toolbelt::PayloadBuffer **GetBufferAddr() const { + ::toolbelt::PayloadBuffer** GetBufferAddr() const { return Message::GetBufferAddr(this, source_offset_); } ::toolbelt::BufferOffset GetMessageBinaryStart() const { @@ -1333,4 +1360,4 @@ class StringVectorField : public Field { #undef DECLARE_ZERO_COPY_VECTOR_BITS #undef DECLARE_RELAY_VECTOR_BITS -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/wireformat.h b/phaser/runtime/wireformat.h index 48ba80c..1255cc4 100644 --- a/phaser/runtime/wireformat.h +++ b/phaser/runtime/wireformat.h @@ -3,17 +3,19 @@ // See LICENSE file for licensing information. #pragma once -#include "absl/status/status.h" -#include "absl/status/statusor.h" -#include "absl/strings/str_format.h" -#include "absl/types/span.h" -#include #include #include + +#include #include #include #include +#include "absl/status/status.h" +#include "absl/status/statusor.h" +#include "absl/strings/str_format.h" +#include "absl/types/span.h" + namespace phaser { enum class WireType { @@ -26,7 +28,7 @@ enum class WireType { }; class ProtoBuffer { -public: + public: static constexpr int kFieldIdShift = 3; static constexpr int kWireTypeMask = (1 << kFieldIdShift) - 1; static constexpr int kFieldIdMask = ~kWireTypeMask; @@ -37,7 +39,7 @@ class ProtoBuffer { // Need a reasonable size to start with. abort(); } - start_ = reinterpret_cast(malloc(size_)); + start_ = reinterpret_cast(malloc(size_)); if (start_ == nullptr) { abort(); } @@ -49,12 +51,18 @@ class ProtoBuffer { } // Fixed buffer in non-owned memory. - ProtoBuffer(char *addr, size_t size) - : owned_(false), start_(addr), size_(size), addr_(addr), + ProtoBuffer(char* addr, size_t size) + : owned_(false), + start_(addr), + size_(size), + addr_(addr), end_(addr_ + size) {} - ProtoBuffer(const char *addr, size_t size) - : owned_(false), start_(const_cast(addr)), size_(size), addr_(const_cast(addr)), + ProtoBuffer(const char* addr, size_t size) + : owned_(false), + start_(const_cast(addr)), + size_(size), + addr_(const_cast(addr)), end_(addr_ + size) {} ProtoBuffer(absl::Span v) { @@ -81,16 +89,20 @@ class ProtoBuffer { size_t size() const { return Size(); } - template T *Data() { return reinterpret_cast(start_); } + template + T* Data() { + return reinterpret_cast(start_); + } - char *data() { return Data(); } + char* data() { return Data(); } std::string AsString() const { return std::string(start_, static_cast(addr_ - start_)); } - template absl::Span AsSpan() const { - return absl::Span(reinterpret_cast(start_), + template + absl::Span AsSpan() const { + return absl::Span(reinterpret_cast(start_), static_cast(addr_ - start_)); } @@ -107,19 +119,22 @@ class ProtoBuffer { // it is free of signed overflow/shift undefined behavior and is correct for // any width of T (the previous implementation hard-coded a 31-bit shift and // produced wrong results for 64-bit values). - template static T ZigZag(T value) { + template + static T ZigZag(T value) { using U = std::make_unsigned_t; constexpr unsigned kSignShift = sizeof(T) * 8 - 1; const U u = static_cast(value); return static_cast((u << 1) ^ static_cast(-(u >> kSignShift))); } - template static T ZagZig(T value) { + template + static T ZagZig(T value) { using U = std::make_unsigned_t; const U u = static_cast(value); return static_cast((u >> 1) ^ static_cast(-(u & U(1)))); } - template static constexpr WireType FixedWireType() { + template + static constexpr WireType FixedWireType() { if (sizeof(T) == 4) { return WireType::kFixed32; } else if (sizeof(T) == 8) { @@ -134,7 +149,8 @@ class ProtoBuffer { static_cast(MakeTag(field_number, wire_type))); } - template static uint64_t ToVarintWire(T value) { + template + static uint64_t ToVarintWire(T value) { if constexpr (Signed) { return static_cast(ZigZag(value)); } @@ -148,7 +164,8 @@ class ProtoBuffer { return static_cast(value); } - template static size_t VarintSize(T value) { + template + static size_t VarintSize(T value) { uint64_t uvalue = ToVarintWire(value); size_t size = 0; for (;;) { @@ -171,7 +188,8 @@ class ProtoBuffer { // Serialization functions. - template absl::Status SerializeRawVarint(T value) { + template + absl::Status SerializeRawVarint(T value) { uint64_t uvalue = ToVarintWire(value); if (auto status = HasSpaceFor(VarintSize(uvalue)); !status.ok()) { @@ -202,7 +220,8 @@ class ProtoBuffer { static_cast(MakeTag(field_number, wire_type))); } - template absl::Status SerializeFixed(int field_number, T value) { + template + absl::Status SerializeFixed(int field_number, T value) { if (auto status = SerializeTag(field_number, FixedWireType()); !status.ok()) { return status; @@ -216,7 +235,7 @@ class ProtoBuffer { return absl::OkStatus(); } - absl::Status SerializeLengthDelimited(int field_number, const void *data, + absl::Status SerializeLengthDelimited(int field_number, const void* data, size_t length) { if (auto status = SerializeTag(field_number, WireType::kLengthDelimited); !status.ok()) { @@ -243,7 +262,7 @@ class ProtoBuffer { return SerializeRawVarint(static_cast(length)); } - absl::Status SerializeRaw(const void *data, size_t length) { + absl::Status SerializeRaw(const void* data, size_t length) { if (auto status = HasSpaceFor(length); !status.ok()) { return status; } @@ -273,44 +292,45 @@ class ProtoBuffer { WireType wire_type = WireType(tag & kWireTypeMask); tag >>= kFieldIdShift; switch (wire_type) { - case WireType::kVarint: - if (absl::Status status = SkipVarint(); !status.ok()) { - return status; - } - break; - case WireType::kFixed64: - if (absl::Status status = Check(8); !status.ok()) { - return status; - } - addr_ += 8; - break; - case WireType::kLengthDelimited: { - absl::StatusOr length = DeserializeVarint(); - if (!length.ok()) { - return length.status(); - } - if (absl::Status status = Check(*length); !status.ok()) { - return status; - } - addr_ += *length; - break; - } - case WireType::kStartGroup: - case WireType::kEndGroup: - return absl::InternalError("Unsupported wire type"); - case WireType::kFixed32: - if (absl::Status status = Check(4); !status.ok()) { - return status; + case WireType::kVarint: + if (absl::Status status = SkipVarint(); !status.ok()) { + return status; + } + break; + case WireType::kFixed64: + if (absl::Status status = Check(8); !status.ok()) { + return status; + } + addr_ += 8; + break; + case WireType::kLengthDelimited: { + absl::StatusOr length = DeserializeVarint(); + if (!length.ok()) { + return length.status(); + } + if (absl::Status status = Check(*length); !status.ok()) { + return status; + } + addr_ += *length; + break; } - addr_ += 4; - break; + case WireType::kStartGroup: + case WireType::kEndGroup: + return absl::InternalError("Unsupported wire type"); + case WireType::kFixed32: + if (absl::Status status = Check(4); !status.ok()) { + return status; + } + addr_ += 4; + break; } return absl::OkStatus(); } // Tag has already been read. - template absl::StatusOr DeserializeVarint() { + template + absl::StatusOr DeserializeVarint() { uint64_t value = 0; for (int shift = 0; shift < 64; shift += 7) { if (absl::Status status = Check(1); !status.ok()) { @@ -334,7 +354,8 @@ class ProtoBuffer { return absl::InternalError("Varint too long"); } - template absl::StatusOr DeserializeFixed() { + template + absl::StatusOr DeserializeFixed() { if (absl::Status status = Check(sizeof(T)); !status.ok()) { return status; } @@ -372,7 +393,7 @@ class ProtoBuffer { return str; } - absl::Status CopyRaw(char *dest, size_t length) { + absl::Status CopyRaw(char* dest, size_t length) { if (absl::Status status = Check(length); !status.ok()) { return status; } @@ -381,21 +402,21 @@ class ProtoBuffer { return absl::OkStatus(); } -private: + private: size_t static MakeTag(int field_number, WireType wire_type) { return static_cast((field_number << kFieldIdShift) | int(wire_type)); } absl::Status HasSpaceFor(size_t n) { - char *next = addr_ + n; + char* next = addr_ + n; // Off-by-one complexity here. The end is one past the end of the buffer. if (next > end_) { if (owned_) { // Expand the buffer. size_t new_size = size_ * 2; - char *new_start = reinterpret_cast(realloc(start_, new_size)); + char* new_start = reinterpret_cast(realloc(start_, new_size)); if (new_start == nullptr) { abort(); } @@ -415,18 +436,18 @@ class ProtoBuffer { } absl::Status Check(size_t n) { - char *next = addr_ + n; + char* next = addr_ + n; if (next <= end_) { return absl::OkStatus(); } return absl::InternalError("End of buffer"); } - bool owned_ = false; // Memory is owned by this buffer. - char *start_ = nullptr; // + bool owned_ = false; // Memory is owned by this buffer. + char* start_ = nullptr; // size_t size_ = 0; - char *addr_ = nullptr; - char *end_ = nullptr; + char* addr_ = nullptr; + char* end_ = nullptr; }; -} // namespace phaser +} // namespace phaser diff --git a/phaser/runtime/wireformat_test.cc b/phaser/runtime/wireformat_test.cc index 807c6cc..5574c06 100644 --- a/phaser/runtime/wireformat_test.cc +++ b/phaser/runtime/wireformat_test.cc @@ -2,14 +2,17 @@ // All Rights Reserved // See LICENSE file for licensing information. -#include "absl/strings/str_format.h" -#include "phaser/runtime/runtime.h" #include "phaser/runtime/wireformat.h" -#include "toolbelt/hexdump.h" -#include + #include + +#include #include +#include "absl/strings/str_format.h" +#include "phaser/runtime/runtime.h" +#include "toolbelt/hexdump.h" + using ProtoBuffer = phaser::ProtoBuffer; using WireType = phaser::WireType; @@ -47,9 +50,9 @@ TEST(Wireformat, ZigZagKnownValues) { // 31-bit sign shift and produced garbage for anything outside the int32 // range. EXPECT_EQ(1u, static_cast(ProtoBuffer::ZigZag(-1))); - EXPECT_EQ(uint64_t(1) << 32, - static_cast(ProtoBuffer::ZigZag(int64_t(1) - << 31))); + EXPECT_EQ( + uint64_t(1) << 32, + static_cast(ProtoBuffer::ZigZag(int64_t(1) << 31))); EXPECT_EQ(0xFFFFFFFFFFFFFFFEull, static_cast(ProtoBuffer::ZigZag(INT64_MAX))); EXPECT_EQ(0xFFFFFFFFFFFFFFFFull, @@ -58,9 +61,8 @@ TEST(Wireformat, ZigZagKnownValues) { TEST(Wireformat, ZigZagRoundTrip) { EXPECT_EQ(0, ProtoBuffer::ZagZig(ProtoBuffer::ZigZag(0))); - for (int32_t v : - {INT32_MIN, INT32_MIN + 1, -123456, -2, -1, 0, 1, 2, 123456, - INT32_MAX - 1, INT32_MAX}) { + for (int32_t v : {INT32_MIN, INT32_MIN + 1, -123456, -2, -1, 0, 1, 2, 123456, + INT32_MAX - 1, INT32_MAX}) { EXPECT_EQ(v, ProtoBuffer::ZagZig(ProtoBuffer::ZigZag(v))) << "int32 value " << v; } @@ -87,9 +89,9 @@ TEST(Wireformat, SintVarintRoundTrip) { ASSERT_TRUE(decoded.ok()); EXPECT_EQ(v, *decoded) << "int64 value " << v; }; - for (int64_t v : {INT64_MIN, int64_t(INT32_MIN) - 1, int64_t(-1), - int64_t(0), int64_t(1), int64_t(1) << 33, - int64_t(INT32_MAX) + 1, INT64_MAX}) { + for (int64_t v : + {INT64_MIN, int64_t(INT32_MIN) - 1, int64_t(-1), int64_t(0), int64_t(1), + int64_t(1) << 33, int64_t(INT32_MAX) + 1, INT64_MAX}) { round_trip64(v); } @@ -107,7 +109,7 @@ TEST(Wireformat, SintVarintRoundTrip) { } } -int main(int argc, char **argv) { +int main(int argc, char** argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); diff --git a/phaser/stress_test.cc b/phaser/stress_test.cc index c5c07f6..0671939 100644 --- a/phaser/stress_test.cc +++ b/phaser/stress_test.cc @@ -2,12 +2,14 @@ // All Rights Reserved // See LICENSE file for licensing information. -#include "phaser/runtime/message.h" -#include "test_helpers.h" -#include "phaser/testdata/TestMessage.phaser.h" #include + #include +#include "phaser/runtime/message.h" +#include "phaser/testdata/TestMessage.phaser.h" +#include "test_helpers.h" + namespace { using foo::bar::phaser::TestMessage; @@ -24,11 +26,11 @@ TEST(StressTest, DynamicStringPressure) { TEST(StressTest, FixedBufferTuningSizeMode) { constexpr size_t kBufSize = 4096; - char *buffer = static_cast(calloc(kBufSize, 1)); + char* buffer = static_cast(calloc(kBufSize, 1)); ASSERT_NE(nullptr, buffer); - TestMessage msg = TestMessage::CreateMutable(buffer, kBufSize, - ::phaser::Tuning::kSize); + TestMessage msg = + TestMessage::CreateMutable(buffer, kBufSize, ::phaser::Tuning::kSize); for (int i = 0; i < 200; i++) { msg.add_vi32(i); } @@ -68,9 +70,9 @@ TEST(StressTest, AllocFailsAtStart) { TEST(StressTest, CustomAllocSucceeds) { TestMessage msg = TestMessage::CreateDynamicMutable( - 512, ::phaser::test::AllocUntilLimit(64 * 1024), [](void *p) { free(p); }, - [](void *p, size_t, size_t new_size) -> absl::StatusOr { - void *r = realloc(p, new_size); + 512, ::phaser::test::AllocUntilLimit(64 * 1024), [](void* p) { free(p); }, + [](void* p, size_t, size_t new_size) -> absl::StatusOr { + void* r = realloc(p, new_size); if (r == nullptr) { return absl::ResourceExhaustedError("realloc failed"); } @@ -85,7 +87,7 @@ TEST(StressTest, ReallocFailureAborts) { { TestMessage msg = TestMessage::CreateDynamicMutable( 256, ::phaser::test::AllocUntilLimit(1024 * 1024), - [](void *p) { free(p); }, ::phaser::test::ReallocAlwaysFails()); + [](void* p) { free(p); }, ::phaser::test::ReallocAlwaysFails()); for (int i = 0; i < 2000; i++) { msg.add_vstr(::phaser::test::MakePatternString(256, 'x')); } @@ -98,7 +100,8 @@ TEST(StressTest, RepeatedStringResizeAndReplace) { ASSERT_FALSE(msg.allocate_buffer(64 * 1024).empty()); msg.resize_vstr(200); for (size_t i = 0; i < 200; i++) { - msg.set_vstr(i, ::phaser::test::MakePatternString(16, static_cast('a' + (i % 26)))); + msg.set_vstr(i, ::phaser::test::MakePatternString( + 16, static_cast('a' + (i % 26)))); } msg.clear_vstr(); EXPECT_EQ(0u, msg.vstr_size()); @@ -112,8 +115,9 @@ TEST(StressTest, MapManyEntries) { TestMessage msg(4096); ASSERT_FALSE(msg.allocate_buffer(128 * 1024).empty()); for (int i = 0; i < 500; i++) { - auto *e = msg.add_values(); - e->set_key(::phaser::test::MakePatternString(8, static_cast('k' + (i % 10)))); + auto* e = msg.add_values(); + e->set_key(::phaser::test::MakePatternString( + 8, static_cast('k' + (i % 10)))); e->set_value(i); } ASSERT_EQ(500u, msg.values_size()); @@ -122,4 +126,4 @@ TEST(StressTest, MapManyEntries) { } } -} // namespace +} // namespace diff --git a/phaser/test_helpers.h b/phaser/test_helpers.h index 44d7e9b..5963c95 100644 --- a/phaser/test_helpers.h +++ b/phaser/test_helpers.h @@ -4,15 +4,16 @@ #pragma once -#include "absl/status/statusor.h" #include #include #include #include +#include "absl/status/statusor.h" + namespace phaser::test { -inline void StripProtobufDebugRedaction(std::string &s) { +inline void StripProtobufDebugRedaction(std::string& s) { // Recent protobuf versions prepend a non-deterministic redaction marker to // DebugString() output (e.g. "goo.gle/debugstr", "goo.gle/debugproto", // "goo.gle/debugonly") to discourage parsing the debug format. The marker is @@ -41,14 +42,14 @@ inline void StripProtobufDebugRedaction(std::string &s) { } // Alloc succeeds until cumulative requested bytes exceed limit. -inline std::function(size_t)> -AllocUntilLimit(size_t limit) { - return [remaining = limit](size_t size) mutable -> absl::StatusOr { +inline std::function(size_t)> AllocUntilLimit( + size_t limit) { + return [remaining = limit](size_t size) mutable -> absl::StatusOr { if (size > remaining) { return absl::ResourceExhaustedError("alloc limit exceeded"); } remaining -= size; - void *p = ::malloc(size); + void* p = ::malloc(size); if (p == nullptr) { return absl::ResourceExhaustedError("malloc failed"); } @@ -56,9 +57,9 @@ AllocUntilLimit(size_t limit) { }; } -inline std::function(void *, size_t, size_t)> +inline std::function(void*, size_t, size_t)> ReallocAlwaysFails() { - return [](void *, size_t, size_t) -> absl::StatusOr { + return [](void*, size_t, size_t) -> absl::StatusOr { return absl::ResourceExhaustedError("realloc denied"); }; } @@ -76,4 +77,4 @@ inline std::string MakePatternBytes(size_t n) { return s; } -} // namespace phaser::test +} // namespace phaser::test