/work/src/bloaty.pb.cc

Source (jump to first uncovered line)
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: bloaty.proto

#include "bloaty.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_bloaty_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CustomDataSource_bloaty_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_bloaty_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Regex_bloaty_2eproto;
namespace bloaty {
class OptionsDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Options> _instance;
} _Options_default_instance_;
class CustomDataSourceDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CustomDataSource> _instance;
} _CustomDataSource_default_instance_;
class RegexDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Regex> _instance;
} _Regex_default_instance_;
}  // namespace bloaty
static void InitDefaultsscc_info_CustomDataSource_bloaty_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::bloaty::_CustomDataSource_default_instance_;
    new (ptr) ::bloaty::CustomDataSource();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::bloaty::CustomDataSource::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_CustomDataSource_bloaty_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_CustomDataSource_bloaty_2eproto}, {
      &scc_info_Regex_bloaty_2eproto.base,}};

static void InitDefaultsscc_info_Options_bloaty_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::bloaty::_Options_default_instance_;
    new (ptr) ::bloaty::Options();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::bloaty::Options::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Options_bloaty_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Options_bloaty_2eproto}, {
      &scc_info_CustomDataSource_bloaty_2eproto.base,}};

static void InitDefaultsscc_info_Regex_bloaty_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::bloaty::_Regex_default_instance_;
    new (ptr) ::bloaty::Regex();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::bloaty::Regex::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Regex_bloaty_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_Regex_bloaty_2eproto}, {}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_bloaty_2eproto[3];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_bloaty_2eproto[2];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_bloaty_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_bloaty_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, filename_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, base_filename_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, debug_filename_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, data_source_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, max_rows_per_level_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, demangle_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, sort_by_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, verbose_level_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, debug_vmaddr_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, debug_fileoff_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, custom_data_source_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, disassemble_function_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, source_filter_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Options, dump_raw_map_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  8,
  2,
  3,
  4,
  6,
  7,
  ~0u,
  0,
  1,
  5,
  PROTOBUF_FIELD_OFFSET(::bloaty::CustomDataSource, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::bloaty::CustomDataSource, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::bloaty::CustomDataSource, name_),
  PROTOBUF_FIELD_OFFSET(::bloaty::CustomDataSource, base_data_source_),
  PROTOBUF_FIELD_OFFSET(::bloaty::CustomDataSource, rewrite_),
  0,
  1,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::bloaty::Regex, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Regex, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::bloaty::Regex, pattern_),
  PROTOBUF_FIELD_OFFSET(::bloaty::Regex, replacement_),
  0,
  1,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 19, sizeof(::bloaty::Options)},
  { 33, 41, sizeof(::bloaty::CustomDataSource)},
  { 44, 51, sizeof(::bloaty::Regex)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::bloaty::_Options_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::bloaty::_CustomDataSource_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::bloaty::_Regex_default_instance_),
};

const char descriptor_table_protodef_bloaty_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\014bloaty.proto\022\006bloaty\"\277\004\n\007Options\022\020\n\010fi"
  "lename\030\001 \003(\t\022\025\n\rbase_filename\030\002 \003(\t\022\026\n\016d"
  "ebug_filename\030\n \003(\t\022\023\n\013data_source\030\003 \003(\t"
  "\022\036\n\022max_rows_per_level\030\004 \001(\003:\00220\022:\n\010dema"
  "ngle\030\005 \001(\0162\030.bloaty.Options.Demangle:\016DE"
  "MANGLE_SHORT\0224\n\007sort_by\030\006 \001(\0162\026.bloaty.O"
  "ptions.SortBy:\013SORTBY_BOTH\022\025\n\rverbose_le"
  "vel\030\007 \001(\005\022\024\n\014debug_vmaddr\030\013 \001(\004\022\025\n\rdebug"
  "_fileoff\030\014 \001(\004\0224\n\022custom_data_source\030\010 \003"
  "(\0132\030.bloaty.CustomDataSource\022\034\n\024disassem"
  "ble_function\030\t \001(\t\022\025\n\rsource_filter\030\r \001("
  "\t\022\024\n\014dump_raw_map\030\016 \001(\010\"D\n\010Demangle\022\022\n\016D"
  "EMANGLE_SHORT\020\000\022\021\n\rDEMANGLE_FULL\020\001\022\021\n\rDE"
  "MANGLE_NONE\020\002\"A\n\006SortBy\022\017\n\013SORTBY_BOTH\020\000"
  "\022\021\n\rSORTBY_VMSIZE\020\001\022\023\n\017SORTBY_FILESIZE\020\002"
  "\"Z\n\020CustomDataSource\022\014\n\004name\030\001 \001(\t\022\030\n\020ba"
  "se_data_source\030\002 \001(\t\022\036\n\007rewrite\030\003 \003(\0132\r."
  "bloaty.Regex\"-\n\005Regex\022\017\n\007pattern\030\001 \001(\t\022\023"
  "\n\013replacement\030\002 \001(\t"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_bloaty_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_bloaty_2eproto_sccs[3] = {
  &scc_info_CustomDataSource_bloaty_2eproto.base,
  &scc_info_Options_bloaty_2eproto.base,
  &scc_info_Regex_bloaty_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_bloaty_2eproto_once;
static bool descriptor_table_bloaty_2eproto_initialized = false;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_bloaty_2eproto = {
  &descriptor_table_bloaty_2eproto_initialized, descriptor_table_protodef_bloaty_2eproto, "bloaty.proto", 739,
  &descriptor_table_bloaty_2eproto_once, descriptor_table_bloaty_2eproto_sccs, descriptor_table_bloaty_2eproto_deps, 3, 0,
  schemas, file_default_instances, TableStruct_bloaty_2eproto::offsets,
  file_level_metadata_bloaty_2eproto, 3, file_level_enum_descriptors_bloaty_2eproto, file_level_service_descriptors_bloaty_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_bloaty_2eproto = (  ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_bloaty_2eproto), true);
namespace bloaty {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Options_Demangle_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_bloaty_2eproto);
  return file_level_enum_descriptors_bloaty_2eproto[0];
}
bool Options_Demangle_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr Options_Demangle Options::DEMANGLE_SHORT;
constexpr Options_Demangle Options::DEMANGLE_FULL;
constexpr Options_Demangle Options::DEMANGLE_NONE;
constexpr Options_Demangle Options::Demangle_MIN;
constexpr Options_Demangle Options::Demangle_MAX;
constexpr int Options::Demangle_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Options_SortBy_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_bloaty_2eproto);
  return file_level_enum_descriptors_bloaty_2eproto[1];
}
bool Options_SortBy_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr Options_SortBy Options::SORTBY_BOTH;
constexpr Options_SortBy Options::SORTBY_VMSIZE;
constexpr Options_SortBy Options::SORTBY_FILESIZE;
constexpr Options_SortBy Options::SortBy_MIN;
constexpr Options_SortBy Options::SortBy_MAX;
constexpr int Options::SortBy_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)

// ===================================================================

void Options::InitAsDefaultInstance() {
}
class Options::_Internal {
 public:
  using HasBits = decltype(std::declval<Options>()._has_bits_);
  static void set_has_max_rows_per_level(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_demangle(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_sort_by(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_verbose_level(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_debug_vmaddr(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_debug_fileoff(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_disassemble_function(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_source_filter(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_dump_raw_map(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

Options::Options()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:bloaty.Options)
}
Options::Options(const Options& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      filename_(from.filename_),
      base_filename_(from.base_filename_),
      data_source_(from.data_source_),
      custom_data_source_(from.custom_data_source_),
      debug_filename_(from.debug_filename_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  disassemble_function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_disassemble_function()) {
    disassemble_function_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.disassemble_function_);
  }
  source_filter_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_source_filter()) {
    source_filter_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.source_filter_);
  }
  ::memcpy(&demangle_, &from.demangle_,
    static_cast<size_t>(reinterpret_cast<char*>(&max_rows_per_level_) -
    reinterpret_cast<char*>(&demangle_)) + sizeof(max_rows_per_level_));
  // @@protoc_insertion_point(copy_constructor:bloaty.Options)
}

void Options::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Options_bloaty_2eproto.base);
  disassemble_function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  source_filter_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&demangle_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&debug_fileoff_) -
      reinterpret_cast<char*>(&demangle_)) + sizeof(debug_fileoff_));
  max_rows_per_level_ = PROTOBUF_LONGLONG(20);
}

Options::~Options() {
  // @@protoc_insertion_point(destructor:bloaty.Options)
  SharedDtor();
}

void Options::SharedDtor() {
  disassemble_function_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  source_filter_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Options::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Options& Options::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Options_bloaty_2eproto.base);
  return *internal_default_instance();
}


void Options::Clear() {
// @@protoc_insertion_point(message_clear_start:bloaty.Options)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  filename_.Clear();
  base_filename_.Clear();
  data_source_.Clear();
  custom_data_source_.Clear();
  debug_filename_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      disassemble_function_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      source_filter_.ClearNonDefaultToEmptyNoArena();
    }
  }
  if (cached_has_bits & 0x000000fcu) {
    ::memset(&demangle_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&debug_fileoff_) -
        reinterpret_cast<char*>(&demangle_)) + sizeof(debug_fileoff_));
  }
  max_rows_per_level_ = PROTOBUF_LONGLONG(20);
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Options::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // repeated string filename = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_add_filename(), ptr, ctx, "bloaty.Options.filename");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated string base_filename = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_add_base_filename(), ptr, ctx, "bloaty.Options.base_filename");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated string data_source = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_add_data_source(), ptr, ctx, "bloaty.Options.data_source");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // optional int64 max_rows_per_level = 4 [default = 20];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_max_rows_per_level(&has_bits);
          max_rows_per_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .bloaty.Options.Demangle demangle = 5 [default = DEMANGLE_SHORT];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::bloaty::Options_Demangle_IsValid(val))) {
            _internal_set_demangle(static_cast<::bloaty::Options_Demangle>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .bloaty.Options.SortBy sort_by = 6 [default = SORTBY_BOTH];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::bloaty::Options_SortBy_IsValid(val))) {
            _internal_set_sort_by(static_cast<::bloaty::Options_SortBy>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional int32 verbose_level = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          _Internal::set_has_verbose_level(&has_bits);
          verbose_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .bloaty.CustomDataSource custom_data_source = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_custom_data_source(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
        } else goto handle_unusual;
        continue;
      // optional string disassemble_function = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_mutable_disassemble_function(), ptr, ctx, "bloaty.Options.disassemble_function");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string debug_filename = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_add_debug_filename(), ptr, ctx, "bloaty.Options.debug_filename");
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<82>(ptr));
        } else goto handle_unusual;
        continue;
      // optional uint64 debug_vmaddr = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_debug_vmaddr(&has_bits);
          debug_vmaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional uint64 debug_fileoff = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) {
          _Internal::set_has_debug_fileoff(&has_bits);
          debug_fileoff_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string source_filter = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_mutable_source_filter(), ptr, ctx, "bloaty.Options.source_filter");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool dump_raw_map = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) {
          _Internal::set_has_dump_raw_map(&has_bits);
          dump_raw_map_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Options::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bloaty.Options)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated string filename = 1;
  for (int i = 0, n = this->_internal_filename_size(); i < n; i++) {
    const auto& s = this->_internal_filename(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.Options.filename");
    target = stream->WriteString(1, s, target);
  }

  // repeated string base_filename = 2;
  for (int i = 0, n = this->_internal_base_filename_size(); i < n; i++) {
    const auto& s = this->_internal_base_filename(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.Options.base_filename");
    target = stream->WriteString(2, s, target);
  }

  // repeated string data_source = 3;
  for (int i = 0, n = this->_internal_data_source_size(); i < n; i++) {
    const auto& s = this->_internal_data_source(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.Options.data_source");
    target = stream->WriteString(3, s, target);
  }

  cached_has_bits = _has_bits_[0];
  // optional int64 max_rows_per_level = 4 [default = 20];
  if (cached_has_bits & 0x00000100u) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_max_rows_per_level(), target);
  }

  // optional .bloaty.Options.Demangle demangle = 5 [default = DEMANGLE_SHORT];
  if (cached_has_bits & 0x00000004u) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      5, this->_internal_demangle(), target);
  }

  // optional .bloaty.Options.SortBy sort_by = 6 [default = SORTBY_BOTH];
  if (cached_has_bits & 0x00000008u) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      6, this->_internal_sort_by(), target);
  }

  // optional int32 verbose_level = 7;
  if (cached_has_bits & 0x00000010u) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(7, this->_internal_verbose_level(), target);
  }

  // repeated .bloaty.CustomDataSource custom_data_source = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_custom_data_source_size()); i < n; i++) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(8, this->_internal_custom_data_source(i), target, stream);
  }

  // optional string disassemble_function = 9;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_disassemble_function().data(), static_cast<int>(this->_internal_disassemble_function().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.Options.disassemble_function");
    target = stream->WriteStringMaybeAliased(
        9, this->_internal_disassemble_function(), target);
  }

  // repeated string debug_filename = 10;
  for (int i = 0, n = this->_internal_debug_filename_size(); i < n; i++) {
    const auto& s = this->_internal_debug_filename(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.Options.debug_filename");
    target = stream->WriteString(10, s, target);
  }

  // optional uint64 debug_vmaddr = 11;
  if (cached_has_bits & 0x00000040u) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(11, this->_internal_debug_vmaddr(), target);
  }

  // optional uint64 debug_fileoff = 12;
  if (cached_has_bits & 0x00000080u) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_debug_fileoff(), target);
  }

  // optional string source_filter = 13;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_source_filter().data(), static_cast<int>(this->_internal_source_filter().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.Options.source_filter");
    target = stream->WriteStringMaybeAliased(
        13, this->_internal_source_filter(), target);
  }

  // optional bool dump_raw_map = 14;
  if (cached_has_bits & 0x00000020u) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(14, this->_internal_dump_raw_map(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bloaty.Options)
  return target;
}

size_t Options::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bloaty.Options)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string filename = 1;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(filename_.size());
  for (int i = 0, n = filename_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      filename_.Get(i));
  }

  // repeated string base_filename = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(base_filename_.size());
  for (int i = 0, n = base_filename_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      base_filename_.Get(i));
  }

  // repeated string data_source = 3;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(data_source_.size());
  for (int i = 0, n = data_source_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      data_source_.Get(i));
  }

  // repeated .bloaty.CustomDataSource custom_data_source = 8;
  total_size += 1UL * this->_internal_custom_data_source_size();
  for (const auto& msg : this->custom_data_source_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated string debug_filename = 10;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(debug_filename_.size());
  for (int i = 0, n = debug_filename_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      debug_filename_.Get(i));
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string disassemble_function = 9;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_disassemble_function());
    }

    // optional string source_filter = 13;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_source_filter());
    }

    // optional .bloaty.Options.Demangle demangle = 5 [default = DEMANGLE_SHORT];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_demangle());
    }

    // optional .bloaty.Options.SortBy sort_by = 6 [default = SORTBY_BOTH];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_sort_by());
    }

    // optional int32 verbose_level = 7;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_verbose_level());
    }

    // optional bool dump_raw_map = 14;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

    // optional uint64 debug_vmaddr = 11;
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_debug_vmaddr());
    }

    // optional uint64 debug_fileoff = 12;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
          this->_internal_debug_fileoff());
    }

  }
  // optional int64 max_rows_per_level = 4 [default = 20];
  if (cached_has_bits & 0x00000100u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
        this->_internal_max_rows_per_level());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Options::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:bloaty.Options)
  GOOGLE_DCHECK_NE(&from, this);
  const Options* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Options>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:bloaty.Options)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:bloaty.Options)
    MergeFrom(*source);
  }
}

void Options::MergeFrom(const Options& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bloaty.Options)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  filename_.MergeFrom(from.filename_);
  base_filename_.MergeFrom(from.base_filename_);
  data_source_.MergeFrom(from.data_source_);
  custom_data_source_.MergeFrom(from.custom_data_source_);
  debug_filename_.MergeFrom(from.debug_filename_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      disassemble_function_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.disassemble_function_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      source_filter_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.source_filter_);
    }
    if (cached_has_bits & 0x00000004u) {
      demangle_ = from.demangle_;
    }
    if (cached_has_bits & 0x00000008u) {
      sort_by_ = from.sort_by_;
    }
    if (cached_has_bits & 0x00000010u) {
      verbose_level_ = from.verbose_level_;
    }
    if (cached_has_bits & 0x00000020u) {
      dump_raw_map_ = from.dump_raw_map_;
    }
    if (cached_has_bits & 0x00000040u) {
      debug_vmaddr_ = from.debug_vmaddr_;
    }
    if (cached_has_bits & 0x00000080u) {
      debug_fileoff_ = from.debug_fileoff_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000100u) {
    _internal_set_max_rows_per_level(from._internal_max_rows_per_level());
  }
}

void Options::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:bloaty.Options)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Options::CopyFrom(const Options& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bloaty.Options)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Options::IsInitialized() const {
  return true;
}

void Options::InternalSwap(Options* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  filename_.InternalSwap(&other->filename_);
  base_filename_.InternalSwap(&other->base_filename_);
  data_source_.InternalSwap(&other->data_source_);
  custom_data_source_.InternalSwap(&other->custom_data_source_);
  debug_filename_.InternalSwap(&other->debug_filename_);
  disassemble_function_.Swap(&other->disassemble_function_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  source_filter_.Swap(&other->source_filter_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  swap(demangle_, other->demangle_);
  swap(sort_by_, other->sort_by_);
  swap(verbose_level_, other->verbose_level_);
  swap(dump_raw_map_, other->dump_raw_map_);
  swap(debug_vmaddr_, other->debug_vmaddr_);
  swap(debug_fileoff_, other->debug_fileoff_);
  swap(max_rows_per_level_, other->max_rows_per_level_);
}

::PROTOBUF_NAMESPACE_ID::Metadata Options::GetMetadata() const {
  return GetMetadataStatic();
}


// ===================================================================

void CustomDataSource::InitAsDefaultInstance() {
}
class CustomDataSource::_Internal {
 public:
  using HasBits = decltype(std::declval<CustomDataSource>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_base_data_source(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

CustomDataSource::CustomDataSource()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:bloaty.CustomDataSource)
}
CustomDataSource::CustomDataSource(const CustomDataSource& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_),
      rewrite_(from.rewrite_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
  }
  base_data_source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_base_data_source()) {
    base_data_source_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.base_data_source_);
  }
  // @@protoc_insertion_point(copy_constructor:bloaty.CustomDataSource)
}

void CustomDataSource::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CustomDataSource_bloaty_2eproto.base);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  base_data_source_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

CustomDataSource::~CustomDataSource() {
  // @@protoc_insertion_point(destructor:bloaty.CustomDataSource)
  SharedDtor();
}

void CustomDataSource::SharedDtor() {
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  base_data_source_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void CustomDataSource::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const CustomDataSource& CustomDataSource::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_CustomDataSource_bloaty_2eproto.base);
  return *internal_default_instance();
}


void CustomDataSource::Clear() {
// @@protoc_insertion_point(message_clear_start:bloaty.CustomDataSource)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  rewrite_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      name_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      base_data_source_.ClearNonDefaultToEmptyNoArena();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* CustomDataSource::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string name = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_mutable_name(), ptr, ctx, "bloaty.CustomDataSource.name");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string base_data_source = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_mutable_base_data_source(), ptr, ctx, "bloaty.CustomDataSource.base_data_source");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .bloaty.Regex rewrite = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_rewrite(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* CustomDataSource::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bloaty.CustomDataSource)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.CustomDataSource.name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_name(), target);
  }

  // optional string base_data_source = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_base_data_source().data(), static_cast<int>(this->_internal_base_data_source().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.CustomDataSource.base_data_source");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_base_data_source(), target);
  }

  // repeated .bloaty.Regex rewrite = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_rewrite_size()); i < n; i++) {
    stream->EnsureSpace(&target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessageToArray(3, this->_internal_rewrite(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bloaty.CustomDataSource)
  return target;
}

size_t CustomDataSource::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bloaty.CustomDataSource)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .bloaty.Regex rewrite = 3;
  total_size += 1UL * this->_internal_rewrite_size();
  for (const auto& msg : this->rewrite_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string name = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

    // optional string base_data_source = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_base_data_source());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void CustomDataSource::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:bloaty.CustomDataSource)
  GOOGLE_DCHECK_NE(&from, this);
  const CustomDataSource* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CustomDataSource>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:bloaty.CustomDataSource)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:bloaty.CustomDataSource)
    MergeFrom(*source);
  }
}

void CustomDataSource::MergeFrom(const CustomDataSource& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bloaty.CustomDataSource)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  rewrite_.MergeFrom(from.rewrite_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.name_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      base_data_source_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.base_data_source_);
    }
  }
}

void CustomDataSource::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:bloaty.CustomDataSource)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void CustomDataSource::CopyFrom(const CustomDataSource& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bloaty.CustomDataSource)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CustomDataSource::IsInitialized() const {
  return true;
}

void CustomDataSource::InternalSwap(CustomDataSource* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  rewrite_.InternalSwap(&other->rewrite_);
  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  base_data_source_.Swap(&other->base_data_source_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata CustomDataSource::GetMetadata() const {
  return GetMetadataStatic();
}


// ===================================================================

void Regex::InitAsDefaultInstance() {
}
class Regex::_Internal {
 public:
  using HasBits = decltype(std::declval<Regex>()._has_bits_);
  static void set_has_pattern(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_replacement(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

Regex::Regex()
  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
  SharedCtor();
  // @@protoc_insertion_point(constructor:bloaty.Regex)
}
Regex::Regex(const Regex& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _internal_metadata_(nullptr),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  pattern_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_pattern()) {
    pattern_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.pattern_);
  }
  replacement_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_replacement()) {
    replacement_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.replacement_);
  }
  // @@protoc_insertion_point(copy_constructor:bloaty.Regex)
}

void Regex::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Regex_bloaty_2eproto.base);
  pattern_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  replacement_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

Regex::~Regex() {
  // @@protoc_insertion_point(destructor:bloaty.Regex)
  SharedDtor();
}

void Regex::SharedDtor() {
  pattern_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  replacement_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void Regex::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Regex& Regex::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Regex_bloaty_2eproto.base);
  return *internal_default_instance();
}


void Regex::Clear() {
// @@protoc_insertion_point(message_clear_start:bloaty.Regex)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      pattern_.ClearNonDefaultToEmptyNoArena();
    }
    if (cached_has_bits & 0x00000002u) {
      replacement_.ClearNonDefaultToEmptyNoArena();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

const char* Regex::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // optional string pattern = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_mutable_pattern(), ptr, ctx, "bloaty.Regex.pattern");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string replacement = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8Verify(_internal_mutable_replacement(), ptr, ctx, "bloaty.Regex.replacement");
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Regex::InternalSerializeWithCachedSizesToArray(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:bloaty.Regex)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string pattern = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_pattern().data(), static_cast<int>(this->_internal_pattern().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.Regex.pattern");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_pattern(), target);
  }

  // optional string replacement = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_replacement().data(), static_cast<int>(this->_internal_replacement().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "bloaty.Regex.replacement");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_replacement(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields(), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:bloaty.Regex)
  return target;
}

size_t Regex::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:bloaty.Regex)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional string pattern = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_pattern());
    }

    // optional string replacement = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_replacement());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Regex::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:bloaty.Regex)
  GOOGLE_DCHECK_NE(&from, this);
  const Regex* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Regex>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:bloaty.Regex)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:bloaty.Regex)
    MergeFrom(*source);
  }
}

void Regex::MergeFrom(const Regex& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:bloaty.Regex)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _has_bits_[0] |= 0x00000001u;
      pattern_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.pattern_);
    }
    if (cached_has_bits & 0x00000002u) {
      _has_bits_[0] |= 0x00000002u;
      replacement_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.replacement_);
    }
  }
}

void Regex::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:bloaty.Regex)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Regex::CopyFrom(const Regex& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:bloaty.Regex)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Regex::IsInitialized() const {
  return true;
}

void Regex::InternalSwap(Regex* other) {
  using std::swap;
  _internal_metadata_.Swap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  pattern_.Swap(&other->pattern_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
  replacement_.Swap(&other->replacement_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
    GetArenaNoVirtual());
}

::PROTOBUF_NAMESPACE_ID::Metadata Regex::GetMetadata() const {
  return GetMetadataStatic();
}


// @@protoc_insertion_point(namespace_scope)
}  // namespace bloaty
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::bloaty::Options* Arena::CreateMaybeMessage< ::bloaty::Options >(Arena* arena) {
  return Arena::CreateInternal< ::bloaty::Options >(arena);
}
template<> PROTOBUF_NOINLINE ::bloaty::CustomDataSource* Arena::CreateMaybeMessage< ::bloaty::CustomDataSource >(Arena* arena) {
  return Arena::CreateInternal< ::bloaty::CustomDataSource >(arena);
}
template<> PROTOBUF_NOINLINE ::bloaty::Regex* Arena::CreateMaybeMessage< ::bloaty::Regex >(Arena* arena) {
  return Arena::CreateInternal< ::bloaty::Regex >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>

Coverage Report

Created: 2023-03-26 09:52