axmol/templates/lua-template-runtime/frameworks/runtime-src/Classes/runtime/Protos.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "Protos.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 runtime {

namespace {

const ::google::protobuf::Descriptor* FileSendProtos_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  FileSendProtos_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* FileSendProtos_CompressType_descriptor_ = NULL;
const ::google::protobuf::EnumDescriptor* FileSendProtos_VerifyMode_descriptor_ = NULL;
const ::google::protobuf::Descriptor* FileSendComplete_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  FileSendComplete_reflection_ = NULL;
const ::google::protobuf::EnumDescriptor* FileSendComplete_RESULT_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_Protos_2eproto() {
  protobuf_AddDesc_Protos_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "Protos.proto");
  GOOGLE_CHECK(file != NULL);
  FileSendProtos_descriptor_ = file->message_type(0);
  static const int FileSendProtos_offsets_[6] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendProtos, filename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendProtos, modified_time_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendProtos, content_size_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendProtos, compress_type_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendProtos, verify_mode_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendProtos, verify_sign_),
  };
  FileSendProtos_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      FileSendProtos_descriptor_,
      FileSendProtos::default_instance_,
      FileSendProtos_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendProtos, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendProtos, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(FileSendProtos));
  FileSendProtos_CompressType_descriptor_ = FileSendProtos_descriptor_->enum_type(0);
  FileSendProtos_VerifyMode_descriptor_ = FileSendProtos_descriptor_->enum_type(1);
  FileSendComplete_descriptor_ = file->message_type(1);
  static const int FileSendComplete_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendComplete, filename_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendComplete, result_),
  };
  FileSendComplete_reflection_ =
    new ::google::protobuf::internal::GeneratedMessageReflection(
      FileSendComplete_descriptor_,
      FileSendComplete::default_instance_,
      FileSendComplete_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendComplete, _has_bits_[0]),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileSendComplete, _unknown_fields_),
      -1,
      ::google::protobuf::DescriptorPool::generated_pool(),
      ::google::protobuf::MessageFactory::generated_factory(),
      sizeof(FileSendComplete));
  FileSendComplete_RESULT_descriptor_ = FileSendComplete_descriptor_->enum_type(0);
}

namespace {

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

void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    FileSendProtos_descriptor_, &FileSendProtos::default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
    FileSendComplete_descriptor_, &FileSendComplete::default_instance());
}

}  // namespace

void protobuf_ShutdownFile_Protos_2eproto() {
  delete FileSendProtos::default_instance_;
  delete FileSendProtos_reflection_;
  delete FileSendComplete::default_instance_;
  delete FileSendComplete_reflection_;
}

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

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\014Protos.proto\022\007runtime\"\263\002\n\016FileSendProt"
    "os\022\020\n\010filename\030\001 \002(\t\022\025\n\rmodified_time\030\002 "
    "\002(\004\022\024\n\014content_size\030\003 \002(\004\022;\n\rcompress_ty"
    "pe\030\004 \002(\0162$.runtime.FileSendProtos.Compre"
    "ssType\0227\n\013verify_mode\030\005 \002(\0162\".runtime.Fi"
    "leSendProtos.VerifyMode\022\023\n\013verify_sign\030\006"
    " \002(\t\"(\n\014CompressType\022\017\n\013NO_COMPRESS\020\000\022\007\n"
    "\003ZIP\020\001\"-\n\nVerifyMode\022\r\n\tNO_VERIFY\020\000\022\007\n\003C"
    "RC\020\001\022\007\n\003MD5\020\002\"\206\001\n\020FileSendComplete\022\020\n\010fi"
    "lename\030\001 \002(\t\0220\n\006result\030\002 \002(\0162 .runtime.F"
    "ileSendComplete.RESULT\".\n\006RESULT\022\013\n\007SUCC"
    "ESS\020\000\022\027\n\023FAILED_LOWDISKSPACE\020\001B\"\n\030org.cc"
    "dt.common.resourceB\006Protos", 506);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "Protos.proto", &protobuf_RegisterTypes);
  FileSendProtos::default_instance_ = new FileSendProtos();
  FileSendComplete::default_instance_ = new FileSendComplete();
  FileSendProtos::default_instance_->InitAsDefaultInstance();
  FileSendComplete::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_Protos_2eproto);
}

// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_Protos_2eproto {
  StaticDescriptorInitializer_Protos_2eproto() {
    protobuf_AddDesc_Protos_2eproto();
  }
} static_descriptor_initializer_Protos_2eproto_;

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

const ::google::protobuf::EnumDescriptor* FileSendProtos_CompressType_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return FileSendProtos_CompressType_descriptor_;
}
bool FileSendProtos_CompressType_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const FileSendProtos_CompressType FileSendProtos::NO_COMPRESS;
const FileSendProtos_CompressType FileSendProtos::ZIP;
const FileSendProtos_CompressType FileSendProtos::CompressType_MIN;
const FileSendProtos_CompressType FileSendProtos::CompressType_MAX;
const int FileSendProtos::CompressType_ARRAYSIZE;
#endif  // _MSC_VER
const ::google::protobuf::EnumDescriptor* FileSendProtos_VerifyMode_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return FileSendProtos_VerifyMode_descriptor_;
}
bool FileSendProtos_VerifyMode_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const FileSendProtos_VerifyMode FileSendProtos::NO_VERIFY;
const FileSendProtos_VerifyMode FileSendProtos::CRC;
const FileSendProtos_VerifyMode FileSendProtos::MD5;
const FileSendProtos_VerifyMode FileSendProtos::VerifyMode_MIN;
const FileSendProtos_VerifyMode FileSendProtos::VerifyMode_MAX;
const int FileSendProtos::VerifyMode_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int FileSendProtos::kFilenameFieldNumber;
const int FileSendProtos::kModifiedTimeFieldNumber;
const int FileSendProtos::kContentSizeFieldNumber;
const int FileSendProtos::kCompressTypeFieldNumber;
const int FileSendProtos::kVerifyModeFieldNumber;
const int FileSendProtos::kVerifySignFieldNumber;
#endif  // !_MSC_VER

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

void FileSendProtos::InitAsDefaultInstance() {
}

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

void FileSendProtos::SharedCtor() {
  _cached_size_ = 0;
  filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  modified_time_ = GOOGLE_ULONGLONG(0);
  content_size_ = GOOGLE_ULONGLONG(0);
  compress_type_ = 0;
  verify_mode_ = 0;
  verify_sign_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void FileSendProtos::SharedDtor() {
  if (filename_ != &::google::protobuf::internal::kEmptyString) {
    delete filename_;
  }
  if (verify_sign_ != &::google::protobuf::internal::kEmptyString) {
    delete verify_sign_;
  }
  if (this != default_instance_) {
  }
}

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

const FileSendProtos& FileSendProtos::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_Protos_2eproto();
  return *default_instance_;
}

FileSendProtos* FileSendProtos::default_instance_ = NULL;

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

void FileSendProtos::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_filename()) {
      if (filename_ != &::google::protobuf::internal::kEmptyString) {
        filename_->clear();
      }
    }
    modified_time_ = GOOGLE_ULONGLONG(0);
    content_size_ = GOOGLE_ULONGLONG(0);
    compress_type_ = 0;
    verify_mode_ = 0;
    if (has_verify_sign()) {
      if (verify_sign_ != &::google::protobuf::internal::kEmptyString) {
        verify_sign_->clear();
      }
    }
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool FileSendProtos::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 string filename = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_filename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->filename().data(), this->filename().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_modified_time;
        break;
      }

      // required uint64 modified_time = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_modified_time:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &modified_time_)));
          set_has_modified_time();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(24)) goto parse_content_size;
        break;
      }

      // required uint64 content_size = 3;
      case 3: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_content_size:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, &content_size_)));
          set_has_content_size();
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(32)) goto parse_compress_type;
        break;
      }

      // required .runtime.FileSendProtos.CompressType compress_type = 4;
      case 4: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_compress_type:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::runtime::FileSendProtos_CompressType_IsValid(value)) {
            set_compress_type(static_cast< ::runtime::FileSendProtos_CompressType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(4, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(40)) goto parse_verify_mode;
        break;
      }

      // required .runtime.FileSendProtos.VerifyMode verify_mode = 5;
      case 5: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_verify_mode:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::runtime::FileSendProtos_VerifyMode_IsValid(value)) {
            set_verify_mode(static_cast< ::runtime::FileSendProtos_VerifyMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(5, value);
          }
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(50)) goto parse_verify_sign;
        break;
      }

      // required string verify_sign = 6;
      case 6: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
         parse_verify_sign:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_verify_sign()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->verify_sign().data(), this->verify_sign().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 FileSendProtos::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string filename = 1;
  if (has_filename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->filename().data(), this->filename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->filename(), output);
  }

  // required uint64 modified_time = 2;
  if (has_modified_time()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->modified_time(), output);
  }

  // required uint64 content_size = 3;
  if (has_content_size()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->content_size(), output);
  }

  // required .runtime.FileSendProtos.CompressType compress_type = 4;
  if (has_compress_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      4, this->compress_type(), output);
  }

  // required .runtime.FileSendProtos.VerifyMode verify_mode = 5;
  if (has_verify_mode()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      5, this->verify_mode(), output);
  }

  // required string verify_sign = 6;
  if (has_verify_sign()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->verify_sign().data(), this->verify_sign().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      6, this->verify_sign(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* FileSendProtos::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string filename = 1;
  if (has_filename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->filename().data(), this->filename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->filename(), target);
  }

  // required uint64 modified_time = 2;
  if (has_modified_time()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->modified_time(), target);
  }

  // required uint64 content_size = 3;
  if (has_content_size()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->content_size(), target);
  }

  // required .runtime.FileSendProtos.CompressType compress_type = 4;
  if (has_compress_type()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      4, this->compress_type(), target);
  }

  // required .runtime.FileSendProtos.VerifyMode verify_mode = 5;
  if (has_verify_mode()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      5, this->verify_mode(), target);
  }

  // required string verify_sign = 6;
  if (has_verify_sign()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->verify_sign().data(), this->verify_sign().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        6, this->verify_sign(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string filename = 1;
    if (has_filename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->filename());
    }

    // required uint64 modified_time = 2;
    if (has_modified_time()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->modified_time());
    }

    // required uint64 content_size = 3;
    if (has_content_size()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
          this->content_size());
    }

    // required .runtime.FileSendProtos.CompressType compress_type = 4;
    if (has_compress_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->compress_type());
    }

    // required .runtime.FileSendProtos.VerifyMode verify_mode = 5;
    if (has_verify_mode()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->verify_mode());
    }

    // required string verify_sign = 6;
    if (has_verify_sign()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->verify_sign());
    }

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

void FileSendProtos::MergeFrom(const FileSendProtos& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_filename()) {
      set_filename(from.filename());
    }
    if (from.has_modified_time()) {
      set_modified_time(from.modified_time());
    }
    if (from.has_content_size()) {
      set_content_size(from.content_size());
    }
    if (from.has_compress_type()) {
      set_compress_type(from.compress_type());
    }
    if (from.has_verify_mode()) {
      set_verify_mode(from.verify_mode());
    }
    if (from.has_verify_sign()) {
      set_verify_sign(from.verify_sign());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void FileSendProtos::Swap(FileSendProtos* other) {
  if (other != this) {
    std::swap(filename_, other->filename_);
    std::swap(modified_time_, other->modified_time_);
    std::swap(content_size_, other->content_size_);
    std::swap(compress_type_, other->compress_type_);
    std::swap(verify_mode_, other->verify_mode_);
    std::swap(verify_sign_, other->verify_sign_);
    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 FileSendProtos::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = FileSendProtos_descriptor_;
  metadata.reflection = FileSendProtos_reflection_;
  return metadata;
}


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

const ::google::protobuf::EnumDescriptor* FileSendComplete_RESULT_descriptor() {
  protobuf_AssignDescriptorsOnce();
  return FileSendComplete_RESULT_descriptor_;
}
bool FileSendComplete_RESULT_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#ifndef _MSC_VER
const FileSendComplete_RESULT FileSendComplete::SUCCESS;
const FileSendComplete_RESULT FileSendComplete::FAILED_LOWDISKSPACE;
const FileSendComplete_RESULT FileSendComplete::RESULT_MIN;
const FileSendComplete_RESULT FileSendComplete::RESULT_MAX;
const int FileSendComplete::RESULT_ARRAYSIZE;
#endif  // _MSC_VER
#ifndef _MSC_VER
const int FileSendComplete::kFilenameFieldNumber;
const int FileSendComplete::kResultFieldNumber;
#endif  // !_MSC_VER

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

void FileSendComplete::InitAsDefaultInstance() {
}

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

void FileSendComplete::SharedCtor() {
  _cached_size_ = 0;
  filename_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
  result_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

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

void FileSendComplete::SharedDtor() {
  if (filename_ != &::google::protobuf::internal::kEmptyString) {
    delete filename_;
  }
  if (this != default_instance_) {
  }
}

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

const FileSendComplete& FileSendComplete::default_instance() {
  if (default_instance_ == NULL) protobuf_AddDesc_Protos_2eproto();
  return *default_instance_;
}

FileSendComplete* FileSendComplete::default_instance_ = NULL;

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

void FileSendComplete::Clear() {
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (has_filename()) {
      if (filename_ != &::google::protobuf::internal::kEmptyString) {
        filename_->clear();
      }
    }
    result_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->Clear();
}

bool FileSendComplete::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 string filename = 1;
      case 1: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_filename()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
            this->filename().data(), this->filename().length(),
            ::google::protobuf::internal::WireFormat::PARSE);
        } else {
          goto handle_uninterpreted;
        }
        if (input->ExpectTag(16)) goto parse_result;
        break;
      }

      // required .runtime.FileSendComplete.RESULT result = 2;
      case 2: {
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
         parse_result:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::runtime::FileSendComplete_RESULT_IsValid(value)) {
            set_result(static_cast< ::runtime::FileSendComplete_RESULT >(value));
          } else {
            mutable_unknown_fields()->AddVarint(2, value);
          }
        } 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 FileSendComplete::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // required string filename = 1;
  if (has_filename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->filename().data(), this->filename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    ::google::protobuf::internal::WireFormatLite::WriteString(
      1, this->filename(), output);
  }

  // required .runtime.FileSendComplete.RESULT result = 2;
  if (has_result()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      2, this->result(), output);
  }

  if (!unknown_fields().empty()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
}

::google::protobuf::uint8* FileSendComplete::SerializeWithCachedSizesToArray(
    ::google::protobuf::uint8* target) const {
  // required string filename = 1;
  if (has_filename()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
      this->filename().data(), this->filename().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE);
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        1, this->filename(), target);
  }

  // required .runtime.FileSendComplete.RESULT result = 2;
  if (has_result()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
      2, this->result(), target);
  }

  if (!unknown_fields().empty()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  return target;
}

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

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string filename = 1;
    if (has_filename()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->filename());
    }

    // required .runtime.FileSendComplete.RESULT result = 2;
    if (has_result()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->result());
    }

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

void FileSendComplete::MergeFrom(const FileSendComplete& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_filename()) {
      set_filename(from.filename());
    }
    if (from.has_result()) {
      set_result(from.result());
    }
  }
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
}

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

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

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

  return true;
}

void FileSendComplete::Swap(FileSendComplete* other) {
  if (other != this) {
    std::swap(filename_, other->filename_);
    std::swap(result_, other->result_);
    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 FileSendComplete::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = FileSendComplete_descriptor_;
  metadata.reflection = FileSendComplete_reflection_;
  return metadata;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace runtime

// @@protoc_insertion_point(global_scope)