TeamTalk/win-client/include/ProtocolBuffer/IM.Other.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "IM.Other.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/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace IM {
namespace Other {

void protobuf_ShutdownFile_IM_2eOther_2eproto() {
  delete IMHeartBeat::default_instance_;
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
void protobuf_AddDesc_IM_2eOther_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#else
void protobuf_AddDesc_IM_2eOther_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#endif
  IMHeartBeat::default_instance_ = new IMHeartBeat();
  IMHeartBeat::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_IM_2eOther_2eproto);
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_IM_2eOther_2eproto_once_);
void protobuf_AddDesc_IM_2eOther_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_IM_2eOther_2eproto_once_,
                 &protobuf_AddDesc_IM_2eOther_2eproto_impl);
}
#else
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_IM_2eOther_2eproto {
  StaticDescriptorInitializer_IM_2eOther_2eproto() {
    protobuf_AddDesc_IM_2eOther_2eproto();
  }
} static_descriptor_initializer_IM_2eOther_2eproto_;
#endif

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

#ifndef _MSC_VER
#endif  // !_MSC_VER

IMHeartBeat::IMHeartBeat()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:IM.Other.IMHeartBeat)
}

void IMHeartBeat::InitAsDefaultInstance() {
}

IMHeartBeat::IMHeartBeat(const IMHeartBeat& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:IM.Other.IMHeartBeat)
}

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

IMHeartBeat::~IMHeartBeat() {
  // @@protoc_insertion_point(destructor:IM.Other.IMHeartBeat)
  SharedDtor();
}

void IMHeartBeat::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void IMHeartBeat::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const IMHeartBeat& IMHeartBeat::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_IM_2eOther_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_IM_2eOther_2eproto();
#endif
  return *default_instance_;
}

IMHeartBeat* IMHeartBeat::default_instance_ = NULL;

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

void IMHeartBeat::Clear() {
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool IMHeartBeat::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:IM.Other.IMHeartBeat)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
  handle_unusual:
    if (tag == 0 ||
        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      goto success;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(
        input, tag, &unknown_fields_stream));
  }
success:
  // @@protoc_insertion_point(parse_success:IM.Other.IMHeartBeat)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:IM.Other.IMHeartBeat)
  return false;
#undef DO_
}

void IMHeartBeat::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:IM.Other.IMHeartBeat)
  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:IM.Other.IMHeartBeat)
}

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

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void IMHeartBeat::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const IMHeartBeat*>(&from));
}

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

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

bool IMHeartBeat::IsInitialized() const {

  return true;
}

void IMHeartBeat::Swap(IMHeartBeat* other) {
  if (other != this) {
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string IMHeartBeat::GetTypeName() const {
  return "IM.Other.IMHeartBeat";
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace Other
}  // namespace IM

// @@protoc_insertion_point(global_scope)