qtprotobuf/tests/test_grpc/echoserver/testserver/simpletest.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: simpletest.proto

#ifndef PROTOBUF_INCLUDED_simpletest_2eproto
#define PROTOBUF_INCLUDED_simpletest_2eproto

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3006001
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_simpletest_2eproto 

namespace protobuf_simpletest_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[24];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
}  // namespace protobuf_simpletest_2eproto
namespace qtprotobufnamespace {
namespace tests {
class ComplexMessage;
class ComplexMessageDefaultTypeInternal;
extern ComplexMessageDefaultTypeInternal _ComplexMessage_default_instance_;
class RepeatedBytesMessage;
class RepeatedBytesMessageDefaultTypeInternal;
extern RepeatedBytesMessageDefaultTypeInternal _RepeatedBytesMessage_default_instance_;
class RepeatedComplexMessage;
class RepeatedComplexMessageDefaultTypeInternal;
extern RepeatedComplexMessageDefaultTypeInternal _RepeatedComplexMessage_default_instance_;
class RepeatedDoubleMessage;
class RepeatedDoubleMessageDefaultTypeInternal;
extern RepeatedDoubleMessageDefaultTypeInternal _RepeatedDoubleMessage_default_instance_;
class RepeatedFloatMessage;
class RepeatedFloatMessageDefaultTypeInternal;
extern RepeatedFloatMessageDefaultTypeInternal _RepeatedFloatMessage_default_instance_;
class RepeatedIntMessage;
class RepeatedIntMessageDefaultTypeInternal;
extern RepeatedIntMessageDefaultTypeInternal _RepeatedIntMessage_default_instance_;
class RepeatedStringMessage;
class RepeatedStringMessageDefaultTypeInternal;
extern RepeatedStringMessageDefaultTypeInternal _RepeatedStringMessage_default_instance_;
class SimpleBoolMessage;
class SimpleBoolMessageDefaultTypeInternal;
extern SimpleBoolMessageDefaultTypeInternal _SimpleBoolMessage_default_instance_;
class SimpleBytesMessage;
class SimpleBytesMessageDefaultTypeInternal;
extern SimpleBytesMessageDefaultTypeInternal _SimpleBytesMessage_default_instance_;
class SimpleDoubleMessage;
class SimpleDoubleMessageDefaultTypeInternal;
extern SimpleDoubleMessageDefaultTypeInternal _SimpleDoubleMessage_default_instance_;
class SimpleEnumMessage;
class SimpleEnumMessageDefaultTypeInternal;
extern SimpleEnumMessageDefaultTypeInternal _SimpleEnumMessage_default_instance_;
class SimpleFileEnumMessage;
class SimpleFileEnumMessageDefaultTypeInternal;
extern SimpleFileEnumMessageDefaultTypeInternal _SimpleFileEnumMessage_default_instance_;
class SimpleFixedInt32Message;
class SimpleFixedInt32MessageDefaultTypeInternal;
extern SimpleFixedInt32MessageDefaultTypeInternal _SimpleFixedInt32Message_default_instance_;
class SimpleFixedInt64Message;
class SimpleFixedInt64MessageDefaultTypeInternal;
extern SimpleFixedInt64MessageDefaultTypeInternal _SimpleFixedInt64Message_default_instance_;
class SimpleFloatMessage;
class SimpleFloatMessageDefaultTypeInternal;
extern SimpleFloatMessageDefaultTypeInternal _SimpleFloatMessage_default_instance_;
class SimpleInt64Message;
class SimpleInt64MessageDefaultTypeInternal;
extern SimpleInt64MessageDefaultTypeInternal _SimpleInt64Message_default_instance_;
class SimpleIntMessage;
class SimpleIntMessageDefaultTypeInternal;
extern SimpleIntMessageDefaultTypeInternal _SimpleIntMessage_default_instance_;
class SimpleSFixedInt32Message;
class SimpleSFixedInt32MessageDefaultTypeInternal;
extern SimpleSFixedInt32MessageDefaultTypeInternal _SimpleSFixedInt32Message_default_instance_;
class SimpleSFixedInt64Message;
class SimpleSFixedInt64MessageDefaultTypeInternal;
extern SimpleSFixedInt64MessageDefaultTypeInternal _SimpleSFixedInt64Message_default_instance_;
class SimpleSInt64Message;
class SimpleSInt64MessageDefaultTypeInternal;
extern SimpleSInt64MessageDefaultTypeInternal _SimpleSInt64Message_default_instance_;
class SimpleSIntMessage;
class SimpleSIntMessageDefaultTypeInternal;
extern SimpleSIntMessageDefaultTypeInternal _SimpleSIntMessage_default_instance_;
class SimpleStringMessage;
class SimpleStringMessageDefaultTypeInternal;
extern SimpleStringMessageDefaultTypeInternal _SimpleStringMessage_default_instance_;
class SimpleUInt64Message;
class SimpleUInt64MessageDefaultTypeInternal;
extern SimpleUInt64MessageDefaultTypeInternal _SimpleUInt64Message_default_instance_;
class SimpleUIntMessage;
class SimpleUIntMessageDefaultTypeInternal;
extern SimpleUIntMessageDefaultTypeInternal _SimpleUIntMessage_default_instance_;
}  // namespace tests
}  // namespace qtprotobufnamespace
namespace google {
namespace protobuf {
template<> ::qtprotobufnamespace::tests::ComplexMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::ComplexMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::RepeatedBytesMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedBytesMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::RepeatedComplexMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedComplexMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::RepeatedDoubleMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedDoubleMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::RepeatedFloatMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedFloatMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::RepeatedIntMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedIntMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::RepeatedStringMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::RepeatedStringMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleBoolMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleBoolMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleBytesMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleBytesMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleDoubleMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleDoubleMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleEnumMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleEnumMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleFileEnumMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleFileEnumMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleFixedInt32Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleFixedInt32Message>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleFixedInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleFixedInt64Message>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleFloatMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleFloatMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleInt64Message>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleIntMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleIntMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleSFixedInt32Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleSFixedInt32Message>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleSFixedInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleSFixedInt64Message>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleSInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleSInt64Message>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleSIntMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleSIntMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleStringMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleStringMessage>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleUInt64Message* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleUInt64Message>(Arena*);
template<> ::qtprotobufnamespace::tests::SimpleUIntMessage* Arena::CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleUIntMessage>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace qtprotobufnamespace {
namespace tests {

enum SimpleEnumMessage_LocalEnum {
  SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE0 = 0,
  SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE1 = 1,
  SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE2 = 2,
  SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE3 = 3,
  SimpleEnumMessage_LocalEnum_SimpleEnumMessage_LocalEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  SimpleEnumMessage_LocalEnum_SimpleEnumMessage_LocalEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool SimpleEnumMessage_LocalEnum_IsValid(int value);
const SimpleEnumMessage_LocalEnum SimpleEnumMessage_LocalEnum_LocalEnum_MIN = SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE0;
const SimpleEnumMessage_LocalEnum SimpleEnumMessage_LocalEnum_LocalEnum_MAX = SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE3;
const int SimpleEnumMessage_LocalEnum_LocalEnum_ARRAYSIZE = SimpleEnumMessage_LocalEnum_LocalEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* SimpleEnumMessage_LocalEnum_descriptor();
inline const ::std::string& SimpleEnumMessage_LocalEnum_Name(SimpleEnumMessage_LocalEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    SimpleEnumMessage_LocalEnum_descriptor(), value);
}
inline bool SimpleEnumMessage_LocalEnum_Parse(
    const ::std::string& name, SimpleEnumMessage_LocalEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SimpleEnumMessage_LocalEnum>(
    SimpleEnumMessage_LocalEnum_descriptor(), name, value);
}
enum TestEnum {
  TEST_ENUM_VALUE0 = 0,
  TEST_ENUM_VALUE1 = 1,
  TEST_ENUM_VALUE2 = 2,
  TEST_ENUM_VALUE3 = 4,
  TEST_ENUM_VALUE4 = 3,
  TestEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  TestEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool TestEnum_IsValid(int value);
const TestEnum TestEnum_MIN = TEST_ENUM_VALUE0;
const TestEnum TestEnum_MAX = TEST_ENUM_VALUE3;
const int TestEnum_ARRAYSIZE = TestEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestEnum_descriptor();
inline const ::std::string& TestEnum_Name(TestEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestEnum_descriptor(), value);
}
inline bool TestEnum_Parse(
    const ::std::string& name, TestEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestEnum>(
    TestEnum_descriptor(), name, value);
}
// ===================================================================

class SimpleEnumMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleEnumMessage) */ {
 public:
  SimpleEnumMessage();
  virtual ~SimpleEnumMessage();

  SimpleEnumMessage(const SimpleEnumMessage& from);

  inline SimpleEnumMessage& operator=(const SimpleEnumMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleEnumMessage(SimpleEnumMessage&& from) noexcept
    : SimpleEnumMessage() {
    *this = ::std::move(from);
  }

  inline SimpleEnumMessage& operator=(SimpleEnumMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleEnumMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleEnumMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleEnumMessage*>(
               &_SimpleEnumMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(SimpleEnumMessage* other);
  friend void swap(SimpleEnumMessage& a, SimpleEnumMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleEnumMessage* New() const final {
    return CreateMaybeMessage<SimpleEnumMessage>(NULL);
  }

  SimpleEnumMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleEnumMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleEnumMessage& from);
  void MergeFrom(const SimpleEnumMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleEnumMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  typedef SimpleEnumMessage_LocalEnum LocalEnum;
  static const LocalEnum LOCAL_ENUM_VALUE0 =
    SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE0;
  static const LocalEnum LOCAL_ENUM_VALUE1 =
    SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE1;
  static const LocalEnum LOCAL_ENUM_VALUE2 =
    SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE2;
  static const LocalEnum LOCAL_ENUM_VALUE3 =
    SimpleEnumMessage_LocalEnum_LOCAL_ENUM_VALUE3;
  static inline bool LocalEnum_IsValid(int value) {
    return SimpleEnumMessage_LocalEnum_IsValid(value);
  }
  static const LocalEnum LocalEnum_MIN =
    SimpleEnumMessage_LocalEnum_LocalEnum_MIN;
  static const LocalEnum LocalEnum_MAX =
    SimpleEnumMessage_LocalEnum_LocalEnum_MAX;
  static const int LocalEnum_ARRAYSIZE =
    SimpleEnumMessage_LocalEnum_LocalEnum_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  LocalEnum_descriptor() {
    return SimpleEnumMessage_LocalEnum_descriptor();
  }
  static inline const ::std::string& LocalEnum_Name(LocalEnum value) {
    return SimpleEnumMessage_LocalEnum_Name(value);
  }
  static inline bool LocalEnum_Parse(const ::std::string& name,
      LocalEnum* value) {
    return SimpleEnumMessage_LocalEnum_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // repeated .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnumList = 2;
  int localenumlist_size() const;
  void clear_localenumlist();
  static const int kLocalEnumListFieldNumber = 2;
  ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum localenumlist(int index) const;
  void set_localenumlist(int index, ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value);
  void add_localenumlist(::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value);
  const ::google::protobuf::RepeatedField<int>& localenumlist() const;
  ::google::protobuf::RepeatedField<int>* mutable_localenumlist();

  // .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnum = 1;
  void clear_localenum();
  static const int kLocalEnumFieldNumber = 1;
  ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum localenum() const;
  void set_localenum(::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleEnumMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField<int> localenumlist_;
  mutable int _localenumlist_cached_byte_size_;
  int localenum_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleFileEnumMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleFileEnumMessage) */ {
 public:
  SimpleFileEnumMessage();
  virtual ~SimpleFileEnumMessage();

  SimpleFileEnumMessage(const SimpleFileEnumMessage& from);

  inline SimpleFileEnumMessage& operator=(const SimpleFileEnumMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleFileEnumMessage(SimpleFileEnumMessage&& from) noexcept
    : SimpleFileEnumMessage() {
    *this = ::std::move(from);
  }

  inline SimpleFileEnumMessage& operator=(SimpleFileEnumMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleFileEnumMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleFileEnumMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleFileEnumMessage*>(
               &_SimpleFileEnumMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(SimpleFileEnumMessage* other);
  friend void swap(SimpleFileEnumMessage& a, SimpleFileEnumMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleFileEnumMessage* New() const final {
    return CreateMaybeMessage<SimpleFileEnumMessage>(NULL);
  }

  SimpleFileEnumMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleFileEnumMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleFileEnumMessage& from);
  void MergeFrom(const SimpleFileEnumMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleFileEnumMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .qtprotobufnamespace.tests.TestEnum globalEnumList = 2;
  int globalenumlist_size() const;
  void clear_globalenumlist();
  static const int kGlobalEnumListFieldNumber = 2;
  ::qtprotobufnamespace::tests::TestEnum globalenumlist(int index) const;
  void set_globalenumlist(int index, ::qtprotobufnamespace::tests::TestEnum value);
  void add_globalenumlist(::qtprotobufnamespace::tests::TestEnum value);
  const ::google::protobuf::RepeatedField<int>& globalenumlist() const;
  ::google::protobuf::RepeatedField<int>* mutable_globalenumlist();

  // .qtprotobufnamespace.tests.TestEnum globalEnum = 1;
  void clear_globalenum();
  static const int kGlobalEnumFieldNumber = 1;
  ::qtprotobufnamespace::tests::TestEnum globalenum() const;
  void set_globalenum(::qtprotobufnamespace::tests::TestEnum value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleFileEnumMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField<int> globalenumlist_;
  mutable int _globalenumlist_cached_byte_size_;
  int globalenum_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleBoolMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleBoolMessage) */ {
 public:
  SimpleBoolMessage();
  virtual ~SimpleBoolMessage();

  SimpleBoolMessage(const SimpleBoolMessage& from);

  inline SimpleBoolMessage& operator=(const SimpleBoolMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleBoolMessage(SimpleBoolMessage&& from) noexcept
    : SimpleBoolMessage() {
    *this = ::std::move(from);
  }

  inline SimpleBoolMessage& operator=(SimpleBoolMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleBoolMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleBoolMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleBoolMessage*>(
               &_SimpleBoolMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(SimpleBoolMessage* other);
  friend void swap(SimpleBoolMessage& a, SimpleBoolMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleBoolMessage* New() const final {
    return CreateMaybeMessage<SimpleBoolMessage>(NULL);
  }

  SimpleBoolMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleBoolMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleBoolMessage& from);
  void MergeFrom(const SimpleBoolMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleBoolMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // bool testFieldBool = 1;
  void clear_testfieldbool();
  static const int kTestFieldBoolFieldNumber = 1;
  bool testfieldbool() const;
  void set_testfieldbool(bool value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleBoolMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  bool testfieldbool_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleIntMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleIntMessage) */ {
 public:
  SimpleIntMessage();
  virtual ~SimpleIntMessage();

  SimpleIntMessage(const SimpleIntMessage& from);

  inline SimpleIntMessage& operator=(const SimpleIntMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleIntMessage(SimpleIntMessage&& from) noexcept
    : SimpleIntMessage() {
    *this = ::std::move(from);
  }

  inline SimpleIntMessage& operator=(SimpleIntMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleIntMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleIntMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleIntMessage*>(
               &_SimpleIntMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(SimpleIntMessage* other);
  friend void swap(SimpleIntMessage& a, SimpleIntMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleIntMessage* New() const final {
    return CreateMaybeMessage<SimpleIntMessage>(NULL);
  }

  SimpleIntMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleIntMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleIntMessage& from);
  void MergeFrom(const SimpleIntMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleIntMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int32 testFieldInt = 1;
  void clear_testfieldint();
  static const int kTestFieldIntFieldNumber = 1;
  ::google::protobuf::int32 testfieldint() const;
  void set_testfieldint(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleIntMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int32 testfieldint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleSIntMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleSIntMessage) */ {
 public:
  SimpleSIntMessage();
  virtual ~SimpleSIntMessage();

  SimpleSIntMessage(const SimpleSIntMessage& from);

  inline SimpleSIntMessage& operator=(const SimpleSIntMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleSIntMessage(SimpleSIntMessage&& from) noexcept
    : SimpleSIntMessage() {
    *this = ::std::move(from);
  }

  inline SimpleSIntMessage& operator=(SimpleSIntMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleSIntMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleSIntMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleSIntMessage*>(
               &_SimpleSIntMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(SimpleSIntMessage* other);
  friend void swap(SimpleSIntMessage& a, SimpleSIntMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleSIntMessage* New() const final {
    return CreateMaybeMessage<SimpleSIntMessage>(NULL);
  }

  SimpleSIntMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleSIntMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleSIntMessage& from);
  void MergeFrom(const SimpleSIntMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleSIntMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // sint32 testFieldInt = 1;
  void clear_testfieldint();
  static const int kTestFieldIntFieldNumber = 1;
  ::google::protobuf::int32 testfieldint() const;
  void set_testfieldint(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleSIntMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int32 testfieldint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleUIntMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleUIntMessage) */ {
 public:
  SimpleUIntMessage();
  virtual ~SimpleUIntMessage();

  SimpleUIntMessage(const SimpleUIntMessage& from);

  inline SimpleUIntMessage& operator=(const SimpleUIntMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleUIntMessage(SimpleUIntMessage&& from) noexcept
    : SimpleUIntMessage() {
    *this = ::std::move(from);
  }

  inline SimpleUIntMessage& operator=(SimpleUIntMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleUIntMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleUIntMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleUIntMessage*>(
               &_SimpleUIntMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(SimpleUIntMessage* other);
  friend void swap(SimpleUIntMessage& a, SimpleUIntMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleUIntMessage* New() const final {
    return CreateMaybeMessage<SimpleUIntMessage>(NULL);
  }

  SimpleUIntMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleUIntMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleUIntMessage& from);
  void MergeFrom(const SimpleUIntMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleUIntMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // uint32 testFieldInt = 1;
  void clear_testfieldint();
  static const int kTestFieldIntFieldNumber = 1;
  ::google::protobuf::uint32 testfieldint() const;
  void set_testfieldint(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleUIntMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 testfieldint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleInt64Message) */ {
 public:
  SimpleInt64Message();
  virtual ~SimpleInt64Message();

  SimpleInt64Message(const SimpleInt64Message& from);

  inline SimpleInt64Message& operator=(const SimpleInt64Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleInt64Message(SimpleInt64Message&& from) noexcept
    : SimpleInt64Message() {
    *this = ::std::move(from);
  }

  inline SimpleInt64Message& operator=(SimpleInt64Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleInt64Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleInt64Message* internal_default_instance() {
    return reinterpret_cast<const SimpleInt64Message*>(
               &_SimpleInt64Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(SimpleInt64Message* other);
  friend void swap(SimpleInt64Message& a, SimpleInt64Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleInt64Message* New() const final {
    return CreateMaybeMessage<SimpleInt64Message>(NULL);
  }

  SimpleInt64Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleInt64Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleInt64Message& from);
  void MergeFrom(const SimpleInt64Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleInt64Message* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 testFieldInt = 1;
  void clear_testfieldint();
  static const int kTestFieldIntFieldNumber = 1;
  ::google::protobuf::int64 testfieldint() const;
  void set_testfieldint(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleInt64Message)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 testfieldint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleSInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleSInt64Message) */ {
 public:
  SimpleSInt64Message();
  virtual ~SimpleSInt64Message();

  SimpleSInt64Message(const SimpleSInt64Message& from);

  inline SimpleSInt64Message& operator=(const SimpleSInt64Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleSInt64Message(SimpleSInt64Message&& from) noexcept
    : SimpleSInt64Message() {
    *this = ::std::move(from);
  }

  inline SimpleSInt64Message& operator=(SimpleSInt64Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleSInt64Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleSInt64Message* internal_default_instance() {
    return reinterpret_cast<const SimpleSInt64Message*>(
               &_SimpleSInt64Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void Swap(SimpleSInt64Message* other);
  friend void swap(SimpleSInt64Message& a, SimpleSInt64Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleSInt64Message* New() const final {
    return CreateMaybeMessage<SimpleSInt64Message>(NULL);
  }

  SimpleSInt64Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleSInt64Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleSInt64Message& from);
  void MergeFrom(const SimpleSInt64Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleSInt64Message* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // sint64 testFieldInt = 1;
  void clear_testfieldint();
  static const int kTestFieldIntFieldNumber = 1;
  ::google::protobuf::int64 testfieldint() const;
  void set_testfieldint(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleSInt64Message)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 testfieldint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleUInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleUInt64Message) */ {
 public:
  SimpleUInt64Message();
  virtual ~SimpleUInt64Message();

  SimpleUInt64Message(const SimpleUInt64Message& from);

  inline SimpleUInt64Message& operator=(const SimpleUInt64Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleUInt64Message(SimpleUInt64Message&& from) noexcept
    : SimpleUInt64Message() {
    *this = ::std::move(from);
  }

  inline SimpleUInt64Message& operator=(SimpleUInt64Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleUInt64Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleUInt64Message* internal_default_instance() {
    return reinterpret_cast<const SimpleUInt64Message*>(
               &_SimpleUInt64Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void Swap(SimpleUInt64Message* other);
  friend void swap(SimpleUInt64Message& a, SimpleUInt64Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleUInt64Message* New() const final {
    return CreateMaybeMessage<SimpleUInt64Message>(NULL);
  }

  SimpleUInt64Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleUInt64Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleUInt64Message& from);
  void MergeFrom(const SimpleUInt64Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleUInt64Message* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // uint64 testFieldInt = 1;
  void clear_testfieldint();
  static const int kTestFieldIntFieldNumber = 1;
  ::google::protobuf::uint64 testfieldint() const;
  void set_testfieldint(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleUInt64Message)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint64 testfieldint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleStringMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleStringMessage) */ {
 public:
  SimpleStringMessage();
  virtual ~SimpleStringMessage();

  SimpleStringMessage(const SimpleStringMessage& from);

  inline SimpleStringMessage& operator=(const SimpleStringMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleStringMessage(SimpleStringMessage&& from) noexcept
    : SimpleStringMessage() {
    *this = ::std::move(from);
  }

  inline SimpleStringMessage& operator=(SimpleStringMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleStringMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleStringMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleStringMessage*>(
               &_SimpleStringMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  void Swap(SimpleStringMessage* other);
  friend void swap(SimpleStringMessage& a, SimpleStringMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleStringMessage* New() const final {
    return CreateMaybeMessage<SimpleStringMessage>(NULL);
  }

  SimpleStringMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleStringMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleStringMessage& from);
  void MergeFrom(const SimpleStringMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleStringMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string testFieldString = 6;
  void clear_testfieldstring();
  static const int kTestFieldStringFieldNumber = 6;
  const ::std::string& testfieldstring() const;
  void set_testfieldstring(const ::std::string& value);
  #if LANG_CXX11
  void set_testfieldstring(::std::string&& value);
  #endif
  void set_testfieldstring(const char* value);
  void set_testfieldstring(const char* value, size_t size);
  ::std::string* mutable_testfieldstring();
  ::std::string* release_testfieldstring();
  void set_allocated_testfieldstring(::std::string* testfieldstring);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleStringMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr testfieldstring_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleFloatMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleFloatMessage) */ {
 public:
  SimpleFloatMessage();
  virtual ~SimpleFloatMessage();

  SimpleFloatMessage(const SimpleFloatMessage& from);

  inline SimpleFloatMessage& operator=(const SimpleFloatMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleFloatMessage(SimpleFloatMessage&& from) noexcept
    : SimpleFloatMessage() {
    *this = ::std::move(from);
  }

  inline SimpleFloatMessage& operator=(SimpleFloatMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleFloatMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleFloatMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleFloatMessage*>(
               &_SimpleFloatMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  void Swap(SimpleFloatMessage* other);
  friend void swap(SimpleFloatMessage& a, SimpleFloatMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleFloatMessage* New() const final {
    return CreateMaybeMessage<SimpleFloatMessage>(NULL);
  }

  SimpleFloatMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleFloatMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleFloatMessage& from);
  void MergeFrom(const SimpleFloatMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleFloatMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // float testFieldFloat = 7;
  void clear_testfieldfloat();
  static const int kTestFieldFloatFieldNumber = 7;
  float testfieldfloat() const;
  void set_testfieldfloat(float value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleFloatMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  float testfieldfloat_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleDoubleMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleDoubleMessage) */ {
 public:
  SimpleDoubleMessage();
  virtual ~SimpleDoubleMessage();

  SimpleDoubleMessage(const SimpleDoubleMessage& from);

  inline SimpleDoubleMessage& operator=(const SimpleDoubleMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleDoubleMessage(SimpleDoubleMessage&& from) noexcept
    : SimpleDoubleMessage() {
    *this = ::std::move(from);
  }

  inline SimpleDoubleMessage& operator=(SimpleDoubleMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleDoubleMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleDoubleMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleDoubleMessage*>(
               &_SimpleDoubleMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  void Swap(SimpleDoubleMessage* other);
  friend void swap(SimpleDoubleMessage& a, SimpleDoubleMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleDoubleMessage* New() const final {
    return CreateMaybeMessage<SimpleDoubleMessage>(NULL);
  }

  SimpleDoubleMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleDoubleMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleDoubleMessage& from);
  void MergeFrom(const SimpleDoubleMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleDoubleMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // double testFieldDouble = 8;
  void clear_testfielddouble();
  static const int kTestFieldDoubleFieldNumber = 8;
  double testfielddouble() const;
  void set_testfielddouble(double value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleDoubleMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  double testfielddouble_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleBytesMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleBytesMessage) */ {
 public:
  SimpleBytesMessage();
  virtual ~SimpleBytesMessage();

  SimpleBytesMessage(const SimpleBytesMessage& from);

  inline SimpleBytesMessage& operator=(const SimpleBytesMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleBytesMessage(SimpleBytesMessage&& from) noexcept
    : SimpleBytesMessage() {
    *this = ::std::move(from);
  }

  inline SimpleBytesMessage& operator=(SimpleBytesMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleBytesMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleBytesMessage* internal_default_instance() {
    return reinterpret_cast<const SimpleBytesMessage*>(
               &_SimpleBytesMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  void Swap(SimpleBytesMessage* other);
  friend void swap(SimpleBytesMessage& a, SimpleBytesMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleBytesMessage* New() const final {
    return CreateMaybeMessage<SimpleBytesMessage>(NULL);
  }

  SimpleBytesMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleBytesMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleBytesMessage& from);
  void MergeFrom(const SimpleBytesMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleBytesMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // bytes testFieldBytes = 1;
  void clear_testfieldbytes();
  static const int kTestFieldBytesFieldNumber = 1;
  const ::std::string& testfieldbytes() const;
  void set_testfieldbytes(const ::std::string& value);
  #if LANG_CXX11
  void set_testfieldbytes(::std::string&& value);
  #endif
  void set_testfieldbytes(const char* value);
  void set_testfieldbytes(const void* value, size_t size);
  ::std::string* mutable_testfieldbytes();
  ::std::string* release_testfieldbytes();
  void set_allocated_testfieldbytes(::std::string* testfieldbytes);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleBytesMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr testfieldbytes_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleFixedInt32Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleFixedInt32Message) */ {
 public:
  SimpleFixedInt32Message();
  virtual ~SimpleFixedInt32Message();

  SimpleFixedInt32Message(const SimpleFixedInt32Message& from);

  inline SimpleFixedInt32Message& operator=(const SimpleFixedInt32Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleFixedInt32Message(SimpleFixedInt32Message&& from) noexcept
    : SimpleFixedInt32Message() {
    *this = ::std::move(from);
  }

  inline SimpleFixedInt32Message& operator=(SimpleFixedInt32Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleFixedInt32Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleFixedInt32Message* internal_default_instance() {
    return reinterpret_cast<const SimpleFixedInt32Message*>(
               &_SimpleFixedInt32Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  void Swap(SimpleFixedInt32Message* other);
  friend void swap(SimpleFixedInt32Message& a, SimpleFixedInt32Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleFixedInt32Message* New() const final {
    return CreateMaybeMessage<SimpleFixedInt32Message>(NULL);
  }

  SimpleFixedInt32Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleFixedInt32Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleFixedInt32Message& from);
  void MergeFrom(const SimpleFixedInt32Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleFixedInt32Message* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // fixed32 testFieldFixedInt32 = 1;
  void clear_testfieldfixedint32();
  static const int kTestFieldFixedInt32FieldNumber = 1;
  ::google::protobuf::uint32 testfieldfixedint32() const;
  void set_testfieldfixedint32(::google::protobuf::uint32 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleFixedInt32Message)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 testfieldfixedint32_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleFixedInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleFixedInt64Message) */ {
 public:
  SimpleFixedInt64Message();
  virtual ~SimpleFixedInt64Message();

  SimpleFixedInt64Message(const SimpleFixedInt64Message& from);

  inline SimpleFixedInt64Message& operator=(const SimpleFixedInt64Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleFixedInt64Message(SimpleFixedInt64Message&& from) noexcept
    : SimpleFixedInt64Message() {
    *this = ::std::move(from);
  }

  inline SimpleFixedInt64Message& operator=(SimpleFixedInt64Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleFixedInt64Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleFixedInt64Message* internal_default_instance() {
    return reinterpret_cast<const SimpleFixedInt64Message*>(
               &_SimpleFixedInt64Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  void Swap(SimpleFixedInt64Message* other);
  friend void swap(SimpleFixedInt64Message& a, SimpleFixedInt64Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleFixedInt64Message* New() const final {
    return CreateMaybeMessage<SimpleFixedInt64Message>(NULL);
  }

  SimpleFixedInt64Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleFixedInt64Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleFixedInt64Message& from);
  void MergeFrom(const SimpleFixedInt64Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleFixedInt64Message* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // fixed64 testFieldFixedInt64 = 1;
  void clear_testfieldfixedint64();
  static const int kTestFieldFixedInt64FieldNumber = 1;
  ::google::protobuf::uint64 testfieldfixedint64() const;
  void set_testfieldfixedint64(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleFixedInt64Message)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint64 testfieldfixedint64_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleSFixedInt32Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleSFixedInt32Message) */ {
 public:
  SimpleSFixedInt32Message();
  virtual ~SimpleSFixedInt32Message();

  SimpleSFixedInt32Message(const SimpleSFixedInt32Message& from);

  inline SimpleSFixedInt32Message& operator=(const SimpleSFixedInt32Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleSFixedInt32Message(SimpleSFixedInt32Message&& from) noexcept
    : SimpleSFixedInt32Message() {
    *this = ::std::move(from);
  }

  inline SimpleSFixedInt32Message& operator=(SimpleSFixedInt32Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleSFixedInt32Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleSFixedInt32Message* internal_default_instance() {
    return reinterpret_cast<const SimpleSFixedInt32Message*>(
               &_SimpleSFixedInt32Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  void Swap(SimpleSFixedInt32Message* other);
  friend void swap(SimpleSFixedInt32Message& a, SimpleSFixedInt32Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleSFixedInt32Message* New() const final {
    return CreateMaybeMessage<SimpleSFixedInt32Message>(NULL);
  }

  SimpleSFixedInt32Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleSFixedInt32Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleSFixedInt32Message& from);
  void MergeFrom(const SimpleSFixedInt32Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleSFixedInt32Message* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // sfixed32 testFieldFixedInt32 = 1;
  void clear_testfieldfixedint32();
  static const int kTestFieldFixedInt32FieldNumber = 1;
  ::google::protobuf::int32 testfieldfixedint32() const;
  void set_testfieldfixedint32(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleSFixedInt32Message)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int32 testfieldfixedint32_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SimpleSFixedInt64Message : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.SimpleSFixedInt64Message) */ {
 public:
  SimpleSFixedInt64Message();
  virtual ~SimpleSFixedInt64Message();

  SimpleSFixedInt64Message(const SimpleSFixedInt64Message& from);

  inline SimpleSFixedInt64Message& operator=(const SimpleSFixedInt64Message& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SimpleSFixedInt64Message(SimpleSFixedInt64Message&& from) noexcept
    : SimpleSFixedInt64Message() {
    *this = ::std::move(from);
  }

  inline SimpleSFixedInt64Message& operator=(SimpleSFixedInt64Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SimpleSFixedInt64Message& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SimpleSFixedInt64Message* internal_default_instance() {
    return reinterpret_cast<const SimpleSFixedInt64Message*>(
               &_SimpleSFixedInt64Message_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  void Swap(SimpleSFixedInt64Message* other);
  friend void swap(SimpleSFixedInt64Message& a, SimpleSFixedInt64Message& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SimpleSFixedInt64Message* New() const final {
    return CreateMaybeMessage<SimpleSFixedInt64Message>(NULL);
  }

  SimpleSFixedInt64Message* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SimpleSFixedInt64Message>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const SimpleSFixedInt64Message& from);
  void MergeFrom(const SimpleSFixedInt64Message& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SimpleSFixedInt64Message* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // sfixed64 testFieldFixedInt64 = 1;
  void clear_testfieldfixedint64();
  static const int kTestFieldFixedInt64FieldNumber = 1;
  ::google::protobuf::int64 testfieldfixedint64() const;
  void set_testfieldfixedint64(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.SimpleSFixedInt64Message)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 testfieldfixedint64_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ComplexMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.ComplexMessage) */ {
 public:
  ComplexMessage();
  virtual ~ComplexMessage();

  ComplexMessage(const ComplexMessage& from);

  inline ComplexMessage& operator=(const ComplexMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ComplexMessage(ComplexMessage&& from) noexcept
    : ComplexMessage() {
    *this = ::std::move(from);
  }

  inline ComplexMessage& operator=(ComplexMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ComplexMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ComplexMessage* internal_default_instance() {
    return reinterpret_cast<const ComplexMessage*>(
               &_ComplexMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  void Swap(ComplexMessage* other);
  friend void swap(ComplexMessage& a, ComplexMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ComplexMessage* New() const final {
    return CreateMaybeMessage<ComplexMessage>(NULL);
  }

  ComplexMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ComplexMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ComplexMessage& from);
  void MergeFrom(const ComplexMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ComplexMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // .qtprotobufnamespace.tests.SimpleStringMessage testComplexField = 2;
  bool has_testcomplexfield() const;
  void clear_testcomplexfield();
  static const int kTestComplexFieldFieldNumber = 2;
  private:
  const ::qtprotobufnamespace::tests::SimpleStringMessage& _internal_testcomplexfield() const;
  public:
  const ::qtprotobufnamespace::tests::SimpleStringMessage& testcomplexfield() const;
  ::qtprotobufnamespace::tests::SimpleStringMessage* release_testcomplexfield();
  ::qtprotobufnamespace::tests::SimpleStringMessage* mutable_testcomplexfield();
  void set_allocated_testcomplexfield(::qtprotobufnamespace::tests::SimpleStringMessage* testcomplexfield);

  // int32 testFieldInt = 1;
  void clear_testfieldint();
  static const int kTestFieldIntFieldNumber = 1;
  ::google::protobuf::int32 testfieldint() const;
  void set_testfieldint(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.ComplexMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::qtprotobufnamespace::tests::SimpleStringMessage* testcomplexfield_;
  ::google::protobuf::int32 testfieldint_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RepeatedIntMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedIntMessage) */ {
 public:
  RepeatedIntMessage();
  virtual ~RepeatedIntMessage();

  RepeatedIntMessage(const RepeatedIntMessage& from);

  inline RepeatedIntMessage& operator=(const RepeatedIntMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepeatedIntMessage(RepeatedIntMessage&& from) noexcept
    : RepeatedIntMessage() {
    *this = ::std::move(from);
  }

  inline RepeatedIntMessage& operator=(RepeatedIntMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepeatedIntMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepeatedIntMessage* internal_default_instance() {
    return reinterpret_cast<const RepeatedIntMessage*>(
               &_RepeatedIntMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  void Swap(RepeatedIntMessage* other);
  friend void swap(RepeatedIntMessage& a, RepeatedIntMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RepeatedIntMessage* New() const final {
    return CreateMaybeMessage<RepeatedIntMessage>(NULL);
  }

  RepeatedIntMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepeatedIntMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepeatedIntMessage& from);
  void MergeFrom(const RepeatedIntMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepeatedIntMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated sint32 testRepeatedInt = 1;
  int testrepeatedint_size() const;
  void clear_testrepeatedint();
  static const int kTestRepeatedIntFieldNumber = 1;
  ::google::protobuf::int32 testrepeatedint(int index) const;
  void set_testrepeatedint(int index, ::google::protobuf::int32 value);
  void add_testrepeatedint(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      testrepeatedint() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_testrepeatedint();

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedIntMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > testrepeatedint_;
  mutable int _testrepeatedint_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RepeatedStringMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedStringMessage) */ {
 public:
  RepeatedStringMessage();
  virtual ~RepeatedStringMessage();

  RepeatedStringMessage(const RepeatedStringMessage& from);

  inline RepeatedStringMessage& operator=(const RepeatedStringMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepeatedStringMessage(RepeatedStringMessage&& from) noexcept
    : RepeatedStringMessage() {
    *this = ::std::move(from);
  }

  inline RepeatedStringMessage& operator=(RepeatedStringMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepeatedStringMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepeatedStringMessage* internal_default_instance() {
    return reinterpret_cast<const RepeatedStringMessage*>(
               &_RepeatedStringMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  void Swap(RepeatedStringMessage* other);
  friend void swap(RepeatedStringMessage& a, RepeatedStringMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RepeatedStringMessage* New() const final {
    return CreateMaybeMessage<RepeatedStringMessage>(NULL);
  }

  RepeatedStringMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepeatedStringMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepeatedStringMessage& from);
  void MergeFrom(const RepeatedStringMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepeatedStringMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated string testRepeatedString = 1;
  int testrepeatedstring_size() const;
  void clear_testrepeatedstring();
  static const int kTestRepeatedStringFieldNumber = 1;
  const ::std::string& testrepeatedstring(int index) const;
  ::std::string* mutable_testrepeatedstring(int index);
  void set_testrepeatedstring(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_testrepeatedstring(int index, ::std::string&& value);
  #endif
  void set_testrepeatedstring(int index, const char* value);
  void set_testrepeatedstring(int index, const char* value, size_t size);
  ::std::string* add_testrepeatedstring();
  void add_testrepeatedstring(const ::std::string& value);
  #if LANG_CXX11
  void add_testrepeatedstring(::std::string&& value);
  #endif
  void add_testrepeatedstring(const char* value);
  void add_testrepeatedstring(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& testrepeatedstring() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_testrepeatedstring();

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedStringMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::std::string> testrepeatedstring_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RepeatedDoubleMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedDoubleMessage) */ {
 public:
  RepeatedDoubleMessage();
  virtual ~RepeatedDoubleMessage();

  RepeatedDoubleMessage(const RepeatedDoubleMessage& from);

  inline RepeatedDoubleMessage& operator=(const RepeatedDoubleMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepeatedDoubleMessage(RepeatedDoubleMessage&& from) noexcept
    : RepeatedDoubleMessage() {
    *this = ::std::move(from);
  }

  inline RepeatedDoubleMessage& operator=(RepeatedDoubleMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepeatedDoubleMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepeatedDoubleMessage* internal_default_instance() {
    return reinterpret_cast<const RepeatedDoubleMessage*>(
               &_RepeatedDoubleMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  void Swap(RepeatedDoubleMessage* other);
  friend void swap(RepeatedDoubleMessage& a, RepeatedDoubleMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RepeatedDoubleMessage* New() const final {
    return CreateMaybeMessage<RepeatedDoubleMessage>(NULL);
  }

  RepeatedDoubleMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepeatedDoubleMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepeatedDoubleMessage& from);
  void MergeFrom(const RepeatedDoubleMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepeatedDoubleMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated double testRepeatedDouble = 1;
  int testrepeateddouble_size() const;
  void clear_testrepeateddouble();
  static const int kTestRepeatedDoubleFieldNumber = 1;
  double testrepeateddouble(int index) const;
  void set_testrepeateddouble(int index, double value);
  void add_testrepeateddouble(double value);
  const ::google::protobuf::RepeatedField< double >&
      testrepeateddouble() const;
  ::google::protobuf::RepeatedField< double >*
      mutable_testrepeateddouble();

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedDoubleMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< double > testrepeateddouble_;
  mutable int _testrepeateddouble_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RepeatedBytesMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedBytesMessage) */ {
 public:
  RepeatedBytesMessage();
  virtual ~RepeatedBytesMessage();

  RepeatedBytesMessage(const RepeatedBytesMessage& from);

  inline RepeatedBytesMessage& operator=(const RepeatedBytesMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepeatedBytesMessage(RepeatedBytesMessage&& from) noexcept
    : RepeatedBytesMessage() {
    *this = ::std::move(from);
  }

  inline RepeatedBytesMessage& operator=(RepeatedBytesMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepeatedBytesMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepeatedBytesMessage* internal_default_instance() {
    return reinterpret_cast<const RepeatedBytesMessage*>(
               &_RepeatedBytesMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  void Swap(RepeatedBytesMessage* other);
  friend void swap(RepeatedBytesMessage& a, RepeatedBytesMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RepeatedBytesMessage* New() const final {
    return CreateMaybeMessage<RepeatedBytesMessage>(NULL);
  }

  RepeatedBytesMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepeatedBytesMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepeatedBytesMessage& from);
  void MergeFrom(const RepeatedBytesMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepeatedBytesMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated bytes testRepeatedBytes = 1;
  int testrepeatedbytes_size() const;
  void clear_testrepeatedbytes();
  static const int kTestRepeatedBytesFieldNumber = 1;
  const ::std::string& testrepeatedbytes(int index) const;
  ::std::string* mutable_testrepeatedbytes(int index);
  void set_testrepeatedbytes(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_testrepeatedbytes(int index, ::std::string&& value);
  #endif
  void set_testrepeatedbytes(int index, const char* value);
  void set_testrepeatedbytes(int index, const void* value, size_t size);
  ::std::string* add_testrepeatedbytes();
  void add_testrepeatedbytes(const ::std::string& value);
  #if LANG_CXX11
  void add_testrepeatedbytes(::std::string&& value);
  #endif
  void add_testrepeatedbytes(const char* value);
  void add_testrepeatedbytes(const void* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& testrepeatedbytes() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_testrepeatedbytes();

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedBytesMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::std::string> testrepeatedbytes_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RepeatedFloatMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedFloatMessage) */ {
 public:
  RepeatedFloatMessage();
  virtual ~RepeatedFloatMessage();

  RepeatedFloatMessage(const RepeatedFloatMessage& from);

  inline RepeatedFloatMessage& operator=(const RepeatedFloatMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepeatedFloatMessage(RepeatedFloatMessage&& from) noexcept
    : RepeatedFloatMessage() {
    *this = ::std::move(from);
  }

  inline RepeatedFloatMessage& operator=(RepeatedFloatMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepeatedFloatMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepeatedFloatMessage* internal_default_instance() {
    return reinterpret_cast<const RepeatedFloatMessage*>(
               &_RepeatedFloatMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  void Swap(RepeatedFloatMessage* other);
  friend void swap(RepeatedFloatMessage& a, RepeatedFloatMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RepeatedFloatMessage* New() const final {
    return CreateMaybeMessage<RepeatedFloatMessage>(NULL);
  }

  RepeatedFloatMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepeatedFloatMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepeatedFloatMessage& from);
  void MergeFrom(const RepeatedFloatMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepeatedFloatMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated float testRepeatedFloat = 1;
  int testrepeatedfloat_size() const;
  void clear_testrepeatedfloat();
  static const int kTestRepeatedFloatFieldNumber = 1;
  float testrepeatedfloat(int index) const;
  void set_testrepeatedfloat(int index, float value);
  void add_testrepeatedfloat(float value);
  const ::google::protobuf::RepeatedField< float >&
      testrepeatedfloat() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_testrepeatedfloat();

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedFloatMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< float > testrepeatedfloat_;
  mutable int _testrepeatedfloat_cached_byte_size_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RepeatedComplexMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:qtprotobufnamespace.tests.RepeatedComplexMessage) */ {
 public:
  RepeatedComplexMessage();
  virtual ~RepeatedComplexMessage();

  RepeatedComplexMessage(const RepeatedComplexMessage& from);

  inline RepeatedComplexMessage& operator=(const RepeatedComplexMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RepeatedComplexMessage(RepeatedComplexMessage&& from) noexcept
    : RepeatedComplexMessage() {
    *this = ::std::move(from);
  }

  inline RepeatedComplexMessage& operator=(RepeatedComplexMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepeatedComplexMessage& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RepeatedComplexMessage* internal_default_instance() {
    return reinterpret_cast<const RepeatedComplexMessage*>(
               &_RepeatedComplexMessage_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  void Swap(RepeatedComplexMessage* other);
  friend void swap(RepeatedComplexMessage& a, RepeatedComplexMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline RepeatedComplexMessage* New() const final {
    return CreateMaybeMessage<RepeatedComplexMessage>(NULL);
  }

  RepeatedComplexMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RepeatedComplexMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const RepeatedComplexMessage& from);
  void MergeFrom(const RepeatedComplexMessage& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RepeatedComplexMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated .qtprotobufnamespace.tests.ComplexMessage testRepeatedComplex = 1;
  int testrepeatedcomplex_size() const;
  void clear_testrepeatedcomplex();
  static const int kTestRepeatedComplexFieldNumber = 1;
  ::qtprotobufnamespace::tests::ComplexMessage* mutable_testrepeatedcomplex(int index);
  ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage >*
      mutable_testrepeatedcomplex();
  const ::qtprotobufnamespace::tests::ComplexMessage& testrepeatedcomplex(int index) const;
  ::qtprotobufnamespace::tests::ComplexMessage* add_testrepeatedcomplex();
  const ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage >&
      testrepeatedcomplex() const;

  // @@protoc_insertion_point(class_scope:qtprotobufnamespace.tests.RepeatedComplexMessage)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage > testrepeatedcomplex_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_simpletest_2eproto::TableStruct;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// SimpleEnumMessage

// .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnum = 1;
inline void SimpleEnumMessage::clear_localenum() {
  localenum_ = 0;
}
inline ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum SimpleEnumMessage::localenum() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleEnumMessage.localEnum)
  return static_cast< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum >(localenum_);
}
inline void SimpleEnumMessage::set_localenum(::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value) {
  
  localenum_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleEnumMessage.localEnum)
}

// repeated .qtprotobufnamespace.tests.SimpleEnumMessage.LocalEnum localEnumList = 2;
inline int SimpleEnumMessage::localenumlist_size() const {
  return localenumlist_.size();
}
inline void SimpleEnumMessage::clear_localenumlist() {
  localenumlist_.Clear();
}
inline ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum SimpleEnumMessage::localenumlist(int index) const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
  return static_cast< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum >(localenumlist_.Get(index));
}
inline void SimpleEnumMessage::set_localenumlist(int index, ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value) {
  localenumlist_.Set(index, value);
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
}
inline void SimpleEnumMessage::add_localenumlist(::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum value) {
  localenumlist_.Add(value);
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
}
inline const ::google::protobuf::RepeatedField<int>&
SimpleEnumMessage::localenumlist() const {
  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
  return localenumlist_;
}
inline ::google::protobuf::RepeatedField<int>*
SimpleEnumMessage::mutable_localenumlist() {
  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.SimpleEnumMessage.localEnumList)
  return &localenumlist_;
}

// -------------------------------------------------------------------

// SimpleFileEnumMessage

// .qtprotobufnamespace.tests.TestEnum globalEnum = 1;
inline void SimpleFileEnumMessage::clear_globalenum() {
  globalenum_ = 0;
}
inline ::qtprotobufnamespace::tests::TestEnum SimpleFileEnumMessage::globalenum() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnum)
  return static_cast< ::qtprotobufnamespace::tests::TestEnum >(globalenum_);
}
inline void SimpleFileEnumMessage::set_globalenum(::qtprotobufnamespace::tests::TestEnum value) {
  
  globalenum_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnum)
}

// repeated .qtprotobufnamespace.tests.TestEnum globalEnumList = 2;
inline int SimpleFileEnumMessage::globalenumlist_size() const {
  return globalenumlist_.size();
}
inline void SimpleFileEnumMessage::clear_globalenumlist() {
  globalenumlist_.Clear();
}
inline ::qtprotobufnamespace::tests::TestEnum SimpleFileEnumMessage::globalenumlist(int index) const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
  return static_cast< ::qtprotobufnamespace::tests::TestEnum >(globalenumlist_.Get(index));
}
inline void SimpleFileEnumMessage::set_globalenumlist(int index, ::qtprotobufnamespace::tests::TestEnum value) {
  globalenumlist_.Set(index, value);
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
}
inline void SimpleFileEnumMessage::add_globalenumlist(::qtprotobufnamespace::tests::TestEnum value) {
  globalenumlist_.Add(value);
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
}
inline const ::google::protobuf::RepeatedField<int>&
SimpleFileEnumMessage::globalenumlist() const {
  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
  return globalenumlist_;
}
inline ::google::protobuf::RepeatedField<int>*
SimpleFileEnumMessage::mutable_globalenumlist() {
  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.SimpleFileEnumMessage.globalEnumList)
  return &globalenumlist_;
}

// -------------------------------------------------------------------

// SimpleBoolMessage

// bool testFieldBool = 1;
inline void SimpleBoolMessage::clear_testfieldbool() {
  testfieldbool_ = false;
}
inline bool SimpleBoolMessage::testfieldbool() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleBoolMessage.testFieldBool)
  return testfieldbool_;
}
inline void SimpleBoolMessage::set_testfieldbool(bool value) {
  
  testfieldbool_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleBoolMessage.testFieldBool)
}

// -------------------------------------------------------------------

// SimpleIntMessage

// int32 testFieldInt = 1;
inline void SimpleIntMessage::clear_testfieldint() {
  testfieldint_ = 0;
}
inline ::google::protobuf::int32 SimpleIntMessage::testfieldint() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleIntMessage.testFieldInt)
  return testfieldint_;
}
inline void SimpleIntMessage::set_testfieldint(::google::protobuf::int32 value) {
  
  testfieldint_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleIntMessage.testFieldInt)
}

// -------------------------------------------------------------------

// SimpleSIntMessage

// sint32 testFieldInt = 1;
inline void SimpleSIntMessage::clear_testfieldint() {
  testfieldint_ = 0;
}
inline ::google::protobuf::int32 SimpleSIntMessage::testfieldint() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleSIntMessage.testFieldInt)
  return testfieldint_;
}
inline void SimpleSIntMessage::set_testfieldint(::google::protobuf::int32 value) {
  
  testfieldint_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleSIntMessage.testFieldInt)
}

// -------------------------------------------------------------------

// SimpleUIntMessage

// uint32 testFieldInt = 1;
inline void SimpleUIntMessage::clear_testfieldint() {
  testfieldint_ = 0u;
}
inline ::google::protobuf::uint32 SimpleUIntMessage::testfieldint() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleUIntMessage.testFieldInt)
  return testfieldint_;
}
inline void SimpleUIntMessage::set_testfieldint(::google::protobuf::uint32 value) {
  
  testfieldint_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleUIntMessage.testFieldInt)
}

// -------------------------------------------------------------------

// SimpleInt64Message

// int64 testFieldInt = 1;
inline void SimpleInt64Message::clear_testfieldint() {
  testfieldint_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 SimpleInt64Message::testfieldint() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleInt64Message.testFieldInt)
  return testfieldint_;
}
inline void SimpleInt64Message::set_testfieldint(::google::protobuf::int64 value) {
  
  testfieldint_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleInt64Message.testFieldInt)
}

// -------------------------------------------------------------------

// SimpleSInt64Message

// sint64 testFieldInt = 1;
inline void SimpleSInt64Message::clear_testfieldint() {
  testfieldint_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 SimpleSInt64Message::testfieldint() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleSInt64Message.testFieldInt)
  return testfieldint_;
}
inline void SimpleSInt64Message::set_testfieldint(::google::protobuf::int64 value) {
  
  testfieldint_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleSInt64Message.testFieldInt)
}

// -------------------------------------------------------------------

// SimpleUInt64Message

// uint64 testFieldInt = 1;
inline void SimpleUInt64Message::clear_testfieldint() {
  testfieldint_ = GOOGLE_ULONGLONG(0);
}
inline ::google::protobuf::uint64 SimpleUInt64Message::testfieldint() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleUInt64Message.testFieldInt)
  return testfieldint_;
}
inline void SimpleUInt64Message::set_testfieldint(::google::protobuf::uint64 value) {
  
  testfieldint_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleUInt64Message.testFieldInt)
}

// -------------------------------------------------------------------

// SimpleStringMessage

// string testFieldString = 6;
inline void SimpleStringMessage::clear_testfieldstring() {
  testfieldstring_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& SimpleStringMessage::testfieldstring() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
  return testfieldstring_.GetNoArena();
}
inline void SimpleStringMessage::set_testfieldstring(const ::std::string& value) {
  
  testfieldstring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
}
#if LANG_CXX11
inline void SimpleStringMessage::set_testfieldstring(::std::string&& value) {
  
  testfieldstring_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
}
#endif
inline void SimpleStringMessage::set_testfieldstring(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  testfieldstring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
}
inline void SimpleStringMessage::set_testfieldstring(const char* value, size_t size) {
  
  testfieldstring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
}
inline ::std::string* SimpleStringMessage::mutable_testfieldstring() {
  
  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
  return testfieldstring_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SimpleStringMessage::release_testfieldstring() {
  // @@protoc_insertion_point(field_release:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
  
  return testfieldstring_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SimpleStringMessage::set_allocated_testfieldstring(::std::string* testfieldstring) {
  if (testfieldstring != NULL) {
    
  } else {
    
  }
  testfieldstring_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), testfieldstring);
  // @@protoc_insertion_point(field_set_allocated:qtprotobufnamespace.tests.SimpleStringMessage.testFieldString)
}

// -------------------------------------------------------------------

// SimpleFloatMessage

// float testFieldFloat = 7;
inline void SimpleFloatMessage::clear_testfieldfloat() {
  testfieldfloat_ = 0;
}
inline float SimpleFloatMessage::testfieldfloat() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFloatMessage.testFieldFloat)
  return testfieldfloat_;
}
inline void SimpleFloatMessage::set_testfieldfloat(float value) {
  
  testfieldfloat_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFloatMessage.testFieldFloat)
}

// -------------------------------------------------------------------

// SimpleDoubleMessage

// double testFieldDouble = 8;
inline void SimpleDoubleMessage::clear_testfielddouble() {
  testfielddouble_ = 0;
}
inline double SimpleDoubleMessage::testfielddouble() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleDoubleMessage.testFieldDouble)
  return testfielddouble_;
}
inline void SimpleDoubleMessage::set_testfielddouble(double value) {
  
  testfielddouble_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleDoubleMessage.testFieldDouble)
}

// -------------------------------------------------------------------

// SimpleBytesMessage

// bytes testFieldBytes = 1;
inline void SimpleBytesMessage::clear_testfieldbytes() {
  testfieldbytes_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& SimpleBytesMessage::testfieldbytes() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
  return testfieldbytes_.GetNoArena();
}
inline void SimpleBytesMessage::set_testfieldbytes(const ::std::string& value) {
  
  testfieldbytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
}
#if LANG_CXX11
inline void SimpleBytesMessage::set_testfieldbytes(::std::string&& value) {
  
  testfieldbytes_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
}
#endif
inline void SimpleBytesMessage::set_testfieldbytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  testfieldbytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
}
inline void SimpleBytesMessage::set_testfieldbytes(const void* value, size_t size) {
  
  testfieldbytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
}
inline ::std::string* SimpleBytesMessage::mutable_testfieldbytes() {
  
  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
  return testfieldbytes_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SimpleBytesMessage::release_testfieldbytes() {
  // @@protoc_insertion_point(field_release:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
  
  return testfieldbytes_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SimpleBytesMessage::set_allocated_testfieldbytes(::std::string* testfieldbytes) {
  if (testfieldbytes != NULL) {
    
  } else {
    
  }
  testfieldbytes_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), testfieldbytes);
  // @@protoc_insertion_point(field_set_allocated:qtprotobufnamespace.tests.SimpleBytesMessage.testFieldBytes)
}

// -------------------------------------------------------------------

// SimpleFixedInt32Message

// fixed32 testFieldFixedInt32 = 1;
inline void SimpleFixedInt32Message::clear_testfieldfixedint32() {
  testfieldfixedint32_ = 0u;
}
inline ::google::protobuf::uint32 SimpleFixedInt32Message::testfieldfixedint32() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFixedInt32Message.testFieldFixedInt32)
  return testfieldfixedint32_;
}
inline void SimpleFixedInt32Message::set_testfieldfixedint32(::google::protobuf::uint32 value) {
  
  testfieldfixedint32_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFixedInt32Message.testFieldFixedInt32)
}

// -------------------------------------------------------------------

// SimpleFixedInt64Message

// fixed64 testFieldFixedInt64 = 1;
inline void SimpleFixedInt64Message::clear_testfieldfixedint64() {
  testfieldfixedint64_ = GOOGLE_ULONGLONG(0);
}
inline ::google::protobuf::uint64 SimpleFixedInt64Message::testfieldfixedint64() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleFixedInt64Message.testFieldFixedInt64)
  return testfieldfixedint64_;
}
inline void SimpleFixedInt64Message::set_testfieldfixedint64(::google::protobuf::uint64 value) {
  
  testfieldfixedint64_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleFixedInt64Message.testFieldFixedInt64)
}

// -------------------------------------------------------------------

// SimpleSFixedInt32Message

// sfixed32 testFieldFixedInt32 = 1;
inline void SimpleSFixedInt32Message::clear_testfieldfixedint32() {
  testfieldfixedint32_ = 0;
}
inline ::google::protobuf::int32 SimpleSFixedInt32Message::testfieldfixedint32() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleSFixedInt32Message.testFieldFixedInt32)
  return testfieldfixedint32_;
}
inline void SimpleSFixedInt32Message::set_testfieldfixedint32(::google::protobuf::int32 value) {
  
  testfieldfixedint32_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleSFixedInt32Message.testFieldFixedInt32)
}

// -------------------------------------------------------------------

// SimpleSFixedInt64Message

// sfixed64 testFieldFixedInt64 = 1;
inline void SimpleSFixedInt64Message::clear_testfieldfixedint64() {
  testfieldfixedint64_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 SimpleSFixedInt64Message::testfieldfixedint64() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.SimpleSFixedInt64Message.testFieldFixedInt64)
  return testfieldfixedint64_;
}
inline void SimpleSFixedInt64Message::set_testfieldfixedint64(::google::protobuf::int64 value) {
  
  testfieldfixedint64_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.SimpleSFixedInt64Message.testFieldFixedInt64)
}

// -------------------------------------------------------------------

// ComplexMessage

// int32 testFieldInt = 1;
inline void ComplexMessage::clear_testfieldint() {
  testfieldint_ = 0;
}
inline ::google::protobuf::int32 ComplexMessage::testfieldint() const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.ComplexMessage.testFieldInt)
  return testfieldint_;
}
inline void ComplexMessage::set_testfieldint(::google::protobuf::int32 value) {
  
  testfieldint_ = value;
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.ComplexMessage.testFieldInt)
}

// .qtprotobufnamespace.tests.SimpleStringMessage testComplexField = 2;
inline bool ComplexMessage::has_testcomplexfield() const {
  return this != internal_default_instance() && testcomplexfield_ != NULL;
}
inline void ComplexMessage::clear_testcomplexfield() {
  if (GetArenaNoVirtual() == NULL && testcomplexfield_ != NULL) {
    delete testcomplexfield_;
  }
  testcomplexfield_ = NULL;
}
inline const ::qtprotobufnamespace::tests::SimpleStringMessage& ComplexMessage::_internal_testcomplexfield() const {
  return *testcomplexfield_;
}
inline const ::qtprotobufnamespace::tests::SimpleStringMessage& ComplexMessage::testcomplexfield() const {
  const ::qtprotobufnamespace::tests::SimpleStringMessage* p = testcomplexfield_;
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.ComplexMessage.testComplexField)
  return p != NULL ? *p : *reinterpret_cast<const ::qtprotobufnamespace::tests::SimpleStringMessage*>(
      &::qtprotobufnamespace::tests::_SimpleStringMessage_default_instance_);
}
inline ::qtprotobufnamespace::tests::SimpleStringMessage* ComplexMessage::release_testcomplexfield() {
  // @@protoc_insertion_point(field_release:qtprotobufnamespace.tests.ComplexMessage.testComplexField)
  
  ::qtprotobufnamespace::tests::SimpleStringMessage* temp = testcomplexfield_;
  testcomplexfield_ = NULL;
  return temp;
}
inline ::qtprotobufnamespace::tests::SimpleStringMessage* ComplexMessage::mutable_testcomplexfield() {
  
  if (testcomplexfield_ == NULL) {
    auto* p = CreateMaybeMessage<::qtprotobufnamespace::tests::SimpleStringMessage>(GetArenaNoVirtual());
    testcomplexfield_ = p;
  }
  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.ComplexMessage.testComplexField)
  return testcomplexfield_;
}
inline void ComplexMessage::set_allocated_testcomplexfield(::qtprotobufnamespace::tests::SimpleStringMessage* testcomplexfield) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete testcomplexfield_;
  }
  if (testcomplexfield) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      testcomplexfield = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, testcomplexfield, submessage_arena);
    }
    
  } else {
    
  }
  testcomplexfield_ = testcomplexfield;
  // @@protoc_insertion_point(field_set_allocated:qtprotobufnamespace.tests.ComplexMessage.testComplexField)
}

// -------------------------------------------------------------------

// RepeatedIntMessage

// repeated sint32 testRepeatedInt = 1;
inline int RepeatedIntMessage::testrepeatedint_size() const {
  return testrepeatedint_.size();
}
inline void RepeatedIntMessage::clear_testrepeatedint() {
  testrepeatedint_.Clear();
}
inline ::google::protobuf::int32 RepeatedIntMessage::testrepeatedint(int index) const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
  return testrepeatedint_.Get(index);
}
inline void RepeatedIntMessage::set_testrepeatedint(int index, ::google::protobuf::int32 value) {
  testrepeatedint_.Set(index, value);
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
}
inline void RepeatedIntMessage::add_testrepeatedint(::google::protobuf::int32 value) {
  testrepeatedint_.Add(value);
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
RepeatedIntMessage::testrepeatedint() const {
  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
  return testrepeatedint_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
RepeatedIntMessage::mutable_testrepeatedint() {
  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedIntMessage.testRepeatedInt)
  return &testrepeatedint_;
}

// -------------------------------------------------------------------

// RepeatedStringMessage

// repeated string testRepeatedString = 1;
inline int RepeatedStringMessage::testrepeatedstring_size() const {
  return testrepeatedstring_.size();
}
inline void RepeatedStringMessage::clear_testrepeatedstring() {
  testrepeatedstring_.Clear();
}
inline const ::std::string& RepeatedStringMessage::testrepeatedstring(int index) const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
  return testrepeatedstring_.Get(index);
}
inline ::std::string* RepeatedStringMessage::mutable_testrepeatedstring(int index) {
  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
  return testrepeatedstring_.Mutable(index);
}
inline void RepeatedStringMessage::set_testrepeatedstring(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
  testrepeatedstring_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void RepeatedStringMessage::set_testrepeatedstring(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
  testrepeatedstring_.Mutable(index)->assign(std::move(value));
}
#endif
inline void RepeatedStringMessage::set_testrepeatedstring(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  testrepeatedstring_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
}
inline void RepeatedStringMessage::set_testrepeatedstring(int index, const char* value, size_t size) {
  testrepeatedstring_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
}
inline ::std::string* RepeatedStringMessage::add_testrepeatedstring() {
  // @@protoc_insertion_point(field_add_mutable:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
  return testrepeatedstring_.Add();
}
inline void RepeatedStringMessage::add_testrepeatedstring(const ::std::string& value) {
  testrepeatedstring_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
}
#if LANG_CXX11
inline void RepeatedStringMessage::add_testrepeatedstring(::std::string&& value) {
  testrepeatedstring_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
}
#endif
inline void RepeatedStringMessage::add_testrepeatedstring(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  testrepeatedstring_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
}
inline void RepeatedStringMessage::add_testrepeatedstring(const char* value, size_t size) {
  testrepeatedstring_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
RepeatedStringMessage::testrepeatedstring() const {
  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
  return testrepeatedstring_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
RepeatedStringMessage::mutable_testrepeatedstring() {
  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedStringMessage.testRepeatedString)
  return &testrepeatedstring_;
}

// -------------------------------------------------------------------

// RepeatedDoubleMessage

// repeated double testRepeatedDouble = 1;
inline int RepeatedDoubleMessage::testrepeateddouble_size() const {
  return testrepeateddouble_.size();
}
inline void RepeatedDoubleMessage::clear_testrepeateddouble() {
  testrepeateddouble_.Clear();
}
inline double RepeatedDoubleMessage::testrepeateddouble(int index) const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
  return testrepeateddouble_.Get(index);
}
inline void RepeatedDoubleMessage::set_testrepeateddouble(int index, double value) {
  testrepeateddouble_.Set(index, value);
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
}
inline void RepeatedDoubleMessage::add_testrepeateddouble(double value) {
  testrepeateddouble_.Add(value);
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
}
inline const ::google::protobuf::RepeatedField< double >&
RepeatedDoubleMessage::testrepeateddouble() const {
  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
  return testrepeateddouble_;
}
inline ::google::protobuf::RepeatedField< double >*
RepeatedDoubleMessage::mutable_testrepeateddouble() {
  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedDoubleMessage.testRepeatedDouble)
  return &testrepeateddouble_;
}

// -------------------------------------------------------------------

// RepeatedBytesMessage

// repeated bytes testRepeatedBytes = 1;
inline int RepeatedBytesMessage::testrepeatedbytes_size() const {
  return testrepeatedbytes_.size();
}
inline void RepeatedBytesMessage::clear_testrepeatedbytes() {
  testrepeatedbytes_.Clear();
}
inline const ::std::string& RepeatedBytesMessage::testrepeatedbytes(int index) const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
  return testrepeatedbytes_.Get(index);
}
inline ::std::string* RepeatedBytesMessage::mutable_testrepeatedbytes(int index) {
  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
  return testrepeatedbytes_.Mutable(index);
}
inline void RepeatedBytesMessage::set_testrepeatedbytes(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
  testrepeatedbytes_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void RepeatedBytesMessage::set_testrepeatedbytes(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
  testrepeatedbytes_.Mutable(index)->assign(std::move(value));
}
#endif
inline void RepeatedBytesMessage::set_testrepeatedbytes(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  testrepeatedbytes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
}
inline void RepeatedBytesMessage::set_testrepeatedbytes(int index, const void* value, size_t size) {
  testrepeatedbytes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
}
inline ::std::string* RepeatedBytesMessage::add_testrepeatedbytes() {
  // @@protoc_insertion_point(field_add_mutable:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
  return testrepeatedbytes_.Add();
}
inline void RepeatedBytesMessage::add_testrepeatedbytes(const ::std::string& value) {
  testrepeatedbytes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
}
#if LANG_CXX11
inline void RepeatedBytesMessage::add_testrepeatedbytes(::std::string&& value) {
  testrepeatedbytes_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
}
#endif
inline void RepeatedBytesMessage::add_testrepeatedbytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  testrepeatedbytes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
}
inline void RepeatedBytesMessage::add_testrepeatedbytes(const void* value, size_t size) {
  testrepeatedbytes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
RepeatedBytesMessage::testrepeatedbytes() const {
  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
  return testrepeatedbytes_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
RepeatedBytesMessage::mutable_testrepeatedbytes() {
  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedBytesMessage.testRepeatedBytes)
  return &testrepeatedbytes_;
}

// -------------------------------------------------------------------

// RepeatedFloatMessage

// repeated float testRepeatedFloat = 1;
inline int RepeatedFloatMessage::testrepeatedfloat_size() const {
  return testrepeatedfloat_.size();
}
inline void RepeatedFloatMessage::clear_testrepeatedfloat() {
  testrepeatedfloat_.Clear();
}
inline float RepeatedFloatMessage::testrepeatedfloat(int index) const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
  return testrepeatedfloat_.Get(index);
}
inline void RepeatedFloatMessage::set_testrepeatedfloat(int index, float value) {
  testrepeatedfloat_.Set(index, value);
  // @@protoc_insertion_point(field_set:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
}
inline void RepeatedFloatMessage::add_testrepeatedfloat(float value) {
  testrepeatedfloat_.Add(value);
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
}
inline const ::google::protobuf::RepeatedField< float >&
RepeatedFloatMessage::testrepeatedfloat() const {
  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
  return testrepeatedfloat_;
}
inline ::google::protobuf::RepeatedField< float >*
RepeatedFloatMessage::mutable_testrepeatedfloat() {
  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedFloatMessage.testRepeatedFloat)
  return &testrepeatedfloat_;
}

// -------------------------------------------------------------------

// RepeatedComplexMessage

// repeated .qtprotobufnamespace.tests.ComplexMessage testRepeatedComplex = 1;
inline int RepeatedComplexMessage::testrepeatedcomplex_size() const {
  return testrepeatedcomplex_.size();
}
inline void RepeatedComplexMessage::clear_testrepeatedcomplex() {
  testrepeatedcomplex_.Clear();
}
inline ::qtprotobufnamespace::tests::ComplexMessage* RepeatedComplexMessage::mutable_testrepeatedcomplex(int index) {
  // @@protoc_insertion_point(field_mutable:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
  return testrepeatedcomplex_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage >*
RepeatedComplexMessage::mutable_testrepeatedcomplex() {
  // @@protoc_insertion_point(field_mutable_list:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
  return &testrepeatedcomplex_;
}
inline const ::qtprotobufnamespace::tests::ComplexMessage& RepeatedComplexMessage::testrepeatedcomplex(int index) const {
  // @@protoc_insertion_point(field_get:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
  return testrepeatedcomplex_.Get(index);
}
inline ::qtprotobufnamespace::tests::ComplexMessage* RepeatedComplexMessage::add_testrepeatedcomplex() {
  // @@protoc_insertion_point(field_add:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
  return testrepeatedcomplex_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::qtprotobufnamespace::tests::ComplexMessage >&
RepeatedComplexMessage::testrepeatedcomplex() const {
  // @@protoc_insertion_point(field_list:qtprotobufnamespace.tests.RepeatedComplexMessage.testRepeatedComplex)
  return testrepeatedcomplex_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace tests
}  // namespace qtprotobufnamespace

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum>() {
  return ::qtprotobufnamespace::tests::SimpleEnumMessage_LocalEnum_descriptor();
}
template <> struct is_proto_enum< ::qtprotobufnamespace::tests::TestEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::qtprotobufnamespace::tests::TestEnum>() {
  return ::qtprotobufnamespace::tests::TestEnum_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_simpletest_2eproto