<filename>ftp/serviceDataArchiverRabbitMQ/upmuDataProtobufRabbitMQ.pb.cc<gh_stars>1-10
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: upmuDataProtobufRabbitMQ.proto

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

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#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/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)

namespace serviceCommon {

namespace {

const ::google::protobuf::Descriptor* syncOutputRabbit_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  syncOutputRabbit_reflection_ = NULL;
const ::google::protobuf::Descriptor* upmuDataRabbit_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  upmuDataRabbit_reflection_ = NULL;

}  // namespace


void protobuf_AssignDesc_upmuDataProtobufRabbitMQ_2eproto() {
  protobuf_AddDesc_upmuDataProtobufRabbitMQ_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "upmuDataProtobufRabbitMQ.proto");
  GOOGLE_CHECK(file != NULL);
  syncOutputRabbit_descriptor_ = file->message_type(0);
  static const int syncOutputRabbit_offsets_[13] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, lockstate_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, l1angle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, l1mag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, l2angle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, l2mag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, l3angle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, l3mag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, c1angle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, c1mag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, c2angle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, c2mag_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, c3angle_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, c3mag_),
  };
  syncOutputRabbit_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      syncOutputRabbit_descriptor_,
      syncOutputRabbit::default_instance_,
      syncOutputRabbit_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(syncOutputRabbit, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(syncOutputRabbit));
  upmuDataRabbit_descriptor_ = file->message_type(1);
  static const int upmuDataRabbit_offsets_[7] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, timestampmsec_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, device_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, domaintype_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, msgtype_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, sampleintervalmsec_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, numsamples_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, sample_),
  };
  upmuDataRabbit_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      upmuDataRabbit_descriptor_,
      upmuDataRabbit::default_instance_,
      upmuDataRabbit_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(upmuDataRabbit, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(upmuDataRabbit));
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    syncOutputRabbit_descriptor_, &syncOutputRabbit::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    upmuDataRabbit_descriptor_, &upmuDataRabbit::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_upmuDataProtobufRabbitMQ_2eproto() {
  delete syncOutputRabbit::default_instance_;
  delete syncOutputRabbit_reflection_;
  delete upmuDataRabbit::default_instance_;
  delete upmuDataRabbit_reflection_;
}

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

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\036upmuDataProtobufRabbitMQ.proto\022\rservic"
    "eCommon\"\345\001\n\020syncOutputRabbit\022\021\n\tlockStat"
    "e\030\001 \002(\r\022\017\n\007L1angle\030\002 \002(\002\022\r\n\005L1mag\030\003 \002(\002\022"
    "\017\n\007L2angle\030\004 \002(\002\022\r\n\005L2mag\030\005 \002(\002\022\017\n\007L3ang"
    "le\030\006 \002(\002\022\r\n\005L3mag\030\007 \002(\002\022\017\n\007C1angle\030\010 \002(\002"
    "\022\r\n\005C1mag\030\t \002(\002\022\017\n\007C2angle\030\n \002(\002\022\r\n\005C2ma"
    "g\030\013 \002(\002\022\017\n\007C3angle\030\014 \002(\002\022\r\n\005C3mag\030\r \002(\002\""
    "\275\001\n\016upmuDataRabbit\022\025\n\rtimeStampMsec\030\001 \002("
    "\004\022\016\n\006device\030\002 \002(\t\022\022\n\ndomainType\030\003 \002(\r\022\017\n"
    "\007msgType\030\004 \002(\r\022\032\n\022sampleIntervalMsec\030\005 \002"
    "(\002\022\022\n\nnumSamples\030\006 \002(\r\022/\n\006sample\030\007 \003(\0132\037"
    ".serviceCommon.syncOutputRabbit", 471);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "upmuDataProtobufRabbitMQ.proto", &protobuf_RegisterTypes);
  syncOutputRabbit::default_instance_ = new syncOutputRabbit();
  upmuDataRabbit::default_instance_ = new upmuDataRabbit();
  syncOutputRabbit::default_instance_->InitAsDefaultInstance();
  upmuDataRabbit::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_upmuDataProtobufRabbitMQ_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_upmuDataProtobufRabbitMQ_2eproto {
  StaticDescriptorInitializer_upmuDataProtobufRabbitMQ_2eproto() {
    protobuf_AddDesc_upmuDataProtobufRabbitMQ_2eproto();
  }
} static_descriptor_initializer_upmuDataProtobufRabbitMQ_2eproto_;

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

#ifndef _MSC_VER
const int syncOutputRabbit::kLockStateFieldNumber;
const int syncOutputRabbit::kL1AngleFieldNumber;
const int syncOutputRabbit::kL1MagFieldNumber;
const int syncOutputRabbit::kL2AngleFieldNumber;
const int syncOutputRabbit::kL2MagFieldNumber;
const int syncOutputRabbit::kL3AngleFieldNumber;
const int syncOutputRabbit::kL3MagFieldNumber;
const int syncOutputRabbit::kC1AngleFieldNumber;
const int syncOutputRabbit::kC1MagFieldNumber;
const int syncOutputRabbit::kC2AngleFieldNumber;
const int syncOutputRabbit::kC2MagFieldNumber;
const int syncOutputRabbit::kC3AngleFieldNumber;
const int syncOutputRabbit::kC3MagFieldNumber;
#endif  // !_MSC_VER

syncOutputRabbit::syncOutputRabbit()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:serviceCommon.syncOutputRabbit)
}

void syncOutputRabbit::InitAsDefaultInstance() {
}

syncOutputRabbit::syncOutputRabbit(const syncOutputRabbit& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:serviceCommon.syncOutputRabbit)
}

void syncOutputRabbit::SharedCtor() {
  _cached_size_ = 0;
  lockstate_ = 0u;
  l1angle_ = 0;
  l1mag_ = 0;
  l2angle_ = 0;
  l2mag_ = 0;
  l3angle_ = 0;
  l3mag_ = 0;
  c1angle_ = 0;
  c1mag_ = 0;
  c2angle_ = 0;
  c2mag_ = 0;
  c3angle_ = 0;
  c3mag_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

syncOutputRabbit::~syncOutputRabbit() {
  // @@protoc_insertion_point(destructor:serviceCommon.syncOutputRabbit)
  SharedDtor();
}

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

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

const syncOutputRabbit& syncOutputRabbit::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_upmuDataProtobufRabbitMQ_2eproto();
  return *default_instance_;
}

syncOutputRabbit* syncOutputRabbit::default_instance_ = NULL;

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

void syncOutputRabbit::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<syncOutputRabbit*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 255) {
    ZR_(lockstate_, c1angle_);
  }
  if (_has_bits_[8 / 32] & 7936) {
    ZR_(c1mag_, c3mag_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool syncOutputRabbit::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:serviceCommon.syncOutputRabbit)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 lockState = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &lockstate_)));
          set_has_lockstate();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(21)) goto parse_L1angle;
        break;
      }

      // required float L1angle = 2;
      case 2: {
        if (tag == 21) {
         parse_L1angle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &l1angle_)));
          set_has_l1angle();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(29)) goto parse_L1mag;
        break;
      }

      // required float L1mag = 3;
      case 3: {
        if (tag == 29) {
         parse_L1mag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &l1mag_)));
          set_has_l1mag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(37)) goto parse_L2angle;
        break;
      }

      // required float L2angle = 4;
      case 4: {
        if (tag == 37) {
         parse_L2angle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &l2angle_)));
          set_has_l2angle();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(45)) goto parse_L2mag;
        break;
      }

      // required float L2mag = 5;
      case 5: {
        if (tag == 45) {
         parse_L2mag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &l2mag_)));
          set_has_l2mag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(53)) goto parse_L3angle;
        break;
      }

      // required float L3angle = 6;
      case 6: {
        if (tag == 53) {
         parse_L3angle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &l3angle_)));
          set_has_l3angle();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(61)) goto parse_L3mag;
        break;
      }

      // required float L3mag = 7;
      case 7: {
        if (tag == 61) {
         parse_L3mag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &l3mag_)));
          set_has_l3mag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(69)) goto parse_C1angle;
        break;
      }

      // required float C1angle = 8;
      case 8: {
        if (tag == 69) {
         parse_C1angle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &c1angle_)));
          set_has_c1angle();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(77)) goto parse_C1mag;
        break;
      }

      // required float C1mag = 9;
      case 9: {
        if (tag == 77) {
         parse_C1mag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &c1mag_)));
          set_has_c1mag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(85)) goto parse_C2angle;
        break;
      }

      // required float C2angle = 10;
      case 10: {
        if (tag == 85) {
         parse_C2angle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &c2angle_)));
          set_has_c2angle();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(93)) goto parse_C2mag;
        break;
      }

      // required float C2mag = 11;
      case 11: {
        if (tag == 93) {
         parse_C2mag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &c2mag_)));
          set_has_c2mag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(101)) goto parse_C3angle;
        break;
      }

      // required float C3angle = 12;
      case 12: {
        if (tag == 101) {
         parse_C3angle:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &c3angle_)));
          set_has_c3angle();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(109)) goto parse_C3mag;
        break;
      }

      // required float C3mag = 13;
      case 13: {
        if (tag == 109) {
         parse_C3mag:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &c3mag_)));
          set_has_c3mag();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:serviceCommon.syncOutputRabbit)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:serviceCommon.syncOutputRabbit)
  return false;
#undef DO_
}

void syncOutputRabbit::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:serviceCommon.syncOutputRabbit)
  // required uint32 lockState = 1;
  if (has_lockstate()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->lockstate(), output);
  }

  // required float L1angle = 2;
  if (has_l1angle()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->l1angle(), output);
  }

  // required float L1mag = 3;
  if (has_l1mag()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->l1mag(), output);
  }

  // required float L2angle = 4;
  if (has_l2angle()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->l2angle(), output);
  }

  // required float L2mag = 5;
  if (has_l2mag()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->l2mag(), output);
  }

  // required float L3angle = 6;
  if (has_l3angle()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->l3angle(), output);
  }

  // required float L3mag = 7;
  if (has_l3mag()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->l3mag(), output);
  }

  // required float C1angle = 8;
  if (has_c1angle()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->c1angle(), output);
  }

  // required float C1mag = 9;
  if (has_c1mag()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(9, this->c1mag(), output);
  }

  // required float C2angle = 10;
  if (has_c2angle()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(10, this->c2angle(), output);
  }

  // required float C2mag = 11;
  if (has_c2mag()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->c2mag(), output);
  }

  // required float C3angle = 12;
  if (has_c3angle()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(12, this->c3angle(), output);
  }

  // required float C3mag = 13;
  if (has_c3mag()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->c3mag(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:serviceCommon.syncOutputRabbit)
}

::google::protobuf::uint8* syncOutputRabbit::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:serviceCommon.syncOutputRabbit)
  // required uint32 lockState = 1;
  if (has_lockstate()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->lockstate(), target);
  }

  // required float L1angle = 2;
  if (has_l1angle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->l1angle(), target);
  }

  // required float L1mag = 3;
  if (has_l1mag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->l1mag(), target);
  }

  // required float L2angle = 4;
  if (has_l2angle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->l2angle(), target);
  }

  // required float L2mag = 5;
  if (has_l2mag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->l2mag(), target);
  }

  // required float L3angle = 6;
  if (has_l3angle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->l3angle(), target);
  }

  // required float L3mag = 7;
  if (has_l3mag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->l3mag(), target);
  }

  // required float C1angle = 8;
  if (has_c1angle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->c1angle(), target);
  }

  // required float C1mag = 9;
  if (has_c1mag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(9, this->c1mag(), target);
  }

  // required float C2angle = 10;
  if (has_c2angle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(10, this->c2angle(), target);
  }

  // required float C2mag = 11;
  if (has_c2mag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->c2mag(), target);
  }

  // required float C3angle = 12;
  if (has_c3angle()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(12, this->c3angle(), target);
  }

  // required float C3mag = 13;
  if (has_c3mag()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->c3mag(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:serviceCommon.syncOutputRabbit)
  return target;
}

int syncOutputRabbit::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 lockState = 1;
    if (has_lockstate()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->lockstate());
    }

    // required float L1angle = 2;
    if (has_l1angle()) {
      total_size += 1 + 4;
    }

    // required float L1mag = 3;
    if (has_l1mag()) {
      total_size += 1 + 4;
    }

    // required float L2angle = 4;
    if (has_l2angle()) {
      total_size += 1 + 4;
    }

    // required float L2mag = 5;
    if (has_l2mag()) {
      total_size += 1 + 4;
    }

    // required float L3angle = 6;
    if (has_l3angle()) {
      total_size += 1 + 4;
    }

    // required float L3mag = 7;
    if (has_l3mag()) {
      total_size += 1 + 4;
    }

    // required float C1angle = 8;
    if (has_c1angle()) {
      total_size += 1 + 4;
    }

  }
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    // required float C1mag = 9;
    if (has_c1mag()) {
      total_size += 1 + 4;
    }

    // required float C2angle = 10;
    if (has_c2angle()) {
      total_size += 1 + 4;
    }

    // required float C2mag = 11;
    if (has_c2mag()) {
      total_size += 1 + 4;
    }

    // required float C3angle = 12;
    if (has_c3angle()) {
      total_size += 1 + 4;
    }

    // required float C3mag = 13;
    if (has_c3mag()) {
      total_size += 1 + 4;
    }

  }
  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 syncOutputRabbit::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const syncOutputRabbit* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const syncOutputRabbit*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void syncOutputRabbit::MergeFrom(const syncOutputRabbit& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_lockstate()) {
      set_lockstate(from.lockstate());
    }
    if (from.has_l1angle()) {
      set_l1angle(from.l1angle());
    }
    if (from.has_l1mag()) {
      set_l1mag(from.l1mag());
    }
    if (from.has_l2angle()) {
      set_l2angle(from.l2angle());
    }
    if (from.has_l2mag()) {
      set_l2mag(from.l2mag());
    }
    if (from.has_l3angle()) {
      set_l3angle(from.l3angle());
    }
    if (from.has_l3mag()) {
      set_l3mag(from.l3mag());
    }
    if (from.has_c1angle()) {
      set_c1angle(from.c1angle());
    }
  }
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
    if (from.has_c1mag()) {
      set_c1mag(from.c1mag());
    }
    if (from.has_c2angle()) {
      set_c2angle(from.c2angle());
    }
    if (from.has_c2mag()) {
      set_c2mag(from.c2mag());
    }
    if (from.has_c3angle()) {
      set_c3angle(from.c3angle());
    }
    if (from.has_c3mag()) {
      set_c3mag(from.c3mag());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool syncOutputRabbit::IsInitialized() const {
  if ((_has_bits_[0] & 0x00001fff) != 0x00001fff) return false;

  return true;
}

void syncOutputRabbit::Swap(syncOutputRabbit* other) {
  if (other != this) {
    std::swap(lockstate_, other->lockstate_);
    std::swap(l1angle_, other->l1angle_);
    std::swap(l1mag_, other->l1mag_);
    std::swap(l2angle_, other->l2angle_);
    std::swap(l2mag_, other->l2mag_);
    std::swap(l3angle_, other->l3angle_);
    std::swap(l3mag_, other->l3mag_);
    std::swap(c1angle_, other->c1angle_);
    std::swap(c1mag_, other->c1mag_);
    std::swap(c2angle_, other->c2angle_);
    std::swap(c2mag_, other->c2mag_);
    std::swap(c3angle_, other->c3angle_);
    std::swap(c3mag_, other->c3mag_);
    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 syncOutputRabbit::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = syncOutputRabbit_descriptor_;
  metadata.reflection = syncOutputRabbit_reflection_;
  return metadata;
}


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

#ifndef _MSC_VER
const int upmuDataRabbit::kTimeStampMsecFieldNumber;
const int upmuDataRabbit::kDeviceFieldNumber;
const int upmuDataRabbit::kDomainTypeFieldNumber;
const int upmuDataRabbit::kMsgTypeFieldNumber;
const int upmuDataRabbit::kSampleIntervalMsecFieldNumber;
const int upmuDataRabbit::kNumSamplesFieldNumber;
const int upmuDataRabbit::kSampleFieldNumber;
#endif  // !_MSC_VER

upmuDataRabbit::upmuDataRabbit()
  : ::google::protobuf::Message() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:serviceCommon.upmuDataRabbit)
}

void upmuDataRabbit::InitAsDefaultInstance() {
}

upmuDataRabbit::upmuDataRabbit(const upmuDataRabbit& from)
  : ::google::protobuf::Message() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:serviceCommon.upmuDataRabbit)
}

void upmuDataRabbit::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  timestampmsec_ = GOOGLE_ULONGLONG(0);
  device_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  domaintype_ = 0u;
  msgtype_ = 0u;
  sampleintervalmsec_ = 0;
  numsamples_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

upmuDataRabbit::~upmuDataRabbit() {
  // @@protoc_insertion_point(destructor:serviceCommon.upmuDataRabbit)
  SharedDtor();
}

void upmuDataRabbit::SharedDtor() {
  if (device_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete device_;
  }
  if (this != default_instance_) {
  }
}

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

const upmuDataRabbit& upmuDataRabbit::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_upmuDataProtobufRabbitMQ_2eproto();
  return *default_instance_;
}

upmuDataRabbit* upmuDataRabbit::default_instance_ = NULL;

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

void upmuDataRabbit::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<upmuDataRabbit*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 63) {
    ZR_(domaintype_, numsamples_);
    timestampmsec_ = GOOGLE_ULONGLONG(0);
    if (has_device()) {
      if (device_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        device_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  sample_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool upmuDataRabbit::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  // @@protoc_insertion_point(parse_start:serviceCommon.upmuDataRabbit)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint64 timeStampMsec = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &timestampmsec_)));
          set_has_timestampmsec();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_device;
        break;
      }

      // required string device = 2;
      case 2: {
        if (tag == 18) {
         parse_device:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_device()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->device().data(), this->device().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "device");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_domainType;
        break;
      }

      // required uint32 domainType = 3;
      case 3: {
        if (tag == 24) {
         parse_domainType:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &domaintype_)));
          set_has_domaintype();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_msgType;
        break;
      }

      // required uint32 msgType = 4;
      case 4: {
        if (tag == 32) {
         parse_msgType:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &msgtype_)));
          set_has_msgtype();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(45)) goto parse_sampleIntervalMsec;
        break;
      }

      // required float sampleIntervalMsec = 5;
      case 5: {
        if (tag == 45) {
         parse_sampleIntervalMsec:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &sampleintervalmsec_)));
          set_has_sampleintervalmsec();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_numSamples;
        break;
      }

      // required uint32 numSamples = 6;
      case 6: {
        if (tag == 48) {
         parse_numSamples:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &numsamples_)));
          set_has_numsamples();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_sample;
        break;
      }

      // repeated .serviceCommon.syncOutputRabbit sample = 7;
      case 7: {
        if (tag == 58) {
         parse_sample:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_sample()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_sample;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:serviceCommon.upmuDataRabbit)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:serviceCommon.upmuDataRabbit)
  return false;
#undef DO_
}

void upmuDataRabbit::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:serviceCommon.upmuDataRabbit)
  // required uint64 timeStampMsec = 1;
  if (has_timestampmsec()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->timestampmsec(), output);
  }

  // required string device = 2;
  if (has_device()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->device().data(), this->device().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "device");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->device(), output);
  }

  // required uint32 domainType = 3;
  if (has_domaintype()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->domaintype(), output);
  }

  // required uint32 msgType = 4;
  if (has_msgtype()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->msgtype(), output);
  }

  // required float sampleIntervalMsec = 5;
  if (has_sampleintervalmsec()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->sampleintervalmsec(), output);
  }

  // required uint32 numSamples = 6;
  if (has_numsamples()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->numsamples(), output);
  }

  // repeated .serviceCommon.syncOutputRabbit sample = 7;
  for (int i = 0; i < this->sample_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      7, this->sample(i), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:serviceCommon.upmuDataRabbit)
}

::google::protobuf::uint8* upmuDataRabbit::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // @@protoc_insertion_point(serialize_to_array_start:serviceCommon.upmuDataRabbit)
  // required uint64 timeStampMsec = 1;
  if (has_timestampmsec()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->timestampmsec(), target);
  }

  // required string device = 2;
  if (has_device()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->device().data(), this->device().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "device");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->device(), target);
  }

  // required uint32 domainType = 3;
  if (has_domaintype()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->domaintype(), target);
  }

  // required uint32 msgType = 4;
  if (has_msgtype()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->msgtype(), target);
  }

  // required float sampleIntervalMsec = 5;
  if (has_sampleintervalmsec()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->sampleintervalmsec(), target);
  }

  // required uint32 numSamples = 6;
  if (has_numsamples()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->numsamples(), target);
  }

  // repeated .serviceCommon.syncOutputRabbit sample = 7;
  for (int i = 0; i < this->sample_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteMessageNoVirtualToArray(
        7, this->sample(i), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:serviceCommon.upmuDataRabbit)
  return target;
}

int upmuDataRabbit::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint64 timeStampMsec = 1;
    if (has_timestampmsec()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->timestampmsec());
    }

    // required string device = 2;
    if (has_device()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->device());
    }

    // required uint32 domainType = 3;
    if (has_domaintype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->domaintype());
    }

    // required uint32 msgType = 4;
    if (has_msgtype()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->msgtype());
    }

    // required float sampleIntervalMsec = 5;
    if (has_sampleintervalmsec()) {
      total_size += 1 + 4;
    }

    // required uint32 numSamples = 6;
    if (has_numsamples()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->numsamples());
    }

  }
  // repeated .serviceCommon.syncOutputRabbit sample = 7;
  total_size += 1 * this->sample_size();
  for (int i = 0; i < this->sample_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->sample(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 upmuDataRabbit::MergeFrom(const ::google::protobuf::Message& from) {
  GOOGLE_CHECK_NE(&from, this);
  const upmuDataRabbit* source =
    ::google::protobuf::internal::dynamic_cast_if_available<const upmuDataRabbit*>(
      &from);
  if (source == NULL) {
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
    MergeFrom(*source);
  }
}

void upmuDataRabbit::MergeFrom(const upmuDataRabbit& from) {
  GOOGLE_CHECK_NE(&from, this);
  sample_.MergeFrom(from.sample_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_timestampmsec()) {
      set_timestampmsec(from.timestampmsec());
    }
    if (from.has_device()) {
      set_device(from.device());
    }
    if (from.has_domaintype()) {
      set_domaintype(from.domaintype());
    }
    if (from.has_msgtype()) {
      set_msgtype(from.msgtype());
    }
    if (from.has_sampleintervalmsec()) {
      set_sampleintervalmsec(from.sampleintervalmsec());
    }
    if (from.has_numsamples()) {
      set_numsamples(from.numsamples());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

bool upmuDataRabbit::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000003f) != 0x0000003f) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->sample())) return false;
  return true;
}

void upmuDataRabbit::Swap(upmuDataRabbit* other) {
  if (other != this) {
    std::swap(timestampmsec_, other->timestampmsec_);
    std::swap(device_, other->device_);
    std::swap(domaintype_, other->domaintype_);
    std::swap(msgtype_, other->msgtype_);
    std::swap(sampleintervalmsec_, other->sampleintervalmsec_);
    std::swap(numsamples_, other->numsamples_);
    sample_.Swap(&other->sample_);
    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 upmuDataRabbit::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = upmuDataRabbit_descriptor_;
  metadata.reflection = upmuDataRabbit_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace serviceCommon

// @@protoc_insertion_point(global_scope)
