| // Generated by the protocol buffer compiler. DO NOT EDIT! |
| // source: process_stats.proto |
| |
| #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION |
| #include "process_stats.pb.h" |
| |
| #include <algorithm> |
| |
| #include <google/protobuf/stubs/common.h> |
| #include <google/protobuf/stubs/port.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 remoting { |
| namespace protocol { |
| |
| void protobuf_ShutdownFile_process_5fstats_2eproto() { |
| delete ProcessResourceUsage::default_instance_; |
| delete AggregatedProcessResourceUsage::default_instance_; |
| } |
| |
| #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER |
| void protobuf_AddDesc_process_5fstats_2eproto_impl() { |
| GOOGLE_PROTOBUF_VERIFY_VERSION; |
| |
| #else |
| void protobuf_AddDesc_process_5fstats_2eproto() { |
| static bool already_here = false; |
| if (already_here) return; |
| already_here = true; |
| GOOGLE_PROTOBUF_VERIFY_VERSION; |
| |
| #endif |
| ProcessResourceUsage::default_instance_ = new ProcessResourceUsage(); |
| AggregatedProcessResourceUsage::default_instance_ = new AggregatedProcessResourceUsage(); |
| ProcessResourceUsage::default_instance_->InitAsDefaultInstance(); |
| AggregatedProcessResourceUsage::default_instance_->InitAsDefaultInstance(); |
| ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_process_5fstats_2eproto); |
| } |
| |
| #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER |
| GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_process_5fstats_2eproto_once_); |
| void protobuf_AddDesc_process_5fstats_2eproto() { |
| ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_process_5fstats_2eproto_once_, |
| &protobuf_AddDesc_process_5fstats_2eproto_impl); |
| } |
| #else |
| // Force AddDescriptors() to be called at static initialization time. |
| struct StaticDescriptorInitializer_process_5fstats_2eproto { |
| StaticDescriptorInitializer_process_5fstats_2eproto() { |
| protobuf_AddDesc_process_5fstats_2eproto(); |
| } |
| } static_descriptor_initializer_process_5fstats_2eproto_; |
| #endif |
| |
| namespace { |
| |
| static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD; |
| GOOGLE_ATTRIBUTE_NOINLINE static void MergeFromFail(int line) { |
| GOOGLE_CHECK(false) << __FILE__ << ":" << line; |
| } |
| |
| } // namespace |
| |
| |
| // =================================================================== |
| |
| static ::std::string* MutableUnknownFieldsForProcessResourceUsage( |
| ProcessResourceUsage* ptr) { |
| return ptr->mutable_unknown_fields(); |
| } |
| |
| #if !defined(_MSC_VER) || _MSC_VER >= 1900 |
| const int ProcessResourceUsage::kProcessNameFieldNumber; |
| const int ProcessResourceUsage::kProcessorUsageFieldNumber; |
| const int ProcessResourceUsage::kWorkingSetSizeFieldNumber; |
| const int ProcessResourceUsage::kPagefileSizeFieldNumber; |
| #endif // !defined(_MSC_VER) || _MSC_VER >= 1900 |
| |
| ProcessResourceUsage::ProcessResourceUsage() |
| : ::google::protobuf::MessageLite(), _arena_ptr_(NULL) { |
| SharedCtor(); |
| // @@protoc_insertion_point(constructor:remoting.protocol.ProcessResourceUsage) |
| } |
| |
| void ProcessResourceUsage::InitAsDefaultInstance() { |
| } |
| |
| ProcessResourceUsage::ProcessResourceUsage(const ProcessResourceUsage& from) |
| : ::google::protobuf::MessageLite(), |
| _arena_ptr_(NULL) { |
| SharedCtor(); |
| MergeFrom(from); |
| // @@protoc_insertion_point(copy_constructor:remoting.protocol.ProcessResourceUsage) |
| } |
| |
| void ProcessResourceUsage::SharedCtor() { |
| ::google::protobuf::internal::GetEmptyString(); |
| _cached_size_ = 0; |
| _unknown_fields_.UnsafeSetDefault( |
| &::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| process_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| processor_usage_ = 0; |
| working_set_size_ = GOOGLE_ULONGLONG(0); |
| pagefile_size_ = GOOGLE_ULONGLONG(0); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| ProcessResourceUsage::~ProcessResourceUsage() { |
| // @@protoc_insertion_point(destructor:remoting.protocol.ProcessResourceUsage) |
| SharedDtor(); |
| } |
| |
| void ProcessResourceUsage::SharedDtor() { |
| _unknown_fields_.DestroyNoArena( |
| &::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| process_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER |
| if (this != &default_instance()) { |
| #else |
| if (this != default_instance_) { |
| #endif |
| } |
| } |
| |
| void ProcessResourceUsage::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const ProcessResourceUsage& ProcessResourceUsage::default_instance() { |
| #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER |
| protobuf_AddDesc_process_5fstats_2eproto(); |
| #else |
| if (default_instance_ == NULL) protobuf_AddDesc_process_5fstats_2eproto(); |
| #endif |
| return *default_instance_; |
| } |
| |
| ProcessResourceUsage* ProcessResourceUsage::default_instance_ = NULL; |
| |
| ProcessResourceUsage* ProcessResourceUsage::New(::google::protobuf::Arena* arena) const { |
| ProcessResourceUsage* n = new ProcessResourceUsage; |
| if (arena != NULL) { |
| arena->Own(n); |
| } |
| return n; |
| } |
| |
| void ProcessResourceUsage::Clear() { |
| // @@protoc_insertion_point(message_clear_start:remoting.protocol.ProcessResourceUsage) |
| #if defined(__clang__) |
| #define ZR_HELPER_(f) \ |
| _Pragma("clang diagnostic push") \ |
| _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ |
| __builtin_offsetof(ProcessResourceUsage, f) \ |
| _Pragma("clang diagnostic pop") |
| #else |
| #define ZR_HELPER_(f) reinterpret_cast<char*>(\ |
| &reinterpret_cast<ProcessResourceUsage*>(16)->f) |
| #endif |
| |
| #define ZR_(first, last) do {\ |
| ::memset(&first, 0,\ |
| ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ |
| } while (0) |
| |
| if (_has_bits_[0 / 32] & 15u) { |
| ZR_(processor_usage_, pagefile_size_); |
| if (has_process_name()) { |
| process_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| } |
| |
| #undef ZR_HELPER_ |
| #undef ZR_ |
| |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| _unknown_fields_.ClearToEmptyNoArena( |
| &::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| |
| bool ProcessResourceUsage::MergePartialFromCodedStream( |
| ::google::protobuf::io::CodedInputStream* input) { |
| #define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure |
| ::google::protobuf::uint32 tag; |
| ::google::protobuf::io::LazyStringOutputStream unknown_fields_string( |
| ::google::protobuf::internal::NewPermanentCallback( |
| &MutableUnknownFieldsForProcessResourceUsage, this)); |
| ::google::protobuf::io::CodedOutputStream unknown_fields_stream( |
| &unknown_fields_string, false); |
| // @@protoc_insertion_point(parse_start:remoting.protocol.ProcessResourceUsage) |
| 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)) { |
| // optional string process_name = 1; |
| case 1: { |
| if (tag == 10) { |
| DO_(::google::protobuf::internal::WireFormatLite::ReadString( |
| input, this->mutable_process_name())); |
| } else { |
| goto handle_unusual; |
| } |
| if (input->ExpectTag(17)) goto parse_processor_usage; |
| break; |
| } |
| |
| // optional double processor_usage = 2; |
| case 2: { |
| if (tag == 17) { |
| parse_processor_usage: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( |
| input, &processor_usage_))); |
| set_has_processor_usage(); |
| } else { |
| goto handle_unusual; |
| } |
| if (input->ExpectTag(24)) goto parse_working_set_size; |
| break; |
| } |
| |
| // optional uint64 working_set_size = 3; |
| case 3: { |
| if (tag == 24) { |
| parse_working_set_size: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( |
| input, &working_set_size_))); |
| set_has_working_set_size(); |
| } else { |
| goto handle_unusual; |
| } |
| if (input->ExpectTag(32)) goto parse_pagefile_size; |
| break; |
| } |
| |
| // optional uint64 pagefile_size = 4; |
| case 4: { |
| if (tag == 32) { |
| parse_pagefile_size: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( |
| input, &pagefile_size_))); |
| set_has_pagefile_size(); |
| } 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::WireFormatLite::SkipField( |
| input, tag, &unknown_fields_stream)); |
| break; |
| } |
| } |
| } |
| success: |
| // @@protoc_insertion_point(parse_success:remoting.protocol.ProcessResourceUsage) |
| return true; |
| failure: |
| // @@protoc_insertion_point(parse_failure:remoting.protocol.ProcessResourceUsage) |
| return false; |
| #undef DO_ |
| } |
| |
| void ProcessResourceUsage::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // @@protoc_insertion_point(serialize_start:remoting.protocol.ProcessResourceUsage) |
| // optional string process_name = 1; |
| if (has_process_name()) { |
| ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( |
| 1, this->process_name(), output); |
| } |
| |
| // optional double processor_usage = 2; |
| if (has_processor_usage()) { |
| ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->processor_usage(), output); |
| } |
| |
| // optional uint64 working_set_size = 3; |
| if (has_working_set_size()) { |
| ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->working_set_size(), output); |
| } |
| |
| // optional uint64 pagefile_size = 4; |
| if (has_pagefile_size()) { |
| ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->pagefile_size(), output); |
| } |
| |
| output->WriteRaw(unknown_fields().data(), |
| static_cast<int>(unknown_fields().size())); |
| // @@protoc_insertion_point(serialize_end:remoting.protocol.ProcessResourceUsage) |
| } |
| |
| int ProcessResourceUsage::ByteSize() const { |
| // @@protoc_insertion_point(message_byte_size_start:remoting.protocol.ProcessResourceUsage) |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & 15u) { |
| // optional string process_name = 1; |
| if (has_process_name()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::StringSize( |
| this->process_name()); |
| } |
| |
| // optional double processor_usage = 2; |
| if (has_processor_usage()) { |
| total_size += 1 + 8; |
| } |
| |
| // optional uint64 working_set_size = 3; |
| if (has_working_set_size()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::UInt64Size( |
| this->working_set_size()); |
| } |
| |
| // optional uint64 pagefile_size = 4; |
| if (has_pagefile_size()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::UInt64Size( |
| this->pagefile_size()); |
| } |
| |
| } |
| total_size += unknown_fields().size(); |
| |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = total_size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| return total_size; |
| } |
| |
| void ProcessResourceUsage::CheckTypeAndMergeFrom( |
| const ::google::protobuf::MessageLite& from) { |
| MergeFrom(*::google::protobuf::down_cast<const ProcessResourceUsage*>(&from)); |
| } |
| |
| void ProcessResourceUsage::MergeFrom(const ProcessResourceUsage& from) { |
| // @@protoc_insertion_point(class_specific_merge_from_start:remoting.protocol.ProcessResourceUsage) |
| if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_process_name()) { |
| set_has_process_name(); |
| process_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.process_name_); |
| } |
| if (from.has_processor_usage()) { |
| set_processor_usage(from.processor_usage()); |
| } |
| if (from.has_working_set_size()) { |
| set_working_set_size(from.working_set_size()); |
| } |
| if (from.has_pagefile_size()) { |
| set_pagefile_size(from.pagefile_size()); |
| } |
| } |
| if (!from.unknown_fields().empty()) { |
| mutable_unknown_fields()->append(from.unknown_fields()); |
| } |
| } |
| |
| void ProcessResourceUsage::CopyFrom(const ProcessResourceUsage& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:remoting.protocol.ProcessResourceUsage) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool ProcessResourceUsage::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void ProcessResourceUsage::Swap(ProcessResourceUsage* other) { |
| if (other == this) return; |
| InternalSwap(other); |
| } |
| void ProcessResourceUsage::InternalSwap(ProcessResourceUsage* other) { |
| process_name_.Swap(&other->process_name_); |
| std::swap(processor_usage_, other->processor_usage_); |
| std::swap(working_set_size_, other->working_set_size_); |
| std::swap(pagefile_size_, other->pagefile_size_); |
| std::swap(_has_bits_[0], other->_has_bits_[0]); |
| _unknown_fields_.Swap(&other->_unknown_fields_); |
| std::swap(_cached_size_, other->_cached_size_); |
| } |
| |
| ::std::string ProcessResourceUsage::GetTypeName() const { |
| return "remoting.protocol.ProcessResourceUsage"; |
| } |
| |
| #if PROTOBUF_INLINE_NOT_IN_HEADERS |
| // ProcessResourceUsage |
| |
| // optional string process_name = 1; |
| bool ProcessResourceUsage::has_process_name() const { |
| return (_has_bits_[0] & 0x00000001u) != 0; |
| } |
| void ProcessResourceUsage::set_has_process_name() { |
| _has_bits_[0] |= 0x00000001u; |
| } |
| void ProcessResourceUsage::clear_has_process_name() { |
| _has_bits_[0] &= ~0x00000001u; |
| } |
| void ProcessResourceUsage::clear_process_name() { |
| process_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| clear_has_process_name(); |
| } |
| const ::std::string& ProcessResourceUsage::process_name() const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.ProcessResourceUsage.process_name) |
| return process_name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| void ProcessResourceUsage::set_process_name(const ::std::string& value) { |
| set_has_process_name(); |
| process_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); |
| // @@protoc_insertion_point(field_set:remoting.protocol.ProcessResourceUsage.process_name) |
| } |
| void ProcessResourceUsage::set_process_name(const char* value) { |
| set_has_process_name(); |
| process_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); |
| // @@protoc_insertion_point(field_set_char:remoting.protocol.ProcessResourceUsage.process_name) |
| } |
| void ProcessResourceUsage::set_process_name(const char* value, size_t size) { |
| set_has_process_name(); |
| process_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), |
| ::std::string(reinterpret_cast<const char*>(value), size)); |
| // @@protoc_insertion_point(field_set_pointer:remoting.protocol.ProcessResourceUsage.process_name) |
| } |
| ::std::string* ProcessResourceUsage::mutable_process_name() { |
| set_has_process_name(); |
| // @@protoc_insertion_point(field_mutable:remoting.protocol.ProcessResourceUsage.process_name) |
| return process_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| ::std::string* ProcessResourceUsage::release_process_name() { |
| // @@protoc_insertion_point(field_release:remoting.protocol.ProcessResourceUsage.process_name) |
| clear_has_process_name(); |
| return process_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| void ProcessResourceUsage::set_allocated_process_name(::std::string* process_name) { |
| if (process_name != NULL) { |
| set_has_process_name(); |
| } else { |
| clear_has_process_name(); |
| } |
| process_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), process_name); |
| // @@protoc_insertion_point(field_set_allocated:remoting.protocol.ProcessResourceUsage.process_name) |
| } |
| |
| // optional double processor_usage = 2; |
| bool ProcessResourceUsage::has_processor_usage() const { |
| return (_has_bits_[0] & 0x00000002u) != 0; |
| } |
| void ProcessResourceUsage::set_has_processor_usage() { |
| _has_bits_[0] |= 0x00000002u; |
| } |
| void ProcessResourceUsage::clear_has_processor_usage() { |
| _has_bits_[0] &= ~0x00000002u; |
| } |
| void ProcessResourceUsage::clear_processor_usage() { |
| processor_usage_ = 0; |
| clear_has_processor_usage(); |
| } |
| double ProcessResourceUsage::processor_usage() const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.ProcessResourceUsage.processor_usage) |
| return processor_usage_; |
| } |
| void ProcessResourceUsage::set_processor_usage(double value) { |
| set_has_processor_usage(); |
| processor_usage_ = value; |
| // @@protoc_insertion_point(field_set:remoting.protocol.ProcessResourceUsage.processor_usage) |
| } |
| |
| // optional uint64 working_set_size = 3; |
| bool ProcessResourceUsage::has_working_set_size() const { |
| return (_has_bits_[0] & 0x00000004u) != 0; |
| } |
| void ProcessResourceUsage::set_has_working_set_size() { |
| _has_bits_[0] |= 0x00000004u; |
| } |
| void ProcessResourceUsage::clear_has_working_set_size() { |
| _has_bits_[0] &= ~0x00000004u; |
| } |
| void ProcessResourceUsage::clear_working_set_size() { |
| working_set_size_ = GOOGLE_ULONGLONG(0); |
| clear_has_working_set_size(); |
| } |
| ::google::protobuf::uint64 ProcessResourceUsage::working_set_size() const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.ProcessResourceUsage.working_set_size) |
| return working_set_size_; |
| } |
| void ProcessResourceUsage::set_working_set_size(::google::protobuf::uint64 value) { |
| set_has_working_set_size(); |
| working_set_size_ = value; |
| // @@protoc_insertion_point(field_set:remoting.protocol.ProcessResourceUsage.working_set_size) |
| } |
| |
| // optional uint64 pagefile_size = 4; |
| bool ProcessResourceUsage::has_pagefile_size() const { |
| return (_has_bits_[0] & 0x00000008u) != 0; |
| } |
| void ProcessResourceUsage::set_has_pagefile_size() { |
| _has_bits_[0] |= 0x00000008u; |
| } |
| void ProcessResourceUsage::clear_has_pagefile_size() { |
| _has_bits_[0] &= ~0x00000008u; |
| } |
| void ProcessResourceUsage::clear_pagefile_size() { |
| pagefile_size_ = GOOGLE_ULONGLONG(0); |
| clear_has_pagefile_size(); |
| } |
| ::google::protobuf::uint64 ProcessResourceUsage::pagefile_size() const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.ProcessResourceUsage.pagefile_size) |
| return pagefile_size_; |
| } |
| void ProcessResourceUsage::set_pagefile_size(::google::protobuf::uint64 value) { |
| set_has_pagefile_size(); |
| pagefile_size_ = value; |
| // @@protoc_insertion_point(field_set:remoting.protocol.ProcessResourceUsage.pagefile_size) |
| } |
| |
| #endif // PROTOBUF_INLINE_NOT_IN_HEADERS |
| |
| // =================================================================== |
| |
| static ::std::string* MutableUnknownFieldsForAggregatedProcessResourceUsage( |
| AggregatedProcessResourceUsage* ptr) { |
| return ptr->mutable_unknown_fields(); |
| } |
| |
| #if !defined(_MSC_VER) || _MSC_VER >= 1900 |
| const int AggregatedProcessResourceUsage::kNameFieldNumber; |
| const int AggregatedProcessResourceUsage::kProcessorUsageFieldNumber; |
| const int AggregatedProcessResourceUsage::kWorkingSetSizeFieldNumber; |
| const int AggregatedProcessResourceUsage::kPagefileSizeFieldNumber; |
| const int AggregatedProcessResourceUsage::kUsagesFieldNumber; |
| #endif // !defined(_MSC_VER) || _MSC_VER >= 1900 |
| |
| AggregatedProcessResourceUsage::AggregatedProcessResourceUsage() |
| : ::google::protobuf::MessageLite(), _arena_ptr_(NULL) { |
| SharedCtor(); |
| // @@protoc_insertion_point(constructor:remoting.protocol.AggregatedProcessResourceUsage) |
| } |
| |
| void AggregatedProcessResourceUsage::InitAsDefaultInstance() { |
| } |
| |
| AggregatedProcessResourceUsage::AggregatedProcessResourceUsage(const AggregatedProcessResourceUsage& from) |
| : ::google::protobuf::MessageLite(), |
| _arena_ptr_(NULL) { |
| SharedCtor(); |
| MergeFrom(from); |
| // @@protoc_insertion_point(copy_constructor:remoting.protocol.AggregatedProcessResourceUsage) |
| } |
| |
| void AggregatedProcessResourceUsage::SharedCtor() { |
| ::google::protobuf::internal::GetEmptyString(); |
| _cached_size_ = 0; |
| _unknown_fields_.UnsafeSetDefault( |
| &::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| processor_usage_ = 0; |
| working_set_size_ = GOOGLE_ULONGLONG(0); |
| pagefile_size_ = GOOGLE_ULONGLONG(0); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| } |
| |
| AggregatedProcessResourceUsage::~AggregatedProcessResourceUsage() { |
| // @@protoc_insertion_point(destructor:remoting.protocol.AggregatedProcessResourceUsage) |
| SharedDtor(); |
| } |
| |
| void AggregatedProcessResourceUsage::SharedDtor() { |
| _unknown_fields_.DestroyNoArena( |
| &::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER |
| if (this != &default_instance()) { |
| #else |
| if (this != default_instance_) { |
| #endif |
| } |
| } |
| |
| void AggregatedProcessResourceUsage::SetCachedSize(int size) const { |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| } |
| const AggregatedProcessResourceUsage& AggregatedProcessResourceUsage::default_instance() { |
| #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER |
| protobuf_AddDesc_process_5fstats_2eproto(); |
| #else |
| if (default_instance_ == NULL) protobuf_AddDesc_process_5fstats_2eproto(); |
| #endif |
| return *default_instance_; |
| } |
| |
| AggregatedProcessResourceUsage* AggregatedProcessResourceUsage::default_instance_ = NULL; |
| |
| AggregatedProcessResourceUsage* AggregatedProcessResourceUsage::New(::google::protobuf::Arena* arena) const { |
| AggregatedProcessResourceUsage* n = new AggregatedProcessResourceUsage; |
| if (arena != NULL) { |
| arena->Own(n); |
| } |
| return n; |
| } |
| |
| void AggregatedProcessResourceUsage::Clear() { |
| // @@protoc_insertion_point(message_clear_start:remoting.protocol.AggregatedProcessResourceUsage) |
| #if defined(__clang__) |
| #define ZR_HELPER_(f) \ |
| _Pragma("clang diagnostic push") \ |
| _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"") \ |
| __builtin_offsetof(AggregatedProcessResourceUsage, f) \ |
| _Pragma("clang diagnostic pop") |
| #else |
| #define ZR_HELPER_(f) reinterpret_cast<char*>(\ |
| &reinterpret_cast<AggregatedProcessResourceUsage*>(16)->f) |
| #endif |
| |
| #define ZR_(first, last) do {\ |
| ::memset(&first, 0,\ |
| ZR_HELPER_(last) - ZR_HELPER_(first) + sizeof(last));\ |
| } while (0) |
| |
| if (_has_bits_[0 / 32] & 15u) { |
| ZR_(processor_usage_, pagefile_size_); |
| if (has_name()) { |
| name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| } |
| |
| #undef ZR_HELPER_ |
| #undef ZR_ |
| |
| usages_.Clear(); |
| ::memset(_has_bits_, 0, sizeof(_has_bits_)); |
| _unknown_fields_.ClearToEmptyNoArena( |
| &::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| |
| bool AggregatedProcessResourceUsage::MergePartialFromCodedStream( |
| ::google::protobuf::io::CodedInputStream* input) { |
| #define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure |
| ::google::protobuf::uint32 tag; |
| ::google::protobuf::io::LazyStringOutputStream unknown_fields_string( |
| ::google::protobuf::internal::NewPermanentCallback( |
| &MutableUnknownFieldsForAggregatedProcessResourceUsage, this)); |
| ::google::protobuf::io::CodedOutputStream unknown_fields_stream( |
| &unknown_fields_string, false); |
| // @@protoc_insertion_point(parse_start:remoting.protocol.AggregatedProcessResourceUsage) |
| 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)) { |
| // optional string name = 1; |
| case 1: { |
| if (tag == 10) { |
| DO_(::google::protobuf::internal::WireFormatLite::ReadString( |
| input, this->mutable_name())); |
| } else { |
| goto handle_unusual; |
| } |
| if (input->ExpectTag(17)) goto parse_processor_usage; |
| break; |
| } |
| |
| // optional double processor_usage = 2; |
| case 2: { |
| if (tag == 17) { |
| parse_processor_usage: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( |
| input, &processor_usage_))); |
| set_has_processor_usage(); |
| } else { |
| goto handle_unusual; |
| } |
| if (input->ExpectTag(24)) goto parse_working_set_size; |
| break; |
| } |
| |
| // optional uint64 working_set_size = 3; |
| case 3: { |
| if (tag == 24) { |
| parse_working_set_size: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( |
| input, &working_set_size_))); |
| set_has_working_set_size(); |
| } else { |
| goto handle_unusual; |
| } |
| if (input->ExpectTag(32)) goto parse_pagefile_size; |
| break; |
| } |
| |
| // optional uint64 pagefile_size = 4; |
| case 4: { |
| if (tag == 32) { |
| parse_pagefile_size: |
| DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< |
| ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>( |
| input, &pagefile_size_))); |
| set_has_pagefile_size(); |
| } else { |
| goto handle_unusual; |
| } |
| if (input->ExpectTag(42)) goto parse_usages; |
| break; |
| } |
| |
| // repeated .remoting.protocol.ProcessResourceUsage usages = 5; |
| case 5: { |
| if (tag == 42) { |
| parse_usages: |
| DO_(input->IncrementRecursionDepth()); |
| parse_loop_usages: |
| DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth( |
| input, add_usages())); |
| } else { |
| goto handle_unusual; |
| } |
| if (input->ExpectTag(42)) goto parse_loop_usages; |
| input->UnsafeDecrementRecursionDepth(); |
| 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::WireFormatLite::SkipField( |
| input, tag, &unknown_fields_stream)); |
| break; |
| } |
| } |
| } |
| success: |
| // @@protoc_insertion_point(parse_success:remoting.protocol.AggregatedProcessResourceUsage) |
| return true; |
| failure: |
| // @@protoc_insertion_point(parse_failure:remoting.protocol.AggregatedProcessResourceUsage) |
| return false; |
| #undef DO_ |
| } |
| |
| void AggregatedProcessResourceUsage::SerializeWithCachedSizes( |
| ::google::protobuf::io::CodedOutputStream* output) const { |
| // @@protoc_insertion_point(serialize_start:remoting.protocol.AggregatedProcessResourceUsage) |
| // optional string name = 1; |
| if (has_name()) { |
| ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( |
| 1, this->name(), output); |
| } |
| |
| // optional double processor_usage = 2; |
| if (has_processor_usage()) { |
| ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->processor_usage(), output); |
| } |
| |
| // optional uint64 working_set_size = 3; |
| if (has_working_set_size()) { |
| ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->working_set_size(), output); |
| } |
| |
| // optional uint64 pagefile_size = 4; |
| if (has_pagefile_size()) { |
| ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->pagefile_size(), output); |
| } |
| |
| // repeated .remoting.protocol.ProcessResourceUsage usages = 5; |
| for (unsigned int i = 0, n = this->usages_size(); i < n; i++) { |
| ::google::protobuf::internal::WireFormatLite::WriteMessage( |
| 5, this->usages(i), output); |
| } |
| |
| output->WriteRaw(unknown_fields().data(), |
| static_cast<int>(unknown_fields().size())); |
| // @@protoc_insertion_point(serialize_end:remoting.protocol.AggregatedProcessResourceUsage) |
| } |
| |
| int AggregatedProcessResourceUsage::ByteSize() const { |
| // @@protoc_insertion_point(message_byte_size_start:remoting.protocol.AggregatedProcessResourceUsage) |
| int total_size = 0; |
| |
| if (_has_bits_[0 / 32] & 15u) { |
| // optional string name = 1; |
| if (has_name()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::StringSize( |
| this->name()); |
| } |
| |
| // optional double processor_usage = 2; |
| if (has_processor_usage()) { |
| total_size += 1 + 8; |
| } |
| |
| // optional uint64 working_set_size = 3; |
| if (has_working_set_size()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::UInt64Size( |
| this->working_set_size()); |
| } |
| |
| // optional uint64 pagefile_size = 4; |
| if (has_pagefile_size()) { |
| total_size += 1 + |
| ::google::protobuf::internal::WireFormatLite::UInt64Size( |
| this->pagefile_size()); |
| } |
| |
| } |
| // repeated .remoting.protocol.ProcessResourceUsage usages = 5; |
| total_size += 1 * this->usages_size(); |
| for (int i = 0; i < this->usages_size(); i++) { |
| total_size += |
| ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( |
| this->usages(i)); |
| } |
| |
| total_size += unknown_fields().size(); |
| |
| GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); |
| _cached_size_ = total_size; |
| GOOGLE_SAFE_CONCURRENT_WRITES_END(); |
| return total_size; |
| } |
| |
| void AggregatedProcessResourceUsage::CheckTypeAndMergeFrom( |
| const ::google::protobuf::MessageLite& from) { |
| MergeFrom(*::google::protobuf::down_cast<const AggregatedProcessResourceUsage*>(&from)); |
| } |
| |
| void AggregatedProcessResourceUsage::MergeFrom(const AggregatedProcessResourceUsage& from) { |
| // @@protoc_insertion_point(class_specific_merge_from_start:remoting.protocol.AggregatedProcessResourceUsage) |
| if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); |
| usages_.MergeFrom(from.usages_); |
| if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { |
| if (from.has_name()) { |
| set_has_name(); |
| name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); |
| } |
| if (from.has_processor_usage()) { |
| set_processor_usage(from.processor_usage()); |
| } |
| if (from.has_working_set_size()) { |
| set_working_set_size(from.working_set_size()); |
| } |
| if (from.has_pagefile_size()) { |
| set_pagefile_size(from.pagefile_size()); |
| } |
| } |
| if (!from.unknown_fields().empty()) { |
| mutable_unknown_fields()->append(from.unknown_fields()); |
| } |
| } |
| |
| void AggregatedProcessResourceUsage::CopyFrom(const AggregatedProcessResourceUsage& from) { |
| // @@protoc_insertion_point(class_specific_copy_from_start:remoting.protocol.AggregatedProcessResourceUsage) |
| if (&from == this) return; |
| Clear(); |
| MergeFrom(from); |
| } |
| |
| bool AggregatedProcessResourceUsage::IsInitialized() const { |
| |
| return true; |
| } |
| |
| void AggregatedProcessResourceUsage::Swap(AggregatedProcessResourceUsage* other) { |
| if (other == this) return; |
| InternalSwap(other); |
| } |
| void AggregatedProcessResourceUsage::InternalSwap(AggregatedProcessResourceUsage* other) { |
| name_.Swap(&other->name_); |
| std::swap(processor_usage_, other->processor_usage_); |
| std::swap(working_set_size_, other->working_set_size_); |
| std::swap(pagefile_size_, other->pagefile_size_); |
| usages_.UnsafeArenaSwap(&other->usages_); |
| std::swap(_has_bits_[0], other->_has_bits_[0]); |
| _unknown_fields_.Swap(&other->_unknown_fields_); |
| std::swap(_cached_size_, other->_cached_size_); |
| } |
| |
| ::std::string AggregatedProcessResourceUsage::GetTypeName() const { |
| return "remoting.protocol.AggregatedProcessResourceUsage"; |
| } |
| |
| #if PROTOBUF_INLINE_NOT_IN_HEADERS |
| // AggregatedProcessResourceUsage |
| |
| // optional string name = 1; |
| bool AggregatedProcessResourceUsage::has_name() const { |
| return (_has_bits_[0] & 0x00000001u) != 0; |
| } |
| void AggregatedProcessResourceUsage::set_has_name() { |
| _has_bits_[0] |= 0x00000001u; |
| } |
| void AggregatedProcessResourceUsage::clear_has_name() { |
| _has_bits_[0] &= ~0x00000001u; |
| } |
| void AggregatedProcessResourceUsage::clear_name() { |
| name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| clear_has_name(); |
| } |
| const ::std::string& AggregatedProcessResourceUsage::name() const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.AggregatedProcessResourceUsage.name) |
| return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| void AggregatedProcessResourceUsage::set_name(const ::std::string& value) { |
| set_has_name(); |
| name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); |
| // @@protoc_insertion_point(field_set:remoting.protocol.AggregatedProcessResourceUsage.name) |
| } |
| void AggregatedProcessResourceUsage::set_name(const char* value) { |
| set_has_name(); |
| name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); |
| // @@protoc_insertion_point(field_set_char:remoting.protocol.AggregatedProcessResourceUsage.name) |
| } |
| void AggregatedProcessResourceUsage::set_name(const char* value, size_t size) { |
| set_has_name(); |
| name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), |
| ::std::string(reinterpret_cast<const char*>(value), size)); |
| // @@protoc_insertion_point(field_set_pointer:remoting.protocol.AggregatedProcessResourceUsage.name) |
| } |
| ::std::string* AggregatedProcessResourceUsage::mutable_name() { |
| set_has_name(); |
| // @@protoc_insertion_point(field_mutable:remoting.protocol.AggregatedProcessResourceUsage.name) |
| return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| ::std::string* AggregatedProcessResourceUsage::release_name() { |
| // @@protoc_insertion_point(field_release:remoting.protocol.AggregatedProcessResourceUsage.name) |
| clear_has_name(); |
| return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); |
| } |
| void AggregatedProcessResourceUsage::set_allocated_name(::std::string* name) { |
| if (name != NULL) { |
| set_has_name(); |
| } else { |
| clear_has_name(); |
| } |
| name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); |
| // @@protoc_insertion_point(field_set_allocated:remoting.protocol.AggregatedProcessResourceUsage.name) |
| } |
| |
| // optional double processor_usage = 2; |
| bool AggregatedProcessResourceUsage::has_processor_usage() const { |
| return (_has_bits_[0] & 0x00000002u) != 0; |
| } |
| void AggregatedProcessResourceUsage::set_has_processor_usage() { |
| _has_bits_[0] |= 0x00000002u; |
| } |
| void AggregatedProcessResourceUsage::clear_has_processor_usage() { |
| _has_bits_[0] &= ~0x00000002u; |
| } |
| void AggregatedProcessResourceUsage::clear_processor_usage() { |
| processor_usage_ = 0; |
| clear_has_processor_usage(); |
| } |
| double AggregatedProcessResourceUsage::processor_usage() const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.AggregatedProcessResourceUsage.processor_usage) |
| return processor_usage_; |
| } |
| void AggregatedProcessResourceUsage::set_processor_usage(double value) { |
| set_has_processor_usage(); |
| processor_usage_ = value; |
| // @@protoc_insertion_point(field_set:remoting.protocol.AggregatedProcessResourceUsage.processor_usage) |
| } |
| |
| // optional uint64 working_set_size = 3; |
| bool AggregatedProcessResourceUsage::has_working_set_size() const { |
| return (_has_bits_[0] & 0x00000004u) != 0; |
| } |
| void AggregatedProcessResourceUsage::set_has_working_set_size() { |
| _has_bits_[0] |= 0x00000004u; |
| } |
| void AggregatedProcessResourceUsage::clear_has_working_set_size() { |
| _has_bits_[0] &= ~0x00000004u; |
| } |
| void AggregatedProcessResourceUsage::clear_working_set_size() { |
| working_set_size_ = GOOGLE_ULONGLONG(0); |
| clear_has_working_set_size(); |
| } |
| ::google::protobuf::uint64 AggregatedProcessResourceUsage::working_set_size() const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.AggregatedProcessResourceUsage.working_set_size) |
| return working_set_size_; |
| } |
| void AggregatedProcessResourceUsage::set_working_set_size(::google::protobuf::uint64 value) { |
| set_has_working_set_size(); |
| working_set_size_ = value; |
| // @@protoc_insertion_point(field_set:remoting.protocol.AggregatedProcessResourceUsage.working_set_size) |
| } |
| |
| // optional uint64 pagefile_size = 4; |
| bool AggregatedProcessResourceUsage::has_pagefile_size() const { |
| return (_has_bits_[0] & 0x00000008u) != 0; |
| } |
| void AggregatedProcessResourceUsage::set_has_pagefile_size() { |
| _has_bits_[0] |= 0x00000008u; |
| } |
| void AggregatedProcessResourceUsage::clear_has_pagefile_size() { |
| _has_bits_[0] &= ~0x00000008u; |
| } |
| void AggregatedProcessResourceUsage::clear_pagefile_size() { |
| pagefile_size_ = GOOGLE_ULONGLONG(0); |
| clear_has_pagefile_size(); |
| } |
| ::google::protobuf::uint64 AggregatedProcessResourceUsage::pagefile_size() const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.AggregatedProcessResourceUsage.pagefile_size) |
| return pagefile_size_; |
| } |
| void AggregatedProcessResourceUsage::set_pagefile_size(::google::protobuf::uint64 value) { |
| set_has_pagefile_size(); |
| pagefile_size_ = value; |
| // @@protoc_insertion_point(field_set:remoting.protocol.AggregatedProcessResourceUsage.pagefile_size) |
| } |
| |
| // repeated .remoting.protocol.ProcessResourceUsage usages = 5; |
| int AggregatedProcessResourceUsage::usages_size() const { |
| return usages_.size(); |
| } |
| void AggregatedProcessResourceUsage::clear_usages() { |
| usages_.Clear(); |
| } |
| const ::remoting::protocol::ProcessResourceUsage& AggregatedProcessResourceUsage::usages(int index) const { |
| // @@protoc_insertion_point(field_get:remoting.protocol.AggregatedProcessResourceUsage.usages) |
| return usages_.Get(index); |
| } |
| ::remoting::protocol::ProcessResourceUsage* AggregatedProcessResourceUsage::mutable_usages(int index) { |
| // @@protoc_insertion_point(field_mutable:remoting.protocol.AggregatedProcessResourceUsage.usages) |
| return usages_.Mutable(index); |
| } |
| ::remoting::protocol::ProcessResourceUsage* AggregatedProcessResourceUsage::add_usages() { |
| // @@protoc_insertion_point(field_add:remoting.protocol.AggregatedProcessResourceUsage.usages) |
| return usages_.Add(); |
| } |
| ::google::protobuf::RepeatedPtrField< ::remoting::protocol::ProcessResourceUsage >* |
| AggregatedProcessResourceUsage::mutable_usages() { |
| // @@protoc_insertion_point(field_mutable_list:remoting.protocol.AggregatedProcessResourceUsage.usages) |
| return &usages_; |
| } |
| const ::google::protobuf::RepeatedPtrField< ::remoting::protocol::ProcessResourceUsage >& |
| AggregatedProcessResourceUsage::usages() const { |
| // @@protoc_insertion_point(field_list:remoting.protocol.AggregatedProcessResourceUsage.usages) |
| return usages_; |
| } |
| |
| #endif // PROTOBUF_INLINE_NOT_IN_HEADERS |
| |
| // @@protoc_insertion_point(namespace_scope) |
| |
| } // namespace protocol |
| } // namespace remoting |
| |
| // @@protoc_insertion_point(global_scope) |