// Generated by the protocol buffer compiler.  DO NOT EDIT!

// source: echo.proto

#ifndef PROTOBUF_INCLUDED_echo_2eproto

#define PROTOBUF_INCLUDED_echo_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/service.h>

#include <google/protobuf/unknown_field_set.h>

#include "idl_options.pb.h"

// @@protoc_insertion_point(includes)

#define PROTOBUF_INTERNAL_EXPORT_protobuf_echo_2eproto 

namespace protobuf_echo_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[11];

  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_echo_2eproto

namespace test {

class BytesRequest;

class BytesRequestDefaultTypeInternal;

extern BytesRequestDefaultTypeInternal _BytesRequest_default_instance_;

class BytesResponse;

class BytesResponseDefaultTypeInternal;

extern BytesResponseDefaultTypeInternal _BytesResponse_default_instance_;

class ComboRequest;

class ComboRequestDefaultTypeInternal;

extern ComboRequestDefaultTypeInternal _ComboRequest_default_instance_;

class ComboResponse;

class ComboResponseDefaultTypeInternal;

extern ComboResponseDefaultTypeInternal _ComboResponse_default_instance_;

class EchoRequest;

class EchoRequestDefaultTypeInternal;

extern EchoRequestDefaultTypeInternal _EchoRequest_default_instance_;

class EchoResponse;

class EchoResponseDefaultTypeInternal;

extern EchoResponseDefaultTypeInternal _EchoResponse_default_instance_;

class HttpRequest;

class HttpRequestDefaultTypeInternal;

extern HttpRequestDefaultTypeInternal _HttpRequest_default_instance_;

class HttpResponse;

class HttpResponseDefaultTypeInternal;

extern HttpResponseDefaultTypeInternal _HttpResponse_default_instance_;

class Message1;

class Message1DefaultTypeInternal;

extern Message1DefaultTypeInternal _Message1_default_instance_;

class Message2;

class Message2DefaultTypeInternal;

extern Message2DefaultTypeInternal _Message2_default_instance_;

class RecursiveMessage;

class RecursiveMessageDefaultTypeInternal;

extern RecursiveMessageDefaultTypeInternal _RecursiveMessage_default_instance_;

}  // namespace test

namespace google {

namespace protobuf {

template<> ::test::BytesRequest* Arena::CreateMaybeMessage<::test::BytesRequest>(Arena*);

template<> ::test::BytesResponse* Arena::CreateMaybeMessage<::test::BytesResponse>(Arena*);

template<> ::test::ComboRequest* Arena::CreateMaybeMessage<::test::ComboRequest>(Arena*);

template<> ::test::ComboResponse* Arena::CreateMaybeMessage<::test::ComboResponse>(Arena*);

template<> ::test::EchoRequest* Arena::CreateMaybeMessage<::test::EchoRequest>(Arena*);

template<> ::test::EchoResponse* Arena::CreateMaybeMessage<::test::EchoResponse>(Arena*);

template<> ::test::HttpRequest* Arena::CreateMaybeMessage<::test::HttpRequest>(Arena*);

template<> ::test::HttpResponse* Arena::CreateMaybeMessage<::test::HttpResponse>(Arena*);

template<> ::test::Message1* Arena::CreateMaybeMessage<::test::Message1>(Arena*);

template<> ::test::Message2* Arena::CreateMaybeMessage<::test::Message2>(Arena*);

template<> ::test::RecursiveMessage* Arena::CreateMaybeMessage<::test::RecursiveMessage>(Arena*);

}  // namespace protobuf

}  // namespace google

namespace test {

enum State0 {

  STATE0_NUM_0 = 0,

  STATE0_NUM_1 = 1,

  STATE0_NUM_2 = 2

};

bool State0_IsValid(int value);

const State0 State0_MIN = STATE0_NUM_0;

const State0 State0_MAX = STATE0_NUM_2;

const int State0_ARRAYSIZE = State0_MAX + 1;

const ::google::protobuf::EnumDescriptor* State0_descriptor();

inline const ::std::string& State0_Name(State0 value) {

  return ::google::protobuf::internal::NameOfEnum(

    State0_descriptor(), value);

}

inline bool State0_Parse(

    const ::std::string& name, State0* value) {

  return ::google::protobuf::internal::ParseNamedEnum<State0>(

    State0_descriptor(), name, value);

}

enum State1 {

  STATE1_NUM_0 = 0,

  STATE1_NUM_1 = 1

};

bool State1_IsValid(int value);

const State1 State1_MIN = STATE1_NUM_0;

const State1 State1_MAX = STATE1_NUM_1;

const int State1_ARRAYSIZE = State1_MAX + 1;

const ::google::protobuf::EnumDescriptor* State1_descriptor();

inline const ::std::string& State1_Name(State1 value) {

  return ::google::protobuf::internal::NameOfEnum(

    State1_descriptor(), value);

}

inline bool State1_Parse(

    const ::std::string& name, State1* value) {

  return ::google::protobuf::internal::ParseNamedEnum<State1>(

    State1_descriptor(), name, value);

}

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

class EchoRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:test.EchoRequest) */ {

 public:

  EchoRequest();

  virtual ~EchoRequest();

  EchoRequest(const EchoRequest& from);

  inline EchoRequest& operator=(const EchoRequest& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  EchoRequest(EchoRequest&& from) noexcept

    : EchoRequest() {

    *this = ::std::move(from);

  }

  inline EchoRequest& operator=(EchoRequest&& 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 EchoRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const EchoRequest* internal_default_instance() {

    return reinterpret_cast<const EchoRequest*>(

               &_EchoRequest_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    0;

  void Swap(EchoRequest* other);

  friend void swap(EchoRequest& a, EchoRequest& b) {

    a.Swap(&b);

  }

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

  inline EchoRequest* New() const final {

    return CreateMaybeMessage<EchoRequest>(NULL);

  }

  EchoRequest* New(::google::protobuf::Arena* arena) const final {

    return CreateMaybeMessage<EchoRequest>(arena);

  }

  void CopyFrom(const ::google::protobuf::Message& from) final;

  void MergeFrom(const ::google::protobuf::Message& from) final;

  void CopyFrom(const EchoRequest& from);

  void MergeFrom(const EchoRequest& 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(EchoRequest* 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 -------------------------------------------------------

  // required string message = 1;

  bool has_message() const;

  void clear_message();

  static const int kMessageFieldNumber = 1;

  const ::std::string& message() const;

  void set_message(const ::std::string& value);

  #if LANG_CXX11

  void set_message(::std::string&& value);

  #endif

  void set_message(const char* value);

  void set_message(const char* value, size_t size);

  ::std::string* mutable_message();

  ::std::string* release_message();

  void set_allocated_message(::std::string* message);

  // optional int32 code = 2;

  bool has_code() const;

  void clear_code();

  static const int kCodeFieldNumber = 2;

  ::google::protobuf::int32 code() const;

  void set_code(::google::protobuf::int32 value);

  // optional bool close_fd = 3;

  bool has_close_fd() const;

  void clear_close_fd();

  static const int kCloseFdFieldNumber = 3;

  bool close_fd() const;

  void set_close_fd(bool value);

  // optional int32 sleep_us = 4;

  bool has_sleep_us() const;

  void clear_sleep_us();

  static const int kSleepUsFieldNumber = 4;

  ::google::protobuf::int32 sleep_us() const;

  void set_sleep_us(::google::protobuf::int32 value);

  // optional int32 server_fail = 5;

  bool has_server_fail() const;

  void clear_server_fail();

  static const int kServerFailFieldNumber = 5;

  ::google::protobuf::int32 server_fail() const;

  void set_server_fail(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:test.EchoRequest)

 private:

  void set_has_message();

  void clear_has_message();

  void set_has_code();

  void clear_has_code();

  void set_has_close_fd();

  void clear_has_close_fd();

  void set_has_sleep_us();

  void clear_has_sleep_us();

  void set_has_server_fail();

  void clear_has_server_fail();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable ::google::protobuf::internal::CachedSize _cached_size_;

  ::google::protobuf::internal::ArenaStringPtr message_;

  ::google::protobuf::int32 code_;

  bool close_fd_;

  ::google::protobuf::int32 sleep_us_;

  ::google::protobuf::int32 server_fail_;

  friend struct ::protobuf_echo_2eproto::TableStruct;

};

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

class EchoResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:test.EchoResponse) */ {

 public:

  EchoResponse();

  virtual ~EchoResponse();

  EchoResponse(const EchoResponse& from);

  inline EchoResponse& operator=(const EchoResponse& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  EchoResponse(EchoResponse&& from) noexcept

    : EchoResponse() {

    *this = ::std::move(from);

  }

  inline EchoResponse& operator=(EchoResponse&& 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 EchoResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const EchoResponse* internal_default_instance() {

    return reinterpret_cast<const EchoResponse*>(

               &_EchoResponse_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    1;

  void Swap(EchoResponse* other);

  friend void swap(EchoResponse& a, EchoResponse& b) {

    a.Swap(&b);

  }

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

  inline EchoResponse* New() const final {

    return CreateMaybeMessage<EchoResponse>(NULL);

  }

  EchoResponse* New(::google::protobuf::Arena* arena) const final {

    return CreateMaybeMessage<EchoResponse>(arena);

  }

  void CopyFrom(const ::google::protobuf::Message& from) final;

  void MergeFrom(const ::google::protobuf::Message& from) final;

  void CopyFrom(const EchoResponse& from);

  void MergeFrom(const EchoResponse& 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(EchoResponse* other);

  private:

  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {

    return NULL;

  }

  inline void* MaybeArenaPtr() const {

    return NULL;

  }

  public:

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

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

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

  // repeated int32 code_list = 2;

  int code_list_size() const;

  void clear_code_list();

  static const int kCodeListFieldNumber = 2;

  ::google::protobuf::int32 code_list(int index) const;

  void set_code_list(int index, ::google::protobuf::int32 value);

  void add_code_list(::google::protobuf::int32 value);

  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&

      code_list() const;

  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*

      mutable_code_list();

  // required string message = 1;

  bool has_message() const;

  void clear_message();

  static const int kMessageFieldNumber = 1;

  const ::std::string& message() const;

  void set_message(const ::std::string& value);

  #if LANG_CXX11

  void set_message(::std::string&& value);

  #endif

  void set_message(const char* value);

  void set_message(const char* value, size_t size);

  ::std::string* mutable_message();

  ::std::string* release_message();

  void set_allocated_message(::std::string* message);

  // optional uint64 receiving_socket_id = 3;

  bool has_receiving_socket_id() const;

  void clear_receiving_socket_id();

  static const int kReceivingSocketIdFieldNumber = 3;

  ::google::protobuf::uint64 receiving_socket_id() const;

  void set_receiving_socket_id(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:test.EchoResponse)

 private:

  void set_has_message();

  void clear_has_message();

  void set_has_receiving_socket_id();

  void clear_has_receiving_socket_id();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable ::google::protobuf::internal::CachedSize _cached_size_;

  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > code_list_;

  ::google::protobuf::internal::ArenaStringPtr message_;

  ::google::protobuf::uint64 receiving_socket_id_;

  friend struct ::protobuf_echo_2eproto::TableStruct;

};

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

class ComboRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:test.ComboRequest) */ {

 public:

  ComboRequest();

  virtual ~ComboRequest();

  ComboRequest(const ComboRequest& from);

  inline ComboRequest& operator=(const ComboRequest& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  ComboRequest(ComboRequest&& from) noexcept

    : ComboRequest() {

    *this = ::std::move(from);

  }

  inline ComboRequest& operator=(ComboRequest&& 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 ComboRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const ComboRequest* internal_default_instance() {

    return reinterpret_cast<const ComboRequest*>(

               &_ComboRequest_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    2;

  void Swap(ComboRequest* other);

  friend void swap(ComboRequest& a, ComboRequest& b) {

    a.Swap(&b);

  }

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

  inline ComboRequest* New() const final {

    return CreateMaybeMessage<ComboRequest>(NULL);

  }

  ComboRequest* New(::google::protobuf::Arena* arena) const final {

    return CreateMaybeMessage<ComboRequest>(arena);

  }

  void CopyFrom(const ::google::protobuf::Message& from) final;

  void MergeFrom(const ::google::protobuf::Message& from) final;

  void CopyFrom(const ComboRequest& from);

  void MergeFrom(const ComboRequest& 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(ComboRequest* other);

  private:

  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {

    return NULL;

  }

  inline void* MaybeArenaPtr() const {

    return NULL;

  }

  public:

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

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

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

  // repeated .test.EchoRequest requests = 1;

  int requests_size() const;

  void clear_requests();

  static const int kRequestsFieldNumber = 1;

  ::test::EchoRequest* mutable_requests(int index);

  ::google::protobuf::RepeatedPtrField< ::test::EchoRequest >*

      mutable_requests();

  const ::test::EchoRequest& requests(int index) const;

  ::test::EchoRequest* add_requests();

  const ::google::protobuf::RepeatedPtrField< ::test::EchoRequest >&

      requests() const;

  // @@protoc_insertion_point(class_scope:test.ComboRequest)

 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable ::google::protobuf::internal::CachedSize _cached_size_;

  ::google::protobuf::RepeatedPtrField< ::test::EchoRequest > requests_;

  friend struct ::protobuf_echo_2eproto::TableStruct;

};

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

class BytesRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:test.BytesRequest) */ {

 public:

  BytesRequest();

  virtual ~BytesRequest();

  BytesRequest(const BytesRequest& from);

  inline BytesRequest& operator=(const BytesRequest& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  BytesRequest(BytesRequest&& from) noexcept

    : BytesRequest() {

    *this = ::std::move(from);

  }

  inline BytesRequest& operator=(BytesRequest&& 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 BytesRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const BytesRequest* internal_default_instance() {

    return reinterpret_cast<const BytesRequest*>(

               &_BytesRequest_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    3;

  void Swap(BytesRequest* other);

  friend void swap(BytesRequest& a, BytesRequest& b) {

    a.Swap(&b);

  }

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

  inline BytesRequest* New() const final {

    return CreateMaybeMessage<BytesRequest>(NULL);

  }

  BytesRequest* New(::google::protobuf::Arena* arena) const final {

    return CreateMaybeMessage<BytesRequest>(arena);

  }

  void CopyFrom(const ::google::protobuf::Message& from) final;

  void MergeFrom(const ::google::protobuf::Message& from) final;

  void CopyFrom(const BytesRequest& from);

  void MergeFrom(const BytesRequest& 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(BytesRequest* 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 -------------------------------------------------------

  // required bytes databytes = 1;

  bool has_databytes() const;

  void clear_databytes();

  static const int kDatabytesFieldNumber = 1;

  const ::std::string& databytes() const;

  void set_databytes(const ::std::string& value);

  #if LANG_CXX11

  void set_databytes(::std::string&& value);

  #endif

  void set_databytes(const char* value);

  void set_databytes(const void* value, size_t size);

  ::std::string* mutable_databytes();

  ::std::string* release_databytes();

  void set_allocated_databytes(::std::string* databytes);

  // @@protoc_insertion_point(class_scope:test.BytesRequest)

 private:

  void set_has_databytes();

  void clear_has_databytes();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable ::google::protobuf::internal::CachedSize _cached_size_;

  ::google::protobuf::internal::ArenaStringPtr databytes_;

  friend struct ::protobuf_echo_2eproto::TableStruct;

};

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

class BytesResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:test.BytesResponse) */ {

 public:

  BytesResponse();

  virtual ~BytesResponse();

  BytesResponse(const BytesResponse& from);

  inline BytesResponse& operator=(const BytesResponse& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  BytesResponse(BytesResponse&& from) noexcept

    : BytesResponse() {

    *this = ::std::move(from);

  }

  inline BytesResponse& operator=(BytesResponse&& 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 BytesResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const BytesResponse* internal_default_instance() {

    return reinterpret_cast<const BytesResponse*>(

               &_BytesResponse_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    4;

  void Swap(BytesResponse* other);

  friend void swap(BytesResponse& a, BytesResponse& b) {

    a.Swap(&b);

  }

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

  inline BytesResponse* New() const final {

    return CreateMaybeMessage<BytesResponse>(NULL);

  }

  BytesResponse* New(::google::protobuf::Arena* arena) const final {

    return CreateMaybeMessage<BytesResponse>(arena);

  }

  void CopyFrom(const ::google::protobuf::Message& from) final;

  void MergeFrom(const ::google::protobuf::Message& from) final;

  void CopyFrom(const BytesResponse& from);

  void MergeFrom(const BytesResponse& 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(BytesResponse* 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 -------------------------------------------------------

  // required bytes databytes = 1;

  bool has_databytes() const;

  void clear_databytes();

  static const int kDatabytesFieldNumber = 1;

  const ::std::string& databytes() const;

  void set_databytes(const ::std::string& value);

  #if LANG_CXX11

  void set_databytes(::std::string&& value);

  #endif

  void set_databytes(const char* value);

  void set_databytes(const void* value, size_t size);

  ::std::string* mutable_databytes();

  ::std::string* release_databytes();

  void set_allocated_databytes(::std::string* databytes);

  // @@protoc_insertion_point(class_scope:test.BytesResponse)

 private:

  void set_has_databytes();

  void clear_has_databytes();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable ::google::protobuf::internal::CachedSize _cached_size_;

  ::google::protobuf::internal::ArenaStringPtr databytes_;

  friend struct ::protobuf_echo_2eproto::TableStruct;

};

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

class ComboResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:test.ComboResponse) */ {

 public:

  ComboResponse();

  virtual ~ComboResponse();

  ComboResponse(const ComboResponse& from);

  inline ComboResponse& operator=(const ComboResponse& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  ComboResponse(ComboResponse&& from) noexcept

    : ComboResponse() {

    *this = ::std::move(from);

  }

  inline ComboResponse& operator=(ComboResponse&& 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 ComboResponse& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const ComboResponse* internal_default_instance() {

    return reinterpret_cast<const ComboResponse*>(

               &_ComboResponse_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    5;

  void Swap(ComboResponse* other);

  friend void swap(ComboResponse& a, ComboResponse& b) {

    a.Swap(&b);

  }

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

  inline ComboResponse* New() const final {

    return CreateMaybeMessage<ComboResponse>(NULL);

  }

  ComboResponse* New(::google::protobuf::Arena* arena) const final {

    return CreateMaybeMessage<ComboResponse>(arena);

  }

  void CopyFrom(const ::google::protobuf::Message& from) final;

  void MergeFrom(const ::google::protobuf::Message& from) final;

  void CopyFrom(const ComboResponse& from);

  void MergeFrom(const ComboResponse& 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(ComboResponse* other);

  private:

  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {

    return NULL;

  }

  inline void* MaybeArenaPtr() const {

    return NULL;

  }

  public:

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

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

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

  // repeated .test.EchoResponse responses = 1;

  int responses_size() const;

  void clear_responses();

  static const int kResponsesFieldNumber = 1;

  ::test::EchoResponse* mutable_responses(int index);

  ::google::protobuf::RepeatedPtrField< ::test::EchoResponse >*

      mutable_responses();

  const ::test::EchoResponse& responses(int index) const;

  ::test::EchoResponse* add_responses();

  const ::google::protobuf::RepeatedPtrField< ::test::EchoResponse >&

      responses() const;

  // @@protoc_insertion_point(class_scope:test.ComboResponse)

 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable ::google::protobuf::internal::CachedSize _cached_size_;

  ::google::protobuf::RepeatedPtrField< ::test::EchoResponse > responses_;

  friend struct ::protobuf_echo_2eproto::TableStruct;

};

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

class HttpRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:test.HttpRequest) */ {

 public:

  HttpRequest();

  virtual ~HttpRequest();

  HttpRequest(const HttpRequest& from);

  inline HttpRequest& operator=(const HttpRequest& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  HttpRequest(HttpRequest&& from) noexcept

    : HttpRequest() {

    *this = ::std::move(from);

  }

  inline HttpRequest& operator=(HttpRequest&& 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 HttpRequest& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY

  static inline const HttpRequest* internal_default_instance() {

    return reinterpret_cast<const HttpRequest*>(

               &_HttpRequest_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    6;

  void Swap(HttpRequest* other);

  friend void swap(HttpRequest& a, HttpRequest& b) {

    a.Swap(&b);

  }

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

  inline HttpRequest* New() const final {

    return CreateMaybeMessage<HttpRequest>(NULL);

  }

  HttpRequest* New(::google::protobuf::Arena* arena) const final {

    return CreateMaybeMessage<HttpRequest>(arena);

  }

  void CopyFrom(const ::google::protobuf::Message& from) final;

  void MergeFrom(const ::google::protobuf::Message& from) final;

  void CopyFrom(const HttpRequest& from);

  void MergeFrom(const HttpRequest& 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(HttpRequest* 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 -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:test.HttpRequest)

 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;

  ::google::protobuf::internal::HasBits<1> _has_bits_;

  mutable ::google::protobuf::internal::CachedSize _cached_size_;

  friend struct ::protobuf_echo_2eproto::TableStruct;

};

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

class HttpResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:test.HttpResponse) */ {

 public:

  HttpResponse();

  virtual ~HttpResponse();

  HttpResponse(const HttpResponse& from);

  inline HttpResponse& operator=(const HttpResponse& from) {

    CopyFrom(from);

    return *this;

  }

  #if LANG_CXX11

  HttpResponse(HttpResponse&& from) noexcept

    : HttpResponse() {

    *this = ::std::move(from);

  }