// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: google/protobuf/unittest_no_arena.proto

#ifndef PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_5fno_5farena_2eproto
#define PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_5fno_5farena_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>
#include <google/protobuf/unittest_import.pb.h>
#include <google/protobuf/unittest_arena.pb.h>
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_google_2fprotobuf_2funittest_5fno_5farena_2eproto 

namespace protobuf_google_2fprotobuf_2funittest_5fno_5farena_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[6];
  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_google_2fprotobuf_2funittest_5fno_5farena_2eproto
namespace protobuf_unittest_no_arena {
class ForeignMessage;
class ForeignMessageDefaultTypeInternal;
extern ForeignMessageDefaultTypeInternal _ForeignMessage_default_instance_;
class TestAllTypes;
class TestAllTypesDefaultTypeInternal;
extern TestAllTypesDefaultTypeInternal _TestAllTypes_default_instance_;
class TestAllTypes_NestedMessage;
class TestAllTypes_NestedMessageDefaultTypeInternal;
extern TestAllTypes_NestedMessageDefaultTypeInternal _TestAllTypes_NestedMessage_default_instance_;
class TestAllTypes_OptionalGroup;
class TestAllTypes_OptionalGroupDefaultTypeInternal;
extern TestAllTypes_OptionalGroupDefaultTypeInternal _TestAllTypes_OptionalGroup_default_instance_;
class TestAllTypes_RepeatedGroup;
class TestAllTypes_RepeatedGroupDefaultTypeInternal;
extern TestAllTypes_RepeatedGroupDefaultTypeInternal _TestAllTypes_RepeatedGroup_default_instance_;
class TestNoArenaMessage;
class TestNoArenaMessageDefaultTypeInternal;
extern TestNoArenaMessageDefaultTypeInternal _TestNoArenaMessage_default_instance_;
}  // namespace protobuf_unittest_no_arena
namespace google {
namespace protobuf {
template<> ::protobuf_unittest_no_arena::ForeignMessage* Arena::CreateMaybeMessage<::protobuf_unittest_no_arena::ForeignMessage>(Arena*);
template<> ::protobuf_unittest_no_arena::TestAllTypes* Arena::CreateMaybeMessage<::protobuf_unittest_no_arena::TestAllTypes>(Arena*);
template<> ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* Arena::CreateMaybeMessage<::protobuf_unittest_no_arena::TestAllTypes_NestedMessage>(Arena*);
template<> ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* Arena::CreateMaybeMessage<::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup>(Arena*);
template<> ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup* Arena::CreateMaybeMessage<::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup>(Arena*);
template<> ::protobuf_unittest_no_arena::TestNoArenaMessage* Arena::CreateMaybeMessage<::protobuf_unittest_no_arena::TestNoArenaMessage>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace protobuf_unittest_no_arena {

enum TestAllTypes_NestedEnum {
  TestAllTypes_NestedEnum_FOO = 1,
  TestAllTypes_NestedEnum_BAR = 2,
  TestAllTypes_NestedEnum_BAZ = 3,
  TestAllTypes_NestedEnum_NEG = -1
};
bool TestAllTypes_NestedEnum_IsValid(int value);
const TestAllTypes_NestedEnum TestAllTypes_NestedEnum_NestedEnum_MIN = TestAllTypes_NestedEnum_NEG;
const TestAllTypes_NestedEnum TestAllTypes_NestedEnum_NestedEnum_MAX = TestAllTypes_NestedEnum_BAZ;
const int TestAllTypes_NestedEnum_NestedEnum_ARRAYSIZE = TestAllTypes_NestedEnum_NestedEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* TestAllTypes_NestedEnum_descriptor();
inline const ::std::string& TestAllTypes_NestedEnum_Name(TestAllTypes_NestedEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    TestAllTypes_NestedEnum_descriptor(), value);
}
inline bool TestAllTypes_NestedEnum_Parse(
    const ::std::string& name, TestAllTypes_NestedEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<TestAllTypes_NestedEnum>(
    TestAllTypes_NestedEnum_descriptor(), name, value);
}
enum ForeignEnum {
  FOREIGN_FOO = 4,
  FOREIGN_BAR = 5,
  FOREIGN_BAZ = 6
};
bool ForeignEnum_IsValid(int value);
const ForeignEnum ForeignEnum_MIN = FOREIGN_FOO;
const ForeignEnum ForeignEnum_MAX = FOREIGN_BAZ;
const int ForeignEnum_ARRAYSIZE = ForeignEnum_MAX + 1;

const ::google::protobuf::EnumDescriptor* ForeignEnum_descriptor();
inline const ::std::string& ForeignEnum_Name(ForeignEnum value) {
  return ::google::protobuf::internal::NameOfEnum(
    ForeignEnum_descriptor(), value);
}
inline bool ForeignEnum_Parse(
    const ::std::string& name, ForeignEnum* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ForeignEnum>(
    ForeignEnum_descriptor(), name, value);
}
// ===================================================================

class TestAllTypes_NestedMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest_no_arena.TestAllTypes.NestedMessage) */ {
 public:
  TestAllTypes_NestedMessage();
  virtual ~TestAllTypes_NestedMessage();

  TestAllTypes_NestedMessage(const TestAllTypes_NestedMessage& from);

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

  inline TestAllTypes_NestedMessage& operator=(TestAllTypes_NestedMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllTypes_NestedMessage& default_instance();

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

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

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

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

  TestAllTypes_NestedMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllTypes_NestedMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllTypes_NestedMessage& from);
  void MergeFrom(const TestAllTypes_NestedMessage& 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(TestAllTypes_NestedMessage* 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 -------------------------------------------------------

  // optional int32 bb = 1;
  bool has_bb() const;
  void clear_bb();
  static const int kBbFieldNumber = 1;
  ::google::protobuf::int32 bb() const;
  void set_bb(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest_no_arena.TestAllTypes.NestedMessage)
 private:
  void set_has_bb();
  void clear_has_bb();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 bb_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_5fno_5farena_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestAllTypes_OptionalGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest_no_arena.TestAllTypes.OptionalGroup) */ {
 public:
  TestAllTypes_OptionalGroup();
  virtual ~TestAllTypes_OptionalGroup();

  TestAllTypes_OptionalGroup(const TestAllTypes_OptionalGroup& from);

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

  inline TestAllTypes_OptionalGroup& operator=(TestAllTypes_OptionalGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllTypes_OptionalGroup& default_instance();

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

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

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

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

  TestAllTypes_OptionalGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllTypes_OptionalGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllTypes_OptionalGroup& from);
  void MergeFrom(const TestAllTypes_OptionalGroup& 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(TestAllTypes_OptionalGroup* 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 -------------------------------------------------------

  // optional int32 a = 17;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 17;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest_no_arena.TestAllTypes.OptionalGroup)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_5fno_5farena_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestAllTypes_RepeatedGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest_no_arena.TestAllTypes.RepeatedGroup) */ {
 public:
  TestAllTypes_RepeatedGroup();
  virtual ~TestAllTypes_RepeatedGroup();

  TestAllTypes_RepeatedGroup(const TestAllTypes_RepeatedGroup& from);

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

  inline TestAllTypes_RepeatedGroup& operator=(TestAllTypes_RepeatedGroup&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllTypes_RepeatedGroup& default_instance();

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

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

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

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

  TestAllTypes_RepeatedGroup* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllTypes_RepeatedGroup>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllTypes_RepeatedGroup& from);
  void MergeFrom(const TestAllTypes_RepeatedGroup& 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(TestAllTypes_RepeatedGroup* 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 -------------------------------------------------------

  // optional int32 a = 47;
  bool has_a() const;
  void clear_a();
  static const int kAFieldNumber = 47;
  ::google::protobuf::int32 a() const;
  void set_a(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest_no_arena.TestAllTypes.RepeatedGroup)
 private:
  void set_has_a();
  void clear_has_a();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 a_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_5fno_5farena_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestAllTypes : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest_no_arena.TestAllTypes) */ {
 public:
  TestAllTypes();
  virtual ~TestAllTypes();

  TestAllTypes(const TestAllTypes& from);

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

  inline TestAllTypes& operator=(TestAllTypes&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestAllTypes& default_instance();

  enum OneofFieldCase {
    kOneofUint32 = 111,
    kOneofNestedMessage = 112,
    kOneofString = 113,
    kOneofBytes = 114,
    kLazyOneofNestedMessage = 115,
    ONEOF_FIELD_NOT_SET = 0,
  };

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

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

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

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

  TestAllTypes* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestAllTypes>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestAllTypes& from);
  void MergeFrom(const TestAllTypes& 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(TestAllTypes* 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 TestAllTypes_NestedMessage NestedMessage;
  typedef TestAllTypes_OptionalGroup OptionalGroup;
  typedef TestAllTypes_RepeatedGroup RepeatedGroup;

  typedef TestAllTypes_NestedEnum NestedEnum;
  static const NestedEnum FOO =
    TestAllTypes_NestedEnum_FOO;
  static const NestedEnum BAR =
    TestAllTypes_NestedEnum_BAR;
  static const NestedEnum BAZ =
    TestAllTypes_NestedEnum_BAZ;
  static const NestedEnum NEG =
    TestAllTypes_NestedEnum_NEG;
  static inline bool NestedEnum_IsValid(int value) {
    return TestAllTypes_NestedEnum_IsValid(value);
  }
  static const NestedEnum NestedEnum_MIN =
    TestAllTypes_NestedEnum_NestedEnum_MIN;
  static const NestedEnum NestedEnum_MAX =
    TestAllTypes_NestedEnum_NestedEnum_MAX;
  static const int NestedEnum_ARRAYSIZE =
    TestAllTypes_NestedEnum_NestedEnum_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  NestedEnum_descriptor() {
    return TestAllTypes_NestedEnum_descriptor();
  }
  static inline const ::std::string& NestedEnum_Name(NestedEnum value) {
    return TestAllTypes_NestedEnum_Name(value);
  }
  static inline bool NestedEnum_Parse(const ::std::string& name,
      NestedEnum* value) {
    return TestAllTypes_NestedEnum_Parse(name, value);
  }

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

  // repeated int32 repeated_int32 = 31;
  int repeated_int32_size() const;
  void clear_repeated_int32();
  static const int kRepeatedInt32FieldNumber = 31;
  ::google::protobuf::int32 repeated_int32(int index) const;
  void set_repeated_int32(int index, ::google::protobuf::int32 value);
  void add_repeated_int32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeated_int32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeated_int32();

  // repeated int64 repeated_int64 = 32;
  int repeated_int64_size() const;
  void clear_repeated_int64();
  static const int kRepeatedInt64FieldNumber = 32;
  ::google::protobuf::int64 repeated_int64(int index) const;
  void set_repeated_int64(int index, ::google::protobuf::int64 value);
  void add_repeated_int64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      repeated_int64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_repeated_int64();

  // repeated uint32 repeated_uint32 = 33;
  int repeated_uint32_size() const;
  void clear_repeated_uint32();
  static const int kRepeatedUint32FieldNumber = 33;
  ::google::protobuf::uint32 repeated_uint32(int index) const;
  void set_repeated_uint32(int index, ::google::protobuf::uint32 value);
  void add_repeated_uint32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      repeated_uint32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_repeated_uint32();

  // repeated uint64 repeated_uint64 = 34;
  int repeated_uint64_size() const;
  void clear_repeated_uint64();
  static const int kRepeatedUint64FieldNumber = 34;
  ::google::protobuf::uint64 repeated_uint64(int index) const;
  void set_repeated_uint64(int index, ::google::protobuf::uint64 value);
  void add_repeated_uint64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      repeated_uint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_repeated_uint64();

  // repeated sint32 repeated_sint32 = 35;
  int repeated_sint32_size() const;
  void clear_repeated_sint32();
  static const int kRepeatedSint32FieldNumber = 35;
  ::google::protobuf::int32 repeated_sint32(int index) const;
  void set_repeated_sint32(int index, ::google::protobuf::int32 value);
  void add_repeated_sint32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeated_sint32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeated_sint32();

  // repeated sint64 repeated_sint64 = 36;
  int repeated_sint64_size() const;
  void clear_repeated_sint64();
  static const int kRepeatedSint64FieldNumber = 36;
  ::google::protobuf::int64 repeated_sint64(int index) const;
  void set_repeated_sint64(int index, ::google::protobuf::int64 value);
  void add_repeated_sint64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      repeated_sint64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_repeated_sint64();

  // repeated fixed32 repeated_fixed32 = 37;
  int repeated_fixed32_size() const;
  void clear_repeated_fixed32();
  static const int kRepeatedFixed32FieldNumber = 37;
  ::google::protobuf::uint32 repeated_fixed32(int index) const;
  void set_repeated_fixed32(int index, ::google::protobuf::uint32 value);
  void add_repeated_fixed32(::google::protobuf::uint32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      repeated_fixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_repeated_fixed32();

  // repeated fixed64 repeated_fixed64 = 38;
  int repeated_fixed64_size() const;
  void clear_repeated_fixed64();
  static const int kRepeatedFixed64FieldNumber = 38;
  ::google::protobuf::uint64 repeated_fixed64(int index) const;
  void set_repeated_fixed64(int index, ::google::protobuf::uint64 value);
  void add_repeated_fixed64(::google::protobuf::uint64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      repeated_fixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_repeated_fixed64();

  // repeated sfixed32 repeated_sfixed32 = 39;
  int repeated_sfixed32_size() const;
  void clear_repeated_sfixed32();
  static const int kRepeatedSfixed32FieldNumber = 39;
  ::google::protobuf::int32 repeated_sfixed32(int index) const;
  void set_repeated_sfixed32(int index, ::google::protobuf::int32 value);
  void add_repeated_sfixed32(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      repeated_sfixed32() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_repeated_sfixed32();

  // repeated sfixed64 repeated_sfixed64 = 40;
  int repeated_sfixed64_size() const;
  void clear_repeated_sfixed64();
  static const int kRepeatedSfixed64FieldNumber = 40;
  ::google::protobuf::int64 repeated_sfixed64(int index) const;
  void set_repeated_sfixed64(int index, ::google::protobuf::int64 value);
  void add_repeated_sfixed64(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      repeated_sfixed64() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_repeated_sfixed64();

  // repeated float repeated_float = 41;
  int repeated_float_size() const;
  void clear_repeated_float();
  static const int kRepeatedFloatFieldNumber = 41;
  float repeated_float(int index) const;
  void set_repeated_float(int index, float value);
  void add_repeated_float(float value);
  const ::google::protobuf::RepeatedField< float >&
      repeated_float() const;
  ::google::protobuf::RepeatedField< float >*
      mutable_repeated_float();

  // repeated double repeated_double = 42;
  int repeated_double_size() const;
  void clear_repeated_double();
  static const int kRepeatedDoubleFieldNumber = 42;
  double repeated_double(int index) const;
  void set_repeated_double(int index, double value);
  void add_repeated_double(double value);
  const ::google::protobuf::RepeatedField< double >&
      repeated_double() const;
  ::google::protobuf::RepeatedField< double >*
      mutable_repeated_double();

  // repeated bool repeated_bool = 43;
  int repeated_bool_size() const;
  void clear_repeated_bool();
  static const int kRepeatedBoolFieldNumber = 43;
  bool repeated_bool(int index) const;
  void set_repeated_bool(int index, bool value);
  void add_repeated_bool(bool value);
  const ::google::protobuf::RepeatedField< bool >&
      repeated_bool() const;
  ::google::protobuf::RepeatedField< bool >*
      mutable_repeated_bool();

  // repeated string repeated_string = 44;
  int repeated_string_size() const;
  void clear_repeated_string();
  static const int kRepeatedStringFieldNumber = 44;
  const ::std::string& repeated_string(int index) const;
  ::std::string* mutable_repeated_string(int index);
  void set_repeated_string(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_string(int index, ::std::string&& value);
  #endif
  void set_repeated_string(int index, const char* value);
  void set_repeated_string(int index, const char* value, size_t size);
  ::std::string* add_repeated_string();
  void add_repeated_string(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_string(::std::string&& value);
  #endif
  void add_repeated_string(const char* value);
  void add_repeated_string(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_string() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_string();

  // repeated bytes repeated_bytes = 45;
  int repeated_bytes_size() const;
  void clear_repeated_bytes();
  static const int kRepeatedBytesFieldNumber = 45;
  const ::std::string& repeated_bytes(int index) const;
  ::std::string* mutable_repeated_bytes(int index);
  void set_repeated_bytes(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_bytes(int index, ::std::string&& value);
  #endif
  void set_repeated_bytes(int index, const char* value);
  void set_repeated_bytes(int index, const void* value, size_t size);
  ::std::string* add_repeated_bytes();
  void add_repeated_bytes(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_bytes(::std::string&& value);
  #endif
  void add_repeated_bytes(const char* value);
  void add_repeated_bytes(const void* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_bytes() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_bytes();

  // repeated group RepeatedGroup = 46 { ... };
  int repeatedgroup_size() const;
  void clear_repeatedgroup();
  static const int kRepeatedgroupFieldNumber = 46;
  ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup* mutable_repeatedgroup(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup >*
      mutable_repeatedgroup();
  const ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup& repeatedgroup(int index) const;
  ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup* add_repeatedgroup();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup >&
      repeatedgroup() const;

  // repeated .protobuf_unittest_no_arena.TestAllTypes.NestedMessage repeated_nested_message = 48;
  int repeated_nested_message_size() const;
  void clear_repeated_nested_message();
  static const int kRepeatedNestedMessageFieldNumber = 48;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* mutable_repeated_nested_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >*
      mutable_repeated_nested_message();
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& repeated_nested_message(int index) const;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* add_repeated_nested_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >&
      repeated_nested_message() const;

  // repeated .protobuf_unittest_no_arena.ForeignMessage repeated_foreign_message = 49;
  int repeated_foreign_message_size() const;
  void clear_repeated_foreign_message();
  static const int kRepeatedForeignMessageFieldNumber = 49;
  ::protobuf_unittest_no_arena::ForeignMessage* mutable_repeated_foreign_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::ForeignMessage >*
      mutable_repeated_foreign_message();
  const ::protobuf_unittest_no_arena::ForeignMessage& repeated_foreign_message(int index) const;
  ::protobuf_unittest_no_arena::ForeignMessage* add_repeated_foreign_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::ForeignMessage >&
      repeated_foreign_message() const;

  // repeated .protobuf_unittest_import.ImportMessage repeated_import_message = 50;
  int repeated_import_message_size() const;
  void clear_repeated_import_message();
  static const int kRepeatedImportMessageFieldNumber = 50;
  ::protobuf_unittest_import::ImportMessage* mutable_repeated_import_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage >*
      mutable_repeated_import_message();
  const ::protobuf_unittest_import::ImportMessage& repeated_import_message(int index) const;
  ::protobuf_unittest_import::ImportMessage* add_repeated_import_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage >&
      repeated_import_message() const;

  // repeated .protobuf_unittest_no_arena.TestAllTypes.NestedEnum repeated_nested_enum = 51;
  int repeated_nested_enum_size() const;
  void clear_repeated_nested_enum();
  static const int kRepeatedNestedEnumFieldNumber = 51;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum repeated_nested_enum(int index) const;
  void set_repeated_nested_enum(int index, ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum value);
  void add_repeated_nested_enum(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum value);
  const ::google::protobuf::RepeatedField<int>& repeated_nested_enum() const;
  ::google::protobuf::RepeatedField<int>* mutable_repeated_nested_enum();

  // repeated .protobuf_unittest_no_arena.ForeignEnum repeated_foreign_enum = 52;
  int repeated_foreign_enum_size() const;
  void clear_repeated_foreign_enum();
  static const int kRepeatedForeignEnumFieldNumber = 52;
  ::protobuf_unittest_no_arena::ForeignEnum repeated_foreign_enum(int index) const;
  void set_repeated_foreign_enum(int index, ::protobuf_unittest_no_arena::ForeignEnum value);
  void add_repeated_foreign_enum(::protobuf_unittest_no_arena::ForeignEnum value);
  const ::google::protobuf::RepeatedField<int>& repeated_foreign_enum() const;
  ::google::protobuf::RepeatedField<int>* mutable_repeated_foreign_enum();

  // repeated .protobuf_unittest_import.ImportEnum repeated_import_enum = 53;
  int repeated_import_enum_size() const;
  void clear_repeated_import_enum();
  static const int kRepeatedImportEnumFieldNumber = 53;
  ::protobuf_unittest_import::ImportEnum repeated_import_enum(int index) const;
  void set_repeated_import_enum(int index, ::protobuf_unittest_import::ImportEnum value);
  void add_repeated_import_enum(::protobuf_unittest_import::ImportEnum value);
  const ::google::protobuf::RepeatedField<int>& repeated_import_enum() const;
  ::google::protobuf::RepeatedField<int>* mutable_repeated_import_enum();

  // repeated string repeated_string_piece = 54 [ctype = STRING_PIECE];
  int repeated_string_piece_size() const;
  void clear_repeated_string_piece();
  static const int kRepeatedStringPieceFieldNumber = 54;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& repeated_string_piece(int index) const;
  ::std::string* mutable_repeated_string_piece(int index);
  void set_repeated_string_piece(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_string_piece(int index, ::std::string&& value);
  #endif
  void set_repeated_string_piece(int index, const char* value);
  void set_repeated_string_piece(int index, const char* value, size_t size);
  ::std::string* add_repeated_string_piece();
  void add_repeated_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_string_piece(::std::string&& value);
  #endif
  void add_repeated_string_piece(const char* value);
  void add_repeated_string_piece(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_string_piece() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_string_piece();
 public:

  // repeated string repeated_cord = 55 [ctype = CORD];
  int repeated_cord_size() const;
  void clear_repeated_cord();
  static const int kRepeatedCordFieldNumber = 55;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& repeated_cord(int index) const;
  ::std::string* mutable_repeated_cord(int index);
  void set_repeated_cord(int index, const ::std::string& value);
  #if LANG_CXX11
  void set_repeated_cord(int index, ::std::string&& value);
  #endif
  void set_repeated_cord(int index, const char* value);
  void set_repeated_cord(int index, const char* value, size_t size);
  ::std::string* add_repeated_cord();
  void add_repeated_cord(const ::std::string& value);
  #if LANG_CXX11
  void add_repeated_cord(::std::string&& value);
  #endif
  void add_repeated_cord(const char* value);
  void add_repeated_cord(const char* value, size_t size);
  const ::google::protobuf::RepeatedPtrField< ::std::string>& repeated_cord() const;
  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_repeated_cord();
 public:

  // repeated .protobuf_unittest_no_arena.TestAllTypes.NestedMessage repeated_lazy_message = 57 [lazy = true];
  int repeated_lazy_message_size() const;
  void clear_repeated_lazy_message();
  static const int kRepeatedLazyMessageFieldNumber = 57;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* mutable_repeated_lazy_message(int index);
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >*
      mutable_repeated_lazy_message();
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& repeated_lazy_message(int index) const;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* add_repeated_lazy_message();
  const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >&
      repeated_lazy_message() const;

  // optional string optional_string = 14;
  bool has_optional_string() const;
  void clear_optional_string();
  static const int kOptionalStringFieldNumber = 14;
  const ::std::string& optional_string() const;
  void set_optional_string(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_string(::std::string&& value);
  #endif
  void set_optional_string(const char* value);
  void set_optional_string(const char* value, size_t size);
  ::std::string* mutable_optional_string();
  ::std::string* release_optional_string();
  void set_allocated_optional_string(::std::string* optional_string);

  // optional bytes optional_bytes = 15;
  bool has_optional_bytes() const;
  void clear_optional_bytes();
  static const int kOptionalBytesFieldNumber = 15;
  const ::std::string& optional_bytes() const;
  void set_optional_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_bytes(::std::string&& value);
  #endif
  void set_optional_bytes(const char* value);
  void set_optional_bytes(const void* value, size_t size);
  ::std::string* mutable_optional_bytes();
  ::std::string* release_optional_bytes();
  void set_allocated_optional_bytes(::std::string* optional_bytes);

  // optional string optional_string_piece = 24 [ctype = STRING_PIECE];
  bool has_optional_string_piece() const;
  void clear_optional_string_piece();
  static const int kOptionalStringPieceFieldNumber = 24;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& optional_string_piece() const;
  void set_optional_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_string_piece(::std::string&& value);
  #endif
  void set_optional_string_piece(const char* value);
  void set_optional_string_piece(const char* value, size_t size);
  ::std::string* mutable_optional_string_piece();
  ::std::string* release_optional_string_piece();
  void set_allocated_optional_string_piece(::std::string* optional_string_piece);
 public:

  // optional string optional_cord = 25 [ctype = CORD];
  bool has_optional_cord() const;
  void clear_optional_cord();
  static const int kOptionalCordFieldNumber = 25;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& optional_cord() const;
  void set_optional_cord(const ::std::string& value);
  #if LANG_CXX11
  void set_optional_cord(::std::string&& value);
  #endif
  void set_optional_cord(const char* value);
  void set_optional_cord(const char* value, size_t size);
  ::std::string* mutable_optional_cord();
  ::std::string* release_optional_cord();
  void set_allocated_optional_cord(::std::string* optional_cord);
 public:

  // optional string default_string = 74 [default = "hello"];
  bool has_default_string() const;
  void clear_default_string();
  static const int kDefaultStringFieldNumber = 74;
  const ::std::string& default_string() const;
  void set_default_string(const ::std::string& value);
  #if LANG_CXX11
  void set_default_string(::std::string&& value);
  #endif
  void set_default_string(const char* value);
  void set_default_string(const char* value, size_t size);
  ::std::string* mutable_default_string();
  ::std::string* release_default_string();
  void set_allocated_default_string(::std::string* default_string);

  // optional bytes default_bytes = 75 [default = "world"];
  bool has_default_bytes() const;
  void clear_default_bytes();
  static const int kDefaultBytesFieldNumber = 75;
  const ::std::string& default_bytes() const;
  void set_default_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_default_bytes(::std::string&& value);
  #endif
  void set_default_bytes(const char* value);
  void set_default_bytes(const void* value, size_t size);
  ::std::string* mutable_default_bytes();
  ::std::string* release_default_bytes();
  void set_allocated_default_bytes(::std::string* default_bytes);

  // optional string default_string_piece = 84 [default = "abc", ctype = STRING_PIECE];
  bool has_default_string_piece() const;
  void clear_default_string_piece();
  static const int kDefaultStringPieceFieldNumber = 84;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& default_string_piece() const;
  void set_default_string_piece(const ::std::string& value);
  #if LANG_CXX11
  void set_default_string_piece(::std::string&& value);
  #endif
  void set_default_string_piece(const char* value);
  void set_default_string_piece(const char* value, size_t size);
  ::std::string* mutable_default_string_piece();
  ::std::string* release_default_string_piece();
  void set_allocated_default_string_piece(::std::string* default_string_piece);
 public:

  // optional string default_cord = 85 [default = "123", ctype = CORD];
  bool has_default_cord() const;
  void clear_default_cord();
  static const int kDefaultCordFieldNumber = 85;
 private:
  // Hidden due to unknown ctype option.
  const ::std::string& default_cord() const;
  void set_default_cord(const ::std::string& value);
  #if LANG_CXX11
  void set_default_cord(::std::string&& value);
  #endif
  void set_default_cord(const char* value);
  void set_default_cord(const char* value, size_t size);
  ::std::string* mutable_default_cord();
  ::std::string* release_default_cord();
  void set_allocated_default_cord(::std::string* default_cord);
 public:

  // optional group OptionalGroup = 16 { ... };
  bool has_optionalgroup() const;
  void clear_optionalgroup();
  static const int kOptionalgroupFieldNumber = 16;
  private:
  const ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup& _internal_optionalgroup() const;
  public:
  const ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup& optionalgroup() const;
  ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* release_optionalgroup();
  ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* mutable_optionalgroup();
  void set_allocated_optionalgroup(::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* optionalgroup);

  // optional .protobuf_unittest_no_arena.TestAllTypes.NestedMessage optional_nested_message = 18;
  bool has_optional_nested_message() const;
  void clear_optional_nested_message();
  static const int kOptionalNestedMessageFieldNumber = 18;
  private:
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& _internal_optional_nested_message() const;
  public:
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& optional_nested_message() const;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* release_optional_nested_message();
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* mutable_optional_nested_message();
  void set_allocated_optional_nested_message(::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* optional_nested_message);

  // optional .protobuf_unittest_no_arena.ForeignMessage optional_foreign_message = 19;
  bool has_optional_foreign_message() const;
  void clear_optional_foreign_message();
  static const int kOptionalForeignMessageFieldNumber = 19;
  private:
  const ::protobuf_unittest_no_arena::ForeignMessage& _internal_optional_foreign_message() const;
  public:
  const ::protobuf_unittest_no_arena::ForeignMessage& optional_foreign_message() const;
  ::protobuf_unittest_no_arena::ForeignMessage* release_optional_foreign_message();
  ::protobuf_unittest_no_arena::ForeignMessage* mutable_optional_foreign_message();
  void set_allocated_optional_foreign_message(::protobuf_unittest_no_arena::ForeignMessage* optional_foreign_message);

  // optional .protobuf_unittest_import.ImportMessage optional_import_message = 20;
  bool has_optional_import_message() const;
  void clear_optional_import_message();
  static const int kOptionalImportMessageFieldNumber = 20;
  private:
  const ::protobuf_unittest_import::ImportMessage& _internal_optional_import_message() const;
  public:
  const ::protobuf_unittest_import::ImportMessage& optional_import_message() const;
  ::protobuf_unittest_import::ImportMessage* release_optional_import_message();
  ::protobuf_unittest_import::ImportMessage* mutable_optional_import_message();
  void set_allocated_optional_import_message(::protobuf_unittest_import::ImportMessage* optional_import_message);

  // optional .protobuf_unittest_import.PublicImportMessage optional_public_import_message = 26;
  bool has_optional_public_import_message() const;
  void clear_optional_public_import_message();
  static const int kOptionalPublicImportMessageFieldNumber = 26;
  private:
  const ::protobuf_unittest_import::PublicImportMessage& _internal_optional_public_import_message() const;
  public:
  const ::protobuf_unittest_import::PublicImportMessage& optional_public_import_message() const;
  ::protobuf_unittest_import::PublicImportMessage* release_optional_public_import_message();
  ::protobuf_unittest_import::PublicImportMessage* mutable_optional_public_import_message();
  void set_allocated_optional_public_import_message(::protobuf_unittest_import::PublicImportMessage* optional_public_import_message);

  // optional .protobuf_unittest_no_arena.TestAllTypes.NestedMessage optional_message = 27 [lazy = true];
  bool has_optional_message() const;
  void clear_optional_message();
  static const int kOptionalMessageFieldNumber = 27;
  private:
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& _internal_optional_message() const;
  public:
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& optional_message() const;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* release_optional_message();
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* mutable_optional_message();
  void set_allocated_optional_message(::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* optional_message);

  // optional int64 optional_int64 = 2;
  bool has_optional_int64() const;
  void clear_optional_int64();
  static const int kOptionalInt64FieldNumber = 2;
  ::google::protobuf::int64 optional_int64() const;
  void set_optional_int64(::google::protobuf::int64 value);

  // optional int32 optional_int32 = 1;
  bool has_optional_int32() const;
  void clear_optional_int32();
  static const int kOptionalInt32FieldNumber = 1;
  ::google::protobuf::int32 optional_int32() const;
  void set_optional_int32(::google::protobuf::int32 value);

  // optional uint32 optional_uint32 = 3;
  bool has_optional_uint32() const;
  void clear_optional_uint32();
  static const int kOptionalUint32FieldNumber = 3;
  ::google::protobuf::uint32 optional_uint32() const;
  void set_optional_uint32(::google::protobuf::uint32 value);

  // optional uint64 optional_uint64 = 4;
  bool has_optional_uint64() const;
  void clear_optional_uint64();
  static const int kOptionalUint64FieldNumber = 4;
  ::google::protobuf::uint64 optional_uint64() const;
  void set_optional_uint64(::google::protobuf::uint64 value);

  // optional sint64 optional_sint64 = 6;
  bool has_optional_sint64() const;
  void clear_optional_sint64();
  static const int kOptionalSint64FieldNumber = 6;
  ::google::protobuf::int64 optional_sint64() const;
  void set_optional_sint64(::google::protobuf::int64 value);

  // optional sint32 optional_sint32 = 5;
  bool has_optional_sint32() const;
  void clear_optional_sint32();
  static const int kOptionalSint32FieldNumber = 5;
  ::google::protobuf::int32 optional_sint32() const;
  void set_optional_sint32(::google::protobuf::int32 value);

  // optional fixed32 optional_fixed32 = 7;
  bool has_optional_fixed32() const;
  void clear_optional_fixed32();
  static const int kOptionalFixed32FieldNumber = 7;
  ::google::protobuf::uint32 optional_fixed32() const;
  void set_optional_fixed32(::google::protobuf::uint32 value);

  // optional fixed64 optional_fixed64 = 8;
  bool has_optional_fixed64() const;
  void clear_optional_fixed64();
  static const int kOptionalFixed64FieldNumber = 8;
  ::google::protobuf::uint64 optional_fixed64() const;
  void set_optional_fixed64(::google::protobuf::uint64 value);

  // optional sfixed64 optional_sfixed64 = 10;
  bool has_optional_sfixed64() const;
  void clear_optional_sfixed64();
  static const int kOptionalSfixed64FieldNumber = 10;
  ::google::protobuf::int64 optional_sfixed64() const;
  void set_optional_sfixed64(::google::protobuf::int64 value);

  // optional sfixed32 optional_sfixed32 = 9;
  bool has_optional_sfixed32() const;
  void clear_optional_sfixed32();
  static const int kOptionalSfixed32FieldNumber = 9;
  ::google::protobuf::int32 optional_sfixed32() const;
  void set_optional_sfixed32(::google::protobuf::int32 value);

  // optional float optional_float = 11;
  bool has_optional_float() const;
  void clear_optional_float();
  static const int kOptionalFloatFieldNumber = 11;
  float optional_float() const;
  void set_optional_float(float value);

  // optional double optional_double = 12;
  bool has_optional_double() const;
  void clear_optional_double();
  static const int kOptionalDoubleFieldNumber = 12;
  double optional_double() const;
  void set_optional_double(double value);

  // optional bool optional_bool = 13;
  bool has_optional_bool() const;
  void clear_optional_bool();
  static const int kOptionalBoolFieldNumber = 13;
  bool optional_bool() const;
  void set_optional_bool(bool value);

  // optional .protobuf_unittest_import.ImportEnum default_import_enum = 83 [default = IMPORT_BAR];
  bool has_default_import_enum() const;
  void clear_default_import_enum();
  static const int kDefaultImportEnumFieldNumber = 83;
  ::protobuf_unittest_import::ImportEnum default_import_enum() const;
  void set_default_import_enum(::protobuf_unittest_import::ImportEnum value);

  // optional .protobuf_unittest_no_arena.TestAllTypes.NestedEnum optional_nested_enum = 21;
  bool has_optional_nested_enum() const;
  void clear_optional_nested_enum();
  static const int kOptionalNestedEnumFieldNumber = 21;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum optional_nested_enum() const;
  void set_optional_nested_enum(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum value);

  // optional .protobuf_unittest_no_arena.ForeignEnum optional_foreign_enum = 22;
  bool has_optional_foreign_enum() const;
  void clear_optional_foreign_enum();
  static const int kOptionalForeignEnumFieldNumber = 22;
  ::protobuf_unittest_no_arena::ForeignEnum optional_foreign_enum() const;
  void set_optional_foreign_enum(::protobuf_unittest_no_arena::ForeignEnum value);

  // optional .protobuf_unittest_import.ImportEnum optional_import_enum = 23;
  bool has_optional_import_enum() const;
  void clear_optional_import_enum();
  static const int kOptionalImportEnumFieldNumber = 23;
  ::protobuf_unittest_import::ImportEnum optional_import_enum() const;
  void set_optional_import_enum(::protobuf_unittest_import::ImportEnum value);

  // optional int32 default_int32 = 61 [default = 41];
  bool has_default_int32() const;
  void clear_default_int32();
  static const int kDefaultInt32FieldNumber = 61;
  ::google::protobuf::int32 default_int32() const;
  void set_default_int32(::google::protobuf::int32 value);

  // optional int64 default_int64 = 62 [default = 42];
  bool has_default_int64() const;
  void clear_default_int64();
  static const int kDefaultInt64FieldNumber = 62;
  ::google::protobuf::int64 default_int64() const;
  void set_default_int64(::google::protobuf::int64 value);

  // optional uint64 default_uint64 = 64 [default = 44];
  bool has_default_uint64() const;
  void clear_default_uint64();
  static const int kDefaultUint64FieldNumber = 64;
  ::google::protobuf::uint64 default_uint64() const;
  void set_default_uint64(::google::protobuf::uint64 value);

  // optional uint32 default_uint32 = 63 [default = 43];
  bool has_default_uint32() const;
  void clear_default_uint32();
  static const int kDefaultUint32FieldNumber = 63;
  ::google::protobuf::uint32 default_uint32() const;
  void set_default_uint32(::google::protobuf::uint32 value);

  // optional sint32 default_sint32 = 65 [default = -45];
  bool has_default_sint32() const;
  void clear_default_sint32();
  static const int kDefaultSint32FieldNumber = 65;
  ::google::protobuf::int32 default_sint32() const;
  void set_default_sint32(::google::protobuf::int32 value);

  // optional sint64 default_sint64 = 66 [default = 46];
  bool has_default_sint64() const;
  void clear_default_sint64();
  static const int kDefaultSint64FieldNumber = 66;
  ::google::protobuf::int64 default_sint64() const;
  void set_default_sint64(::google::protobuf::int64 value);

  // optional fixed64 default_fixed64 = 68 [default = 48];
  bool has_default_fixed64() const;
  void clear_default_fixed64();
  static const int kDefaultFixed64FieldNumber = 68;
  ::google::protobuf::uint64 default_fixed64() const;
  void set_default_fixed64(::google::protobuf::uint64 value);

  // optional fixed32 default_fixed32 = 67 [default = 47];
  bool has_default_fixed32() const;
  void clear_default_fixed32();
  static const int kDefaultFixed32FieldNumber = 67;
  ::google::protobuf::uint32 default_fixed32() const;
  void set_default_fixed32(::google::protobuf::uint32 value);

  // optional sfixed32 default_sfixed32 = 69 [default = 49];
  bool has_default_sfixed32() const;
  void clear_default_sfixed32();
  static const int kDefaultSfixed32FieldNumber = 69;
  ::google::protobuf::int32 default_sfixed32() const;
  void set_default_sfixed32(::google::protobuf::int32 value);

  // optional sfixed64 default_sfixed64 = 70 [default = -50];
  bool has_default_sfixed64() const;
  void clear_default_sfixed64();
  static const int kDefaultSfixed64FieldNumber = 70;
  ::google::protobuf::int64 default_sfixed64() const;
  void set_default_sfixed64(::google::protobuf::int64 value);

  // optional double default_double = 72 [default = 52000];
  bool has_default_double() const;
  void clear_default_double();
  static const int kDefaultDoubleFieldNumber = 72;
  double default_double() const;
  void set_default_double(double value);

  // optional float default_float = 71 [default = 51.5];
  bool has_default_float() const;
  void clear_default_float();
  static const int kDefaultFloatFieldNumber = 71;
  float default_float() const;
  void set_default_float(float value);

  // optional bool default_bool = 73 [default = true];
  bool has_default_bool() const;
  void clear_default_bool();
  static const int kDefaultBoolFieldNumber = 73;
  bool default_bool() const;
  void set_default_bool(bool value);

  // optional .protobuf_unittest_no_arena.TestAllTypes.NestedEnum default_nested_enum = 81 [default = BAR];
  bool has_default_nested_enum() const;
  void clear_default_nested_enum();
  static const int kDefaultNestedEnumFieldNumber = 81;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum default_nested_enum() const;
  void set_default_nested_enum(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum value);

  // optional .protobuf_unittest_no_arena.ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR];
  bool has_default_foreign_enum() const;
  void clear_default_foreign_enum();
  static const int kDefaultForeignEnumFieldNumber = 82;
  ::protobuf_unittest_no_arena::ForeignEnum default_foreign_enum() const;
  void set_default_foreign_enum(::protobuf_unittest_no_arena::ForeignEnum value);

  // optional uint32 oneof_uint32 = 111;
  bool has_oneof_uint32() const;
  void clear_oneof_uint32();
  static const int kOneofUint32FieldNumber = 111;
  ::google::protobuf::uint32 oneof_uint32() const;
  void set_oneof_uint32(::google::protobuf::uint32 value);

  // optional .protobuf_unittest_no_arena.TestAllTypes.NestedMessage oneof_nested_message = 112;
  bool has_oneof_nested_message() const;
  void clear_oneof_nested_message();
  static const int kOneofNestedMessageFieldNumber = 112;
  private:
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& _internal_oneof_nested_message() const;
  public:
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& oneof_nested_message() const;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* release_oneof_nested_message();
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* mutable_oneof_nested_message();
  void set_allocated_oneof_nested_message(::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* oneof_nested_message);

  // optional string oneof_string = 113;
  bool has_oneof_string() const;
  void clear_oneof_string();
  static const int kOneofStringFieldNumber = 113;
  const ::std::string& oneof_string() const;
  void set_oneof_string(const ::std::string& value);
  #if LANG_CXX11
  void set_oneof_string(::std::string&& value);
  #endif
  void set_oneof_string(const char* value);
  void set_oneof_string(const char* value, size_t size);
  ::std::string* mutable_oneof_string();
  ::std::string* release_oneof_string();
  void set_allocated_oneof_string(::std::string* oneof_string);

  // optional bytes oneof_bytes = 114;
  bool has_oneof_bytes() const;
  void clear_oneof_bytes();
  static const int kOneofBytesFieldNumber = 114;
  const ::std::string& oneof_bytes() const;
  void set_oneof_bytes(const ::std::string& value);
  #if LANG_CXX11
  void set_oneof_bytes(::std::string&& value);
  #endif
  void set_oneof_bytes(const char* value);
  void set_oneof_bytes(const void* value, size_t size);
  ::std::string* mutable_oneof_bytes();
  ::std::string* release_oneof_bytes();
  void set_allocated_oneof_bytes(::std::string* oneof_bytes);

  // optional .protobuf_unittest_no_arena.TestAllTypes.NestedMessage lazy_oneof_nested_message = 115 [lazy = true];
  bool has_lazy_oneof_nested_message() const;
  void clear_lazy_oneof_nested_message();
  static const int kLazyOneofNestedMessageFieldNumber = 115;
  private:
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& _internal_lazy_oneof_nested_message() const;
  public:
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& lazy_oneof_nested_message() const;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* release_lazy_oneof_nested_message();
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* mutable_lazy_oneof_nested_message();
  void set_allocated_lazy_oneof_nested_message(::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* lazy_oneof_nested_message);

  void clear_oneof_field();
  OneofFieldCase oneof_field_case() const;
  // @@protoc_insertion_point(class_scope:protobuf_unittest_no_arena.TestAllTypes)
 private:
  void set_has_optional_int32();
  void clear_has_optional_int32();
  void set_has_optional_int64();
  void clear_has_optional_int64();
  void set_has_optional_uint32();
  void clear_has_optional_uint32();
  void set_has_optional_uint64();
  void clear_has_optional_uint64();
  void set_has_optional_sint32();
  void clear_has_optional_sint32();
  void set_has_optional_sint64();
  void clear_has_optional_sint64();
  void set_has_optional_fixed32();
  void clear_has_optional_fixed32();
  void set_has_optional_fixed64();
  void clear_has_optional_fixed64();
  void set_has_optional_sfixed32();
  void clear_has_optional_sfixed32();
  void set_has_optional_sfixed64();
  void clear_has_optional_sfixed64();
  void set_has_optional_float();
  void clear_has_optional_float();
  void set_has_optional_double();
  void clear_has_optional_double();
  void set_has_optional_bool();
  void clear_has_optional_bool();
  void set_has_optional_string();
  void clear_has_optional_string();
  void set_has_optional_bytes();
  void clear_has_optional_bytes();
  void set_has_optionalgroup();
  void clear_has_optionalgroup();
  void set_has_optional_nested_message();
  void clear_has_optional_nested_message();
  void set_has_optional_foreign_message();
  void clear_has_optional_foreign_message();
  void set_has_optional_import_message();
  void clear_has_optional_import_message();
  void set_has_optional_nested_enum();
  void clear_has_optional_nested_enum();
  void set_has_optional_foreign_enum();
  void clear_has_optional_foreign_enum();
  void set_has_optional_import_enum();
  void clear_has_optional_import_enum();
  void set_has_optional_string_piece();
  void clear_has_optional_string_piece();
  void set_has_optional_cord();
  void clear_has_optional_cord();
  void set_has_optional_public_import_message();
  void clear_has_optional_public_import_message();
  void set_has_optional_message();
  void clear_has_optional_message();
  void set_has_default_int32();
  void clear_has_default_int32();
  void set_has_default_int64();
  void clear_has_default_int64();
  void set_has_default_uint32();
  void clear_has_default_uint32();
  void set_has_default_uint64();
  void clear_has_default_uint64();
  void set_has_default_sint32();
  void clear_has_default_sint32();
  void set_has_default_sint64();
  void clear_has_default_sint64();
  void set_has_default_fixed32();
  void clear_has_default_fixed32();
  void set_has_default_fixed64();
  void clear_has_default_fixed64();
  void set_has_default_sfixed32();
  void clear_has_default_sfixed32();
  void set_has_default_sfixed64();
  void clear_has_default_sfixed64();
  void set_has_default_float();
  void clear_has_default_float();
  void set_has_default_double();
  void clear_has_default_double();
  void set_has_default_bool();
  void clear_has_default_bool();
  void set_has_default_string();
  void clear_has_default_string();
  void set_has_default_bytes();
  void clear_has_default_bytes();
  void set_has_default_nested_enum();
  void clear_has_default_nested_enum();
  void set_has_default_foreign_enum();
  void clear_has_default_foreign_enum();
  void set_has_default_import_enum();
  void clear_has_default_import_enum();
  void set_has_default_string_piece();
  void clear_has_default_string_piece();
  void set_has_default_cord();
  void clear_has_default_cord();
  void set_has_oneof_uint32();
  void set_has_oneof_nested_message();
  void set_has_oneof_string();
  void set_has_oneof_bytes();
  void set_has_lazy_oneof_nested_message();

  inline bool has_oneof_field() const;
  inline void clear_has_oneof_field();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<2> _has_bits_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeated_int32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > repeated_int64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > repeated_uint32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > repeated_uint64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeated_sint32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > repeated_sint64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > repeated_fixed32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > repeated_fixed64_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > repeated_sfixed32_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > repeated_sfixed64_;
  ::google::protobuf::RepeatedField< float > repeated_float_;
  ::google::protobuf::RepeatedField< double > repeated_double_;
  ::google::protobuf::RepeatedField< bool > repeated_bool_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_string_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_bytes_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup > repeatedgroup_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage > repeated_nested_message_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::ForeignMessage > repeated_foreign_message_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage > repeated_import_message_;
  ::google::protobuf::RepeatedField<int> repeated_nested_enum_;
  ::google::protobuf::RepeatedField<int> repeated_foreign_enum_;
  ::google::protobuf::RepeatedField<int> repeated_import_enum_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_string_piece_;
  ::google::protobuf::RepeatedPtrField< ::std::string> repeated_cord_;
  ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage > repeated_lazy_message_;
  ::google::protobuf::internal::ArenaStringPtr optional_string_;
  ::google::protobuf::internal::ArenaStringPtr optional_bytes_;
  ::google::protobuf::internal::ArenaStringPtr optional_string_piece_;
  ::google::protobuf::internal::ArenaStringPtr optional_cord_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_default_string_;
  private:
  ::google::protobuf::internal::ArenaStringPtr default_string_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_default_bytes_;
  private:
  ::google::protobuf::internal::ArenaStringPtr default_bytes_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_default_string_piece_;
  private:
  ::google::protobuf::internal::ArenaStringPtr default_string_piece_;
  public:
  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_default_cord_;
  private:
  ::google::protobuf::internal::ArenaStringPtr default_cord_;
  ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* optionalgroup_;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* optional_nested_message_;
  ::protobuf_unittest_no_arena::ForeignMessage* optional_foreign_message_;
  ::protobuf_unittest_import::ImportMessage* optional_import_message_;
  ::protobuf_unittest_import::PublicImportMessage* optional_public_import_message_;
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* optional_message_;
  ::google::protobuf::int64 optional_int64_;
  ::google::protobuf::int32 optional_int32_;
  ::google::protobuf::uint32 optional_uint32_;
  ::google::protobuf::uint64 optional_uint64_;
  ::google::protobuf::int64 optional_sint64_;
  ::google::protobuf::int32 optional_sint32_;
  ::google::protobuf::uint32 optional_fixed32_;
  ::google::protobuf::uint64 optional_fixed64_;
  ::google::protobuf::int64 optional_sfixed64_;
  ::google::protobuf::int32 optional_sfixed32_;
  float optional_float_;
  double optional_double_;
  bool optional_bool_;
  int default_import_enum_;
  int optional_nested_enum_;
  int optional_foreign_enum_;
  int optional_import_enum_;
  ::google::protobuf::int32 default_int32_;
  ::google::protobuf::int64 default_int64_;
  ::google::protobuf::uint64 default_uint64_;
  ::google::protobuf::uint32 default_uint32_;
  ::google::protobuf::int32 default_sint32_;
  ::google::protobuf::int64 default_sint64_;
  ::google::protobuf::uint64 default_fixed64_;
  ::google::protobuf::uint32 default_fixed32_;
  ::google::protobuf::int32 default_sfixed32_;
  ::google::protobuf::int64 default_sfixed64_;
  double default_double_;
  float default_float_;
  bool default_bool_;
  int default_nested_enum_;
  int default_foreign_enum_;
  union OneofFieldUnion {
    OneofFieldUnion() {}
    ::google::protobuf::uint32 oneof_uint32_;
    ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* oneof_nested_message_;
    ::google::protobuf::internal::ArenaStringPtr oneof_string_;
    ::google::protobuf::internal::ArenaStringPtr oneof_bytes_;
    ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* lazy_oneof_nested_message_;
  } oneof_field_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_google_2fprotobuf_2funittest_5fno_5farena_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ForeignMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest_no_arena.ForeignMessage) */ {
 public:
  ForeignMessage();
  virtual ~ForeignMessage();

  ForeignMessage(const ForeignMessage& from);

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

  inline ForeignMessage& operator=(ForeignMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ForeignMessage& default_instance();

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

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

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

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

  ForeignMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ForeignMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const ForeignMessage& from);
  void MergeFrom(const ForeignMessage& 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(ForeignMessage* 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 -------------------------------------------------------

  // optional int32 c = 1;
  bool has_c() const;
  void clear_c();
  static const int kCFieldNumber = 1;
  ::google::protobuf::int32 c() const;
  void set_c(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:protobuf_unittest_no_arena.ForeignMessage)
 private:
  void set_has_c();
  void clear_has_c();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 c_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_5fno_5farena_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TestNoArenaMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:protobuf_unittest_no_arena.TestNoArenaMessage) */ {
 public:
  TestNoArenaMessage();
  virtual ~TestNoArenaMessage();

  TestNoArenaMessage(const TestNoArenaMessage& from);

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

  inline TestNoArenaMessage& operator=(TestNoArenaMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const TestNoArenaMessage& default_instance();

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

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

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

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

  TestNoArenaMessage* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TestNoArenaMessage>(arena);
  }
  void CopyFrom(const ::google::protobuf::Message& from) final;
  void MergeFrom(const ::google::protobuf::Message& from) final;
  void CopyFrom(const TestNoArenaMessage& from);
  void MergeFrom(const TestNoArenaMessage& 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(TestNoArenaMessage* 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 -------------------------------------------------------

  // optional .proto2_arena_unittest.ArenaMessage arena_message = 1;
  bool has_arena_message() const;
  void clear_arena_message();
  static const int kArenaMessageFieldNumber = 1;
  private:
  const ::proto2_arena_unittest::ArenaMessage& _internal_arena_message() const;
  public:
  const ::proto2_arena_unittest::ArenaMessage& arena_message() const;
  ::proto2_arena_unittest::ArenaMessage* release_arena_message();
  ::proto2_arena_unittest::ArenaMessage* mutable_arena_message();
  void set_allocated_arena_message(::proto2_arena_unittest::ArenaMessage* arena_message);

  // @@protoc_insertion_point(class_scope:protobuf_unittest_no_arena.TestNoArenaMessage)
 private:
  void set_has_arena_message();
  void clear_has_arena_message();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::proto2_arena_unittest::ArenaMessage* arena_message_;
  friend struct ::protobuf_google_2fprotobuf_2funittest_5fno_5farena_2eproto::TableStruct;
};
// ===================================================================


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

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

// optional int32 bb = 1;
inline bool TestAllTypes_NestedMessage::has_bb() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestAllTypes_NestedMessage::set_has_bb() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestAllTypes_NestedMessage::clear_has_bb() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestAllTypes_NestedMessage::clear_bb() {
  bb_ = 0;
  clear_has_bb();
}
inline ::google::protobuf::int32 TestAllTypes_NestedMessage::bb() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.NestedMessage.bb)
  return bb_;
}
inline void TestAllTypes_NestedMessage::set_bb(::google::protobuf::int32 value) {
  set_has_bb();
  bb_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.NestedMessage.bb)
}

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

// TestAllTypes_OptionalGroup

// optional int32 a = 17;
inline bool TestAllTypes_OptionalGroup::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestAllTypes_OptionalGroup::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestAllTypes_OptionalGroup::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestAllTypes_OptionalGroup::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestAllTypes_OptionalGroup::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.OptionalGroup.a)
  return a_;
}
inline void TestAllTypes_OptionalGroup::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.OptionalGroup.a)
}

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

// TestAllTypes_RepeatedGroup

// optional int32 a = 47;
inline bool TestAllTypes_RepeatedGroup::has_a() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestAllTypes_RepeatedGroup::set_has_a() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestAllTypes_RepeatedGroup::clear_has_a() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestAllTypes_RepeatedGroup::clear_a() {
  a_ = 0;
  clear_has_a();
}
inline ::google::protobuf::int32 TestAllTypes_RepeatedGroup::a() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.RepeatedGroup.a)
  return a_;
}
inline void TestAllTypes_RepeatedGroup::set_a(::google::protobuf::int32 value) {
  set_has_a();
  a_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.RepeatedGroup.a)
}

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

// TestAllTypes

// optional int32 optional_int32 = 1;
inline bool TestAllTypes::has_optional_int32() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void TestAllTypes::set_has_optional_int32() {
  _has_bits_[0] |= 0x00008000u;
}
inline void TestAllTypes::clear_has_optional_int32() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void TestAllTypes::clear_optional_int32() {
  optional_int32_ = 0;
  clear_has_optional_int32();
}
inline ::google::protobuf::int32 TestAllTypes::optional_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_int32)
  return optional_int32_;
}
inline void TestAllTypes::set_optional_int32(::google::protobuf::int32 value) {
  set_has_optional_int32();
  optional_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_int32)
}

// optional int64 optional_int64 = 2;
inline bool TestAllTypes::has_optional_int64() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TestAllTypes::set_has_optional_int64() {
  _has_bits_[0] |= 0x00004000u;
}
inline void TestAllTypes::clear_has_optional_int64() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void TestAllTypes::clear_optional_int64() {
  optional_int64_ = GOOGLE_LONGLONG(0);
  clear_has_optional_int64();
}
inline ::google::protobuf::int64 TestAllTypes::optional_int64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_int64)
  return optional_int64_;
}
inline void TestAllTypes::set_optional_int64(::google::protobuf::int64 value) {
  set_has_optional_int64();
  optional_int64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_int64)
}

// optional uint32 optional_uint32 = 3;
inline bool TestAllTypes::has_optional_uint32() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void TestAllTypes::set_has_optional_uint32() {
  _has_bits_[0] |= 0x00010000u;
}
inline void TestAllTypes::clear_has_optional_uint32() {
  _has_bits_[0] &= ~0x00010000u;
}
inline void TestAllTypes::clear_optional_uint32() {
  optional_uint32_ = 0u;
  clear_has_optional_uint32();
}
inline ::google::protobuf::uint32 TestAllTypes::optional_uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_uint32)
  return optional_uint32_;
}
inline void TestAllTypes::set_optional_uint32(::google::protobuf::uint32 value) {
  set_has_optional_uint32();
  optional_uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_uint32)
}

// optional uint64 optional_uint64 = 4;
inline bool TestAllTypes::has_optional_uint64() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void TestAllTypes::set_has_optional_uint64() {
  _has_bits_[0] |= 0x00020000u;
}
inline void TestAllTypes::clear_has_optional_uint64() {
  _has_bits_[0] &= ~0x00020000u;
}
inline void TestAllTypes::clear_optional_uint64() {
  optional_uint64_ = GOOGLE_ULONGLONG(0);
  clear_has_optional_uint64();
}
inline ::google::protobuf::uint64 TestAllTypes::optional_uint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_uint64)
  return optional_uint64_;
}
inline void TestAllTypes::set_optional_uint64(::google::protobuf::uint64 value) {
  set_has_optional_uint64();
  optional_uint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_uint64)
}

// optional sint32 optional_sint32 = 5;
inline bool TestAllTypes::has_optional_sint32() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void TestAllTypes::set_has_optional_sint32() {
  _has_bits_[0] |= 0x00080000u;
}
inline void TestAllTypes::clear_has_optional_sint32() {
  _has_bits_[0] &= ~0x00080000u;
}
inline void TestAllTypes::clear_optional_sint32() {
  optional_sint32_ = 0;
  clear_has_optional_sint32();
}
inline ::google::protobuf::int32 TestAllTypes::optional_sint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_sint32)
  return optional_sint32_;
}
inline void TestAllTypes::set_optional_sint32(::google::protobuf::int32 value) {
  set_has_optional_sint32();
  optional_sint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_sint32)
}

// optional sint64 optional_sint64 = 6;
inline bool TestAllTypes::has_optional_sint64() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void TestAllTypes::set_has_optional_sint64() {
  _has_bits_[0] |= 0x00040000u;
}
inline void TestAllTypes::clear_has_optional_sint64() {
  _has_bits_[0] &= ~0x00040000u;
}
inline void TestAllTypes::clear_optional_sint64() {
  optional_sint64_ = GOOGLE_LONGLONG(0);
  clear_has_optional_sint64();
}
inline ::google::protobuf::int64 TestAllTypes::optional_sint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_sint64)
  return optional_sint64_;
}
inline void TestAllTypes::set_optional_sint64(::google::protobuf::int64 value) {
  set_has_optional_sint64();
  optional_sint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_sint64)
}

// optional fixed32 optional_fixed32 = 7;
inline bool TestAllTypes::has_optional_fixed32() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void TestAllTypes::set_has_optional_fixed32() {
  _has_bits_[0] |= 0x00100000u;
}
inline void TestAllTypes::clear_has_optional_fixed32() {
  _has_bits_[0] &= ~0x00100000u;
}
inline void TestAllTypes::clear_optional_fixed32() {
  optional_fixed32_ = 0u;
  clear_has_optional_fixed32();
}
inline ::google::protobuf::uint32 TestAllTypes::optional_fixed32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_fixed32)
  return optional_fixed32_;
}
inline void TestAllTypes::set_optional_fixed32(::google::protobuf::uint32 value) {
  set_has_optional_fixed32();
  optional_fixed32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_fixed32)
}

// optional fixed64 optional_fixed64 = 8;
inline bool TestAllTypes::has_optional_fixed64() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void TestAllTypes::set_has_optional_fixed64() {
  _has_bits_[0] |= 0x00200000u;
}
inline void TestAllTypes::clear_has_optional_fixed64() {
  _has_bits_[0] &= ~0x00200000u;
}
inline void TestAllTypes::clear_optional_fixed64() {
  optional_fixed64_ = GOOGLE_ULONGLONG(0);
  clear_has_optional_fixed64();
}
inline ::google::protobuf::uint64 TestAllTypes::optional_fixed64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_fixed64)
  return optional_fixed64_;
}
inline void TestAllTypes::set_optional_fixed64(::google::protobuf::uint64 value) {
  set_has_optional_fixed64();
  optional_fixed64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_fixed64)
}

// optional sfixed32 optional_sfixed32 = 9;
inline bool TestAllTypes::has_optional_sfixed32() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void TestAllTypes::set_has_optional_sfixed32() {
  _has_bits_[0] |= 0x00800000u;
}
inline void TestAllTypes::clear_has_optional_sfixed32() {
  _has_bits_[0] &= ~0x00800000u;
}
inline void TestAllTypes::clear_optional_sfixed32() {
  optional_sfixed32_ = 0;
  clear_has_optional_sfixed32();
}
inline ::google::protobuf::int32 TestAllTypes::optional_sfixed32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_sfixed32)
  return optional_sfixed32_;
}
inline void TestAllTypes::set_optional_sfixed32(::google::protobuf::int32 value) {
  set_has_optional_sfixed32();
  optional_sfixed32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_sfixed32)
}

// optional sfixed64 optional_sfixed64 = 10;
inline bool TestAllTypes::has_optional_sfixed64() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void TestAllTypes::set_has_optional_sfixed64() {
  _has_bits_[0] |= 0x00400000u;
}
inline void TestAllTypes::clear_has_optional_sfixed64() {
  _has_bits_[0] &= ~0x00400000u;
}
inline void TestAllTypes::clear_optional_sfixed64() {
  optional_sfixed64_ = GOOGLE_LONGLONG(0);
  clear_has_optional_sfixed64();
}
inline ::google::protobuf::int64 TestAllTypes::optional_sfixed64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_sfixed64)
  return optional_sfixed64_;
}
inline void TestAllTypes::set_optional_sfixed64(::google::protobuf::int64 value) {
  set_has_optional_sfixed64();
  optional_sfixed64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_sfixed64)
}

// optional float optional_float = 11;
inline bool TestAllTypes::has_optional_float() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void TestAllTypes::set_has_optional_float() {
  _has_bits_[0] |= 0x01000000u;
}
inline void TestAllTypes::clear_has_optional_float() {
  _has_bits_[0] &= ~0x01000000u;
}
inline void TestAllTypes::clear_optional_float() {
  optional_float_ = 0;
  clear_has_optional_float();
}
inline float TestAllTypes::optional_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_float)
  return optional_float_;
}
inline void TestAllTypes::set_optional_float(float value) {
  set_has_optional_float();
  optional_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_float)
}

// optional double optional_double = 12;
inline bool TestAllTypes::has_optional_double() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void TestAllTypes::set_has_optional_double() {
  _has_bits_[0] |= 0x02000000u;
}
inline void TestAllTypes::clear_has_optional_double() {
  _has_bits_[0] &= ~0x02000000u;
}
inline void TestAllTypes::clear_optional_double() {
  optional_double_ = 0;
  clear_has_optional_double();
}
inline double TestAllTypes::optional_double() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_double)
  return optional_double_;
}
inline void TestAllTypes::set_optional_double(double value) {
  set_has_optional_double();
  optional_double_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_double)
}

// optional bool optional_bool = 13;
inline bool TestAllTypes::has_optional_bool() const {
  return (_has_bits_[0] & 0x04000000u) != 0;
}
inline void TestAllTypes::set_has_optional_bool() {
  _has_bits_[0] |= 0x04000000u;
}
inline void TestAllTypes::clear_has_optional_bool() {
  _has_bits_[0] &= ~0x04000000u;
}
inline void TestAllTypes::clear_optional_bool() {
  optional_bool_ = false;
  clear_has_optional_bool();
}
inline bool TestAllTypes::optional_bool() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_bool)
  return optional_bool_;
}
inline void TestAllTypes::set_optional_bool(bool value) {
  set_has_optional_bool();
  optional_bool_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_bool)
}

// optional string optional_string = 14;
inline bool TestAllTypes::has_optional_string() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestAllTypes::set_has_optional_string() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestAllTypes::clear_has_optional_string() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TestAllTypes::clear_optional_string() {
  optional_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_optional_string();
}
inline const ::std::string& TestAllTypes::optional_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_string)
  return optional_string_.GetNoArena();
}
inline void TestAllTypes::set_optional_string(const ::std::string& value) {
  set_has_optional_string();
  optional_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_string)
}
#if LANG_CXX11
inline void TestAllTypes::set_optional_string(::std::string&& value) {
  set_has_optional_string();
  optional_string_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.optional_string)
}
#endif
inline void TestAllTypes::set_optional_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_string();
  optional_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.optional_string)
}
inline void TestAllTypes::set_optional_string(const char* value, size_t size) {
  set_has_optional_string();
  optional_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.optional_string)
}
inline ::std::string* TestAllTypes::mutable_optional_string() {
  set_has_optional_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_string)
  return optional_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestAllTypes::release_optional_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_string)
  if (!has_optional_string()) {
    return NULL;
  }
  clear_has_optional_string();
  return optional_string_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestAllTypes::set_allocated_optional_string(::std::string* optional_string) {
  if (optional_string != NULL) {
    set_has_optional_string();
  } else {
    clear_has_optional_string();
  }
  optional_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_string);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_string)
}

// optional bytes optional_bytes = 15;
inline bool TestAllTypes::has_optional_bytes() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TestAllTypes::set_has_optional_bytes() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TestAllTypes::clear_has_optional_bytes() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TestAllTypes::clear_optional_bytes() {
  optional_bytes_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_optional_bytes();
}
inline const ::std::string& TestAllTypes::optional_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_bytes)
  return optional_bytes_.GetNoArena();
}
inline void TestAllTypes::set_optional_bytes(const ::std::string& value) {
  set_has_optional_bytes();
  optional_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_bytes)
}
#if LANG_CXX11
inline void TestAllTypes::set_optional_bytes(::std::string&& value) {
  set_has_optional_bytes();
  optional_bytes_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.optional_bytes)
}
#endif
inline void TestAllTypes::set_optional_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_bytes();
  optional_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.optional_bytes)
}
inline void TestAllTypes::set_optional_bytes(const void* value, size_t size) {
  set_has_optional_bytes();
  optional_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.optional_bytes)
}
inline ::std::string* TestAllTypes::mutable_optional_bytes() {
  set_has_optional_bytes();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_bytes)
  return optional_bytes_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestAllTypes::release_optional_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_bytes)
  if (!has_optional_bytes()) {
    return NULL;
  }
  clear_has_optional_bytes();
  return optional_bytes_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestAllTypes::set_allocated_optional_bytes(::std::string* optional_bytes) {
  if (optional_bytes != NULL) {
    set_has_optional_bytes();
  } else {
    clear_has_optional_bytes();
  }
  optional_bytes_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_bytes);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_bytes)
}

// optional group OptionalGroup = 16 { ... };
inline bool TestAllTypes::has_optionalgroup() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TestAllTypes::set_has_optionalgroup() {
  _has_bits_[0] |= 0x00000100u;
}
inline void TestAllTypes::clear_has_optionalgroup() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void TestAllTypes::clear_optionalgroup() {
  if (optionalgroup_ != NULL) optionalgroup_->Clear();
  clear_has_optionalgroup();
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup& TestAllTypes::_internal_optionalgroup() const {
  return *optionalgroup_;
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup& TestAllTypes::optionalgroup() const {
  const ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* p = optionalgroup_;
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optionalgroup)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup*>(
      &::protobuf_unittest_no_arena::_TestAllTypes_OptionalGroup_default_instance_);
}
inline ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* TestAllTypes::release_optionalgroup() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optionalgroup)
  clear_has_optionalgroup();
  ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* temp = optionalgroup_;
  optionalgroup_ = NULL;
  return temp;
}
inline ::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* TestAllTypes::mutable_optionalgroup() {
  set_has_optionalgroup();
  if (optionalgroup_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup>(GetArenaNoVirtual());
    optionalgroup_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optionalgroup)
  return optionalgroup_;
}
inline void TestAllTypes::set_allocated_optionalgroup(::protobuf_unittest_no_arena::TestAllTypes_OptionalGroup* optionalgroup) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optionalgroup_;
  }
  if (optionalgroup) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      optionalgroup = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optionalgroup, submessage_arena);
    }
    set_has_optionalgroup();
  } else {
    clear_has_optionalgroup();
  }
  optionalgroup_ = optionalgroup;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optionalgroup)
}

// optional .protobuf_unittest_no_arena.TestAllTypes.NestedMessage optional_nested_message = 18;
inline bool TestAllTypes::has_optional_nested_message() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TestAllTypes::set_has_optional_nested_message() {
  _has_bits_[0] |= 0x00000200u;
}
inline void TestAllTypes::clear_has_optional_nested_message() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void TestAllTypes::clear_optional_nested_message() {
  if (optional_nested_message_ != NULL) optional_nested_message_->Clear();
  clear_has_optional_nested_message();
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::_internal_optional_nested_message() const {
  return *optional_nested_message_;
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::optional_nested_message() const {
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* p = optional_nested_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_nested_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage*>(
      &::protobuf_unittest_no_arena::_TestAllTypes_NestedMessage_default_instance_);
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::release_optional_nested_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_nested_message)
  clear_has_optional_nested_message();
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* temp = optional_nested_message_;
  optional_nested_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::mutable_optional_nested_message() {
  set_has_optional_nested_message();
  if (optional_nested_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest_no_arena::TestAllTypes_NestedMessage>(GetArenaNoVirtual());
    optional_nested_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_nested_message)
  return optional_nested_message_;
}
inline void TestAllTypes::set_allocated_optional_nested_message(::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* optional_nested_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_nested_message_;
  }
  if (optional_nested_message) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      optional_nested_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_nested_message, submessage_arena);
    }
    set_has_optional_nested_message();
  } else {
    clear_has_optional_nested_message();
  }
  optional_nested_message_ = optional_nested_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_nested_message)
}

// optional .protobuf_unittest_no_arena.ForeignMessage optional_foreign_message = 19;
inline bool TestAllTypes::has_optional_foreign_message() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TestAllTypes::set_has_optional_foreign_message() {
  _has_bits_[0] |= 0x00000400u;
}
inline void TestAllTypes::clear_has_optional_foreign_message() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void TestAllTypes::clear_optional_foreign_message() {
  if (optional_foreign_message_ != NULL) optional_foreign_message_->Clear();
  clear_has_optional_foreign_message();
}
inline const ::protobuf_unittest_no_arena::ForeignMessage& TestAllTypes::_internal_optional_foreign_message() const {
  return *optional_foreign_message_;
}
inline const ::protobuf_unittest_no_arena::ForeignMessage& TestAllTypes::optional_foreign_message() const {
  const ::protobuf_unittest_no_arena::ForeignMessage* p = optional_foreign_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_foreign_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest_no_arena::ForeignMessage*>(
      &::protobuf_unittest_no_arena::_ForeignMessage_default_instance_);
}
inline ::protobuf_unittest_no_arena::ForeignMessage* TestAllTypes::release_optional_foreign_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_foreign_message)
  clear_has_optional_foreign_message();
  ::protobuf_unittest_no_arena::ForeignMessage* temp = optional_foreign_message_;
  optional_foreign_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_no_arena::ForeignMessage* TestAllTypes::mutable_optional_foreign_message() {
  set_has_optional_foreign_message();
  if (optional_foreign_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest_no_arena::ForeignMessage>(GetArenaNoVirtual());
    optional_foreign_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_foreign_message)
  return optional_foreign_message_;
}
inline void TestAllTypes::set_allocated_optional_foreign_message(::protobuf_unittest_no_arena::ForeignMessage* optional_foreign_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_foreign_message_;
  }
  if (optional_foreign_message) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      optional_foreign_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_foreign_message, submessage_arena);
    }
    set_has_optional_foreign_message();
  } else {
    clear_has_optional_foreign_message();
  }
  optional_foreign_message_ = optional_foreign_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_foreign_message)
}

// optional .protobuf_unittest_import.ImportMessage optional_import_message = 20;
inline bool TestAllTypes::has_optional_import_message() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TestAllTypes::set_has_optional_import_message() {
  _has_bits_[0] |= 0x00000800u;
}
inline void TestAllTypes::clear_has_optional_import_message() {
  _has_bits_[0] &= ~0x00000800u;
}
inline const ::protobuf_unittest_import::ImportMessage& TestAllTypes::_internal_optional_import_message() const {
  return *optional_import_message_;
}
inline const ::protobuf_unittest_import::ImportMessage& TestAllTypes::optional_import_message() const {
  const ::protobuf_unittest_import::ImportMessage* p = optional_import_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_import_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest_import::ImportMessage*>(
      &::protobuf_unittest_import::_ImportMessage_default_instance_);
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::release_optional_import_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_import_message)
  clear_has_optional_import_message();
  ::protobuf_unittest_import::ImportMessage* temp = optional_import_message_;
  optional_import_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::mutable_optional_import_message() {
  set_has_optional_import_message();
  if (optional_import_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest_import::ImportMessage>(GetArenaNoVirtual());
    optional_import_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_import_message)
  return optional_import_message_;
}
inline void TestAllTypes::set_allocated_optional_import_message(::protobuf_unittest_import::ImportMessage* optional_import_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(optional_import_message_);
  }
  if (optional_import_message) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(optional_import_message)->GetArena();
    if (message_arena != submessage_arena) {
      optional_import_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_import_message, submessage_arena);
    }
    set_has_optional_import_message();
  } else {
    clear_has_optional_import_message();
  }
  optional_import_message_ = optional_import_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_import_message)
}

// optional .protobuf_unittest_no_arena.TestAllTypes.NestedEnum optional_nested_enum = 21;
inline bool TestAllTypes::has_optional_nested_enum() const {
  return (_has_bits_[0] & 0x10000000u) != 0;
}
inline void TestAllTypes::set_has_optional_nested_enum() {
  _has_bits_[0] |= 0x10000000u;
}
inline void TestAllTypes::clear_has_optional_nested_enum() {
  _has_bits_[0] &= ~0x10000000u;
}
inline void TestAllTypes::clear_optional_nested_enum() {
  optional_nested_enum_ = 1;
  clear_has_optional_nested_enum();
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum TestAllTypes::optional_nested_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_nested_enum)
  return static_cast< ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum >(optional_nested_enum_);
}
inline void TestAllTypes::set_optional_nested_enum(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum value) {
  assert(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum_IsValid(value));
  set_has_optional_nested_enum();
  optional_nested_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_nested_enum)
}

// optional .protobuf_unittest_no_arena.ForeignEnum optional_foreign_enum = 22;
inline bool TestAllTypes::has_optional_foreign_enum() const {
  return (_has_bits_[0] & 0x20000000u) != 0;
}
inline void TestAllTypes::set_has_optional_foreign_enum() {
  _has_bits_[0] |= 0x20000000u;
}
inline void TestAllTypes::clear_has_optional_foreign_enum() {
  _has_bits_[0] &= ~0x20000000u;
}
inline void TestAllTypes::clear_optional_foreign_enum() {
  optional_foreign_enum_ = 4;
  clear_has_optional_foreign_enum();
}
inline ::protobuf_unittest_no_arena::ForeignEnum TestAllTypes::optional_foreign_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_foreign_enum)
  return static_cast< ::protobuf_unittest_no_arena::ForeignEnum >(optional_foreign_enum_);
}
inline void TestAllTypes::set_optional_foreign_enum(::protobuf_unittest_no_arena::ForeignEnum value) {
  assert(::protobuf_unittest_no_arena::ForeignEnum_IsValid(value));
  set_has_optional_foreign_enum();
  optional_foreign_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_foreign_enum)
}

// optional .protobuf_unittest_import.ImportEnum optional_import_enum = 23;
inline bool TestAllTypes::has_optional_import_enum() const {
  return (_has_bits_[0] & 0x40000000u) != 0;
}
inline void TestAllTypes::set_has_optional_import_enum() {
  _has_bits_[0] |= 0x40000000u;
}
inline void TestAllTypes::clear_has_optional_import_enum() {
  _has_bits_[0] &= ~0x40000000u;
}
inline void TestAllTypes::clear_optional_import_enum() {
  optional_import_enum_ = 7;
  clear_has_optional_import_enum();
}
inline ::protobuf_unittest_import::ImportEnum TestAllTypes::optional_import_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_import_enum)
  return static_cast< ::protobuf_unittest_import::ImportEnum >(optional_import_enum_);
}
inline void TestAllTypes::set_optional_import_enum(::protobuf_unittest_import::ImportEnum value) {
  assert(::protobuf_unittest_import::ImportEnum_IsValid(value));
  set_has_optional_import_enum();
  optional_import_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_import_enum)
}

// optional string optional_string_piece = 24 [ctype = STRING_PIECE];
inline bool TestAllTypes::has_optional_string_piece() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TestAllTypes::set_has_optional_string_piece() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TestAllTypes::clear_has_optional_string_piece() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void TestAllTypes::clear_optional_string_piece() {
  optional_string_piece_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_optional_string_piece();
}
inline const ::std::string& TestAllTypes::optional_string_piece() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_string_piece)
  return optional_string_piece_.GetNoArena();
}
inline void TestAllTypes::set_optional_string_piece(const ::std::string& value) {
  set_has_optional_string_piece();
  optional_string_piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_string_piece)
}
#if LANG_CXX11
inline void TestAllTypes::set_optional_string_piece(::std::string&& value) {
  set_has_optional_string_piece();
  optional_string_piece_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.optional_string_piece)
}
#endif
inline void TestAllTypes::set_optional_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_string_piece();
  optional_string_piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.optional_string_piece)
}
inline void TestAllTypes::set_optional_string_piece(const char* value, size_t size) {
  set_has_optional_string_piece();
  optional_string_piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.optional_string_piece)
}
inline ::std::string* TestAllTypes::mutable_optional_string_piece() {
  set_has_optional_string_piece();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_string_piece)
  return optional_string_piece_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestAllTypes::release_optional_string_piece() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_string_piece)
  if (!has_optional_string_piece()) {
    return NULL;
  }
  clear_has_optional_string_piece();
  return optional_string_piece_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestAllTypes::set_allocated_optional_string_piece(::std::string* optional_string_piece) {
  if (optional_string_piece != NULL) {
    set_has_optional_string_piece();
  } else {
    clear_has_optional_string_piece();
  }
  optional_string_piece_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_string_piece);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_string_piece)
}

// optional string optional_cord = 25 [ctype = CORD];
inline bool TestAllTypes::has_optional_cord() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TestAllTypes::set_has_optional_cord() {
  _has_bits_[0] |= 0x00000008u;
}
inline void TestAllTypes::clear_has_optional_cord() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void TestAllTypes::clear_optional_cord() {
  optional_cord_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_optional_cord();
}
inline const ::std::string& TestAllTypes::optional_cord() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_cord)
  return optional_cord_.GetNoArena();
}
inline void TestAllTypes::set_optional_cord(const ::std::string& value) {
  set_has_optional_cord();
  optional_cord_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.optional_cord)
}
#if LANG_CXX11
inline void TestAllTypes::set_optional_cord(::std::string&& value) {
  set_has_optional_cord();
  optional_cord_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.optional_cord)
}
#endif
inline void TestAllTypes::set_optional_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_optional_cord();
  optional_cord_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.optional_cord)
}
inline void TestAllTypes::set_optional_cord(const char* value, size_t size) {
  set_has_optional_cord();
  optional_cord_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.optional_cord)
}
inline ::std::string* TestAllTypes::mutable_optional_cord() {
  set_has_optional_cord();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_cord)
  return optional_cord_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestAllTypes::release_optional_cord() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_cord)
  if (!has_optional_cord()) {
    return NULL;
  }
  clear_has_optional_cord();
  return optional_cord_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TestAllTypes::set_allocated_optional_cord(::std::string* optional_cord) {
  if (optional_cord != NULL) {
    set_has_optional_cord();
  } else {
    clear_has_optional_cord();
  }
  optional_cord_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), optional_cord);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_cord)
}

// optional .protobuf_unittest_import.PublicImportMessage optional_public_import_message = 26;
inline bool TestAllTypes::has_optional_public_import_message() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TestAllTypes::set_has_optional_public_import_message() {
  _has_bits_[0] |= 0x00001000u;
}
inline void TestAllTypes::clear_has_optional_public_import_message() {
  _has_bits_[0] &= ~0x00001000u;
}
inline const ::protobuf_unittest_import::PublicImportMessage& TestAllTypes::_internal_optional_public_import_message() const {
  return *optional_public_import_message_;
}
inline const ::protobuf_unittest_import::PublicImportMessage& TestAllTypes::optional_public_import_message() const {
  const ::protobuf_unittest_import::PublicImportMessage* p = optional_public_import_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_public_import_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest_import::PublicImportMessage*>(
      &::protobuf_unittest_import::_PublicImportMessage_default_instance_);
}
inline ::protobuf_unittest_import::PublicImportMessage* TestAllTypes::release_optional_public_import_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_public_import_message)
  clear_has_optional_public_import_message();
  ::protobuf_unittest_import::PublicImportMessage* temp = optional_public_import_message_;
  optional_public_import_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_import::PublicImportMessage* TestAllTypes::mutable_optional_public_import_message() {
  set_has_optional_public_import_message();
  if (optional_public_import_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest_import::PublicImportMessage>(GetArenaNoVirtual());
    optional_public_import_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_public_import_message)
  return optional_public_import_message_;
}
inline void TestAllTypes::set_allocated_optional_public_import_message(::protobuf_unittest_import::PublicImportMessage* optional_public_import_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(optional_public_import_message_);
  }
  if (optional_public_import_message) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      optional_public_import_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_public_import_message, submessage_arena);
    }
    set_has_optional_public_import_message();
  } else {
    clear_has_optional_public_import_message();
  }
  optional_public_import_message_ = optional_public_import_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_public_import_message)
}

// optional .protobuf_unittest_no_arena.TestAllTypes.NestedMessage optional_message = 27 [lazy = true];
inline bool TestAllTypes::has_optional_message() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TestAllTypes::set_has_optional_message() {
  _has_bits_[0] |= 0x00002000u;
}
inline void TestAllTypes::clear_has_optional_message() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void TestAllTypes::clear_optional_message() {
  if (optional_message_ != NULL) optional_message_->Clear();
  clear_has_optional_message();
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::_internal_optional_message() const {
  return *optional_message_;
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::optional_message() const {
  const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* p = optional_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.optional_message)
  return p != NULL ? *p : *reinterpret_cast<const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage*>(
      &::protobuf_unittest_no_arena::_TestAllTypes_NestedMessage_default_instance_);
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::release_optional_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.optional_message)
  clear_has_optional_message();
  ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* temp = optional_message_;
  optional_message_ = NULL;
  return temp;
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::mutable_optional_message() {
  set_has_optional_message();
  if (optional_message_ == NULL) {
    auto* p = CreateMaybeMessage<::protobuf_unittest_no_arena::TestAllTypes_NestedMessage>(GetArenaNoVirtual());
    optional_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.optional_message)
  return optional_message_;
}
inline void TestAllTypes::set_allocated_optional_message(::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* optional_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete optional_message_;
  }
  if (optional_message) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      optional_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, optional_message, submessage_arena);
    }
    set_has_optional_message();
  } else {
    clear_has_optional_message();
  }
  optional_message_ = optional_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.optional_message)
}

// repeated int32 repeated_int32 = 31;
inline int TestAllTypes::repeated_int32_size() const {
  return repeated_int32_.size();
}
inline void TestAllTypes::clear_repeated_int32() {
  repeated_int32_.Clear();
}
inline ::google::protobuf::int32 TestAllTypes::repeated_int32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_int32)
  return repeated_int32_.Get(index);
}
inline void TestAllTypes::set_repeated_int32(int index, ::google::protobuf::int32 value) {
  repeated_int32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_int32)
}
inline void TestAllTypes::add_repeated_int32(::google::protobuf::int32 value) {
  repeated_int32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_int32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestAllTypes::repeated_int32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_int32)
  return repeated_int32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestAllTypes::mutable_repeated_int32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_int32)
  return &repeated_int32_;
}

// repeated int64 repeated_int64 = 32;
inline int TestAllTypes::repeated_int64_size() const {
  return repeated_int64_.size();
}
inline void TestAllTypes::clear_repeated_int64() {
  repeated_int64_.Clear();
}
inline ::google::protobuf::int64 TestAllTypes::repeated_int64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_int64)
  return repeated_int64_.Get(index);
}
inline void TestAllTypes::set_repeated_int64(int index, ::google::protobuf::int64 value) {
  repeated_int64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_int64)
}
inline void TestAllTypes::add_repeated_int64(::google::protobuf::int64 value) {
  repeated_int64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_int64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestAllTypes::repeated_int64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_int64)
  return repeated_int64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestAllTypes::mutable_repeated_int64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_int64)
  return &repeated_int64_;
}

// repeated uint32 repeated_uint32 = 33;
inline int TestAllTypes::repeated_uint32_size() const {
  return repeated_uint32_.size();
}
inline void TestAllTypes::clear_repeated_uint32() {
  repeated_uint32_.Clear();
}
inline ::google::protobuf::uint32 TestAllTypes::repeated_uint32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_uint32)
  return repeated_uint32_.Get(index);
}
inline void TestAllTypes::set_repeated_uint32(int index, ::google::protobuf::uint32 value) {
  repeated_uint32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_uint32)
}
inline void TestAllTypes::add_repeated_uint32(::google::protobuf::uint32 value) {
  repeated_uint32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_uint32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestAllTypes::repeated_uint32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_uint32)
  return repeated_uint32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestAllTypes::mutable_repeated_uint32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_uint32)
  return &repeated_uint32_;
}

// repeated uint64 repeated_uint64 = 34;
inline int TestAllTypes::repeated_uint64_size() const {
  return repeated_uint64_.size();
}
inline void TestAllTypes::clear_repeated_uint64() {
  repeated_uint64_.Clear();
}
inline ::google::protobuf::uint64 TestAllTypes::repeated_uint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_uint64)
  return repeated_uint64_.Get(index);
}
inline void TestAllTypes::set_repeated_uint64(int index, ::google::protobuf::uint64 value) {
  repeated_uint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_uint64)
}
inline void TestAllTypes::add_repeated_uint64(::google::protobuf::uint64 value) {
  repeated_uint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_uint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestAllTypes::repeated_uint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_uint64)
  return repeated_uint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestAllTypes::mutable_repeated_uint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_uint64)
  return &repeated_uint64_;
}

// repeated sint32 repeated_sint32 = 35;
inline int TestAllTypes::repeated_sint32_size() const {
  return repeated_sint32_.size();
}
inline void TestAllTypes::clear_repeated_sint32() {
  repeated_sint32_.Clear();
}
inline ::google::protobuf::int32 TestAllTypes::repeated_sint32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_sint32)
  return repeated_sint32_.Get(index);
}
inline void TestAllTypes::set_repeated_sint32(int index, ::google::protobuf::int32 value) {
  repeated_sint32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_sint32)
}
inline void TestAllTypes::add_repeated_sint32(::google::protobuf::int32 value) {
  repeated_sint32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_sint32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestAllTypes::repeated_sint32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_sint32)
  return repeated_sint32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestAllTypes::mutable_repeated_sint32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_sint32)
  return &repeated_sint32_;
}

// repeated sint64 repeated_sint64 = 36;
inline int TestAllTypes::repeated_sint64_size() const {
  return repeated_sint64_.size();
}
inline void TestAllTypes::clear_repeated_sint64() {
  repeated_sint64_.Clear();
}
inline ::google::protobuf::int64 TestAllTypes::repeated_sint64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_sint64)
  return repeated_sint64_.Get(index);
}
inline void TestAllTypes::set_repeated_sint64(int index, ::google::protobuf::int64 value) {
  repeated_sint64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_sint64)
}
inline void TestAllTypes::add_repeated_sint64(::google::protobuf::int64 value) {
  repeated_sint64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_sint64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestAllTypes::repeated_sint64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_sint64)
  return repeated_sint64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestAllTypes::mutable_repeated_sint64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_sint64)
  return &repeated_sint64_;
}

// repeated fixed32 repeated_fixed32 = 37;
inline int TestAllTypes::repeated_fixed32_size() const {
  return repeated_fixed32_.size();
}
inline void TestAllTypes::clear_repeated_fixed32() {
  repeated_fixed32_.Clear();
}
inline ::google::protobuf::uint32 TestAllTypes::repeated_fixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed32)
  return repeated_fixed32_.Get(index);
}
inline void TestAllTypes::set_repeated_fixed32(int index, ::google::protobuf::uint32 value) {
  repeated_fixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed32)
}
inline void TestAllTypes::add_repeated_fixed32(::google::protobuf::uint32 value) {
  repeated_fixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
TestAllTypes::repeated_fixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed32)
  return repeated_fixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
TestAllTypes::mutable_repeated_fixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed32)
  return &repeated_fixed32_;
}

// repeated fixed64 repeated_fixed64 = 38;
inline int TestAllTypes::repeated_fixed64_size() const {
  return repeated_fixed64_.size();
}
inline void TestAllTypes::clear_repeated_fixed64() {
  repeated_fixed64_.Clear();
}
inline ::google::protobuf::uint64 TestAllTypes::repeated_fixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed64)
  return repeated_fixed64_.Get(index);
}
inline void TestAllTypes::set_repeated_fixed64(int index, ::google::protobuf::uint64 value) {
  repeated_fixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed64)
}
inline void TestAllTypes::add_repeated_fixed64(::google::protobuf::uint64 value) {
  repeated_fixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
TestAllTypes::repeated_fixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed64)
  return repeated_fixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
TestAllTypes::mutable_repeated_fixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_fixed64)
  return &repeated_fixed64_;
}

// repeated sfixed32 repeated_sfixed32 = 39;
inline int TestAllTypes::repeated_sfixed32_size() const {
  return repeated_sfixed32_.size();
}
inline void TestAllTypes::clear_repeated_sfixed32() {
  repeated_sfixed32_.Clear();
}
inline ::google::protobuf::int32 TestAllTypes::repeated_sfixed32(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed32)
  return repeated_sfixed32_.Get(index);
}
inline void TestAllTypes::set_repeated_sfixed32(int index, ::google::protobuf::int32 value) {
  repeated_sfixed32_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed32)
}
inline void TestAllTypes::add_repeated_sfixed32(::google::protobuf::int32 value) {
  repeated_sfixed32_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed32)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
TestAllTypes::repeated_sfixed32() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed32)
  return repeated_sfixed32_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
TestAllTypes::mutable_repeated_sfixed32() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed32)
  return &repeated_sfixed32_;
}

// repeated sfixed64 repeated_sfixed64 = 40;
inline int TestAllTypes::repeated_sfixed64_size() const {
  return repeated_sfixed64_.size();
}
inline void TestAllTypes::clear_repeated_sfixed64() {
  repeated_sfixed64_.Clear();
}
inline ::google::protobuf::int64 TestAllTypes::repeated_sfixed64(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed64)
  return repeated_sfixed64_.Get(index);
}
inline void TestAllTypes::set_repeated_sfixed64(int index, ::google::protobuf::int64 value) {
  repeated_sfixed64_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed64)
}
inline void TestAllTypes::add_repeated_sfixed64(::google::protobuf::int64 value) {
  repeated_sfixed64_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed64)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
TestAllTypes::repeated_sfixed64() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed64)
  return repeated_sfixed64_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
TestAllTypes::mutable_repeated_sfixed64() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_sfixed64)
  return &repeated_sfixed64_;
}

// repeated float repeated_float = 41;
inline int TestAllTypes::repeated_float_size() const {
  return repeated_float_.size();
}
inline void TestAllTypes::clear_repeated_float() {
  repeated_float_.Clear();
}
inline float TestAllTypes::repeated_float(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_float)
  return repeated_float_.Get(index);
}
inline void TestAllTypes::set_repeated_float(int index, float value) {
  repeated_float_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_float)
}
inline void TestAllTypes::add_repeated_float(float value) {
  repeated_float_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_float)
}
inline const ::google::protobuf::RepeatedField< float >&
TestAllTypes::repeated_float() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_float)
  return repeated_float_;
}
inline ::google::protobuf::RepeatedField< float >*
TestAllTypes::mutable_repeated_float() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_float)
  return &repeated_float_;
}

// repeated double repeated_double = 42;
inline int TestAllTypes::repeated_double_size() const {
  return repeated_double_.size();
}
inline void TestAllTypes::clear_repeated_double() {
  repeated_double_.Clear();
}
inline double TestAllTypes::repeated_double(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_double)
  return repeated_double_.Get(index);
}
inline void TestAllTypes::set_repeated_double(int index, double value) {
  repeated_double_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_double)
}
inline void TestAllTypes::add_repeated_double(double value) {
  repeated_double_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_double)
}
inline const ::google::protobuf::RepeatedField< double >&
TestAllTypes::repeated_double() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_double)
  return repeated_double_;
}
inline ::google::protobuf::RepeatedField< double >*
TestAllTypes::mutable_repeated_double() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_double)
  return &repeated_double_;
}

// repeated bool repeated_bool = 43;
inline int TestAllTypes::repeated_bool_size() const {
  return repeated_bool_.size();
}
inline void TestAllTypes::clear_repeated_bool() {
  repeated_bool_.Clear();
}
inline bool TestAllTypes::repeated_bool(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_bool)
  return repeated_bool_.Get(index);
}
inline void TestAllTypes::set_repeated_bool(int index, bool value) {
  repeated_bool_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_bool)
}
inline void TestAllTypes::add_repeated_bool(bool value) {
  repeated_bool_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_bool)
}
inline const ::google::protobuf::RepeatedField< bool >&
TestAllTypes::repeated_bool() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_bool)
  return repeated_bool_;
}
inline ::google::protobuf::RepeatedField< bool >*
TestAllTypes::mutable_repeated_bool() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_bool)
  return &repeated_bool_;
}

// repeated string repeated_string = 44;
inline int TestAllTypes::repeated_string_size() const {
  return repeated_string_.size();
}
inline void TestAllTypes::clear_repeated_string() {
  repeated_string_.Clear();
}
inline const ::std::string& TestAllTypes::repeated_string(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
  return repeated_string_.Get(index);
}
inline ::std::string* TestAllTypes::mutable_repeated_string(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
  return repeated_string_.Mutable(index);
}
inline void TestAllTypes::set_repeated_string(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
  repeated_string_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestAllTypes::set_repeated_string(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
  repeated_string_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestAllTypes::set_repeated_string(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_string_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
}
inline void TestAllTypes::set_repeated_string(int index, const char* value, size_t size) {
  repeated_string_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
}
inline ::std::string* TestAllTypes::add_repeated_string() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
  return repeated_string_.Add();
}
inline void TestAllTypes::add_repeated_string(const ::std::string& value) {
  repeated_string_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
}
#if LANG_CXX11
inline void TestAllTypes::add_repeated_string(::std::string&& value) {
  repeated_string_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
}
#endif
inline void TestAllTypes::add_repeated_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_string_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
}
inline void TestAllTypes::add_repeated_string(const char* value, size_t size) {
  repeated_string_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestAllTypes::repeated_string() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
  return repeated_string_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestAllTypes::mutable_repeated_string() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_string)
  return &repeated_string_;
}

// repeated bytes repeated_bytes = 45;
inline int TestAllTypes::repeated_bytes_size() const {
  return repeated_bytes_.size();
}
inline void TestAllTypes::clear_repeated_bytes() {
  repeated_bytes_.Clear();
}
inline const ::std::string& TestAllTypes::repeated_bytes(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
  return repeated_bytes_.Get(index);
}
inline ::std::string* TestAllTypes::mutable_repeated_bytes(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
  return repeated_bytes_.Mutable(index);
}
inline void TestAllTypes::set_repeated_bytes(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
  repeated_bytes_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestAllTypes::set_repeated_bytes(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
  repeated_bytes_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestAllTypes::set_repeated_bytes(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_bytes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
}
inline void TestAllTypes::set_repeated_bytes(int index, const void* value, size_t size) {
  repeated_bytes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
}
inline ::std::string* TestAllTypes::add_repeated_bytes() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
  return repeated_bytes_.Add();
}
inline void TestAllTypes::add_repeated_bytes(const ::std::string& value) {
  repeated_bytes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
}
#if LANG_CXX11
inline void TestAllTypes::add_repeated_bytes(::std::string&& value) {
  repeated_bytes_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
}
#endif
inline void TestAllTypes::add_repeated_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_bytes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
}
inline void TestAllTypes::add_repeated_bytes(const void* value, size_t size) {
  repeated_bytes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestAllTypes::repeated_bytes() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
  return repeated_bytes_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestAllTypes::mutable_repeated_bytes() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_bytes)
  return &repeated_bytes_;
}

// repeated group RepeatedGroup = 46 { ... };
inline int TestAllTypes::repeatedgroup_size() const {
  return repeatedgroup_.size();
}
inline void TestAllTypes::clear_repeatedgroup() {
  repeatedgroup_.Clear();
}
inline ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup* TestAllTypes::mutable_repeatedgroup(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeatedgroup)
  return repeatedgroup_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup >*
TestAllTypes::mutable_repeatedgroup() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeatedgroup)
  return &repeatedgroup_;
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup& TestAllTypes::repeatedgroup(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeatedgroup)
  return repeatedgroup_.Get(index);
}
inline ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup* TestAllTypes::add_repeatedgroup() {
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeatedgroup)
  return repeatedgroup_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_RepeatedGroup >&
TestAllTypes::repeatedgroup() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeatedgroup)
  return repeatedgroup_;
}

// repeated .protobuf_unittest_no_arena.TestAllTypes.NestedMessage repeated_nested_message = 48;
inline int TestAllTypes::repeated_nested_message_size() const {
  return repeated_nested_message_.size();
}
inline void TestAllTypes::clear_repeated_nested_message() {
  repeated_nested_message_.Clear();
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::mutable_repeated_nested_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_message)
  return repeated_nested_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >*
TestAllTypes::mutable_repeated_nested_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_message)
  return &repeated_nested_message_;
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::repeated_nested_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_message)
  return repeated_nested_message_.Get(index);
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::add_repeated_nested_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_message)
  return repeated_nested_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >&
TestAllTypes::repeated_nested_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_message)
  return repeated_nested_message_;
}

// repeated .protobuf_unittest_no_arena.ForeignMessage repeated_foreign_message = 49;
inline int TestAllTypes::repeated_foreign_message_size() const {
  return repeated_foreign_message_.size();
}
inline void TestAllTypes::clear_repeated_foreign_message() {
  repeated_foreign_message_.Clear();
}
inline ::protobuf_unittest_no_arena::ForeignMessage* TestAllTypes::mutable_repeated_foreign_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_message)
  return repeated_foreign_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::ForeignMessage >*
TestAllTypes::mutable_repeated_foreign_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_message)
  return &repeated_foreign_message_;
}
inline const ::protobuf_unittest_no_arena::ForeignMessage& TestAllTypes::repeated_foreign_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_message)
  return repeated_foreign_message_.Get(index);
}
inline ::protobuf_unittest_no_arena::ForeignMessage* TestAllTypes::add_repeated_foreign_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_message)
  return repeated_foreign_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::ForeignMessage >&
TestAllTypes::repeated_foreign_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_message)
  return repeated_foreign_message_;
}

// repeated .protobuf_unittest_import.ImportMessage repeated_import_message = 50;
inline int TestAllTypes::repeated_import_message_size() const {
  return repeated_import_message_.size();
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::mutable_repeated_import_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_import_message)
  return repeated_import_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage >*
TestAllTypes::mutable_repeated_import_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_import_message)
  return &repeated_import_message_;
}
inline const ::protobuf_unittest_import::ImportMessage& TestAllTypes::repeated_import_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_import_message)
  return repeated_import_message_.Get(index);
}
inline ::protobuf_unittest_import::ImportMessage* TestAllTypes::add_repeated_import_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_import_message)
  return repeated_import_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_import::ImportMessage >&
TestAllTypes::repeated_import_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_import_message)
  return repeated_import_message_;
}

// repeated .protobuf_unittest_no_arena.TestAllTypes.NestedEnum repeated_nested_enum = 51;
inline int TestAllTypes::repeated_nested_enum_size() const {
  return repeated_nested_enum_.size();
}
inline void TestAllTypes::clear_repeated_nested_enum() {
  repeated_nested_enum_.Clear();
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum TestAllTypes::repeated_nested_enum(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_enum)
  return static_cast< ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum >(repeated_nested_enum_.Get(index));
}
inline void TestAllTypes::set_repeated_nested_enum(int index, ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum value) {
  assert(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum_IsValid(value));
  repeated_nested_enum_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_enum)
}
inline void TestAllTypes::add_repeated_nested_enum(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum value) {
  assert(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum_IsValid(value));
  repeated_nested_enum_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_enum)
}
inline const ::google::protobuf::RepeatedField<int>&
TestAllTypes::repeated_nested_enum() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_enum)
  return repeated_nested_enum_;
}
inline ::google::protobuf::RepeatedField<int>*
TestAllTypes::mutable_repeated_nested_enum() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_nested_enum)
  return &repeated_nested_enum_;
}

// repeated .protobuf_unittest_no_arena.ForeignEnum repeated_foreign_enum = 52;
inline int TestAllTypes::repeated_foreign_enum_size() const {
  return repeated_foreign_enum_.size();
}
inline void TestAllTypes::clear_repeated_foreign_enum() {
  repeated_foreign_enum_.Clear();
}
inline ::protobuf_unittest_no_arena::ForeignEnum TestAllTypes::repeated_foreign_enum(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_enum)
  return static_cast< ::protobuf_unittest_no_arena::ForeignEnum >(repeated_foreign_enum_.Get(index));
}
inline void TestAllTypes::set_repeated_foreign_enum(int index, ::protobuf_unittest_no_arena::ForeignEnum value) {
  assert(::protobuf_unittest_no_arena::ForeignEnum_IsValid(value));
  repeated_foreign_enum_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_enum)
}
inline void TestAllTypes::add_repeated_foreign_enum(::protobuf_unittest_no_arena::ForeignEnum value) {
  assert(::protobuf_unittest_no_arena::ForeignEnum_IsValid(value));
  repeated_foreign_enum_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_enum)
}
inline const ::google::protobuf::RepeatedField<int>&
TestAllTypes::repeated_foreign_enum() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_enum)
  return repeated_foreign_enum_;
}
inline ::google::protobuf::RepeatedField<int>*
TestAllTypes::mutable_repeated_foreign_enum() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_foreign_enum)
  return &repeated_foreign_enum_;
}

// repeated .protobuf_unittest_import.ImportEnum repeated_import_enum = 53;
inline int TestAllTypes::repeated_import_enum_size() const {
  return repeated_import_enum_.size();
}
inline void TestAllTypes::clear_repeated_import_enum() {
  repeated_import_enum_.Clear();
}
inline ::protobuf_unittest_import::ImportEnum TestAllTypes::repeated_import_enum(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_import_enum)
  return static_cast< ::protobuf_unittest_import::ImportEnum >(repeated_import_enum_.Get(index));
}
inline void TestAllTypes::set_repeated_import_enum(int index, ::protobuf_unittest_import::ImportEnum value) {
  assert(::protobuf_unittest_import::ImportEnum_IsValid(value));
  repeated_import_enum_.Set(index, value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_import_enum)
}
inline void TestAllTypes::add_repeated_import_enum(::protobuf_unittest_import::ImportEnum value) {
  assert(::protobuf_unittest_import::ImportEnum_IsValid(value));
  repeated_import_enum_.Add(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_import_enum)
}
inline const ::google::protobuf::RepeatedField<int>&
TestAllTypes::repeated_import_enum() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_import_enum)
  return repeated_import_enum_;
}
inline ::google::protobuf::RepeatedField<int>*
TestAllTypes::mutable_repeated_import_enum() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_import_enum)
  return &repeated_import_enum_;
}

// repeated string repeated_string_piece = 54 [ctype = STRING_PIECE];
inline int TestAllTypes::repeated_string_piece_size() const {
  return repeated_string_piece_.size();
}
inline void TestAllTypes::clear_repeated_string_piece() {
  repeated_string_piece_.Clear();
}
inline const ::std::string& TestAllTypes::repeated_string_piece(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
  return repeated_string_piece_.Get(index);
}
inline ::std::string* TestAllTypes::mutable_repeated_string_piece(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
  return repeated_string_piece_.Mutable(index);
}
inline void TestAllTypes::set_repeated_string_piece(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
  repeated_string_piece_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestAllTypes::set_repeated_string_piece(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
  repeated_string_piece_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestAllTypes::set_repeated_string_piece(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_string_piece_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
}
inline void TestAllTypes::set_repeated_string_piece(int index, const char* value, size_t size) {
  repeated_string_piece_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
}
inline ::std::string* TestAllTypes::add_repeated_string_piece() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
  return repeated_string_piece_.Add();
}
inline void TestAllTypes::add_repeated_string_piece(const ::std::string& value) {
  repeated_string_piece_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
}
#if LANG_CXX11
inline void TestAllTypes::add_repeated_string_piece(::std::string&& value) {
  repeated_string_piece_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
}
#endif
inline void TestAllTypes::add_repeated_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_string_piece_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
}
inline void TestAllTypes::add_repeated_string_piece(const char* value, size_t size) {
  repeated_string_piece_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestAllTypes::repeated_string_piece() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
  return repeated_string_piece_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestAllTypes::mutable_repeated_string_piece() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_string_piece)
  return &repeated_string_piece_;
}

// repeated string repeated_cord = 55 [ctype = CORD];
inline int TestAllTypes::repeated_cord_size() const {
  return repeated_cord_.size();
}
inline void TestAllTypes::clear_repeated_cord() {
  repeated_cord_.Clear();
}
inline const ::std::string& TestAllTypes::repeated_cord(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
  return repeated_cord_.Get(index);
}
inline ::std::string* TestAllTypes::mutable_repeated_cord(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
  return repeated_cord_.Mutable(index);
}
inline void TestAllTypes::set_repeated_cord(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
  repeated_cord_.Mutable(index)->assign(value);
}
#if LANG_CXX11
inline void TestAllTypes::set_repeated_cord(int index, ::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
  repeated_cord_.Mutable(index)->assign(std::move(value));
}
#endif
inline void TestAllTypes::set_repeated_cord(int index, const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_cord_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
}
inline void TestAllTypes::set_repeated_cord(int index, const char* value, size_t size) {
  repeated_cord_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
}
inline ::std::string* TestAllTypes::add_repeated_cord() {
  // @@protoc_insertion_point(field_add_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
  return repeated_cord_.Add();
}
inline void TestAllTypes::add_repeated_cord(const ::std::string& value) {
  repeated_cord_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
}
#if LANG_CXX11
inline void TestAllTypes::add_repeated_cord(::std::string&& value) {
  repeated_cord_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
}
#endif
inline void TestAllTypes::add_repeated_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  repeated_cord_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
}
inline void TestAllTypes::add_repeated_cord(const char* value, size_t size) {
  repeated_cord_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
TestAllTypes::repeated_cord() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
  return repeated_cord_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
TestAllTypes::mutable_repeated_cord() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_cord)
  return &repeated_cord_;
}

// repeated .protobuf_unittest_no_arena.TestAllTypes.NestedMessage repeated_lazy_message = 57 [lazy = true];
inline int TestAllTypes::repeated_lazy_message_size() const {
  return repeated_lazy_message_.size();
}
inline void TestAllTypes::clear_repeated_lazy_message() {
  repeated_lazy_message_.Clear();
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::mutable_repeated_lazy_message(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.repeated_lazy_message)
  return repeated_lazy_message_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >*
TestAllTypes::mutable_repeated_lazy_message() {
  // @@protoc_insertion_point(field_mutable_list:protobuf_unittest_no_arena.TestAllTypes.repeated_lazy_message)
  return &repeated_lazy_message_;
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::repeated_lazy_message(int index) const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.repeated_lazy_message)
  return repeated_lazy_message_.Get(index);
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::add_repeated_lazy_message() {
  // @@protoc_insertion_point(field_add:protobuf_unittest_no_arena.TestAllTypes.repeated_lazy_message)
  return repeated_lazy_message_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >&
TestAllTypes::repeated_lazy_message() const {
  // @@protoc_insertion_point(field_list:protobuf_unittest_no_arena.TestAllTypes.repeated_lazy_message)
  return repeated_lazy_message_;
}

// optional int32 default_int32 = 61 [default = 41];
inline bool TestAllTypes::has_default_int32() const {
  return (_has_bits_[0] & 0x80000000u) != 0;
}
inline void TestAllTypes::set_has_default_int32() {
  _has_bits_[0] |= 0x80000000u;
}
inline void TestAllTypes::clear_has_default_int32() {
  _has_bits_[0] &= ~0x80000000u;
}
inline void TestAllTypes::clear_default_int32() {
  default_int32_ = 41;
  clear_has_default_int32();
}
inline ::google::protobuf::int32 TestAllTypes::default_int32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_int32)
  return default_int32_;
}
inline void TestAllTypes::set_default_int32(::google::protobuf::int32 value) {
  set_has_default_int32();
  default_int32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_int32)
}

// optional int64 default_int64 = 62 [default = 42];
inline bool TestAllTypes::has_default_int64() const {
  return (_has_bits_[1] & 0x00000001u) != 0;
}
inline void TestAllTypes::set_has_default_int64() {
  _has_bits_[1] |= 0x00000001u;
}
inline void TestAllTypes::clear_has_default_int64() {
  _has_bits_[1] &= ~0x00000001u;
}
inline void TestAllTypes::clear_default_int64() {
  default_int64_ = GOOGLE_LONGLONG(42);
  clear_has_default_int64();
}
inline ::google::protobuf::int64 TestAllTypes::default_int64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_int64)
  return default_int64_;
}
inline void TestAllTypes::set_default_int64(::google::protobuf::int64 value) {
  set_has_default_int64();
  default_int64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_int64)
}

// optional uint32 default_uint32 = 63 [default = 43];
inline bool TestAllTypes::has_default_uint32() const {
  return (_has_bits_[1] & 0x00000004u) != 0;
}
inline void TestAllTypes::set_has_default_uint32() {
  _has_bits_[1] |= 0x00000004u;
}
inline void TestAllTypes::clear_has_default_uint32() {
  _has_bits_[1] &= ~0x00000004u;
}
inline void TestAllTypes::clear_default_uint32() {
  default_uint32_ = 43u;
  clear_has_default_uint32();
}
inline ::google::protobuf::uint32 TestAllTypes::default_uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_uint32)
  return default_uint32_;
}
inline void TestAllTypes::set_default_uint32(::google::protobuf::uint32 value) {
  set_has_default_uint32();
  default_uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_uint32)
}

// optional uint64 default_uint64 = 64 [default = 44];
inline bool TestAllTypes::has_default_uint64() const {
  return (_has_bits_[1] & 0x00000002u) != 0;
}
inline void TestAllTypes::set_has_default_uint64() {
  _has_bits_[1] |= 0x00000002u;
}
inline void TestAllTypes::clear_has_default_uint64() {
  _has_bits_[1] &= ~0x00000002u;
}
inline void TestAllTypes::clear_default_uint64() {
  default_uint64_ = GOOGLE_ULONGLONG(44);
  clear_has_default_uint64();
}
inline ::google::protobuf::uint64 TestAllTypes::default_uint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_uint64)
  return default_uint64_;
}
inline void TestAllTypes::set_default_uint64(::google::protobuf::uint64 value) {
  set_has_default_uint64();
  default_uint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_uint64)
}

// optional sint32 default_sint32 = 65 [default = -45];
inline bool TestAllTypes::has_default_sint32() const {
  return (_has_bits_[1] & 0x00000008u) != 0;
}
inline void TestAllTypes::set_has_default_sint32() {
  _has_bits_[1] |= 0x00000008u;
}
inline void TestAllTypes::clear_has_default_sint32() {
  _has_bits_[1] &= ~0x00000008u;
}
inline void TestAllTypes::clear_default_sint32() {
  default_sint32_ = -45;
  clear_has_default_sint32();
}
inline ::google::protobuf::int32 TestAllTypes::default_sint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_sint32)
  return default_sint32_;
}
inline void TestAllTypes::set_default_sint32(::google::protobuf::int32 value) {
  set_has_default_sint32();
  default_sint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_sint32)
}

// optional sint64 default_sint64 = 66 [default = 46];
inline bool TestAllTypes::has_default_sint64() const {
  return (_has_bits_[1] & 0x00000010u) != 0;
}
inline void TestAllTypes::set_has_default_sint64() {
  _has_bits_[1] |= 0x00000010u;
}
inline void TestAllTypes::clear_has_default_sint64() {
  _has_bits_[1] &= ~0x00000010u;
}
inline void TestAllTypes::clear_default_sint64() {
  default_sint64_ = GOOGLE_LONGLONG(46);
  clear_has_default_sint64();
}
inline ::google::protobuf::int64 TestAllTypes::default_sint64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_sint64)
  return default_sint64_;
}
inline void TestAllTypes::set_default_sint64(::google::protobuf::int64 value) {
  set_has_default_sint64();
  default_sint64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_sint64)
}

// optional fixed32 default_fixed32 = 67 [default = 47];
inline bool TestAllTypes::has_default_fixed32() const {
  return (_has_bits_[1] & 0x00000040u) != 0;
}
inline void TestAllTypes::set_has_default_fixed32() {
  _has_bits_[1] |= 0x00000040u;
}
inline void TestAllTypes::clear_has_default_fixed32() {
  _has_bits_[1] &= ~0x00000040u;
}
inline void TestAllTypes::clear_default_fixed32() {
  default_fixed32_ = 47u;
  clear_has_default_fixed32();
}
inline ::google::protobuf::uint32 TestAllTypes::default_fixed32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_fixed32)
  return default_fixed32_;
}
inline void TestAllTypes::set_default_fixed32(::google::protobuf::uint32 value) {
  set_has_default_fixed32();
  default_fixed32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_fixed32)
}

// optional fixed64 default_fixed64 = 68 [default = 48];
inline bool TestAllTypes::has_default_fixed64() const {
  return (_has_bits_[1] & 0x00000020u) != 0;
}
inline void TestAllTypes::set_has_default_fixed64() {
  _has_bits_[1] |= 0x00000020u;
}
inline void TestAllTypes::clear_has_default_fixed64() {
  _has_bits_[1] &= ~0x00000020u;
}
inline void TestAllTypes::clear_default_fixed64() {
  default_fixed64_ = GOOGLE_ULONGLONG(48);
  clear_has_default_fixed64();
}
inline ::google::protobuf::uint64 TestAllTypes::default_fixed64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_fixed64)
  return default_fixed64_;
}
inline void TestAllTypes::set_default_fixed64(::google::protobuf::uint64 value) {
  set_has_default_fixed64();
  default_fixed64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_fixed64)
}

// optional sfixed32 default_sfixed32 = 69 [default = 49];
inline bool TestAllTypes::has_default_sfixed32() const {
  return (_has_bits_[1] & 0x00000080u) != 0;
}
inline void TestAllTypes::set_has_default_sfixed32() {
  _has_bits_[1] |= 0x00000080u;
}
inline void TestAllTypes::clear_has_default_sfixed32() {
  _has_bits_[1] &= ~0x00000080u;
}
inline void TestAllTypes::clear_default_sfixed32() {
  default_sfixed32_ = 49;
  clear_has_default_sfixed32();
}
inline ::google::protobuf::int32 TestAllTypes::default_sfixed32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_sfixed32)
  return default_sfixed32_;
}
inline void TestAllTypes::set_default_sfixed32(::google::protobuf::int32 value) {
  set_has_default_sfixed32();
  default_sfixed32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_sfixed32)
}

// optional sfixed64 default_sfixed64 = 70 [default = -50];
inline bool TestAllTypes::has_default_sfixed64() const {
  return (_has_bits_[1] & 0x00000100u) != 0;
}
inline void TestAllTypes::set_has_default_sfixed64() {
  _has_bits_[1] |= 0x00000100u;
}
inline void TestAllTypes::clear_has_default_sfixed64() {
  _has_bits_[1] &= ~0x00000100u;
}
inline void TestAllTypes::clear_default_sfixed64() {
  default_sfixed64_ = GOOGLE_LONGLONG(-50);
  clear_has_default_sfixed64();
}
inline ::google::protobuf::int64 TestAllTypes::default_sfixed64() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_sfixed64)
  return default_sfixed64_;
}
inline void TestAllTypes::set_default_sfixed64(::google::protobuf::int64 value) {
  set_has_default_sfixed64();
  default_sfixed64_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_sfixed64)
}

// optional float default_float = 71 [default = 51.5];
inline bool TestAllTypes::has_default_float() const {
  return (_has_bits_[1] & 0x00000400u) != 0;
}
inline void TestAllTypes::set_has_default_float() {
  _has_bits_[1] |= 0x00000400u;
}
inline void TestAllTypes::clear_has_default_float() {
  _has_bits_[1] &= ~0x00000400u;
}
inline void TestAllTypes::clear_default_float() {
  default_float_ = 51.5f;
  clear_has_default_float();
}
inline float TestAllTypes::default_float() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_float)
  return default_float_;
}
inline void TestAllTypes::set_default_float(float value) {
  set_has_default_float();
  default_float_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_float)
}

// optional double default_double = 72 [default = 52000];
inline bool TestAllTypes::has_default_double() const {
  return (_has_bits_[1] & 0x00000200u) != 0;
}
inline void TestAllTypes::set_has_default_double() {
  _has_bits_[1] |= 0x00000200u;
}
inline void TestAllTypes::clear_has_default_double() {
  _has_bits_[1] &= ~0x00000200u;
}
inline void TestAllTypes::clear_default_double() {
  default_double_ = 52000;
  clear_has_default_double();
}
inline double TestAllTypes::default_double() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_double)
  return default_double_;
}
inline void TestAllTypes::set_default_double(double value) {
  set_has_default_double();
  default_double_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_double)
}

// optional bool default_bool = 73 [default = true];
inline bool TestAllTypes::has_default_bool() const {
  return (_has_bits_[1] & 0x00000800u) != 0;
}
inline void TestAllTypes::set_has_default_bool() {
  _has_bits_[1] |= 0x00000800u;
}
inline void TestAllTypes::clear_has_default_bool() {
  _has_bits_[1] &= ~0x00000800u;
}
inline void TestAllTypes::clear_default_bool() {
  default_bool_ = true;
  clear_has_default_bool();
}
inline bool TestAllTypes::default_bool() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_bool)
  return default_bool_;
}
inline void TestAllTypes::set_default_bool(bool value) {
  set_has_default_bool();
  default_bool_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_bool)
}

// optional string default_string = 74 [default = "hello"];
inline bool TestAllTypes::has_default_string() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TestAllTypes::set_has_default_string() {
  _has_bits_[0] |= 0x00000010u;
}
inline void TestAllTypes::clear_has_default_string() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void TestAllTypes::clear_default_string() {
  default_string_.ClearToDefaultNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get());
  clear_has_default_string();
}
inline const ::std::string& TestAllTypes::default_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_string)
  return default_string_.GetNoArena();
}
inline void TestAllTypes::set_default_string(const ::std::string& value) {
  set_has_default_string();
  default_string_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_string)
}
#if LANG_CXX11
inline void TestAllTypes::set_default_string(::std::string&& value) {
  set_has_default_string();
  default_string_.SetNoArena(
    &::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.default_string)
}
#endif
inline void TestAllTypes::set_default_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_string();
  default_string_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.default_string)
}
inline void TestAllTypes::set_default_string(const char* value, size_t size) {
  set_has_default_string();
  default_string_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.default_string)
}
inline ::std::string* TestAllTypes::mutable_default_string() {
  set_has_default_string();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.default_string)
  return default_string_.MutableNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get());
}
inline ::std::string* TestAllTypes::release_default_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.default_string)
  if (!has_default_string()) {
    return NULL;
  }
  clear_has_default_string();
  return default_string_.ReleaseNonDefaultNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get());
}
inline void TestAllTypes::set_allocated_default_string(::std::string* default_string) {
  if (default_string != NULL) {
    set_has_default_string();
  } else {
    clear_has_default_string();
  }
  default_string_.SetAllocatedNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_.get(), default_string);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.default_string)
}

// optional bytes default_bytes = 75 [default = "world"];
inline bool TestAllTypes::has_default_bytes() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TestAllTypes::set_has_default_bytes() {
  _has_bits_[0] |= 0x00000020u;
}
inline void TestAllTypes::clear_has_default_bytes() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void TestAllTypes::clear_default_bytes() {
  default_bytes_.ClearToDefaultNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get());
  clear_has_default_bytes();
}
inline const ::std::string& TestAllTypes::default_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_bytes)
  return default_bytes_.GetNoArena();
}
inline void TestAllTypes::set_default_bytes(const ::std::string& value) {
  set_has_default_bytes();
  default_bytes_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_bytes)
}
#if LANG_CXX11
inline void TestAllTypes::set_default_bytes(::std::string&& value) {
  set_has_default_bytes();
  default_bytes_.SetNoArena(
    &::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.default_bytes)
}
#endif
inline void TestAllTypes::set_default_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_bytes();
  default_bytes_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.default_bytes)
}
inline void TestAllTypes::set_default_bytes(const void* value, size_t size) {
  set_has_default_bytes();
  default_bytes_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.default_bytes)
}
inline ::std::string* TestAllTypes::mutable_default_bytes() {
  set_has_default_bytes();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.default_bytes)
  return default_bytes_.MutableNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get());
}
inline ::std::string* TestAllTypes::release_default_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.default_bytes)
  if (!has_default_bytes()) {
    return NULL;
  }
  clear_has_default_bytes();
  return default_bytes_.ReleaseNonDefaultNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get());
}
inline void TestAllTypes::set_allocated_default_bytes(::std::string* default_bytes) {
  if (default_bytes != NULL) {
    set_has_default_bytes();
  } else {
    clear_has_default_bytes();
  }
  default_bytes_.SetAllocatedNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_bytes_.get(), default_bytes);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.default_bytes)
}

// optional .protobuf_unittest_no_arena.TestAllTypes.NestedEnum default_nested_enum = 81 [default = BAR];
inline bool TestAllTypes::has_default_nested_enum() const {
  return (_has_bits_[1] & 0x00001000u) != 0;
}
inline void TestAllTypes::set_has_default_nested_enum() {
  _has_bits_[1] |= 0x00001000u;
}
inline void TestAllTypes::clear_has_default_nested_enum() {
  _has_bits_[1] &= ~0x00001000u;
}
inline void TestAllTypes::clear_default_nested_enum() {
  default_nested_enum_ = 2;
  clear_has_default_nested_enum();
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum TestAllTypes::default_nested_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_nested_enum)
  return static_cast< ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum >(default_nested_enum_);
}
inline void TestAllTypes::set_default_nested_enum(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum value) {
  assert(::protobuf_unittest_no_arena::TestAllTypes_NestedEnum_IsValid(value));
  set_has_default_nested_enum();
  default_nested_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_nested_enum)
}

// optional .protobuf_unittest_no_arena.ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR];
inline bool TestAllTypes::has_default_foreign_enum() const {
  return (_has_bits_[1] & 0x00002000u) != 0;
}
inline void TestAllTypes::set_has_default_foreign_enum() {
  _has_bits_[1] |= 0x00002000u;
}
inline void TestAllTypes::clear_has_default_foreign_enum() {
  _has_bits_[1] &= ~0x00002000u;
}
inline void TestAllTypes::clear_default_foreign_enum() {
  default_foreign_enum_ = 5;
  clear_has_default_foreign_enum();
}
inline ::protobuf_unittest_no_arena::ForeignEnum TestAllTypes::default_foreign_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_foreign_enum)
  return static_cast< ::protobuf_unittest_no_arena::ForeignEnum >(default_foreign_enum_);
}
inline void TestAllTypes::set_default_foreign_enum(::protobuf_unittest_no_arena::ForeignEnum value) {
  assert(::protobuf_unittest_no_arena::ForeignEnum_IsValid(value));
  set_has_default_foreign_enum();
  default_foreign_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_foreign_enum)
}

// optional .protobuf_unittest_import.ImportEnum default_import_enum = 83 [default = IMPORT_BAR];
inline bool TestAllTypes::has_default_import_enum() const {
  return (_has_bits_[0] & 0x08000000u) != 0;
}
inline void TestAllTypes::set_has_default_import_enum() {
  _has_bits_[0] |= 0x08000000u;
}
inline void TestAllTypes::clear_has_default_import_enum() {
  _has_bits_[0] &= ~0x08000000u;
}
inline void TestAllTypes::clear_default_import_enum() {
  default_import_enum_ = 8;
  clear_has_default_import_enum();
}
inline ::protobuf_unittest_import::ImportEnum TestAllTypes::default_import_enum() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_import_enum)
  return static_cast< ::protobuf_unittest_import::ImportEnum >(default_import_enum_);
}
inline void TestAllTypes::set_default_import_enum(::protobuf_unittest_import::ImportEnum value) {
  assert(::protobuf_unittest_import::ImportEnum_IsValid(value));
  set_has_default_import_enum();
  default_import_enum_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_import_enum)
}

// optional string default_string_piece = 84 [default = "abc", ctype = STRING_PIECE];
inline bool TestAllTypes::has_default_string_piece() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TestAllTypes::set_has_default_string_piece() {
  _has_bits_[0] |= 0x00000040u;
}
inline void TestAllTypes::clear_has_default_string_piece() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void TestAllTypes::clear_default_string_piece() {
  default_string_piece_.ClearToDefaultNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get());
  clear_has_default_string_piece();
}
inline const ::std::string& TestAllTypes::default_string_piece() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_string_piece)
  return default_string_piece_.GetNoArena();
}
inline void TestAllTypes::set_default_string_piece(const ::std::string& value) {
  set_has_default_string_piece();
  default_string_piece_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_string_piece)
}
#if LANG_CXX11
inline void TestAllTypes::set_default_string_piece(::std::string&& value) {
  set_has_default_string_piece();
  default_string_piece_.SetNoArena(
    &::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.default_string_piece)
}
#endif
inline void TestAllTypes::set_default_string_piece(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_string_piece();
  default_string_piece_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.default_string_piece)
}
inline void TestAllTypes::set_default_string_piece(const char* value, size_t size) {
  set_has_default_string_piece();
  default_string_piece_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.default_string_piece)
}
inline ::std::string* TestAllTypes::mutable_default_string_piece() {
  set_has_default_string_piece();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.default_string_piece)
  return default_string_piece_.MutableNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get());
}
inline ::std::string* TestAllTypes::release_default_string_piece() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.default_string_piece)
  if (!has_default_string_piece()) {
    return NULL;
  }
  clear_has_default_string_piece();
  return default_string_piece_.ReleaseNonDefaultNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get());
}
inline void TestAllTypes::set_allocated_default_string_piece(::std::string* default_string_piece) {
  if (default_string_piece != NULL) {
    set_has_default_string_piece();
  } else {
    clear_has_default_string_piece();
  }
  default_string_piece_.SetAllocatedNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_string_piece_.get(), default_string_piece);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.default_string_piece)
}

// optional string default_cord = 85 [default = "123", ctype = CORD];
inline bool TestAllTypes::has_default_cord() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TestAllTypes::set_has_default_cord() {
  _has_bits_[0] |= 0x00000080u;
}
inline void TestAllTypes::clear_has_default_cord() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void TestAllTypes::clear_default_cord() {
  default_cord_.ClearToDefaultNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get());
  clear_has_default_cord();
}
inline const ::std::string& TestAllTypes::default_cord() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.default_cord)
  return default_cord_.GetNoArena();
}
inline void TestAllTypes::set_default_cord(const ::std::string& value) {
  set_has_default_cord();
  default_cord_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.default_cord)
}
#if LANG_CXX11
inline void TestAllTypes::set_default_cord(::std::string&& value) {
  set_has_default_cord();
  default_cord_.SetNoArena(
    &::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.default_cord)
}
#endif
inline void TestAllTypes::set_default_cord(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_default_cord();
  default_cord_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.default_cord)
}
inline void TestAllTypes::set_default_cord(const char* value, size_t size) {
  set_has_default_cord();
  default_cord_.SetNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.default_cord)
}
inline ::std::string* TestAllTypes::mutable_default_cord() {
  set_has_default_cord();
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.default_cord)
  return default_cord_.MutableNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get());
}
inline ::std::string* TestAllTypes::release_default_cord() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.default_cord)
  if (!has_default_cord()) {
    return NULL;
  }
  clear_has_default_cord();
  return default_cord_.ReleaseNonDefaultNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get());
}
inline void TestAllTypes::set_allocated_default_cord(::std::string* default_cord) {
  if (default_cord != NULL) {
    set_has_default_cord();
  } else {
    clear_has_default_cord();
  }
  default_cord_.SetAllocatedNoArena(&::protobuf_unittest_no_arena::TestAllTypes::_i_give_permission_to_break_this_code_default_default_cord_.get(), default_cord);
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.default_cord)
}

// optional uint32 oneof_uint32 = 111;
inline bool TestAllTypes::has_oneof_uint32() const {
  return oneof_field_case() == kOneofUint32;
}
inline void TestAllTypes::set_has_oneof_uint32() {
  _oneof_case_[0] = kOneofUint32;
}
inline void TestAllTypes::clear_oneof_uint32() {
  if (has_oneof_uint32()) {
    oneof_field_.oneof_uint32_ = 0u;
    clear_has_oneof_field();
  }
}
inline ::google::protobuf::uint32 TestAllTypes::oneof_uint32() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.oneof_uint32)
  if (has_oneof_uint32()) {
    return oneof_field_.oneof_uint32_;
  }
  return 0u;
}
inline void TestAllTypes::set_oneof_uint32(::google::protobuf::uint32 value) {
  if (!has_oneof_uint32()) {
    clear_oneof_field();
    set_has_oneof_uint32();
  }
  oneof_field_.oneof_uint32_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.oneof_uint32)
}

// optional .protobuf_unittest_no_arena.TestAllTypes.NestedMessage oneof_nested_message = 112;
inline bool TestAllTypes::has_oneof_nested_message() const {
  return oneof_field_case() == kOneofNestedMessage;
}
inline void TestAllTypes::set_has_oneof_nested_message() {
  _oneof_case_[0] = kOneofNestedMessage;
}
inline void TestAllTypes::clear_oneof_nested_message() {
  if (has_oneof_nested_message()) {
    delete oneof_field_.oneof_nested_message_;
    clear_has_oneof_field();
  }
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::_internal_oneof_nested_message() const {
  return *oneof_field_.oneof_nested_message_;
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::release_oneof_nested_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.oneof_nested_message)
  if (has_oneof_nested_message()) {
    clear_has_oneof_field();
      ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* temp = oneof_field_.oneof_nested_message_;
    oneof_field_.oneof_nested_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::oneof_nested_message() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.oneof_nested_message)
  return has_oneof_nested_message()
      ? *oneof_field_.oneof_nested_message_
      : *reinterpret_cast< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage*>(&::protobuf_unittest_no_arena::_TestAllTypes_NestedMessage_default_instance_);
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::mutable_oneof_nested_message() {
  if (!has_oneof_nested_message()) {
    clear_oneof_field();
    set_has_oneof_nested_message();
    oneof_field_.oneof_nested_message_ = CreateMaybeMessage< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.oneof_nested_message)
  return oneof_field_.oneof_nested_message_;
}

// optional string oneof_string = 113;
inline bool TestAllTypes::has_oneof_string() const {
  return oneof_field_case() == kOneofString;
}
inline void TestAllTypes::set_has_oneof_string() {
  _oneof_case_[0] = kOneofString;
}
inline void TestAllTypes::clear_oneof_string() {
  if (has_oneof_string()) {
    oneof_field_.oneof_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_oneof_field();
  }
}
inline const ::std::string& TestAllTypes::oneof_string() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
  if (has_oneof_string()) {
    return oneof_field_.oneof_string_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestAllTypes::set_oneof_string(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
}
#if LANG_CXX11
inline void TestAllTypes::set_oneof_string(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
}
#endif
inline void TestAllTypes::set_oneof_string(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
}
inline void TestAllTypes::set_oneof_string(const char* value, size_t size) {
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
}
inline ::std::string* TestAllTypes::mutable_oneof_string() {
  if (!has_oneof_string()) {
    clear_oneof_field();
    set_has_oneof_string();
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
  return oneof_field_.oneof_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestAllTypes::release_oneof_string() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
  if (has_oneof_string()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void TestAllTypes::set_allocated_oneof_string(::std::string* oneof_string) {
  if (!has_oneof_string()) {
    oneof_field_.oneof_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_string != NULL) {
    set_has_oneof_string();
    oneof_field_.oneof_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_string);
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.oneof_string)
}

// optional bytes oneof_bytes = 114;
inline bool TestAllTypes::has_oneof_bytes() const {
  return oneof_field_case() == kOneofBytes;
}
inline void TestAllTypes::set_has_oneof_bytes() {
  _oneof_case_[0] = kOneofBytes;
}
inline void TestAllTypes::clear_oneof_bytes() {
  if (has_oneof_bytes()) {
    oneof_field_.oneof_bytes_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    clear_has_oneof_field();
  }
}
inline const ::std::string& TestAllTypes::oneof_bytes() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
  if (has_oneof_bytes()) {
    return oneof_field_.oneof_bytes_.GetNoArena();
  }
  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void TestAllTypes::set_oneof_bytes(const ::std::string& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
}
#if LANG_CXX11
inline void TestAllTypes::set_oneof_bytes(::std::string&& value) {
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
}
#endif
inline void TestAllTypes::set_oneof_bytes(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
}
inline void TestAllTypes::set_oneof_bytes(const void* value, size_t size) {
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  oneof_field_.oneof_bytes_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
}
inline ::std::string* TestAllTypes::mutable_oneof_bytes() {
  if (!has_oneof_bytes()) {
    clear_oneof_field();
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
  return oneof_field_.oneof_bytes_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TestAllTypes::release_oneof_bytes() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
  if (has_oneof_bytes()) {
    clear_has_oneof_field();
    return oneof_field_.oneof_bytes_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  } else {
    return NULL;
  }
}
inline void TestAllTypes::set_allocated_oneof_bytes(::std::string* oneof_bytes) {
  if (!has_oneof_bytes()) {
    oneof_field_.oneof_bytes_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  clear_oneof_field();
  if (oneof_bytes != NULL) {
    set_has_oneof_bytes();
    oneof_field_.oneof_bytes_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), oneof_bytes);
  }
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestAllTypes.oneof_bytes)
}

// optional .protobuf_unittest_no_arena.TestAllTypes.NestedMessage lazy_oneof_nested_message = 115 [lazy = true];
inline bool TestAllTypes::has_lazy_oneof_nested_message() const {
  return oneof_field_case() == kLazyOneofNestedMessage;
}
inline void TestAllTypes::set_has_lazy_oneof_nested_message() {
  _oneof_case_[0] = kLazyOneofNestedMessage;
}
inline void TestAllTypes::clear_lazy_oneof_nested_message() {
  if (has_lazy_oneof_nested_message()) {
    delete oneof_field_.lazy_oneof_nested_message_;
    clear_has_oneof_field();
  }
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::_internal_lazy_oneof_nested_message() const {
  return *oneof_field_.lazy_oneof_nested_message_;
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::release_lazy_oneof_nested_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestAllTypes.lazy_oneof_nested_message)
  if (has_lazy_oneof_nested_message()) {
    clear_has_oneof_field();
      ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* temp = oneof_field_.lazy_oneof_nested_message_;
    oneof_field_.lazy_oneof_nested_message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage& TestAllTypes::lazy_oneof_nested_message() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestAllTypes.lazy_oneof_nested_message)
  return has_lazy_oneof_nested_message()
      ? *oneof_field_.lazy_oneof_nested_message_
      : *reinterpret_cast< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage*>(&::protobuf_unittest_no_arena::_TestAllTypes_NestedMessage_default_instance_);
}
inline ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage* TestAllTypes::mutable_lazy_oneof_nested_message() {
  if (!has_lazy_oneof_nested_message()) {
    clear_oneof_field();
    set_has_lazy_oneof_nested_message();
    oneof_field_.lazy_oneof_nested_message_ = CreateMaybeMessage< ::protobuf_unittest_no_arena::TestAllTypes_NestedMessage >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestAllTypes.lazy_oneof_nested_message)
  return oneof_field_.lazy_oneof_nested_message_;
}

inline bool TestAllTypes::has_oneof_field() const {
  return oneof_field_case() != ONEOF_FIELD_NOT_SET;
}
inline void TestAllTypes::clear_has_oneof_field() {
  _oneof_case_[0] = ONEOF_FIELD_NOT_SET;
}
inline TestAllTypes::OneofFieldCase TestAllTypes::oneof_field_case() const {
  return TestAllTypes::OneofFieldCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ForeignMessage

// optional int32 c = 1;
inline bool ForeignMessage::has_c() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ForeignMessage::set_has_c() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ForeignMessage::clear_has_c() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ForeignMessage::clear_c() {
  c_ = 0;
  clear_has_c();
}
inline ::google::protobuf::int32 ForeignMessage::c() const {
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.ForeignMessage.c)
  return c_;
}
inline void ForeignMessage::set_c(::google::protobuf::int32 value) {
  set_has_c();
  c_ = value;
  // @@protoc_insertion_point(field_set:protobuf_unittest_no_arena.ForeignMessage.c)
}

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

// TestNoArenaMessage

// optional .proto2_arena_unittest.ArenaMessage arena_message = 1;
inline bool TestNoArenaMessage::has_arena_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TestNoArenaMessage::set_has_arena_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TestNoArenaMessage::clear_has_arena_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::proto2_arena_unittest::ArenaMessage& TestNoArenaMessage::_internal_arena_message() const {
  return *arena_message_;
}
inline const ::proto2_arena_unittest::ArenaMessage& TestNoArenaMessage::arena_message() const {
  const ::proto2_arena_unittest::ArenaMessage* p = arena_message_;
  // @@protoc_insertion_point(field_get:protobuf_unittest_no_arena.TestNoArenaMessage.arena_message)
  return p != NULL ? *p : *reinterpret_cast<const ::proto2_arena_unittest::ArenaMessage*>(
      &::proto2_arena_unittest::_ArenaMessage_default_instance_);
}
inline ::proto2_arena_unittest::ArenaMessage* TestNoArenaMessage::release_arena_message() {
  // @@protoc_insertion_point(field_release:protobuf_unittest_no_arena.TestNoArenaMessage.arena_message)
  clear_has_arena_message();
  ::proto2_arena_unittest::ArenaMessage* temp = arena_message_;
  arena_message_ = NULL;
  return temp;
}
inline ::proto2_arena_unittest::ArenaMessage* TestNoArenaMessage::mutable_arena_message() {
  set_has_arena_message();
  if (arena_message_ == NULL) {
    auto* p = CreateMaybeMessage<::proto2_arena_unittest::ArenaMessage>(GetArenaNoVirtual());
    arena_message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:protobuf_unittest_no_arena.TestNoArenaMessage.arena_message)
  return arena_message_;
}
inline void TestNoArenaMessage::set_allocated_arena_message(::proto2_arena_unittest::ArenaMessage* arena_message) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(arena_message_);
  }
  if (arena_message) {
    ::google::protobuf::Arena* submessage_arena =
      reinterpret_cast<::google::protobuf::MessageLite*>(arena_message)->GetArena();
    if (message_arena != submessage_arena) {
      arena_message = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, arena_message, submessage_arena);
    }
    set_has_arena_message();
  } else {
    clear_has_arena_message();
  }
  arena_message_ = arena_message;
  // @@protoc_insertion_point(field_set_allocated:protobuf_unittest_no_arena.TestNoArenaMessage.arena_message)
}

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace protobuf_unittest_no_arena

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum>() {
  return ::protobuf_unittest_no_arena::TestAllTypes_NestedEnum_descriptor();
}
template <> struct is_proto_enum< ::protobuf_unittest_no_arena::ForeignEnum> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest_no_arena::ForeignEnum>() {
  return ::protobuf_unittest_no_arena::ForeignEnum_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_5fno_5farena_2eproto
