ZMQMessages.pb.cc

Go to the documentation of this file.

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "ZMQMessages.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace {

const ::google::protobuf::Descriptor* ZMQAttentionValueHolderMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ZMQAttentionValueHolderMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ZMQVersionHandleMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ZMQVersionHandleMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ZMQSingleTruthValueMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ZMQSingleTruthValueMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ZMQTruthValueMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ZMQTruthValueMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ZMQTrailMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ZMQTrailMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ZMQAtomMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ZMQAtomMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ZMQRequestMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ZMQRequestMessage_reflection_ = NULL;
const ::google::protobuf::Descriptor* ZMQReplyMessage_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ZMQReplyMessage_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* ZMQTruthValueType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ZMQAtomType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* ZMQFunctionType_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_ZMQMessages_2eproto() {
  protobuf_AddDesc_ZMQMessages_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "ZMQMessages.proto");
  GOOGLE_CHECK(file != NULL);
  ZMQAttentionValueHolderMessage_descriptor_ = file->message_type(0);
  static const int ZMQAttentionValueHolderMessage_offsets_[3] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAttentionValueHolderMessage, sti_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAttentionValueHolderMessage, lti_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAttentionValueHolderMessage, vlti_),
  };
  ZMQAttentionValueHolderMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ZMQAttentionValueHolderMessage_descriptor_,
      ZMQAttentionValueHolderMessage::default_instance_,
      ZMQAttentionValueHolderMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAttentionValueHolderMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAttentionValueHolderMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ZMQAttentionValueHolderMessage));
  ZMQVersionHandleMessage_descriptor_ = file->message_type(1);
  static const int ZMQVersionHandleMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQVersionHandleMessage, indicator_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQVersionHandleMessage, substantive_),
  };
  ZMQVersionHandleMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ZMQVersionHandleMessage_descriptor_,
      ZMQVersionHandleMessage::default_instance_,
      ZMQVersionHandleMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQVersionHandleMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQVersionHandleMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ZMQVersionHandleMessage));
  ZMQSingleTruthValueMessage_descriptor_ = file->message_type(2);
  static const int ZMQSingleTruthValueMessage_offsets_[11] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, truthvaluetype_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, mean_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, confidence_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, count_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, versionhandle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, u_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, l_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, confidencelevel_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, symmetric_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, diff_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, firstorderdistribution_),
  };
  ZMQSingleTruthValueMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ZMQSingleTruthValueMessage_descriptor_,
      ZMQSingleTruthValueMessage::default_instance_,
      ZMQSingleTruthValueMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQSingleTruthValueMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ZMQSingleTruthValueMessage));
  ZMQTruthValueMessage_descriptor_ = file->message_type(3);
  static const int ZMQTruthValueMessage_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQTruthValueMessage, singletruthvalue_),
  };
  ZMQTruthValueMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ZMQTruthValueMessage_descriptor_,
      ZMQTruthValueMessage::default_instance_,
      ZMQTruthValueMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQTruthValueMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQTruthValueMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ZMQTruthValueMessage));
  ZMQTrailMessage_descriptor_ = file->message_type(4);
  static const int ZMQTrailMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQTrailMessage, maxsize_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQTrailMessage, trail_),
  };
  ZMQTrailMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ZMQTrailMessage_descriptor_,
      ZMQTrailMessage::default_instance_,
      ZMQTrailMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQTrailMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQTrailMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ZMQTrailMessage));
  ZMQAtomMessage_descriptor_ = file->message_type(5);
  static const int ZMQAtomMessage_offsets_[10] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, atomtype_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, attentionvalueholder_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, handle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, incoming_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, flags_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, truthvalue_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, name_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, outgoing_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, trail_),
  };
  ZMQAtomMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ZMQAtomMessage_descriptor_,
      ZMQAtomMessage::default_instance_,
      ZMQAtomMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQAtomMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ZMQAtomMessage));
  ZMQRequestMessage_descriptor_ = file->message_type(6);
  static const int ZMQRequestMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQRequestMessage, function_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQRequestMessage, handle_),
  };
  ZMQRequestMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ZMQRequestMessage_descriptor_,
      ZMQRequestMessage::default_instance_,
      ZMQRequestMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQRequestMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQRequestMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ZMQRequestMessage));
  ZMQReplyMessage_descriptor_ = file->message_type(7);
  static const int ZMQReplyMessage_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQReplyMessage, atom_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQReplyMessage, str_),
  };
  ZMQReplyMessage_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      ZMQReplyMessage_descriptor_,
      ZMQReplyMessage::default_instance_,
      ZMQReplyMessage_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQReplyMessage, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ZMQReplyMessage, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(ZMQReplyMessage));
  ZMQTruthValueType_descriptor_ = file->enum_type(0);
  ZMQAtomType_descriptor_ = file->enum_type(1);
  ZMQFunctionType_descriptor_ = file->enum_type(2);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
inline void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_ZMQMessages_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ZMQAttentionValueHolderMessage_descriptor_, &ZMQAttentionValueHolderMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ZMQVersionHandleMessage_descriptor_, &ZMQVersionHandleMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ZMQSingleTruthValueMessage_descriptor_, &ZMQSingleTruthValueMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ZMQTruthValueMessage_descriptor_, &ZMQTruthValueMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ZMQTrailMessage_descriptor_, &ZMQTrailMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ZMQAtomMessage_descriptor_, &ZMQAtomMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ZMQRequestMessage_descriptor_, &ZMQRequestMessage::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    ZMQReplyMessage_descriptor_, &ZMQReplyMessage::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_ZMQMessages_2eproto() {
  delete ZMQAttentionValueHolderMessage::default_instance_;
  delete ZMQAttentionValueHolderMessage_reflection_;
  delete ZMQVersionHandleMessage::default_instance_;
  delete ZMQVersionHandleMessage_reflection_;
  delete ZMQSingleTruthValueMessage::default_instance_;
  delete ZMQSingleTruthValueMessage_reflection_;
  delete ZMQTruthValueMessage::default_instance_;
  delete ZMQTruthValueMessage_reflection_;
  delete ZMQTrailMessage::default_instance_;
  delete ZMQTrailMessage_reflection_;
  delete ZMQAtomMessage::default_instance_;
  delete ZMQAtomMessage_reflection_;
  delete ZMQRequestMessage::default_instance_;
  delete ZMQRequestMessage_reflection_;
  delete ZMQReplyMessage::default_instance_;
  delete ZMQReplyMessage_reflection_;
}

void protobuf_AddDesc_ZMQMessages_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\021ZMQMessages.proto\"H\n\036ZMQAttentionValue"
    "HolderMessage\022\013\n\003STI\030\001 \002(\005\022\013\n\003LTI\030\002 \002(\005\022"
    "\014\n\004VLTI\030\003 \002(\005\"A\n\027ZMQVersionHandleMessage"
    "\022\021\n\tindicator\030\001 \002(\r\022\023\n\013substantive\030\002 \002(\004"
    "\"\232\002\n\032ZMQSingleTruthValueMessage\022*\n\016truth"
    "valuetype\030\001 \002(\0162\022.ZMQTruthValueType\022\014\n\004m"
    "ean\030\002 \001(\002\022\022\n\nconfidence\030\003 \001(\002\022\r\n\005count\030\004"
    " \001(\002\022/\n\rversionHandle\030\005 \001(\0132\030.ZMQVersion"
    "HandleMessage\022\t\n\001U\030\006 \001(\002\022\t\n\001L\030\007 \001(\002\022\027\n\017c"
    "onfidenceLevel\030\010 \001(\002\022\021\n\tsymmetric\030\t \001(\005\022"
    "\014\n\004diff\030\n \001(\002\022\036\n\026firstOrderDistribution\030"
    "\013 \003(\002\"M\n\024ZMQTruthValueMessage\0225\n\020singleT"
    "ruthValue\030\001 \003(\0132\033.ZMQSingleTruthValueMes"
    "sage\"1\n\017ZMQTrailMessage\022\017\n\007maxSize\030\001 \002(\005"
    "\022\r\n\005trail\030\002 \003(\004\"\232\002\n\016ZMQAtomMessage\022\036\n\010at"
    "omtype\030\001 \002(\0162\014.ZMQAtomType\022=\n\024attentionv"
    "alueholder\030\002 \002(\0132\037.ZMQAttentionValueHold"
    "erMessage\022\016\n\006handle\030\003 \002(\004\022\020\n\010incoming\030\004 "
    "\003(\004\022\014\n\004type\030\005 \002(\005\022\r\n\005flags\030\006 \001(\005\022)\n\ntrut"
    "hValue\030\007 \001(\0132\025.ZMQTruthValueMessage\022\014\n\004n"
    "ame\030\010 \001(\t\022\020\n\010outgoing\030\t \003(\004\022\037\n\005trail\030\n \001"
    "(\0132\020.ZMQTrailMessage\"G\n\021ZMQRequestMessag"
    "e\022\"\n\010function\030\001 \002(\0162\020.ZMQFunctionType\022\016\n"
    "\006handle\030\002 \001(\004\"=\n\017ZMQReplyMessage\022\035\n\004atom"
    "\030\001 \001(\0132\017.ZMQAtomMessage\022\013\n\003str\030\002 \001(\t*\250\001\n"
    "\021ZMQTruthValueType\022\033\n\027ZMQTruthValueTypeS"
    "imple\020\000\022\032\n\026ZMQTruthValueTypeCount\020\001\022\031\n\025Z"
    "MQTruthValueTypeNull\020\002\022\037\n\033ZMQTruthValueT"
    "ypeIndefinite\020\003\022\036\n\032ZMQTruthValueTypeComp"
    "osite\020\004*7\n\013ZMQAtomType\022\023\n\017ZMQAtomTypeNod"
    "e\020\000\022\023\n\017ZMQAtomTypeLink\020\001*1\n\017ZMQFunctionT"
    "ype\022\016\n\nZMQgetAtom\020\000\022\016\n\nZMQgetName\020\001", 1275);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "ZMQMessages.proto", &protobuf_RegisterTypes);
  ZMQAttentionValueHolderMessage::default_instance_ = new ZMQAttentionValueHolderMessage();
  ZMQVersionHandleMessage::default_instance_ = new ZMQVersionHandleMessage();
  ZMQSingleTruthValueMessage::default_instance_ = new ZMQSingleTruthValueMessage();
  ZMQTruthValueMessage::default_instance_ = new ZMQTruthValueMessage();
  ZMQTrailMessage::default_instance_ = new ZMQTrailMessage();
  ZMQAtomMessage::default_instance_ = new ZMQAtomMessage();
  ZMQRequestMessage::default_instance_ = new ZMQRequestMessage();
  ZMQReplyMessage::default_instance_ = new ZMQReplyMessage();
  ZMQAttentionValueHolderMessage::default_instance_->InitAsDefaultInstance();
  ZMQVersionHandleMessage::default_instance_->InitAsDefaultInstance();
  ZMQSingleTruthValueMessage::default_instance_->InitAsDefaultInstance();
  ZMQTruthValueMessage::default_instance_->InitAsDefaultInstance();
  ZMQTrailMessage::default_instance_->InitAsDefaultInstance();
  ZMQAtomMessage::default_instance_->InitAsDefaultInstance();
  ZMQRequestMessage::default_instance_->InitAsDefaultInstance();
  ZMQReplyMessage::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_ZMQMessages_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_ZMQMessages_2eproto {
  StaticDescriptorInitializer_ZMQMessages_2eproto() {
    protobuf_AddDesc_ZMQMessages_2eproto();
  }
} static_descriptor_initializer_ZMQMessages_2eproto_;

const ::google::protobuf::EnumDescriptor* ZMQTruthValueType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQTruthValueType_descriptor_;
}
bool ZMQTruthValueType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ZMQAtomType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQAtomType_descriptor_;
}
bool ZMQAtomType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::google::protobuf::EnumDescriptor* ZMQFunctionType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQFunctionType_descriptor_;
}
bool ZMQFunctionType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int ZMQAttentionValueHolderMessage::kSTIFieldNumber;
const int ZMQAttentionValueHolderMessage::kLTIFieldNumber;
const int ZMQAttentionValueHolderMessage::kVLTIFieldNumber;
#endif  // !_MSC_VER

ZMQAttentionValueHolderMessage::ZMQAttentionValueHolderMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ZMQAttentionValueHolderMessage::InitAsDefaultInstance() {
}

ZMQAttentionValueHolderMessage::ZMQAttentionValueHolderMessage(const ZMQAttentionValueHolderMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ZMQAttentionValueHolderMessage::SharedCtor() {
  _cached_size_ = 0;
  sti_ = 0;
  lti_ = 0;
  vlti_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ZMQAttentionValueHolderMessage::~ZMQAttentionValueHolderMessage() {
  SharedDtor();
}

void ZMQAttentionValueHolderMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ZMQAttentionValueHolderMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ZMQAttentionValueHolderMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQAttentionValueHolderMessage_descriptor_;
}

const ZMQAttentionValueHolderMessage& ZMQAttentionValueHolderMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ZMQMessages_2eproto();  return *default_instance_;
}

ZMQAttentionValueHolderMessage* ZMQAttentionValueHolderMessage::default_instance_ = NULL;

ZMQAttentionValueHolderMessage* ZMQAttentionValueHolderMessage::New() const {
  return new ZMQAttentionValueHolderMessage;
}

void ZMQAttentionValueHolderMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    sti_ = 0;
    lti_ = 0;
    vlti_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ZMQAttentionValueHolderMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 STI = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &sti_)));
          set_has_sti();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_LTI;
        break;
      }
      
      // required int32 LTI = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_LTI:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &lti_)));
          set_has_lti();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_VLTI;
        break;
      }
      
      // required int32 VLTI = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_VLTI:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &vlti_)));
          set_has_vlti();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ZMQAttentionValueHolderMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required int32 STI = 1;
  if (has_sti()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->sti(), output);
  }
  
  // required int32 LTI = 2;
  if (has_lti()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->lti(), output);
  }
  
  // required int32 VLTI = 3;
  if (has_vlti()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->vlti(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ZMQAttentionValueHolderMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required int32 STI = 1;
  if (has_sti()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->sti(), target);
  }
  
  // required int32 LTI = 2;
  if (has_lti()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->lti(), target);
  }
  
  // required int32 VLTI = 3;
  if (has_vlti()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->vlti(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ZMQAttentionValueHolderMessage::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 STI = 1;
    if (has_sti()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->sti());
    }
    
    // required int32 LTI = 2;
    if (has_lti()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->lti());
    }
    
    // required int32 VLTI = 3;
    if (has_vlti()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->vlti());
    }
    
  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ZMQAttentionValueHolderMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ZMQAttentionValueHolderMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ZMQAttentionValueHolderMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ZMQAttentionValueHolderMessage::MergeFrom(const ZMQAttentionValueHolderMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_sti()) {
      set_sti(from.sti());
    }
    if (from.has_lti()) {
      set_lti(from.lti());
    }
    if (from.has_vlti()) {
      set_vlti(from.vlti());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ZMQAttentionValueHolderMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ZMQAttentionValueHolderMessage::CopyFrom(const ZMQAttentionValueHolderMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ZMQAttentionValueHolderMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
  
  return true;
}

void ZMQAttentionValueHolderMessage::Swap(ZMQAttentionValueHolderMessage* other) {
  if (other != this) {
    std::swap(sti_, other->sti_);
    std::swap(lti_, other->lti_);
    std::swap(vlti_, other->vlti_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ZMQAttentionValueHolderMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ZMQAttentionValueHolderMessage_descriptor_;
  metadata.reflection = ZMQAttentionValueHolderMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ZMQVersionHandleMessage::kIndicatorFieldNumber;
const int ZMQVersionHandleMessage::kSubstantiveFieldNumber;
#endif  // !_MSC_VER

ZMQVersionHandleMessage::ZMQVersionHandleMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ZMQVersionHandleMessage::InitAsDefaultInstance() {
}

ZMQVersionHandleMessage::ZMQVersionHandleMessage(const ZMQVersionHandleMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ZMQVersionHandleMessage::SharedCtor() {
  _cached_size_ = 0;
  indicator_ = 0u;
  substantive_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ZMQVersionHandleMessage::~ZMQVersionHandleMessage() {
  SharedDtor();
}

void ZMQVersionHandleMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ZMQVersionHandleMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ZMQVersionHandleMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQVersionHandleMessage_descriptor_;
}

const ZMQVersionHandleMessage& ZMQVersionHandleMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ZMQMessages_2eproto();  return *default_instance_;
}

ZMQVersionHandleMessage* ZMQVersionHandleMessage::default_instance_ = NULL;

ZMQVersionHandleMessage* ZMQVersionHandleMessage::New() const {
  return new ZMQVersionHandleMessage;
}

void ZMQVersionHandleMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    indicator_ = 0u;
    substantive_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ZMQVersionHandleMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 indicator = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &indicator_)));
          set_has_indicator();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_substantive;
        break;
      }
      
      // required uint64 substantive = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_substantive:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &substantive_)));
          set_has_substantive();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ZMQVersionHandleMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required uint32 indicator = 1;
  if (has_indicator()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->indicator(), output);
  }
  
  // required uint64 substantive = 2;
  if (has_substantive()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->substantive(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ZMQVersionHandleMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required uint32 indicator = 1;
  if (has_indicator()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->indicator(), target);
  }
  
  // required uint64 substantive = 2;
  if (has_substantive()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->substantive(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ZMQVersionHandleMessage::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 indicator = 1;
    if (has_indicator()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->indicator());
    }
    
    // required uint64 substantive = 2;
    if (has_substantive()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->substantive());
    }
    
  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ZMQVersionHandleMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ZMQVersionHandleMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ZMQVersionHandleMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ZMQVersionHandleMessage::MergeFrom(const ZMQVersionHandleMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_indicator()) {
      set_indicator(from.indicator());
    }
    if (from.has_substantive()) {
      set_substantive(from.substantive());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ZMQVersionHandleMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ZMQVersionHandleMessage::CopyFrom(const ZMQVersionHandleMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ZMQVersionHandleMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
  
  return true;
}

void ZMQVersionHandleMessage::Swap(ZMQVersionHandleMessage* other) {
  if (other != this) {
    std::swap(indicator_, other->indicator_);
    std::swap(substantive_, other->substantive_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ZMQVersionHandleMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ZMQVersionHandleMessage_descriptor_;
  metadata.reflection = ZMQVersionHandleMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ZMQSingleTruthValueMessage::kTruthvaluetypeFieldNumber;
const int ZMQSingleTruthValueMessage::kMeanFieldNumber;
const int ZMQSingleTruthValueMessage::kConfidenceFieldNumber;
const int ZMQSingleTruthValueMessage::kCountFieldNumber;
const int ZMQSingleTruthValueMessage::kVersionHandleFieldNumber;
const int ZMQSingleTruthValueMessage::kUFieldNumber;
const int ZMQSingleTruthValueMessage::kLFieldNumber;
const int ZMQSingleTruthValueMessage::kConfidenceLevelFieldNumber;
const int ZMQSingleTruthValueMessage::kSymmetricFieldNumber;
const int ZMQSingleTruthValueMessage::kDiffFieldNumber;
const int ZMQSingleTruthValueMessage::kFirstOrderDistributionFieldNumber;
#endif  // !_MSC_VER

ZMQSingleTruthValueMessage::ZMQSingleTruthValueMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ZMQSingleTruthValueMessage::InitAsDefaultInstance() {
  versionhandle_ = const_cast< ::ZMQVersionHandleMessage*>(&::ZMQVersionHandleMessage::default_instance());
}

ZMQSingleTruthValueMessage::ZMQSingleTruthValueMessage(const ZMQSingleTruthValueMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ZMQSingleTruthValueMessage::SharedCtor() {
  _cached_size_ = 0;
  truthvaluetype_ = 0;
  mean_ = 0;
  confidence_ = 0;
  count_ = 0;
  versionhandle_ = NULL;
  u_ = 0;
  l_ = 0;
  confidencelevel_ = 0;
  symmetric_ = 0;
  diff_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ZMQSingleTruthValueMessage::~ZMQSingleTruthValueMessage() {
  SharedDtor();
}

void ZMQSingleTruthValueMessage::SharedDtor() {
  if (this != default_instance_) {
    delete versionhandle_;
  }
}

void ZMQSingleTruthValueMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ZMQSingleTruthValueMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQSingleTruthValueMessage_descriptor_;
}

const ZMQSingleTruthValueMessage& ZMQSingleTruthValueMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ZMQMessages_2eproto();  return *default_instance_;
}

ZMQSingleTruthValueMessage* ZMQSingleTruthValueMessage::default_instance_ = NULL;

ZMQSingleTruthValueMessage* ZMQSingleTruthValueMessage::New() const {
  return new ZMQSingleTruthValueMessage;
}

void ZMQSingleTruthValueMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    truthvaluetype_ = 0;
    mean_ = 0;
    confidence_ = 0;
    count_ = 0;
    if (has_versionhandle()) {
      if (versionhandle_ != NULL) versionhandle_->::ZMQVersionHandleMessage::Clear();
    }
    u_ = 0;
    l_ = 0;
    confidencelevel_ = 0;
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    symmetric_ = 0;
    diff_ = 0;
  }
  firstorderdistribution_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ZMQSingleTruthValueMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .ZMQTruthValueType truthvaluetype = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (ZMQTruthValueType_IsValid(value)) {
            set_truthvaluetype(static_cast< ZMQTruthValueType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(21)) goto parse_mean;
        break;
      }
      
      // optional float mean = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_mean:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &mean_)));
          set_has_mean();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(29)) goto parse_confidence;
        break;
      }
      
      // optional float confidence = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_confidence:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &confidence_)));
          set_has_confidence();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(37)) goto parse_count;
        break;
      }
      
      // optional float count = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_count:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &count_)));
          set_has_count();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(42)) goto parse_versionHandle;
        break;
      }
      
      // optional .ZMQVersionHandleMessage versionHandle = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_versionHandle:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_versionhandle()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(53)) goto parse_U;
        break;
      }
      
      // optional float U = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_U:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &u_)));
          set_has_u();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(61)) goto parse_L;
        break;
      }
      
      // optional float L = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_L:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &l_)));
          set_has_l();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(69)) goto parse_confidenceLevel;
        break;
      }
      
      // optional float confidenceLevel = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_confidenceLevel:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &confidencelevel_)));
          set_has_confidencelevel();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_symmetric;
        break;
      }
      
      // optional int32 symmetric = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_symmetric:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &symmetric_)));
          set_has_symmetric();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(85)) goto parse_diff;
        break;
      }
      
      // optional float diff = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_diff:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &diff_)));
          set_has_diff();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(93)) goto parse_firstOrderDistribution;
        break;
      }
      
      // repeated float firstOrderDistribution = 11;
      case 11: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED32) {
         parse_firstOrderDistribution:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 1, 93, input, this->mutable_firstorderdistribution())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, this->mutable_firstorderdistribution())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(93)) goto parse_firstOrderDistribution;
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ZMQSingleTruthValueMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .ZMQTruthValueType truthvaluetype = 1;
  if (has_truthvaluetype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->truthvaluetype(), output);
  }
  
  // optional float mean = 2;
  if (has_mean()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->mean(), output);
  }
  
  // optional float confidence = 3;
  if (has_confidence()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->confidence(), output);
  }
  
  // optional float count = 4;
  if (has_count()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->count(), output);
  }
  
  // optional .ZMQVersionHandleMessage versionHandle = 5;
  if (has_versionhandle()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      5, this->versionhandle(), output);
  }
  
  // optional float U = 6;
  if (has_u()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->u(), output);
  }
  
  // optional float L = 7;
  if (has_l()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->l(), output);
  }
  
  // optional float confidenceLevel = 8;
  if (has_confidencelevel()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->confidencelevel(), output);
  }
  
  // optional int32 symmetric = 9;
  if (has_symmetric()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->symmetric(), output);
  }
  
  // optional float diff = 10;
  if (has_diff()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->diff(), output);
  }
  
  // repeated float firstOrderDistribution = 11;
  for (int i = 0; i < this->firstorderdistribution_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(
      11, this->firstorderdistribution(i), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ZMQSingleTruthValueMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .ZMQTruthValueType truthvaluetype = 1;
  if (has_truthvaluetype()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->truthvaluetype(), target);
  }
  
  // optional float mean = 2;
  if (has_mean()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->mean(), target);
  }
  
  // optional float confidence = 3;
  if (has_confidence()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->confidence(), target);
  }
  
  // optional float count = 4;
  if (has_count()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->count(), target);
  }
  
  // optional .ZMQVersionHandleMessage versionHandle = 5;
  if (has_versionhandle()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        5, this->versionhandle(), target);
  }
  
  // optional float U = 6;
  if (has_u()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->u(), target);
  }
  
  // optional float L = 7;
  if (has_l()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->l(), target);
  }
  
  // optional float confidenceLevel = 8;
  if (has_confidencelevel()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->confidencelevel(), target);
  }
  
  // optional int32 symmetric = 9;
  if (has_symmetric()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->symmetric(), target);
  }
  
  // optional float diff = 10;
  if (has_diff()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(10, this->diff(), target);
  }
  
  // repeated float firstOrderDistribution = 11;
  for (int i = 0; i < this->firstorderdistribution_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteFloatToArray(11, this->firstorderdistribution(i), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ZMQSingleTruthValueMessage::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .ZMQTruthValueType truthvaluetype = 1;
    if (has_truthvaluetype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->truthvaluetype());
    }
    
    // optional float mean = 2;
    if (has_mean()) {
      total_size += 1 + 4;
    }
    
    // optional float confidence = 3;
    if (has_confidence()) {
      total_size += 1 + 4;
    }
    
    // optional float count = 4;
    if (has_count()) {
      total_size += 1 + 4;
    }
    
    // optional .ZMQVersionHandleMessage versionHandle = 5;
    if (has_versionhandle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->versionhandle());
    }
    
    // optional float U = 6;
    if (has_u()) {
      total_size += 1 + 4;
    }
    
    // optional float L = 7;
    if (has_l()) {
      total_size += 1 + 4;
    }
    
    // optional float confidenceLevel = 8;
    if (has_confidencelevel()) {
      total_size += 1 + 4;
    }
    
  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // optional int32 symmetric = 9;
    if (has_symmetric()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->symmetric());
    }
    
    // optional float diff = 10;
    if (has_diff()) {
      total_size += 1 + 4;
    }
    
  }
  // repeated float firstOrderDistribution = 11;
  {
    int data_size = 0;
    data_size = 4 * this->firstorderdistribution_size();
    total_size += 1 * this->firstorderdistribution_size() + data_size;
  }
  
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ZMQSingleTruthValueMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ZMQSingleTruthValueMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ZMQSingleTruthValueMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ZMQSingleTruthValueMessage::MergeFrom(const ZMQSingleTruthValueMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  firstorderdistribution_.MergeFrom(from.firstorderdistribution_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_truthvaluetype()) {
      set_truthvaluetype(from.truthvaluetype());
    }
    if (from.has_mean()) {
      set_mean(from.mean());
    }
    if (from.has_confidence()) {
      set_confidence(from.confidence());
    }
    if (from.has_count()) {
      set_count(from.count());
    }
    if (from.has_versionhandle()) {
      mutable_versionhandle()->::ZMQVersionHandleMessage::MergeFrom(from.versionhandle());
    }
    if (from.has_u()) {
      set_u(from.u());
    }
    if (from.has_l()) {
      set_l(from.l());
    }
    if (from.has_confidencelevel()) {
      set_confidencelevel(from.confidencelevel());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_symmetric()) {
      set_symmetric(from.symmetric());
    }
    if (from.has_diff()) {
      set_diff(from.diff());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ZMQSingleTruthValueMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ZMQSingleTruthValueMessage::CopyFrom(const ZMQSingleTruthValueMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ZMQSingleTruthValueMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  
  if (has_versionhandle()) {
    if (!this->versionhandle().IsInitialized()) return false;
  }
  return true;
}

void ZMQSingleTruthValueMessage::Swap(ZMQSingleTruthValueMessage* other) {
  if (other != this) {
    std::swap(truthvaluetype_, other->truthvaluetype_);
    std::swap(mean_, other->mean_);
    std::swap(confidence_, other->confidence_);
    std::swap(count_, other->count_);
    std::swap(versionhandle_, other->versionhandle_);
    std::swap(u_, other->u_);
    std::swap(l_, other->l_);
    std::swap(confidencelevel_, other->confidencelevel_);
    std::swap(symmetric_, other->symmetric_);
    std::swap(diff_, other->diff_);
    firstorderdistribution_.Swap(&other->firstorderdistribution_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ZMQSingleTruthValueMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ZMQSingleTruthValueMessage_descriptor_;
  metadata.reflection = ZMQSingleTruthValueMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ZMQTruthValueMessage::kSingleTruthValueFieldNumber;
#endif  // !_MSC_VER

ZMQTruthValueMessage::ZMQTruthValueMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ZMQTruthValueMessage::InitAsDefaultInstance() {
}

ZMQTruthValueMessage::ZMQTruthValueMessage(const ZMQTruthValueMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ZMQTruthValueMessage::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ZMQTruthValueMessage::~ZMQTruthValueMessage() {
  SharedDtor();
}

void ZMQTruthValueMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ZMQTruthValueMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ZMQTruthValueMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQTruthValueMessage_descriptor_;
}

const ZMQTruthValueMessage& ZMQTruthValueMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ZMQMessages_2eproto();  return *default_instance_;
}

ZMQTruthValueMessage* ZMQTruthValueMessage::default_instance_ = NULL;

ZMQTruthValueMessage* ZMQTruthValueMessage::New() const {
  return new ZMQTruthValueMessage;
}

void ZMQTruthValueMessage::Clear() {
  singletruthvalue_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ZMQTruthValueMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .ZMQSingleTruthValueMessage singleTruthValue = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_singleTruthValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_singletruthvalue()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(10)) goto parse_singleTruthValue;
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ZMQTruthValueMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // repeated .ZMQSingleTruthValueMessage singleTruthValue = 1;
  for (int i = 0; i < this->singletruthvalue_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->singletruthvalue(i), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ZMQTruthValueMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // repeated .ZMQSingleTruthValueMessage singleTruthValue = 1;
  for (int i = 0; i < this->singletruthvalue_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->singletruthvalue(i), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ZMQTruthValueMessage::ByteSize() const {
  int total_size = 0;
  
  // repeated .ZMQSingleTruthValueMessage singleTruthValue = 1;
  total_size += 1 * this->singletruthvalue_size();
  for (int i = 0; i < this->singletruthvalue_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->singletruthvalue(i));
  }
  
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ZMQTruthValueMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ZMQTruthValueMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ZMQTruthValueMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ZMQTruthValueMessage::MergeFrom(const ZMQTruthValueMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  singletruthvalue_.MergeFrom(from.singletruthvalue_);
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ZMQTruthValueMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ZMQTruthValueMessage::CopyFrom(const ZMQTruthValueMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ZMQTruthValueMessage::IsInitialized() const {
  
  for (int i = 0; i < singletruthvalue_size(); i++) {
    if (!this->singletruthvalue(i).IsInitialized()) return false;
  }
  return true;
}

void ZMQTruthValueMessage::Swap(ZMQTruthValueMessage* other) {
  if (other != this) {
    singletruthvalue_.Swap(&other->singletruthvalue_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ZMQTruthValueMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ZMQTruthValueMessage_descriptor_;
  metadata.reflection = ZMQTruthValueMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ZMQTrailMessage::kMaxSizeFieldNumber;
const int ZMQTrailMessage::kTrailFieldNumber;
#endif  // !_MSC_VER

ZMQTrailMessage::ZMQTrailMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ZMQTrailMessage::InitAsDefaultInstance() {
}

ZMQTrailMessage::ZMQTrailMessage(const ZMQTrailMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ZMQTrailMessage::SharedCtor() {
  _cached_size_ = 0;
  maxsize_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ZMQTrailMessage::~ZMQTrailMessage() {
  SharedDtor();
}

void ZMQTrailMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ZMQTrailMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ZMQTrailMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQTrailMessage_descriptor_;
}

const ZMQTrailMessage& ZMQTrailMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ZMQMessages_2eproto();  return *default_instance_;
}

ZMQTrailMessage* ZMQTrailMessage::default_instance_ = NULL;

ZMQTrailMessage* ZMQTrailMessage::New() const {
  return new ZMQTrailMessage;
}

void ZMQTrailMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    maxsize_ = 0;
  }
  trail_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ZMQTrailMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 maxSize = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &maxsize_)));
          set_has_maxsize();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_trail;
        break;
      }
      
      // repeated uint64 trail = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_trail:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 1, 16, input, this->mutable_trail())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, this->mutable_trail())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_trail;
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ZMQTrailMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required int32 maxSize = 1;
  if (has_maxsize()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->maxsize(), output);
  }
  
  // repeated uint64 trail = 2;
  for (int i = 0; i < this->trail_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(
      2, this->trail(i), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ZMQTrailMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required int32 maxSize = 1;
  if (has_maxsize()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->maxsize(), target);
  }
  
  // repeated uint64 trail = 2;
  for (int i = 0; i < this->trail_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteUInt64ToArray(2, this->trail(i), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ZMQTrailMessage::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 maxSize = 1;
    if (has_maxsize()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->maxsize());
    }
    
  }
  // repeated uint64 trail = 2;
  {
    int data_size = 0;
    for (int i = 0; i < this->trail_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt64Size(this->trail(i));
    }
    total_size += 1 * this->trail_size() + data_size;
  }
  
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ZMQTrailMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ZMQTrailMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ZMQTrailMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ZMQTrailMessage::MergeFrom(const ZMQTrailMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  trail_.MergeFrom(from.trail_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_maxsize()) {
      set_maxsize(from.maxsize());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ZMQTrailMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ZMQTrailMessage::CopyFrom(const ZMQTrailMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ZMQTrailMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  
  return true;
}

void ZMQTrailMessage::Swap(ZMQTrailMessage* other) {
  if (other != this) {
    std::swap(maxsize_, other->maxsize_);
    trail_.Swap(&other->trail_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ZMQTrailMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ZMQTrailMessage_descriptor_;
  metadata.reflection = ZMQTrailMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ZMQAtomMessage::kAtomtypeFieldNumber;
const int ZMQAtomMessage::kAttentionvalueholderFieldNumber;
const int ZMQAtomMessage::kHandleFieldNumber;
const int ZMQAtomMessage::kIncomingFieldNumber;
const int ZMQAtomMessage::kTypeFieldNumber;
const int ZMQAtomMessage::kFlagsFieldNumber;
const int ZMQAtomMessage::kTruthValueFieldNumber;
const int ZMQAtomMessage::kNameFieldNumber;
const int ZMQAtomMessage::kOutgoingFieldNumber;
const int ZMQAtomMessage::kTrailFieldNumber;
#endif  // !_MSC_VER

ZMQAtomMessage::ZMQAtomMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ZMQAtomMessage::InitAsDefaultInstance() {
  attentionvalueholder_ = const_cast< ::ZMQAttentionValueHolderMessage*>(&::ZMQAttentionValueHolderMessage::default_instance());
  truthvalue_ = const_cast< ::ZMQTruthValueMessage*>(&::ZMQTruthValueMessage::default_instance());
  trail_ = const_cast< ::ZMQTrailMessage*>(&::ZMQTrailMessage::default_instance());
}

ZMQAtomMessage::ZMQAtomMessage(const ZMQAtomMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ZMQAtomMessage::SharedCtor() {
  _cached_size_ = 0;
  atomtype_ = 0;
  attentionvalueholder_ = NULL;
  handle_ = GOOGLE_ULONGLONG(0);
  type_ = 0;
  flags_ = 0;
  truthvalue_ = NULL;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  trail_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ZMQAtomMessage::~ZMQAtomMessage() {
  SharedDtor();
}

void ZMQAtomMessage::SharedDtor() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    delete name_;
  }
  if (this != default_instance_) {
    delete attentionvalueholder_;
    delete truthvalue_;
    delete trail_;
  }
}

void ZMQAtomMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ZMQAtomMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQAtomMessage_descriptor_;
}

const ZMQAtomMessage& ZMQAtomMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ZMQMessages_2eproto();  return *default_instance_;
}

ZMQAtomMessage* ZMQAtomMessage::default_instance_ = NULL;

ZMQAtomMessage* ZMQAtomMessage::New() const {
  return new ZMQAtomMessage;
}

void ZMQAtomMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    atomtype_ = 0;
    if (has_attentionvalueholder()) {
      if (attentionvalueholder_ != NULL) attentionvalueholder_->::ZMQAttentionValueHolderMessage::Clear();
    }
    handle_ = GOOGLE_ULONGLONG(0);
    type_ = 0;
    flags_ = 0;
    if (has_truthvalue()) {
      if (truthvalue_ != NULL) truthvalue_->::ZMQTruthValueMessage::Clear();
    }
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::kEmptyString) {
        name_->clear();
      }
    }
  }
  if (_has_bits_[9 / 32] & (0xffu << (9 % 32))) {
    if (has_trail()) {
      if (trail_ != NULL) trail_->::ZMQTrailMessage::Clear();
    }
  }
  incoming_.Clear();
  outgoing_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ZMQAtomMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .ZMQAtomType atomtype = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (ZMQAtomType_IsValid(value)) {
            set_atomtype(static_cast< ZMQAtomType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_attentionvalueholder;
        break;
      }
      
      // required .ZMQAttentionValueHolderMessage attentionvalueholder = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_attentionvalueholder:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_attentionvalueholder()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_handle;
        break;
      }
      
      // required uint64 handle = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_handle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &handle_)));
          set_has_handle();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_incoming;
        break;
      }
      
      // repeated uint64 incoming = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_incoming:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 1, 32, input, this->mutable_incoming())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, this->mutable_incoming())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_incoming;
        if (input->ExpectTag(40)) goto parse_type;
        break;
      }
      
      // required int32 type = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &type_)));
          set_has_type();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(48)) goto parse_flags;
        break;
      }
      
      // optional int32 flags = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_flags:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &flags_)));
          set_has_flags();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(58)) goto parse_truthValue;
        break;
      }
      
      // optional .ZMQTruthValueMessage truthValue = 7;
      case 7: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_truthValue:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_truthvalue()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(66)) goto parse_name;
        break;
      }
      
      // optional string name = 8;
      case 8: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_name:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->name().data(), this->name().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_outgoing;
        break;
      }
      
      // repeated uint64 outgoing = 9;
      case 9: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_outgoing:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 1, 72, input, this->mutable_outgoing())));
        } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
                   == ::google::protobuf::internal::WireFormatLite::
                      WIRETYPE_LENGTH_DELIMITED) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, this->mutable_outgoing())));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(72)) goto parse_outgoing;
        if (input->ExpectTag(82)) goto parse_trail;
        break;
      }
      
      // optional .ZMQTrailMessage trail = 10;
      case 10: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_trail:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_trail()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ZMQAtomMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .ZMQAtomType atomtype = 1;
  if (has_atomtype()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->atomtype(), output);
  }
  
  // required .ZMQAttentionValueHolderMessage attentionvalueholder = 2;
  if (has_attentionvalueholder()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->attentionvalueholder(), output);
  }
  
  // required uint64 handle = 3;
  if (has_handle()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->handle(), output);
  }
  
  // repeated uint64 incoming = 4;
  for (int i = 0; i < this->incoming_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(
      4, this->incoming(i), output);
  }
  
  // required int32 type = 5;
  if (has_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->type(), output);
  }
  
  // optional int32 flags = 6;
  if (has_flags()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->flags(), output);
  }
  
  // optional .ZMQTruthValueMessage truthValue = 7;
  if (has_truthvalue()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, this->truthvalue(), output);
  }
  
  // optional string name = 8;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      8, this->name(), output);
  }
  
  // repeated uint64 outgoing = 9;
  for (int i = 0; i < this->outgoing_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(
      9, this->outgoing(i), output);
  }
  
  // optional .ZMQTrailMessage trail = 10;
  if (has_trail()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      10, this->trail(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ZMQAtomMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .ZMQAtomType atomtype = 1;
  if (has_atomtype()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->atomtype(), target);
  }
  
  // required .ZMQAttentionValueHolderMessage attentionvalueholder = 2;
  if (has_attentionvalueholder()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        2, this->attentionvalueholder(), target);
  }
  
  // required uint64 handle = 3;
  if (has_handle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->handle(), target);
  }
  
  // repeated uint64 incoming = 4;
  for (int i = 0; i < this->incoming_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteUInt64ToArray(4, this->incoming(i), target);
  }
  
  // required int32 type = 5;
  if (has_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->type(), target);
  }
  
  // optional int32 flags = 6;
  if (has_flags()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->flags(), target);
  }
  
  // optional .ZMQTruthValueMessage truthValue = 7;
  if (has_truthvalue()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        7, this->truthvalue(), target);
  }
  
  // optional string name = 8;
  if (has_name()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->name().data(), this->name().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        8, this->name(), target);
  }
  
  // repeated uint64 outgoing = 9;
  for (int i = 0; i < this->outgoing_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteUInt64ToArray(9, this->outgoing(i), target);
  }
  
  // optional .ZMQTrailMessage trail = 10;
  if (has_trail()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        10, this->trail(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ZMQAtomMessage::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .ZMQAtomType atomtype = 1;
    if (has_atomtype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->atomtype());
    }
    
    // required .ZMQAttentionValueHolderMessage attentionvalueholder = 2;
    if (has_attentionvalueholder()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->attentionvalueholder());
    }
    
    // required uint64 handle = 3;
    if (has_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->handle());
    }
    
    // required int32 type = 5;
    if (has_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->type());
    }
    
    // optional int32 flags = 6;
    if (has_flags()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->flags());
    }
    
    // optional .ZMQTruthValueMessage truthValue = 7;
    if (has_truthvalue()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->truthvalue());
    }
    
    // optional string name = 8;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }
    
  }
  if (_has_bits_[9 / 32] & (0xffu << (9 % 32))) {
    // optional .ZMQTrailMessage trail = 10;
    if (has_trail()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->trail());
    }
    
  }
  // repeated uint64 incoming = 4;
  {
    int data_size = 0;
    for (int i = 0; i < this->incoming_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt64Size(this->incoming(i));
    }
    total_size += 1 * this->incoming_size() + data_size;
  }
  
  // repeated uint64 outgoing = 9;
  {
    int data_size = 0;
    for (int i = 0; i < this->outgoing_size(); i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt64Size(this->outgoing(i));
    }
    total_size += 1 * this->outgoing_size() + data_size;
  }
  
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ZMQAtomMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ZMQAtomMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ZMQAtomMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ZMQAtomMessage::MergeFrom(const ZMQAtomMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  incoming_.MergeFrom(from.incoming_);
  outgoing_.MergeFrom(from.outgoing_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_atomtype()) {
      set_atomtype(from.atomtype());
    }
    if (from.has_attentionvalueholder()) {
      mutable_attentionvalueholder()->::ZMQAttentionValueHolderMessage::MergeFrom(from.attentionvalueholder());
    }
    if (from.has_handle()) {
      set_handle(from.handle());
    }
    if (from.has_type()) {
      set_type(from.type());
    }
    if (from.has_flags()) {
      set_flags(from.flags());
    }
    if (from.has_truthvalue()) {
      mutable_truthvalue()->::ZMQTruthValueMessage::MergeFrom(from.truthvalue());
    }
    if (from.has_name()) {
      set_name(from.name());
    }
  }
  if (from._has_bits_[9 / 32] & (0xffu << (9 % 32))) {
    if (from.has_trail()) {
      mutable_trail()->::ZMQTrailMessage::MergeFrom(from.trail());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ZMQAtomMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ZMQAtomMessage::CopyFrom(const ZMQAtomMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ZMQAtomMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000017) != 0x00000017) return false;
  
  if (has_attentionvalueholder()) {
    if (!this->attentionvalueholder().IsInitialized()) return false;
  }
  if (has_truthvalue()) {
    if (!this->truthvalue().IsInitialized()) return false;
  }
  if (has_trail()) {
    if (!this->trail().IsInitialized()) return false;
  }
  return true;
}

void ZMQAtomMessage::Swap(ZMQAtomMessage* other) {
  if (other != this) {
    std::swap(atomtype_, other->atomtype_);
    std::swap(attentionvalueholder_, other->attentionvalueholder_);
    std::swap(handle_, other->handle_);
    incoming_.Swap(&other->incoming_);
    std::swap(type_, other->type_);
    std::swap(flags_, other->flags_);
    std::swap(truthvalue_, other->truthvalue_);
    std::swap(name_, other->name_);
    outgoing_.Swap(&other->outgoing_);
    std::swap(trail_, other->trail_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ZMQAtomMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ZMQAtomMessage_descriptor_;
  metadata.reflection = ZMQAtomMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ZMQRequestMessage::kFunctionFieldNumber;
const int ZMQRequestMessage::kHandleFieldNumber;
#endif  // !_MSC_VER

ZMQRequestMessage::ZMQRequestMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ZMQRequestMessage::InitAsDefaultInstance() {
}

ZMQRequestMessage::ZMQRequestMessage(const ZMQRequestMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ZMQRequestMessage::SharedCtor() {
  _cached_size_ = 0;
  function_ = 0;
  handle_ = GOOGLE_ULONGLONG(0);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ZMQRequestMessage::~ZMQRequestMessage() {
  SharedDtor();
}

void ZMQRequestMessage::SharedDtor() {
  if (this != default_instance_) {
  }
}

void ZMQRequestMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ZMQRequestMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQRequestMessage_descriptor_;
}

const ZMQRequestMessage& ZMQRequestMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ZMQMessages_2eproto();  return *default_instance_;
}

ZMQRequestMessage* ZMQRequestMessage::default_instance_ = NULL;

ZMQRequestMessage* ZMQRequestMessage::New() const {
  return new ZMQRequestMessage;
}

void ZMQRequestMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    function_ = 0;
    handle_ = GOOGLE_ULONGLONG(0);
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ZMQRequestMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .ZMQFunctionType function = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (ZMQFunctionType_IsValid(value)) {
            set_function(static_cast< ZMQFunctionType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_handle;
        break;
      }
      
      // optional uint64 handle = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_handle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &handle_)));
          set_has_handle();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ZMQRequestMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required .ZMQFunctionType function = 1;
  if (has_function()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      1, this->function(), output);
  }
  
  // optional uint64 handle = 2;
  if (has_handle()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->handle(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ZMQRequestMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required .ZMQFunctionType function = 1;
  if (has_function()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      1, this->function(), target);
  }
  
  // optional uint64 handle = 2;
  if (has_handle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->handle(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ZMQRequestMessage::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .ZMQFunctionType function = 1;
    if (has_function()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->function());
    }
    
    // optional uint64 handle = 2;
    if (has_handle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->handle());
    }
    
  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ZMQRequestMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ZMQRequestMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ZMQRequestMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ZMQRequestMessage::MergeFrom(const ZMQRequestMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_function()) {
      set_function(from.function());
    }
    if (from.has_handle()) {
      set_handle(from.handle());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ZMQRequestMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ZMQRequestMessage::CopyFrom(const ZMQRequestMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ZMQRequestMessage::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
  
  return true;
}

void ZMQRequestMessage::Swap(ZMQRequestMessage* other) {
  if (other != this) {
    std::swap(function_, other->function_);
    std::swap(handle_, other->handle_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ZMQRequestMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ZMQRequestMessage_descriptor_;
  metadata.reflection = ZMQRequestMessage_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int ZMQReplyMessage::kAtomFieldNumber;
const int ZMQReplyMessage::kStrFieldNumber;
#endif  // !_MSC_VER

ZMQReplyMessage::ZMQReplyMessage()
  : ::google::protobuf::Message() {
  SharedCtor();
}

void ZMQReplyMessage::InitAsDefaultInstance() {
  atom_ = const_cast< ::ZMQAtomMessage*>(&::ZMQAtomMessage::default_instance());
}

ZMQReplyMessage::ZMQReplyMessage(const ZMQReplyMessage& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
}

void ZMQReplyMessage::SharedCtor() {
  _cached_size_ = 0;
  atom_ = NULL;
  str_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ZMQReplyMessage::~ZMQReplyMessage() {
  SharedDtor();
}

void ZMQReplyMessage::SharedDtor() {
  if (str_ != &::google::protobuf::internal::kEmptyString) {
    delete str_;
  }
  if (this != default_instance_) {
    delete atom_;
  }
}

void ZMQReplyMessage::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ZMQReplyMessage::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ZMQReplyMessage_descriptor_;
}

const ZMQReplyMessage& ZMQReplyMessage::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_ZMQMessages_2eproto();  return *default_instance_;
}

ZMQReplyMessage* ZMQReplyMessage::default_instance_ = NULL;

ZMQReplyMessage* ZMQReplyMessage::New() const {
  return new ZMQReplyMessage;
}

void ZMQReplyMessage::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_atom()) {
      if (atom_ != NULL) atom_->::ZMQAtomMessage::Clear();
    }
    if (has_str()) {
      if (str_ != &::google::protobuf::internal::kEmptyString) {
        str_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool ZMQReplyMessage::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .ZMQAtomMessage atom = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_atom()));
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(18)) goto parse_str;
        break;
      }
      
      // optional string str = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_str:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_str()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->str().data(), this->str().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectAtEnd()) return true;
        break;
      }
      
      default: {
      handle_uninterpreted:
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          return true;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void ZMQReplyMessage::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // optional .ZMQAtomMessage atom = 1;
  if (has_atom()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->atom(), output);
  }
  
  // optional string str = 2;
  if (has_str()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->str().data(), this->str().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      2, this->str(), output);
  }
  
  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* ZMQReplyMessage::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // optional .ZMQAtomMessage atom = 1;
  if (has_atom()) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        1, this->atom(), target);
  }
  
  // optional string str = 2;
  if (has_str()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->str().data(), this->str().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->str(), target);
  }
  
  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

int ZMQReplyMessage::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // optional .ZMQAtomMessage atom = 1;
    if (has_atom()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->atom());
    }
    
    // optional string str = 2;
    if (has_str()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->str());
    }
    
  }
  if (!unknown_fields().empty()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ZMQReplyMessage::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const ZMQReplyMessage* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const ZMQReplyMessage*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void ZMQReplyMessage::MergeFrom(const ZMQReplyMessage& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_atom()) {
      mutable_atom()->::ZMQAtomMessage::MergeFrom(from.atom());
    }
    if (from.has_str()) {
      set_str(from.str());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

void ZMQReplyMessage::CopyFrom(const ::google::protobuf::Message& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ZMQReplyMessage::CopyFrom(const ZMQReplyMessage& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ZMQReplyMessage::IsInitialized() const {
  
  if (has_atom()) {
    if (!this->atom().IsInitialized()) return false;
  }
  return true;
}

void ZMQReplyMessage::Swap(ZMQReplyMessage* other) {
  if (other != this) {
    std::swap(atom_, other->atom_);
    std::swap(str_, other->str_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.Swap(&other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::google::protobuf::Metadata ZMQReplyMessage::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ZMQReplyMessage_descriptor_;
  metadata.reflection = ZMQReplyMessage_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

// @@protoc_insertion_point(global_scope)