requests.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "requests.pb.h"
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>

namespace req {

void protobuf_ShutdownFile_requests_2eproto() {
  delete Request::default_instance_;
  delete TaggingRequest::default_instance_;
  delete NumberedRequest::default_instance_;
}

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

  Request::default_instance_ = new Request();
  TaggingRequest::default_instance_ = new TaggingRequest();
  NumberedRequest::default_instance_ = new NumberedRequest();
  Request::default_instance_->InitAsDefaultInstance();
  TaggingRequest::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
    &::req::Request::default_instance(),
    1, 11, false, false,
    &::req::TaggingRequest::default_instance());
  NumberedRequest::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
    &::req::Request::default_instance(),
    2, 11, false, false,
    &::req::NumberedRequest::default_instance());
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_requests_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_requests_2eproto {
  StaticDescriptorInitializer_requests_2eproto() {
    protobuf_AddDesc_requests_2eproto();
  }
} static_descriptor_initializer_requests_2eproto_;


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

#ifndef _MSC_VER
#endif  // !_MSC_VER

Request::Request() {
  SharedCtor();
}

void Request::InitAsDefaultInstance() {
}

Request::Request(const Request& from) {
  SharedCtor();
  MergeFrom(from);
}

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

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

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

const Request& Request::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_requests_2eproto();  return *default_instance_;
}

Request* Request::default_instance_ = NULL;

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

void Request::Clear() {
  _extensions_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool Request::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      return true;
    }
    if ((8u <= tag && tag < 88u)) {
      DO_(_extensions_.ParseField(tag, input, default_instance_));
      continue;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
  }
  return true;
#undef DO_
}

void Request::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // Extension range [1, 11)
  _extensions_.SerializeWithCachedSizes(
      1, 11, output);
  
}

int Request::ByteSize() const {
  int total_size = 0;
  
  total_size += _extensions_.ByteSize();
  
  _cached_size_ = total_size;
  return total_size;
}

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

void Request::MergeFrom(const Request& from) {
  GOOGLE_CHECK_NE(&from, this);
  _extensions_.MergeFrom(from._extensions_);
}

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

bool Request::IsInitialized() const {
  
  
  if (!_extensions_.IsInitialized()) return false;  return true;
}

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

::std::string Request::GetTypeName() const {
  return "req.Request";
}


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

#ifndef _MSC_VER
#endif  // !_MSC_VER

#ifndef _MSC_VER
const int TaggingRequest::kTaggingFieldNumber;
#endif
::google::protobuf::internal::ExtensionIdentifier< ::req::Request,
    ::google::protobuf::internal::MessageTypeTraits< ::req::TaggingRequest >, 11, false >
  TaggingRequest::tagging(kTaggingFieldNumber, ::req::TaggingRequest::default_instance());
TaggingRequest::TaggingRequest() {
  SharedCtor();
}

void TaggingRequest::InitAsDefaultInstance() {
}

TaggingRequest::TaggingRequest(const TaggingRequest& from) {
  SharedCtor();
  MergeFrom(from);
}

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

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

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

const TaggingRequest& TaggingRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_requests_2eproto();  return *default_instance_;
}

TaggingRequest* TaggingRequest::default_instance_ = NULL;

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

void TaggingRequest::Clear() {
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool TaggingRequest::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
  ::google::protobuf::uint32 tag;
  while ((tag = input->ReadTag()) != 0) {
    if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
      return true;
    }
    DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
  }
  return true;
#undef DO_
}

void TaggingRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
}

int TaggingRequest::ByteSize() const {
  int total_size = 0;
  
  _cached_size_ = total_size;
  return total_size;
}

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

void TaggingRequest::MergeFrom(const TaggingRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
}

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

bool TaggingRequest::IsInitialized() const {
  
  return true;
}

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

::std::string TaggingRequest::GetTypeName() const {
  return "req.TaggingRequest";
}


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

#ifndef _MSC_VER
const int NumberedRequest::kNumberFieldNumber;
#endif  // !_MSC_VER

#ifndef _MSC_VER
const int NumberedRequest::kNumberedFieldNumber;
#endif
::google::protobuf::internal::ExtensionIdentifier< ::req::Request,
    ::google::protobuf::internal::MessageTypeTraits< ::req::NumberedRequest >, 11, false >
  NumberedRequest::numbered(kNumberedFieldNumber, ::req::NumberedRequest::default_instance());
NumberedRequest::NumberedRequest() {
  SharedCtor();
}

void NumberedRequest::InitAsDefaultInstance() {
}

NumberedRequest::NumberedRequest(const NumberedRequest& from) {
  SharedCtor();
  MergeFrom(from);
}

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

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

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

const NumberedRequest& NumberedRequest::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_requests_2eproto();  return *default_instance_;
}

NumberedRequest* NumberedRequest::default_instance_ = NULL;

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

void NumberedRequest::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    number_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

bool NumberedRequest::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 number = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
          goto handle_uninterpreted;
        }
        DO_(::google::protobuf::internal::WireFormatLite::ReadInt32(
              input, &number_));
        _set_bit(0);
        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::WireFormatLite::SkipField(input, tag));
        break;
      }
    }
  }
  return true;
#undef DO_
}

void NumberedRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required int32 number = 1;
  if (_has_bit(0)) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->number(), output);
  }
  
}

int NumberedRequest::ByteSize() const {
  int total_size = 0;
  
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 number = 1;
    if (has_number()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->number());
    }
    
  }
  _cached_size_ = total_size;
  return total_size;
}

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

void NumberedRequest::MergeFrom(const NumberedRequest& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from._has_bit(0)) {
      set_number(from.number());
    }
  }
}

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

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

void NumberedRequest::Swap(NumberedRequest* other) {
  if (other != this) {
    std::swap(number_, other->number_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string NumberedRequest::GetTypeName() const {
  return "req.NumberedRequest";
}


}  // namespace req