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

#ifndef GOOGLE_PROTOBUF_INCLUDED_dnstap_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_dnstap_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3008000
#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 3008000 < 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/port_undef.inc>
#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/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_dnstap_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_dnstap_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_dnstap_2eproto;
namespace dnstap {
class Dnstap;
class DnstapDefaultTypeInternal;
extern DnstapDefaultTypeInternal _Dnstap_default_instance_;
class Message;
class MessageDefaultTypeInternal;
extern MessageDefaultTypeInternal _Message_default_instance_;
}  // namespace dnstap
PROTOBUF_NAMESPACE_OPEN
template<> ::dnstap::Dnstap* Arena::CreateMaybeMessage<::dnstap::Dnstap>(Arena*);
template<> ::dnstap::Message* Arena::CreateMaybeMessage<::dnstap::Message>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace dnstap {

enum Dnstap_Type : int {
  Dnstap_Type_MESSAGE = 1
};
bool Dnstap_Type_IsValid(int value);
constexpr Dnstap_Type Dnstap_Type_Type_MIN = Dnstap_Type_MESSAGE;
constexpr Dnstap_Type Dnstap_Type_Type_MAX = Dnstap_Type_MESSAGE;
constexpr int Dnstap_Type_Type_ARRAYSIZE = Dnstap_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Dnstap_Type_descriptor();
template<typename T>
inline const std::string& Dnstap_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Dnstap_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Dnstap_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Dnstap_Type_descriptor(), enum_t_value);
}
inline bool Dnstap_Type_Parse(
    const std::string& name, Dnstap_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Dnstap_Type>(
    Dnstap_Type_descriptor(), name, value);
}
enum Message_Type : int {
  Message_Type_AUTH_QUERY = 1,
  Message_Type_AUTH_RESPONSE = 2,
  Message_Type_RESOLVER_QUERY = 3,
  Message_Type_RESOLVER_RESPONSE = 4,
  Message_Type_CLIENT_QUERY = 5,
  Message_Type_CLIENT_RESPONSE = 6,
  Message_Type_FORWARDER_QUERY = 7,
  Message_Type_FORWARDER_RESPONSE = 8,
  Message_Type_STUB_QUERY = 9,
  Message_Type_STUB_RESPONSE = 10,
  Message_Type_TOOL_QUERY = 11,
  Message_Type_TOOL_RESPONSE = 12
};
bool Message_Type_IsValid(int value);
constexpr Message_Type Message_Type_Type_MIN = Message_Type_AUTH_QUERY;
constexpr Message_Type Message_Type_Type_MAX = Message_Type_TOOL_RESPONSE;
constexpr int Message_Type_Type_ARRAYSIZE = Message_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Message_Type_descriptor();
template<typename T>
inline const std::string& Message_Type_Name(T enum_t_value) {
  static_assert(::std::is_same<T, Message_Type>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function Message_Type_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    Message_Type_descriptor(), enum_t_value);
}
inline bool Message_Type_Parse(
    const std::string& name, Message_Type* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Message_Type>(
    Message_Type_descriptor(), name, value);
}
enum SocketFamily : int {
  INET = 1,
  INET6 = 2
};
bool SocketFamily_IsValid(int value);
constexpr SocketFamily SocketFamily_MIN = INET;
constexpr SocketFamily SocketFamily_MAX = INET6;
constexpr int SocketFamily_ARRAYSIZE = SocketFamily_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SocketFamily_descriptor();
template<typename T>
inline const std::string& SocketFamily_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SocketFamily>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SocketFamily_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SocketFamily_descriptor(), enum_t_value);
}
inline bool SocketFamily_Parse(
    const std::string& name, SocketFamily* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SocketFamily>(
    SocketFamily_descriptor(), name, value);
}
enum SocketProtocol : int {
  UDP = 1,
  TCP = 2
};
bool SocketProtocol_IsValid(int value);
constexpr SocketProtocol SocketProtocol_MIN = UDP;
constexpr SocketProtocol SocketProtocol_MAX = TCP;
constexpr int SocketProtocol_ARRAYSIZE = SocketProtocol_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SocketProtocol_descriptor();
template<typename T>
inline const std::string& SocketProtocol_Name(T enum_t_value) {
  static_assert(::std::is_same<T, SocketProtocol>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function SocketProtocol_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    SocketProtocol_descriptor(), enum_t_value);
}
inline bool SocketProtocol_Parse(
    const std::string& name, SocketProtocol* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SocketProtocol>(
    SocketProtocol_descriptor(), name, value);
}
// ===================================================================

class Dnstap :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:dnstap.Dnstap) */ {
 public:
  Dnstap();
  virtual ~Dnstap();

  Dnstap(const Dnstap& from);
  Dnstap(Dnstap&& from) noexcept
    : Dnstap() {
    *this = ::std::move(from);
  }

  inline Dnstap& operator=(const Dnstap& from) {
    CopyFrom(from);
    return *this;
  }
  inline Dnstap& operator=(Dnstap&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Dnstap& default_instance();

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

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

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

  inline Dnstap* New() const final {
    return CreateMaybeMessage<Dnstap>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Dnstap* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "dnstap.Dnstap";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_dnstap_2eproto);
    return ::descriptor_table_dnstap_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef Dnstap_Type Type;
  static constexpr Type MESSAGE =
    Dnstap_Type_MESSAGE;
  static inline bool Type_IsValid(int value) {
    return Dnstap_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Dnstap_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Dnstap_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Dnstap_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Dnstap_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return Dnstap_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(const std::string& name,
      Type* value) {
    return Dnstap_Type_Parse(name, value);
  }

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

  // optional bytes identity = 1;
  bool has_identity() const;
  void clear_identity();
  static const int kIdentityFieldNumber = 1;
  const std::string& identity() const;
  void set_identity(const std::string& value);
  void set_identity(std::string&& value);
  void set_identity(const char* value);
  void set_identity(const void* value, size_t size);
  std::string* mutable_identity();
  std::string* release_identity();
  void set_allocated_identity(std::string* identity);

  // optional bytes version = 2;
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 2;
  const std::string& version() const;
  void set_version(const std::string& value);
  void set_version(std::string&& value);
  void set_version(const char* value);
  void set_version(const void* value, size_t size);
  std::string* mutable_version();
  std::string* release_version();
  void set_allocated_version(std::string* version);

  // optional bytes extra = 3;
  bool has_extra() const;
  void clear_extra();
  static const int kExtraFieldNumber = 3;
  const std::string& extra() const;
  void set_extra(const std::string& value);
  void set_extra(std::string&& value);
  void set_extra(const char* value);
  void set_extra(const void* value, size_t size);
  std::string* mutable_extra();
  std::string* release_extra();
  void set_allocated_extra(std::string* extra);

  // optional .dnstap.Message message = 14;
  bool has_message() const;
  void clear_message();
  static const int kMessageFieldNumber = 14;
  const ::dnstap::Message& message() const;
  ::dnstap::Message* release_message();
  ::dnstap::Message* mutable_message();
  void set_allocated_message(::dnstap::Message* message);

  // required .dnstap.Dnstap.Type type = 15;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 15;
  ::dnstap::Dnstap_Type type() const;
  void set_type(::dnstap::Dnstap_Type value);

  // @@protoc_insertion_point(class_scope:dnstap.Dnstap)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identity_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extra_;
  ::dnstap::Message* message_;
  int type_;
  friend struct ::TableStruct_dnstap_2eproto;
};
// -------------------------------------------------------------------

class Message :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:dnstap.Message) */ {
 public:
  Message();
  virtual ~Message();

  Message(const Message& from);
  Message(Message&& from) noexcept
    : Message() {
    *this = ::std::move(from);
  }

  inline Message& operator=(const Message& from) {
    CopyFrom(from);
    return *this;
  }
  inline Message& operator=(Message&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Message& default_instance();

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

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

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

  inline Message* New() const final {
    return CreateMaybeMessage<Message>(nullptr);
  }

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

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Message* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "dnstap.Message";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_dnstap_2eproto);
    return ::descriptor_table_dnstap_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

  typedef Message_Type Type;
  static constexpr Type AUTH_QUERY =
    Message_Type_AUTH_QUERY;
  static constexpr Type AUTH_RESPONSE =
    Message_Type_AUTH_RESPONSE;
  static constexpr Type RESOLVER_QUERY =
    Message_Type_RESOLVER_QUERY;
  static constexpr Type RESOLVER_RESPONSE =
    Message_Type_RESOLVER_RESPONSE;
  static constexpr Type CLIENT_QUERY =
    Message_Type_CLIENT_QUERY;
  static constexpr Type CLIENT_RESPONSE =
    Message_Type_CLIENT_RESPONSE;
  static constexpr Type FORWARDER_QUERY =
    Message_Type_FORWARDER_QUERY;
  static constexpr Type FORWARDER_RESPONSE =
    Message_Type_FORWARDER_RESPONSE;
  static constexpr Type STUB_QUERY =
    Message_Type_STUB_QUERY;
  static constexpr Type STUB_RESPONSE =
    Message_Type_STUB_RESPONSE;
  static constexpr Type TOOL_QUERY =
    Message_Type_TOOL_QUERY;
  static constexpr Type TOOL_RESPONSE =
    Message_Type_TOOL_RESPONSE;
  static inline bool Type_IsValid(int value) {
    return Message_Type_IsValid(value);
  }
  static constexpr Type Type_MIN =
    Message_Type_Type_MIN;
  static constexpr Type Type_MAX =
    Message_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE =
    Message_Type_Type_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Type_descriptor() {
    return Message_Type_descriptor();
  }
  template<typename T>
  static inline const std::string& Type_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Type>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Type_Name.");
    return Message_Type_Name(enum_t_value);
  }
  static inline bool Type_Parse(const std::string& name,
      Type* value) {
    return Message_Type_Parse(name, value);
  }

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

  // optional bytes query_address = 4;
  bool has_query_address() const;
  void clear_query_address();
  static const int kQueryAddressFieldNumber = 4;
  const std::string& query_address() const;
  void set_query_address(const std::string& value);
  void set_query_address(std::string&& value);
  void set_query_address(const char* value);
  void set_query_address(const void* value, size_t size);
  std::string* mutable_query_address();
  std::string* release_query_address();
  void set_allocated_query_address(std::string* query_address);

  // optional bytes response_address = 5;
  bool has_response_address() const;
  void clear_response_address();
  static const int kResponseAddressFieldNumber = 5;
  const std::string& response_address() const;
  void set_response_address(const std::string& value);
  void set_response_address(std::string&& value);
  void set_response_address(const char* value);
  void set_response_address(const void* value, size_t size);
  std::string* mutable_response_address();
  std::string* release_response_address();
  void set_allocated_response_address(std::string* response_address);

  // optional bytes query_message = 10;
  bool has_query_message() const;
  void clear_query_message();
  static const int kQueryMessageFieldNumber = 10;
  const std::string& query_message() const;
  void set_query_message(const std::string& value);
  void set_query_message(std::string&& value);
  void set_query_message(const char* value);
  void set_query_message(const void* value, size_t size);
  std::string* mutable_query_message();
  std::string* release_query_message();
  void set_allocated_query_message(std::string* query_message);

  // optional bytes query_zone = 11;
  bool has_query_zone() const;
  void clear_query_zone();
  static const int kQueryZoneFieldNumber = 11;
  const std::string& query_zone() const;
  void set_query_zone(const std::string& value);
  void set_query_zone(std::string&& value);
  void set_query_zone(const char* value);
  void set_query_zone(const void* value, size_t size);
  std::string* mutable_query_zone();
  std::string* release_query_zone();
  void set_allocated_query_zone(std::string* query_zone);

  // optional bytes response_message = 14;
  bool has_response_message() const;
  void clear_response_message();
  static const int kResponseMessageFieldNumber = 14;
  const std::string& response_message() const;
  void set_response_message(const std::string& value);
  void set_response_message(std::string&& value);
  void set_response_message(const char* value);
  void set_response_message(const void* value, size_t size);
  std::string* mutable_response_message();
  std::string* release_response_message();
  void set_allocated_response_message(std::string* response_message);

  // optional uint32 query_port = 6;
  bool has_query_port() const;
  void clear_query_port();
  static const int kQueryPortFieldNumber = 6;
  ::PROTOBUF_NAMESPACE_ID::uint32 query_port() const;
  void set_query_port(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 response_port = 7;
  bool has_response_port() const;
  void clear_response_port();
  static const int kResponsePortFieldNumber = 7;
  ::PROTOBUF_NAMESPACE_ID::uint32 response_port() const;
  void set_response_port(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint64 query_time_sec = 8;
  bool has_query_time_sec() const;
  void clear_query_time_sec();
  static const int kQueryTimeSecFieldNumber = 8;
  ::PROTOBUF_NAMESPACE_ID::uint64 query_time_sec() const;
  void set_query_time_sec(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional fixed32 query_time_nsec = 9;
  bool has_query_time_nsec() const;
  void clear_query_time_nsec();
  static const int kQueryTimeNsecFieldNumber = 9;
  ::PROTOBUF_NAMESPACE_ID::uint32 query_time_nsec() const;
  void set_query_time_nsec(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional fixed32 response_time_nsec = 13;
  bool has_response_time_nsec() const;
  void clear_response_time_nsec();
  static const int kResponseTimeNsecFieldNumber = 13;
  ::PROTOBUF_NAMESPACE_ID::uint32 response_time_nsec() const;
  void set_response_time_nsec(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint64 response_time_sec = 12;
  bool has_response_time_sec() const;
  void clear_response_time_sec();
  static const int kResponseTimeSecFieldNumber = 12;
  ::PROTOBUF_NAMESPACE_ID::uint64 response_time_sec() const;
  void set_response_time_sec(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional .dnstap.SocketProtocol socket_protocol = 3;
  bool has_socket_protocol() const;
  void clear_socket_protocol();
  static const int kSocketProtocolFieldNumber = 3;
  ::dnstap::SocketProtocol socket_protocol() const;
  void set_socket_protocol(::dnstap::SocketProtocol value);

  // required .dnstap.Message.Type type = 1;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::dnstap::Message_Type type() const;
  void set_type(::dnstap::Message_Type value);

  // optional .dnstap.SocketFamily socket_family = 2;
  bool has_socket_family() const;
  void clear_socket_family();
  static const int kSocketFamilyFieldNumber = 2;
  ::dnstap::SocketFamily socket_family() const;
  void set_socket_family(::dnstap::SocketFamily value);

  // @@protoc_insertion_point(class_scope:dnstap.Message)
 private:
  class HasBitSetters;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr query_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr query_message_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr query_zone_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_message_;
  ::PROTOBUF_NAMESPACE_ID::uint32 query_port_;
  ::PROTOBUF_NAMESPACE_ID::uint32 response_port_;
  ::PROTOBUF_NAMESPACE_ID::uint64 query_time_sec_;
  ::PROTOBUF_NAMESPACE_ID::uint32 query_time_nsec_;
  ::PROTOBUF_NAMESPACE_ID::uint32 response_time_nsec_;
  ::PROTOBUF_NAMESPACE_ID::uint64 response_time_sec_;
  int socket_protocol_;
  int type_;
  int socket_family_;
  friend struct ::TableStruct_dnstap_2eproto;
};
// ===================================================================


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

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

// optional bytes identity = 1;
inline bool Dnstap::has_identity() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Dnstap::clear_identity() {
  identity_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Dnstap::identity() const {
  // @@protoc_insertion_point(field_get:dnstap.Dnstap.identity)
  return identity_.GetNoArena();
}
inline void Dnstap::set_identity(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  identity_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dnstap.Dnstap.identity)
}
inline void Dnstap::set_identity(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  identity_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dnstap.Dnstap.identity)
}
inline void Dnstap::set_identity(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  identity_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dnstap.Dnstap.identity)
}
inline void Dnstap::set_identity(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  identity_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dnstap.Dnstap.identity)
}
inline std::string* Dnstap::mutable_identity() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:dnstap.Dnstap.identity)
  return identity_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Dnstap::release_identity() {
  // @@protoc_insertion_point(field_release:dnstap.Dnstap.identity)
  if (!has_identity()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return identity_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Dnstap::set_allocated_identity(std::string* identity) {
  if (identity != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  identity_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), identity);
  // @@protoc_insertion_point(field_set_allocated:dnstap.Dnstap.identity)
}

// optional bytes version = 2;
inline bool Dnstap::has_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Dnstap::clear_version() {
  version_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Dnstap::version() const {
  // @@protoc_insertion_point(field_get:dnstap.Dnstap.version)
  return version_.GetNoArena();
}
inline void Dnstap::set_version(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dnstap.Dnstap.version)
}
inline void Dnstap::set_version(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  version_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dnstap.Dnstap.version)
}
inline void Dnstap::set_version(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dnstap.Dnstap.version)
}
inline void Dnstap::set_version(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  version_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dnstap.Dnstap.version)
}
inline std::string* Dnstap::mutable_version() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:dnstap.Dnstap.version)
  return version_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Dnstap::release_version() {
  // @@protoc_insertion_point(field_release:dnstap.Dnstap.version)
  if (!has_version()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return version_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Dnstap::set_allocated_version(std::string* version) {
  if (version != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  version_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version);
  // @@protoc_insertion_point(field_set_allocated:dnstap.Dnstap.version)
}

// optional bytes extra = 3;
inline bool Dnstap::has_extra() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Dnstap::clear_extra() {
  extra_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Dnstap::extra() const {
  // @@protoc_insertion_point(field_get:dnstap.Dnstap.extra)
  return extra_.GetNoArena();
}
inline void Dnstap::set_extra(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  extra_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dnstap.Dnstap.extra)
}
inline void Dnstap::set_extra(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  extra_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dnstap.Dnstap.extra)
}
inline void Dnstap::set_extra(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  extra_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dnstap.Dnstap.extra)
}
inline void Dnstap::set_extra(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000004u;
  extra_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dnstap.Dnstap.extra)
}
inline std::string* Dnstap::mutable_extra() {
  _has_bits_[0] |= 0x00000004u;
  // @@protoc_insertion_point(field_mutable:dnstap.Dnstap.extra)
  return extra_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Dnstap::release_extra() {
  // @@protoc_insertion_point(field_release:dnstap.Dnstap.extra)
  if (!has_extra()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return extra_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Dnstap::set_allocated_extra(std::string* extra) {
  if (extra != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  extra_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), extra);
  // @@protoc_insertion_point(field_set_allocated:dnstap.Dnstap.extra)
}

// required .dnstap.Dnstap.Type type = 15;
inline bool Dnstap::has_type() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Dnstap::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::dnstap::Dnstap_Type Dnstap::type() const {
  // @@protoc_insertion_point(field_get:dnstap.Dnstap.type)
  return static_cast< ::dnstap::Dnstap_Type >(type_);
}
inline void Dnstap::set_type(::dnstap::Dnstap_Type value) {
  assert(::dnstap::Dnstap_Type_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  type_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Dnstap.type)
}

// optional .dnstap.Message message = 14;
inline bool Dnstap::has_message() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Dnstap::clear_message() {
  if (message_ != nullptr) message_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::dnstap::Message& Dnstap::message() const {
  const ::dnstap::Message* p = message_;
  // @@protoc_insertion_point(field_get:dnstap.Dnstap.message)
  return p != nullptr ? *p : *reinterpret_cast<const ::dnstap::Message*>(
      &::dnstap::_Message_default_instance_);
}
inline ::dnstap::Message* Dnstap::release_message() {
  // @@protoc_insertion_point(field_release:dnstap.Dnstap.message)
  _has_bits_[0] &= ~0x00000008u;
  ::dnstap::Message* temp = message_;
  message_ = nullptr;
  return temp;
}
inline ::dnstap::Message* Dnstap::mutable_message() {
  _has_bits_[0] |= 0x00000008u;
  if (message_ == nullptr) {
    auto* p = CreateMaybeMessage<::dnstap::Message>(GetArenaNoVirtual());
    message_ = p;
  }
  // @@protoc_insertion_point(field_mutable:dnstap.Dnstap.message)
  return message_;
}
inline void Dnstap::set_allocated_message(::dnstap::Message* message) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete message_;
  }
  if (message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, message, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  message_ = message;
  // @@protoc_insertion_point(field_set_allocated:dnstap.Dnstap.message)
}

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

// Message

// required .dnstap.Message.Type type = 1;
inline bool Message::has_type() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Message::clear_type() {
  type_ = 1;
  _has_bits_[0] &= ~0x00001000u;
}
inline ::dnstap::Message_Type Message::type() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.type)
  return static_cast< ::dnstap::Message_Type >(type_);
}
inline void Message::set_type(::dnstap::Message_Type value) {
  assert(::dnstap::Message_Type_IsValid(value));
  _has_bits_[0] |= 0x00001000u;
  type_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.type)
}

// optional .dnstap.SocketFamily socket_family = 2;
inline bool Message::has_socket_family() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void Message::clear_socket_family() {
  socket_family_ = 1;
  _has_bits_[0] &= ~0x00002000u;
}
inline ::dnstap::SocketFamily Message::socket_family() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.socket_family)
  return static_cast< ::dnstap::SocketFamily >(socket_family_);
}
inline void Message::set_socket_family(::dnstap::SocketFamily value) {
  assert(::dnstap::SocketFamily_IsValid(value));
  _has_bits_[0] |= 0x00002000u;
  socket_family_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.socket_family)
}

// optional .dnstap.SocketProtocol socket_protocol = 3;
inline bool Message::has_socket_protocol() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Message::clear_socket_protocol() {
  socket_protocol_ = 1;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::dnstap::SocketProtocol Message::socket_protocol() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.socket_protocol)
  return static_cast< ::dnstap::SocketProtocol >(socket_protocol_);
}
inline void Message::set_socket_protocol(::dnstap::SocketProtocol value) {
  assert(::dnstap::SocketProtocol_IsValid(value));
  _has_bits_[0] |= 0x00000800u;
  socket_protocol_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.socket_protocol)
}

// optional bytes query_address = 4;
inline bool Message::has_query_address() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Message::clear_query_address() {
  query_address_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Message::query_address() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.query_address)
  return query_address_.GetNoArena();
}
inline void Message::set_query_address(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  query_address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dnstap.Message.query_address)
}
inline void Message::set_query_address(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  query_address_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dnstap.Message.query_address)
}
inline void Message::set_query_address(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  query_address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dnstap.Message.query_address)
}
inline void Message::set_query_address(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  query_address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dnstap.Message.query_address)
}
inline std::string* Message::mutable_query_address() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:dnstap.Message.query_address)
  return query_address_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Message::release_query_address() {
  // @@protoc_insertion_point(field_release:dnstap.Message.query_address)
  if (!has_query_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return query_address_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Message::set_allocated_query_address(std::string* query_address) {
  if (query_address != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  query_address_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), query_address);
  // @@protoc_insertion_point(field_set_allocated:dnstap.Message.query_address)
}

// optional bytes response_address = 5;
inline bool Message::has_response_address() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Message::clear_response_address() {
  response_address_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Message::response_address() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.response_address)
  return response_address_.GetNoArena();
}
inline void Message::set_response_address(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  response_address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dnstap.Message.response_address)
}
inline void Message::set_response_address(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  response_address_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dnstap.Message.response_address)
}
inline void Message::set_response_address(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  response_address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dnstap.Message.response_address)
}
inline void Message::set_response_address(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  response_address_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dnstap.Message.response_address)
}
inline std::string* Message::mutable_response_address() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:dnstap.Message.response_address)
  return response_address_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Message::release_response_address() {
  // @@protoc_insertion_point(field_release:dnstap.Message.response_address)
  if (!has_response_address()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return response_address_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Message::set_allocated_response_address(std::string* response_address) {
  if (response_address != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  response_address_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response_address);
  // @@protoc_insertion_point(field_set_allocated:dnstap.Message.response_address)
}

// optional uint32 query_port = 6;
inline bool Message::has_query_port() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Message::clear_query_port() {
  query_port_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Message::query_port() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.query_port)
  return query_port_;
}
inline void Message::set_query_port(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  query_port_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.query_port)
}

// optional uint32 response_port = 7;
inline bool Message::has_response_port() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Message::clear_response_port() {
  response_port_ = 0u;
  _has_bits_[0] &= ~0x00000040u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Message::response_port() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.response_port)
  return response_port_;
}
inline void Message::set_response_port(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000040u;
  response_port_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.response_port)
}

// optional uint64 query_time_sec = 8;
inline bool Message::has_query_time_sec() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Message::clear_query_time_sec() {
  query_time_sec_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000080u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Message::query_time_sec() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.query_time_sec)
  return query_time_sec_;
}
inline void Message::set_query_time_sec(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000080u;
  query_time_sec_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.query_time_sec)
}

// optional fixed32 query_time_nsec = 9;
inline bool Message::has_query_time_nsec() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Message::clear_query_time_nsec() {
  query_time_nsec_ = 0u;
  _has_bits_[0] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Message::query_time_nsec() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.query_time_nsec)
  return query_time_nsec_;
}
inline void Message::set_query_time_nsec(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000100u;
  query_time_nsec_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.query_time_nsec)
}

// optional bytes query_message = 10;
inline bool Message::has_query_message() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Message::clear_query_message() {
  query_message_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Message::query_message() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.query_message)
  return query_message_.GetNoArena();
}
inline void Message::set_query_message(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  query_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dnstap.Message.query_message)
}
inline void Message::set_query_message(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  query_message_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dnstap.Message.query_message)
}
inline void Message::set_query_message(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  query_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dnstap.Message.query_message)
}
inline void Message::set_query_message(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000004u;
  query_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dnstap.Message.query_message)
}
inline std::string* Message::mutable_query_message() {
  _has_bits_[0] |= 0x00000004u;
  // @@protoc_insertion_point(field_mutable:dnstap.Message.query_message)
  return query_message_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Message::release_query_message() {
  // @@protoc_insertion_point(field_release:dnstap.Message.query_message)
  if (!has_query_message()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return query_message_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Message::set_allocated_query_message(std::string* query_message) {
  if (query_message != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  query_message_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), query_message);
  // @@protoc_insertion_point(field_set_allocated:dnstap.Message.query_message)
}

// optional bytes query_zone = 11;
inline bool Message::has_query_zone() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Message::clear_query_zone() {
  query_zone_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Message::query_zone() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.query_zone)
  return query_zone_.GetNoArena();
}
inline void Message::set_query_zone(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  query_zone_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dnstap.Message.query_zone)
}
inline void Message::set_query_zone(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  query_zone_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dnstap.Message.query_zone)
}
inline void Message::set_query_zone(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  query_zone_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dnstap.Message.query_zone)
}
inline void Message::set_query_zone(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000008u;
  query_zone_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dnstap.Message.query_zone)
}
inline std::string* Message::mutable_query_zone() {
  _has_bits_[0] |= 0x00000008u;
  // @@protoc_insertion_point(field_mutable:dnstap.Message.query_zone)
  return query_zone_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Message::release_query_zone() {
  // @@protoc_insertion_point(field_release:dnstap.Message.query_zone)
  if (!has_query_zone()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return query_zone_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Message::set_allocated_query_zone(std::string* query_zone) {
  if (query_zone != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  query_zone_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), query_zone);
  // @@protoc_insertion_point(field_set_allocated:dnstap.Message.query_zone)
}

// optional uint64 response_time_sec = 12;
inline bool Message::has_response_time_sec() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Message::clear_response_time_sec() {
  response_time_sec_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 Message::response_time_sec() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.response_time_sec)
  return response_time_sec_;
}
inline void Message::set_response_time_sec(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000400u;
  response_time_sec_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.response_time_sec)
}

// optional fixed32 response_time_nsec = 13;
inline bool Message::has_response_time_nsec() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Message::clear_response_time_nsec() {
  response_time_nsec_ = 0u;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Message::response_time_nsec() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.response_time_nsec)
  return response_time_nsec_;
}
inline void Message::set_response_time_nsec(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000200u;
  response_time_nsec_ = value;
  // @@protoc_insertion_point(field_set:dnstap.Message.response_time_nsec)
}

// optional bytes response_message = 14;
inline bool Message::has_response_message() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Message::clear_response_message() {
  response_message_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Message::response_message() const {
  // @@protoc_insertion_point(field_get:dnstap.Message.response_message)
  return response_message_.GetNoArena();
}
inline void Message::set_response_message(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  response_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dnstap.Message.response_message)
}
inline void Message::set_response_message(std::string&& value) {
  _has_bits_[0] |= 0x00000010u;
  response_message_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dnstap.Message.response_message)
}
inline void Message::set_response_message(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000010u;
  response_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dnstap.Message.response_message)
}
inline void Message::set_response_message(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000010u;
  response_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dnstap.Message.response_message)
}
inline std::string* Message::mutable_response_message() {
  _has_bits_[0] |= 0x00000010u;
  // @@protoc_insertion_point(field_mutable:dnstap.Message.response_message)
  return response_message_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* Message::release_response_message() {
  // @@protoc_insertion_point(field_release:dnstap.Message.response_message)
  if (!has_response_message()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  return response_message_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void Message::set_allocated_response_message(std::string* response_message) {
  if (response_message != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  response_message_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response_message);
  // @@protoc_insertion_point(field_set_allocated:dnstap.Message.response_message)
}

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace dnstap

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::dnstap::Dnstap_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dnstap::Dnstap_Type>() {
  return ::dnstap::Dnstap_Type_descriptor();
}
template <> struct is_proto_enum< ::dnstap::Message_Type> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dnstap::Message_Type>() {
  return ::dnstap::Message_Type_descriptor();
}
template <> struct is_proto_enum< ::dnstap::SocketFamily> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dnstap::SocketFamily>() {
  return ::dnstap::SocketFamily_descriptor();
}
template <> struct is_proto_enum< ::dnstap::SocketProtocol> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dnstap::SocketProtocol>() {
  return ::dnstap::SocketProtocol_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_dnstap_2eproto
