| OLD | NEW |
| (Empty) |
| 1 // Generated by the protocol buffer compiler. DO NOT EDIT! | |
| 2 // source: google/protobuf/wrappers.proto | |
| 3 | |
| 4 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION | |
| 5 #include "google/protobuf/wrappers.pb.h" | |
| 6 | |
| 7 #include <algorithm> | |
| 8 | |
| 9 #include <google/protobuf/stubs/common.h> | |
| 10 #include <google/protobuf/stubs/once.h> | |
| 11 #include <google/protobuf/io/coded_stream.h> | |
| 12 #include <google/protobuf/wire_format_lite_inl.h> | |
| 13 #include <google/protobuf/descriptor.h> | |
| 14 #include <google/protobuf/generated_message_reflection.h> | |
| 15 #include <google/protobuf/reflection_ops.h> | |
| 16 #include <google/protobuf/wire_format.h> | |
| 17 // @@protoc_insertion_point(includes) | |
| 18 | |
| 19 namespace google { | |
| 20 namespace protobuf { | |
| 21 | |
| 22 namespace { | |
| 23 | |
| 24 const ::google::protobuf::Descriptor* DoubleValue_descriptor_ = NULL; | |
| 25 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 26 DoubleValue_reflection_ = NULL; | |
| 27 const ::google::protobuf::Descriptor* FloatValue_descriptor_ = NULL; | |
| 28 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 29 FloatValue_reflection_ = NULL; | |
| 30 const ::google::protobuf::Descriptor* Int64Value_descriptor_ = NULL; | |
| 31 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 32 Int64Value_reflection_ = NULL; | |
| 33 const ::google::protobuf::Descriptor* UInt64Value_descriptor_ = NULL; | |
| 34 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 35 UInt64Value_reflection_ = NULL; | |
| 36 const ::google::protobuf::Descriptor* Int32Value_descriptor_ = NULL; | |
| 37 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 38 Int32Value_reflection_ = NULL; | |
| 39 const ::google::protobuf::Descriptor* UInt32Value_descriptor_ = NULL; | |
| 40 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 41 UInt32Value_reflection_ = NULL; | |
| 42 const ::google::protobuf::Descriptor* BoolValue_descriptor_ = NULL; | |
| 43 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 44 BoolValue_reflection_ = NULL; | |
| 45 const ::google::protobuf::Descriptor* StringValue_descriptor_ = NULL; | |
| 46 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 47 StringValue_reflection_ = NULL; | |
| 48 const ::google::protobuf::Descriptor* BytesValue_descriptor_ = NULL; | |
| 49 const ::google::protobuf::internal::GeneratedMessageReflection* | |
| 50 BytesValue_reflection_ = NULL; | |
| 51 | |
| 52 } // namespace | |
| 53 | |
| 54 | |
| 55 void protobuf_AssignDesc_google_2fprotobuf_2fwrappers_2eproto() { | |
| 56 protobuf_AddDesc_google_2fprotobuf_2fwrappers_2eproto(); | |
| 57 const ::google::protobuf::FileDescriptor* file = | |
| 58 ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName( | |
| 59 "google/protobuf/wrappers.proto"); | |
| 60 GOOGLE_CHECK(file != NULL); | |
| 61 DoubleValue_descriptor_ = file->message_type(0); | |
| 62 static const int DoubleValue_offsets_[1] = { | |
| 63 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DoubleValue, value_), | |
| 64 }; | |
| 65 DoubleValue_reflection_ = | |
| 66 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 67 DoubleValue_descriptor_, | |
| 68 DoubleValue::default_instance_, | |
| 69 DoubleValue_offsets_, | |
| 70 -1, | |
| 71 -1, | |
| 72 -1, | |
| 73 sizeof(DoubleValue), | |
| 74 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DoubleValue, _internal_meta
data_), | |
| 75 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DoubleValue, _is_default_in
stance_)); | |
| 76 FloatValue_descriptor_ = file->message_type(1); | |
| 77 static const int FloatValue_offsets_[1] = { | |
| 78 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatValue, value_), | |
| 79 }; | |
| 80 FloatValue_reflection_ = | |
| 81 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 82 FloatValue_descriptor_, | |
| 83 FloatValue::default_instance_, | |
| 84 FloatValue_offsets_, | |
| 85 -1, | |
| 86 -1, | |
| 87 -1, | |
| 88 sizeof(FloatValue), | |
| 89 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatValue, _internal_metad
ata_), | |
| 90 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FloatValue, _is_default_ins
tance_)); | |
| 91 Int64Value_descriptor_ = file->message_type(2); | |
| 92 static const int Int64Value_offsets_[1] = { | |
| 93 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Int64Value, value_), | |
| 94 }; | |
| 95 Int64Value_reflection_ = | |
| 96 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 97 Int64Value_descriptor_, | |
| 98 Int64Value::default_instance_, | |
| 99 Int64Value_offsets_, | |
| 100 -1, | |
| 101 -1, | |
| 102 -1, | |
| 103 sizeof(Int64Value), | |
| 104 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Int64Value, _internal_metad
ata_), | |
| 105 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Int64Value, _is_default_ins
tance_)); | |
| 106 UInt64Value_descriptor_ = file->message_type(3); | |
| 107 static const int UInt64Value_offsets_[1] = { | |
| 108 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UInt64Value, value_), | |
| 109 }; | |
| 110 UInt64Value_reflection_ = | |
| 111 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 112 UInt64Value_descriptor_, | |
| 113 UInt64Value::default_instance_, | |
| 114 UInt64Value_offsets_, | |
| 115 -1, | |
| 116 -1, | |
| 117 -1, | |
| 118 sizeof(UInt64Value), | |
| 119 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UInt64Value, _internal_meta
data_), | |
| 120 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UInt64Value, _is_default_in
stance_)); | |
| 121 Int32Value_descriptor_ = file->message_type(4); | |
| 122 static const int Int32Value_offsets_[1] = { | |
| 123 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Int32Value, value_), | |
| 124 }; | |
| 125 Int32Value_reflection_ = | |
| 126 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 127 Int32Value_descriptor_, | |
| 128 Int32Value::default_instance_, | |
| 129 Int32Value_offsets_, | |
| 130 -1, | |
| 131 -1, | |
| 132 -1, | |
| 133 sizeof(Int32Value), | |
| 134 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Int32Value, _internal_metad
ata_), | |
| 135 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Int32Value, _is_default_ins
tance_)); | |
| 136 UInt32Value_descriptor_ = file->message_type(5); | |
| 137 static const int UInt32Value_offsets_[1] = { | |
| 138 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UInt32Value, value_), | |
| 139 }; | |
| 140 UInt32Value_reflection_ = | |
| 141 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 142 UInt32Value_descriptor_, | |
| 143 UInt32Value::default_instance_, | |
| 144 UInt32Value_offsets_, | |
| 145 -1, | |
| 146 -1, | |
| 147 -1, | |
| 148 sizeof(UInt32Value), | |
| 149 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UInt32Value, _internal_meta
data_), | |
| 150 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UInt32Value, _is_default_in
stance_)); | |
| 151 BoolValue_descriptor_ = file->message_type(6); | |
| 152 static const int BoolValue_offsets_[1] = { | |
| 153 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoolValue, value_), | |
| 154 }; | |
| 155 BoolValue_reflection_ = | |
| 156 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 157 BoolValue_descriptor_, | |
| 158 BoolValue::default_instance_, | |
| 159 BoolValue_offsets_, | |
| 160 -1, | |
| 161 -1, | |
| 162 -1, | |
| 163 sizeof(BoolValue), | |
| 164 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoolValue, _internal_metada
ta_), | |
| 165 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoolValue, _is_default_inst
ance_)); | |
| 166 StringValue_descriptor_ = file->message_type(7); | |
| 167 static const int StringValue_offsets_[1] = { | |
| 168 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringValue, value_), | |
| 169 }; | |
| 170 StringValue_reflection_ = | |
| 171 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 172 StringValue_descriptor_, | |
| 173 StringValue::default_instance_, | |
| 174 StringValue_offsets_, | |
| 175 -1, | |
| 176 -1, | |
| 177 -1, | |
| 178 sizeof(StringValue), | |
| 179 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringValue, _internal_meta
data_), | |
| 180 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StringValue, _is_default_in
stance_)); | |
| 181 BytesValue_descriptor_ = file->message_type(8); | |
| 182 static const int BytesValue_offsets_[1] = { | |
| 183 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BytesValue, value_), | |
| 184 }; | |
| 185 BytesValue_reflection_ = | |
| 186 ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessag
eReflection( | |
| 187 BytesValue_descriptor_, | |
| 188 BytesValue::default_instance_, | |
| 189 BytesValue_offsets_, | |
| 190 -1, | |
| 191 -1, | |
| 192 -1, | |
| 193 sizeof(BytesValue), | |
| 194 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BytesValue, _internal_metad
ata_), | |
| 195 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BytesValue, _is_default_ins
tance_)); | |
| 196 } | |
| 197 | |
| 198 namespace { | |
| 199 | |
| 200 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_); | |
| 201 inline void protobuf_AssignDescriptorsOnce() { | |
| 202 ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_, | |
| 203 &protobuf_AssignDesc_google_2fprotobuf_2fwrappers_2eproto); | |
| 204 } | |
| 205 | |
| 206 void protobuf_RegisterTypes(const ::std::string&) { | |
| 207 protobuf_AssignDescriptorsOnce(); | |
| 208 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 209 DoubleValue_descriptor_, &DoubleValue::default_instance()); | |
| 210 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 211 FloatValue_descriptor_, &FloatValue::default_instance()); | |
| 212 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 213 Int64Value_descriptor_, &Int64Value::default_instance()); | |
| 214 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 215 UInt64Value_descriptor_, &UInt64Value::default_instance()); | |
| 216 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 217 Int32Value_descriptor_, &Int32Value::default_instance()); | |
| 218 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 219 UInt32Value_descriptor_, &UInt32Value::default_instance()); | |
| 220 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 221 BoolValue_descriptor_, &BoolValue::default_instance()); | |
| 222 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 223 StringValue_descriptor_, &StringValue::default_instance()); | |
| 224 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( | |
| 225 BytesValue_descriptor_, &BytesValue::default_instance()); | |
| 226 } | |
| 227 | |
| 228 } // namespace | |
| 229 | |
| 230 void protobuf_ShutdownFile_google_2fprotobuf_2fwrappers_2eproto() { | |
| 231 delete DoubleValue::default_instance_; | |
| 232 delete DoubleValue_reflection_; | |
| 233 delete FloatValue::default_instance_; | |
| 234 delete FloatValue_reflection_; | |
| 235 delete Int64Value::default_instance_; | |
| 236 delete Int64Value_reflection_; | |
| 237 delete UInt64Value::default_instance_; | |
| 238 delete UInt64Value_reflection_; | |
| 239 delete Int32Value::default_instance_; | |
| 240 delete Int32Value_reflection_; | |
| 241 delete UInt32Value::default_instance_; | |
| 242 delete UInt32Value_reflection_; | |
| 243 delete BoolValue::default_instance_; | |
| 244 delete BoolValue_reflection_; | |
| 245 delete StringValue::default_instance_; | |
| 246 delete StringValue_reflection_; | |
| 247 delete BytesValue::default_instance_; | |
| 248 delete BytesValue_reflection_; | |
| 249 } | |
| 250 | |
| 251 void protobuf_AddDesc_google_2fprotobuf_2fwrappers_2eproto() { | |
| 252 static bool already_here = false; | |
| 253 if (already_here) return; | |
| 254 already_here = true; | |
| 255 GOOGLE_PROTOBUF_VERIFY_VERSION; | |
| 256 | |
| 257 ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( | |
| 258 "\n\036google/protobuf/wrappers.proto\022\017google" | |
| 259 ".protobuf\"\034\n\013DoubleValue\022\r\n\005value\030\001 \001(\001\"" | |
| 260 "\033\n\nFloatValue\022\r\n\005value\030\001 \001(\002\"\033\n\nInt64Val" | |
| 261 "ue\022\r\n\005value\030\001 \001(\003\"\034\n\013UInt64Value\022\r\n\005val
u" | |
| 262 "e\030\001 \001(\004\"\033\n\nInt32Value\022\r\n\005value\030\001 \001(\005\
"\034\n\013" | |
| 263 "UInt32Value\022\r\n\005value\030\001 \001(\r\"\032\n\tBoolValue\022" | |
| 264 "\r\n\005value\030\001 \001(\010\"\034\n\013StringValue\022\r\n\005value\030
\001" | |
| 265 " \001(\t\"\033\n\nBytesValue\022\r\n\005value\030\001 \001(\014BM\n\023com" | |
| 266 ".google.protobufB\rWrappersProtoP\001\242\002\003GPB\252" | |
| 267 "\002\036Google.Protobuf.WellKnownTypesb\006proto3", 400); | |
| 268 ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( | |
| 269 "google/protobuf/wrappers.proto", &protobuf_RegisterTypes); | |
| 270 DoubleValue::default_instance_ = new DoubleValue(); | |
| 271 FloatValue::default_instance_ = new FloatValue(); | |
| 272 Int64Value::default_instance_ = new Int64Value(); | |
| 273 UInt64Value::default_instance_ = new UInt64Value(); | |
| 274 Int32Value::default_instance_ = new Int32Value(); | |
| 275 UInt32Value::default_instance_ = new UInt32Value(); | |
| 276 BoolValue::default_instance_ = new BoolValue(); | |
| 277 StringValue::default_instance_ = new StringValue(); | |
| 278 BytesValue::default_instance_ = new BytesValue(); | |
| 279 DoubleValue::default_instance_->InitAsDefaultInstance(); | |
| 280 FloatValue::default_instance_->InitAsDefaultInstance(); | |
| 281 Int64Value::default_instance_->InitAsDefaultInstance(); | |
| 282 UInt64Value::default_instance_->InitAsDefaultInstance(); | |
| 283 Int32Value::default_instance_->InitAsDefaultInstance(); | |
| 284 UInt32Value::default_instance_->InitAsDefaultInstance(); | |
| 285 BoolValue::default_instance_->InitAsDefaultInstance(); | |
| 286 StringValue::default_instance_->InitAsDefaultInstance(); | |
| 287 BytesValue::default_instance_->InitAsDefaultInstance(); | |
| 288 ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fproto
buf_2fwrappers_2eproto); | |
| 289 } | |
| 290 | |
| 291 // Force AddDescriptors() to be called at static initialization time. | |
| 292 struct StaticDescriptorInitializer_google_2fprotobuf_2fwrappers_2eproto { | |
| 293 StaticDescriptorInitializer_google_2fprotobuf_2fwrappers_2eproto() { | |
| 294 protobuf_AddDesc_google_2fprotobuf_2fwrappers_2eproto(); | |
| 295 } | |
| 296 } static_descriptor_initializer_google_2fprotobuf_2fwrappers_2eproto_; | |
| 297 | |
| 298 namespace { | |
| 299 | |
| 300 static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD; | |
| 301 static void MergeFromFail(int line) { | |
| 302 GOOGLE_CHECK(false) << __FILE__ << ":" << line; | |
| 303 } | |
| 304 | |
| 305 } // namespace | |
| 306 | |
| 307 | |
| 308 // =================================================================== | |
| 309 | |
| 310 #ifndef _MSC_VER | |
| 311 const int DoubleValue::kValueFieldNumber; | |
| 312 #endif // !_MSC_VER | |
| 313 | |
| 314 DoubleValue::DoubleValue() | |
| 315 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 316 SharedCtor(); | |
| 317 // @@protoc_insertion_point(constructor:google.protobuf.DoubleValue) | |
| 318 } | |
| 319 | |
| 320 void DoubleValue::InitAsDefaultInstance() { | |
| 321 _is_default_instance_ = true; | |
| 322 } | |
| 323 | |
| 324 DoubleValue::DoubleValue(const DoubleValue& from) | |
| 325 : ::google::protobuf::Message(), | |
| 326 _internal_metadata_(NULL) { | |
| 327 SharedCtor(); | |
| 328 MergeFrom(from); | |
| 329 // @@protoc_insertion_point(copy_constructor:google.protobuf.DoubleValue) | |
| 330 } | |
| 331 | |
| 332 void DoubleValue::SharedCtor() { | |
| 333 _is_default_instance_ = false; | |
| 334 _cached_size_ = 0; | |
| 335 value_ = 0; | |
| 336 } | |
| 337 | |
| 338 DoubleValue::~DoubleValue() { | |
| 339 // @@protoc_insertion_point(destructor:google.protobuf.DoubleValue) | |
| 340 SharedDtor(); | |
| 341 } | |
| 342 | |
| 343 void DoubleValue::SharedDtor() { | |
| 344 if (this != default_instance_) { | |
| 345 } | |
| 346 } | |
| 347 | |
| 348 void DoubleValue::SetCachedSize(int size) const { | |
| 349 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 350 _cached_size_ = size; | |
| 351 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 352 } | |
| 353 const ::google::protobuf::Descriptor* DoubleValue::descriptor() { | |
| 354 protobuf_AssignDescriptorsOnce(); | |
| 355 return DoubleValue_descriptor_; | |
| 356 } | |
| 357 | |
| 358 const DoubleValue& DoubleValue::default_instance() { | |
| 359 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 360 return *default_instance_; | |
| 361 } | |
| 362 | |
| 363 DoubleValue* DoubleValue::default_instance_ = NULL; | |
| 364 | |
| 365 DoubleValue* DoubleValue::New(::google::protobuf::Arena* arena) const { | |
| 366 DoubleValue* n = new DoubleValue; | |
| 367 if (arena != NULL) { | |
| 368 arena->Own(n); | |
| 369 } | |
| 370 return n; | |
| 371 } | |
| 372 | |
| 373 void DoubleValue::Clear() { | |
| 374 value_ = 0; | |
| 375 } | |
| 376 | |
| 377 bool DoubleValue::MergePartialFromCodedStream( | |
| 378 ::google::protobuf::io::CodedInputStream* input) { | |
| 379 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 380 ::google::protobuf::uint32 tag; | |
| 381 // @@protoc_insertion_point(parse_start:google.protobuf.DoubleValue) | |
| 382 for (;;) { | |
| 383 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 384 tag = p.first; | |
| 385 if (!p.second) goto handle_unusual; | |
| 386 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 387 // optional double value = 1; | |
| 388 case 1: { | |
| 389 if (tag == 9) { | |
| 390 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< | |
| 391 double, ::google::protobuf::internal::WireFormatLite::TYPE_DO
UBLE>( | |
| 392 input, &value_))); | |
| 393 | |
| 394 } else { | |
| 395 goto handle_unusual; | |
| 396 } | |
| 397 if (input->ExpectAtEnd()) goto success; | |
| 398 break; | |
| 399 } | |
| 400 | |
| 401 default: { | |
| 402 handle_unusual: | |
| 403 if (tag == 0 || | |
| 404 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 405 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 406 goto success; | |
| 407 } | |
| 408 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 409 break; | |
| 410 } | |
| 411 } | |
| 412 } | |
| 413 success: | |
| 414 // @@protoc_insertion_point(parse_success:google.protobuf.DoubleValue) | |
| 415 return true; | |
| 416 failure: | |
| 417 // @@protoc_insertion_point(parse_failure:google.protobuf.DoubleValue) | |
| 418 return false; | |
| 419 #undef DO_ | |
| 420 } | |
| 421 | |
| 422 void DoubleValue::SerializeWithCachedSizes( | |
| 423 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 424 // @@protoc_insertion_point(serialize_start:google.protobuf.DoubleValue) | |
| 425 // optional double value = 1; | |
| 426 if (this->value() != 0) { | |
| 427 ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->value(),
output); | |
| 428 } | |
| 429 | |
| 430 // @@protoc_insertion_point(serialize_end:google.protobuf.DoubleValue) | |
| 431 } | |
| 432 | |
| 433 ::google::protobuf::uint8* DoubleValue::SerializeWithCachedSizesToArray( | |
| 434 ::google::protobuf::uint8* target) const { | |
| 435 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.DoubleVal
ue) | |
| 436 // optional double value = 1; | |
| 437 if (this->value() != 0) { | |
| 438 target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1,
this->value(), target); | |
| 439 } | |
| 440 | |
| 441 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.DoubleValue
) | |
| 442 return target; | |
| 443 } | |
| 444 | |
| 445 int DoubleValue::ByteSize() const { | |
| 446 int total_size = 0; | |
| 447 | |
| 448 // optional double value = 1; | |
| 449 if (this->value() != 0) { | |
| 450 total_size += 1 + 8; | |
| 451 } | |
| 452 | |
| 453 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 454 _cached_size_ = total_size; | |
| 455 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 456 return total_size; | |
| 457 } | |
| 458 | |
| 459 void DoubleValue::MergeFrom(const ::google::protobuf::Message& from) { | |
| 460 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 461 const DoubleValue* source = | |
| 462 ::google::protobuf::internal::DynamicCastToGenerated<const DoubleValue>( | |
| 463 &from); | |
| 464 if (source == NULL) { | |
| 465 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 466 } else { | |
| 467 MergeFrom(*source); | |
| 468 } | |
| 469 } | |
| 470 | |
| 471 void DoubleValue::MergeFrom(const DoubleValue& from) { | |
| 472 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 473 if (from.value() != 0) { | |
| 474 set_value(from.value()); | |
| 475 } | |
| 476 } | |
| 477 | |
| 478 void DoubleValue::CopyFrom(const ::google::protobuf::Message& from) { | |
| 479 if (&from == this) return; | |
| 480 Clear(); | |
| 481 MergeFrom(from); | |
| 482 } | |
| 483 | |
| 484 void DoubleValue::CopyFrom(const DoubleValue& from) { | |
| 485 if (&from == this) return; | |
| 486 Clear(); | |
| 487 MergeFrom(from); | |
| 488 } | |
| 489 | |
| 490 bool DoubleValue::IsInitialized() const { | |
| 491 | |
| 492 return true; | |
| 493 } | |
| 494 | |
| 495 void DoubleValue::Swap(DoubleValue* other) { | |
| 496 if (other == this) return; | |
| 497 InternalSwap(other); | |
| 498 } | |
| 499 void DoubleValue::InternalSwap(DoubleValue* other) { | |
| 500 std::swap(value_, other->value_); | |
| 501 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 502 std::swap(_cached_size_, other->_cached_size_); | |
| 503 } | |
| 504 | |
| 505 ::google::protobuf::Metadata DoubleValue::GetMetadata() const { | |
| 506 protobuf_AssignDescriptorsOnce(); | |
| 507 ::google::protobuf::Metadata metadata; | |
| 508 metadata.descriptor = DoubleValue_descriptor_; | |
| 509 metadata.reflection = DoubleValue_reflection_; | |
| 510 return metadata; | |
| 511 } | |
| 512 | |
| 513 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 514 // DoubleValue | |
| 515 | |
| 516 // optional double value = 1; | |
| 517 void DoubleValue::clear_value() { | |
| 518 value_ = 0; | |
| 519 } | |
| 520 double DoubleValue::value() const { | |
| 521 // @@protoc_insertion_point(field_get:google.protobuf.DoubleValue.value) | |
| 522 return value_; | |
| 523 } | |
| 524 void DoubleValue::set_value(double value) { | |
| 525 | |
| 526 value_ = value; | |
| 527 // @@protoc_insertion_point(field_set:google.protobuf.DoubleValue.value) | |
| 528 } | |
| 529 | |
| 530 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 531 | |
| 532 // =================================================================== | |
| 533 | |
| 534 #ifndef _MSC_VER | |
| 535 const int FloatValue::kValueFieldNumber; | |
| 536 #endif // !_MSC_VER | |
| 537 | |
| 538 FloatValue::FloatValue() | |
| 539 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 540 SharedCtor(); | |
| 541 // @@protoc_insertion_point(constructor:google.protobuf.FloatValue) | |
| 542 } | |
| 543 | |
| 544 void FloatValue::InitAsDefaultInstance() { | |
| 545 _is_default_instance_ = true; | |
| 546 } | |
| 547 | |
| 548 FloatValue::FloatValue(const FloatValue& from) | |
| 549 : ::google::protobuf::Message(), | |
| 550 _internal_metadata_(NULL) { | |
| 551 SharedCtor(); | |
| 552 MergeFrom(from); | |
| 553 // @@protoc_insertion_point(copy_constructor:google.protobuf.FloatValue) | |
| 554 } | |
| 555 | |
| 556 void FloatValue::SharedCtor() { | |
| 557 _is_default_instance_ = false; | |
| 558 _cached_size_ = 0; | |
| 559 value_ = 0; | |
| 560 } | |
| 561 | |
| 562 FloatValue::~FloatValue() { | |
| 563 // @@protoc_insertion_point(destructor:google.protobuf.FloatValue) | |
| 564 SharedDtor(); | |
| 565 } | |
| 566 | |
| 567 void FloatValue::SharedDtor() { | |
| 568 if (this != default_instance_) { | |
| 569 } | |
| 570 } | |
| 571 | |
| 572 void FloatValue::SetCachedSize(int size) const { | |
| 573 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 574 _cached_size_ = size; | |
| 575 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 576 } | |
| 577 const ::google::protobuf::Descriptor* FloatValue::descriptor() { | |
| 578 protobuf_AssignDescriptorsOnce(); | |
| 579 return FloatValue_descriptor_; | |
| 580 } | |
| 581 | |
| 582 const FloatValue& FloatValue::default_instance() { | |
| 583 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 584 return *default_instance_; | |
| 585 } | |
| 586 | |
| 587 FloatValue* FloatValue::default_instance_ = NULL; | |
| 588 | |
| 589 FloatValue* FloatValue::New(::google::protobuf::Arena* arena) const { | |
| 590 FloatValue* n = new FloatValue; | |
| 591 if (arena != NULL) { | |
| 592 arena->Own(n); | |
| 593 } | |
| 594 return n; | |
| 595 } | |
| 596 | |
| 597 void FloatValue::Clear() { | |
| 598 value_ = 0; | |
| 599 } | |
| 600 | |
| 601 bool FloatValue::MergePartialFromCodedStream( | |
| 602 ::google::protobuf::io::CodedInputStream* input) { | |
| 603 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 604 ::google::protobuf::uint32 tag; | |
| 605 // @@protoc_insertion_point(parse_start:google.protobuf.FloatValue) | |
| 606 for (;;) { | |
| 607 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 608 tag = p.first; | |
| 609 if (!p.second) goto handle_unusual; | |
| 610 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 611 // optional float value = 1; | |
| 612 case 1: { | |
| 613 if (tag == 13) { | |
| 614 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< | |
| 615 float, ::google::protobuf::internal::WireFormatLite::TYPE_FLO
AT>( | |
| 616 input, &value_))); | |
| 617 | |
| 618 } else { | |
| 619 goto handle_unusual; | |
| 620 } | |
| 621 if (input->ExpectAtEnd()) goto success; | |
| 622 break; | |
| 623 } | |
| 624 | |
| 625 default: { | |
| 626 handle_unusual: | |
| 627 if (tag == 0 || | |
| 628 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 629 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 630 goto success; | |
| 631 } | |
| 632 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 633 break; | |
| 634 } | |
| 635 } | |
| 636 } | |
| 637 success: | |
| 638 // @@protoc_insertion_point(parse_success:google.protobuf.FloatValue) | |
| 639 return true; | |
| 640 failure: | |
| 641 // @@protoc_insertion_point(parse_failure:google.protobuf.FloatValue) | |
| 642 return false; | |
| 643 #undef DO_ | |
| 644 } | |
| 645 | |
| 646 void FloatValue::SerializeWithCachedSizes( | |
| 647 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 648 // @@protoc_insertion_point(serialize_start:google.protobuf.FloatValue) | |
| 649 // optional float value = 1; | |
| 650 if (this->value() != 0) { | |
| 651 ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->value(), o
utput); | |
| 652 } | |
| 653 | |
| 654 // @@protoc_insertion_point(serialize_end:google.protobuf.FloatValue) | |
| 655 } | |
| 656 | |
| 657 ::google::protobuf::uint8* FloatValue::SerializeWithCachedSizesToArray( | |
| 658 ::google::protobuf::uint8* target) const { | |
| 659 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.FloatValu
e) | |
| 660 // optional float value = 1; | |
| 661 if (this->value() != 0) { | |
| 662 target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1,
this->value(), target); | |
| 663 } | |
| 664 | |
| 665 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.FloatValue) | |
| 666 return target; | |
| 667 } | |
| 668 | |
| 669 int FloatValue::ByteSize() const { | |
| 670 int total_size = 0; | |
| 671 | |
| 672 // optional float value = 1; | |
| 673 if (this->value() != 0) { | |
| 674 total_size += 1 + 4; | |
| 675 } | |
| 676 | |
| 677 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 678 _cached_size_ = total_size; | |
| 679 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 680 return total_size; | |
| 681 } | |
| 682 | |
| 683 void FloatValue::MergeFrom(const ::google::protobuf::Message& from) { | |
| 684 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 685 const FloatValue* source = | |
| 686 ::google::protobuf::internal::DynamicCastToGenerated<const FloatValue>( | |
| 687 &from); | |
| 688 if (source == NULL) { | |
| 689 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 690 } else { | |
| 691 MergeFrom(*source); | |
| 692 } | |
| 693 } | |
| 694 | |
| 695 void FloatValue::MergeFrom(const FloatValue& from) { | |
| 696 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 697 if (from.value() != 0) { | |
| 698 set_value(from.value()); | |
| 699 } | |
| 700 } | |
| 701 | |
| 702 void FloatValue::CopyFrom(const ::google::protobuf::Message& from) { | |
| 703 if (&from == this) return; | |
| 704 Clear(); | |
| 705 MergeFrom(from); | |
| 706 } | |
| 707 | |
| 708 void FloatValue::CopyFrom(const FloatValue& from) { | |
| 709 if (&from == this) return; | |
| 710 Clear(); | |
| 711 MergeFrom(from); | |
| 712 } | |
| 713 | |
| 714 bool FloatValue::IsInitialized() const { | |
| 715 | |
| 716 return true; | |
| 717 } | |
| 718 | |
| 719 void FloatValue::Swap(FloatValue* other) { | |
| 720 if (other == this) return; | |
| 721 InternalSwap(other); | |
| 722 } | |
| 723 void FloatValue::InternalSwap(FloatValue* other) { | |
| 724 std::swap(value_, other->value_); | |
| 725 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 726 std::swap(_cached_size_, other->_cached_size_); | |
| 727 } | |
| 728 | |
| 729 ::google::protobuf::Metadata FloatValue::GetMetadata() const { | |
| 730 protobuf_AssignDescriptorsOnce(); | |
| 731 ::google::protobuf::Metadata metadata; | |
| 732 metadata.descriptor = FloatValue_descriptor_; | |
| 733 metadata.reflection = FloatValue_reflection_; | |
| 734 return metadata; | |
| 735 } | |
| 736 | |
| 737 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 738 // FloatValue | |
| 739 | |
| 740 // optional float value = 1; | |
| 741 void FloatValue::clear_value() { | |
| 742 value_ = 0; | |
| 743 } | |
| 744 float FloatValue::value() const { | |
| 745 // @@protoc_insertion_point(field_get:google.protobuf.FloatValue.value) | |
| 746 return value_; | |
| 747 } | |
| 748 void FloatValue::set_value(float value) { | |
| 749 | |
| 750 value_ = value; | |
| 751 // @@protoc_insertion_point(field_set:google.protobuf.FloatValue.value) | |
| 752 } | |
| 753 | |
| 754 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 755 | |
| 756 // =================================================================== | |
| 757 | |
| 758 #ifndef _MSC_VER | |
| 759 const int Int64Value::kValueFieldNumber; | |
| 760 #endif // !_MSC_VER | |
| 761 | |
| 762 Int64Value::Int64Value() | |
| 763 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 764 SharedCtor(); | |
| 765 // @@protoc_insertion_point(constructor:google.protobuf.Int64Value) | |
| 766 } | |
| 767 | |
| 768 void Int64Value::InitAsDefaultInstance() { | |
| 769 _is_default_instance_ = true; | |
| 770 } | |
| 771 | |
| 772 Int64Value::Int64Value(const Int64Value& from) | |
| 773 : ::google::protobuf::Message(), | |
| 774 _internal_metadata_(NULL) { | |
| 775 SharedCtor(); | |
| 776 MergeFrom(from); | |
| 777 // @@protoc_insertion_point(copy_constructor:google.protobuf.Int64Value) | |
| 778 } | |
| 779 | |
| 780 void Int64Value::SharedCtor() { | |
| 781 _is_default_instance_ = false; | |
| 782 _cached_size_ = 0; | |
| 783 value_ = GOOGLE_LONGLONG(0); | |
| 784 } | |
| 785 | |
| 786 Int64Value::~Int64Value() { | |
| 787 // @@protoc_insertion_point(destructor:google.protobuf.Int64Value) | |
| 788 SharedDtor(); | |
| 789 } | |
| 790 | |
| 791 void Int64Value::SharedDtor() { | |
| 792 if (this != default_instance_) { | |
| 793 } | |
| 794 } | |
| 795 | |
| 796 void Int64Value::SetCachedSize(int size) const { | |
| 797 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 798 _cached_size_ = size; | |
| 799 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 800 } | |
| 801 const ::google::protobuf::Descriptor* Int64Value::descriptor() { | |
| 802 protobuf_AssignDescriptorsOnce(); | |
| 803 return Int64Value_descriptor_; | |
| 804 } | |
| 805 | |
| 806 const Int64Value& Int64Value::default_instance() { | |
| 807 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 808 return *default_instance_; | |
| 809 } | |
| 810 | |
| 811 Int64Value* Int64Value::default_instance_ = NULL; | |
| 812 | |
| 813 Int64Value* Int64Value::New(::google::protobuf::Arena* arena) const { | |
| 814 Int64Value* n = new Int64Value; | |
| 815 if (arena != NULL) { | |
| 816 arena->Own(n); | |
| 817 } | |
| 818 return n; | |
| 819 } | |
| 820 | |
| 821 void Int64Value::Clear() { | |
| 822 value_ = GOOGLE_LONGLONG(0); | |
| 823 } | |
| 824 | |
| 825 bool Int64Value::MergePartialFromCodedStream( | |
| 826 ::google::protobuf::io::CodedInputStream* input) { | |
| 827 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 828 ::google::protobuf::uint32 tag; | |
| 829 // @@protoc_insertion_point(parse_start:google.protobuf.Int64Value) | |
| 830 for (;;) { | |
| 831 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 832 tag = p.first; | |
| 833 if (!p.second) goto handle_unusual; | |
| 834 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 835 // optional int64 value = 1; | |
| 836 case 1: { | |
| 837 if (tag == 8) { | |
| 838 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< | |
| 839 ::google::protobuf::int64, ::google::protobuf::internal::Wire
FormatLite::TYPE_INT64>( | |
| 840 input, &value_))); | |
| 841 | |
| 842 } else { | |
| 843 goto handle_unusual; | |
| 844 } | |
| 845 if (input->ExpectAtEnd()) goto success; | |
| 846 break; | |
| 847 } | |
| 848 | |
| 849 default: { | |
| 850 handle_unusual: | |
| 851 if (tag == 0 || | |
| 852 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 853 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 854 goto success; | |
| 855 } | |
| 856 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 857 break; | |
| 858 } | |
| 859 } | |
| 860 } | |
| 861 success: | |
| 862 // @@protoc_insertion_point(parse_success:google.protobuf.Int64Value) | |
| 863 return true; | |
| 864 failure: | |
| 865 // @@protoc_insertion_point(parse_failure:google.protobuf.Int64Value) | |
| 866 return false; | |
| 867 #undef DO_ | |
| 868 } | |
| 869 | |
| 870 void Int64Value::SerializeWithCachedSizes( | |
| 871 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 872 // @@protoc_insertion_point(serialize_start:google.protobuf.Int64Value) | |
| 873 // optional int64 value = 1; | |
| 874 if (this->value() != 0) { | |
| 875 ::google::protobuf::internal::WireFormatLite::WriteInt64(1, this->value(), o
utput); | |
| 876 } | |
| 877 | |
| 878 // @@protoc_insertion_point(serialize_end:google.protobuf.Int64Value) | |
| 879 } | |
| 880 | |
| 881 ::google::protobuf::uint8* Int64Value::SerializeWithCachedSizesToArray( | |
| 882 ::google::protobuf::uint8* target) const { | |
| 883 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Int64Valu
e) | |
| 884 // optional int64 value = 1; | |
| 885 if (this->value() != 0) { | |
| 886 target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(1,
this->value(), target); | |
| 887 } | |
| 888 | |
| 889 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.Int64Value) | |
| 890 return target; | |
| 891 } | |
| 892 | |
| 893 int Int64Value::ByteSize() const { | |
| 894 int total_size = 0; | |
| 895 | |
| 896 // optional int64 value = 1; | |
| 897 if (this->value() != 0) { | |
| 898 total_size += 1 + | |
| 899 ::google::protobuf::internal::WireFormatLite::Int64Size( | |
| 900 this->value()); | |
| 901 } | |
| 902 | |
| 903 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 904 _cached_size_ = total_size; | |
| 905 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 906 return total_size; | |
| 907 } | |
| 908 | |
| 909 void Int64Value::MergeFrom(const ::google::protobuf::Message& from) { | |
| 910 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 911 const Int64Value* source = | |
| 912 ::google::protobuf::internal::DynamicCastToGenerated<const Int64Value>( | |
| 913 &from); | |
| 914 if (source == NULL) { | |
| 915 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 916 } else { | |
| 917 MergeFrom(*source); | |
| 918 } | |
| 919 } | |
| 920 | |
| 921 void Int64Value::MergeFrom(const Int64Value& from) { | |
| 922 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 923 if (from.value() != 0) { | |
| 924 set_value(from.value()); | |
| 925 } | |
| 926 } | |
| 927 | |
| 928 void Int64Value::CopyFrom(const ::google::protobuf::Message& from) { | |
| 929 if (&from == this) return; | |
| 930 Clear(); | |
| 931 MergeFrom(from); | |
| 932 } | |
| 933 | |
| 934 void Int64Value::CopyFrom(const Int64Value& from) { | |
| 935 if (&from == this) return; | |
| 936 Clear(); | |
| 937 MergeFrom(from); | |
| 938 } | |
| 939 | |
| 940 bool Int64Value::IsInitialized() const { | |
| 941 | |
| 942 return true; | |
| 943 } | |
| 944 | |
| 945 void Int64Value::Swap(Int64Value* other) { | |
| 946 if (other == this) return; | |
| 947 InternalSwap(other); | |
| 948 } | |
| 949 void Int64Value::InternalSwap(Int64Value* other) { | |
| 950 std::swap(value_, other->value_); | |
| 951 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 952 std::swap(_cached_size_, other->_cached_size_); | |
| 953 } | |
| 954 | |
| 955 ::google::protobuf::Metadata Int64Value::GetMetadata() const { | |
| 956 protobuf_AssignDescriptorsOnce(); | |
| 957 ::google::protobuf::Metadata metadata; | |
| 958 metadata.descriptor = Int64Value_descriptor_; | |
| 959 metadata.reflection = Int64Value_reflection_; | |
| 960 return metadata; | |
| 961 } | |
| 962 | |
| 963 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 964 // Int64Value | |
| 965 | |
| 966 // optional int64 value = 1; | |
| 967 void Int64Value::clear_value() { | |
| 968 value_ = GOOGLE_LONGLONG(0); | |
| 969 } | |
| 970 ::google::protobuf::int64 Int64Value::value() const { | |
| 971 // @@protoc_insertion_point(field_get:google.protobuf.Int64Value.value) | |
| 972 return value_; | |
| 973 } | |
| 974 void Int64Value::set_value(::google::protobuf::int64 value) { | |
| 975 | |
| 976 value_ = value; | |
| 977 // @@protoc_insertion_point(field_set:google.protobuf.Int64Value.value) | |
| 978 } | |
| 979 | |
| 980 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 981 | |
| 982 // =================================================================== | |
| 983 | |
| 984 #ifndef _MSC_VER | |
| 985 const int UInt64Value::kValueFieldNumber; | |
| 986 #endif // !_MSC_VER | |
| 987 | |
| 988 UInt64Value::UInt64Value() | |
| 989 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 990 SharedCtor(); | |
| 991 // @@protoc_insertion_point(constructor:google.protobuf.UInt64Value) | |
| 992 } | |
| 993 | |
| 994 void UInt64Value::InitAsDefaultInstance() { | |
| 995 _is_default_instance_ = true; | |
| 996 } | |
| 997 | |
| 998 UInt64Value::UInt64Value(const UInt64Value& from) | |
| 999 : ::google::protobuf::Message(), | |
| 1000 _internal_metadata_(NULL) { | |
| 1001 SharedCtor(); | |
| 1002 MergeFrom(from); | |
| 1003 // @@protoc_insertion_point(copy_constructor:google.protobuf.UInt64Value) | |
| 1004 } | |
| 1005 | |
| 1006 void UInt64Value::SharedCtor() { | |
| 1007 _is_default_instance_ = false; | |
| 1008 _cached_size_ = 0; | |
| 1009 value_ = GOOGLE_ULONGLONG(0); | |
| 1010 } | |
| 1011 | |
| 1012 UInt64Value::~UInt64Value() { | |
| 1013 // @@protoc_insertion_point(destructor:google.protobuf.UInt64Value) | |
| 1014 SharedDtor(); | |
| 1015 } | |
| 1016 | |
| 1017 void UInt64Value::SharedDtor() { | |
| 1018 if (this != default_instance_) { | |
| 1019 } | |
| 1020 } | |
| 1021 | |
| 1022 void UInt64Value::SetCachedSize(int size) const { | |
| 1023 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1024 _cached_size_ = size; | |
| 1025 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1026 } | |
| 1027 const ::google::protobuf::Descriptor* UInt64Value::descriptor() { | |
| 1028 protobuf_AssignDescriptorsOnce(); | |
| 1029 return UInt64Value_descriptor_; | |
| 1030 } | |
| 1031 | |
| 1032 const UInt64Value& UInt64Value::default_instance() { | |
| 1033 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 1034 return *default_instance_; | |
| 1035 } | |
| 1036 | |
| 1037 UInt64Value* UInt64Value::default_instance_ = NULL; | |
| 1038 | |
| 1039 UInt64Value* UInt64Value::New(::google::protobuf::Arena* arena) const { | |
| 1040 UInt64Value* n = new UInt64Value; | |
| 1041 if (arena != NULL) { | |
| 1042 arena->Own(n); | |
| 1043 } | |
| 1044 return n; | |
| 1045 } | |
| 1046 | |
| 1047 void UInt64Value::Clear() { | |
| 1048 value_ = GOOGLE_ULONGLONG(0); | |
| 1049 } | |
| 1050 | |
| 1051 bool UInt64Value::MergePartialFromCodedStream( | |
| 1052 ::google::protobuf::io::CodedInputStream* input) { | |
| 1053 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 1054 ::google::protobuf::uint32 tag; | |
| 1055 // @@protoc_insertion_point(parse_start:google.protobuf.UInt64Value) | |
| 1056 for (;;) { | |
| 1057 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 1058 tag = p.first; | |
| 1059 if (!p.second) goto handle_unusual; | |
| 1060 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 1061 // optional uint64 value = 1; | |
| 1062 case 1: { | |
| 1063 if (tag == 8) { | |
| 1064 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< | |
| 1065 ::google::protobuf::uint64, ::google::protobuf::internal::Wir
eFormatLite::TYPE_UINT64>( | |
| 1066 input, &value_))); | |
| 1067 | |
| 1068 } else { | |
| 1069 goto handle_unusual; | |
| 1070 } | |
| 1071 if (input->ExpectAtEnd()) goto success; | |
| 1072 break; | |
| 1073 } | |
| 1074 | |
| 1075 default: { | |
| 1076 handle_unusual: | |
| 1077 if (tag == 0 || | |
| 1078 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 1079 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 1080 goto success; | |
| 1081 } | |
| 1082 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 1083 break; | |
| 1084 } | |
| 1085 } | |
| 1086 } | |
| 1087 success: | |
| 1088 // @@protoc_insertion_point(parse_success:google.protobuf.UInt64Value) | |
| 1089 return true; | |
| 1090 failure: | |
| 1091 // @@protoc_insertion_point(parse_failure:google.protobuf.UInt64Value) | |
| 1092 return false; | |
| 1093 #undef DO_ | |
| 1094 } | |
| 1095 | |
| 1096 void UInt64Value::SerializeWithCachedSizes( | |
| 1097 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 1098 // @@protoc_insertion_point(serialize_start:google.protobuf.UInt64Value) | |
| 1099 // optional uint64 value = 1; | |
| 1100 if (this->value() != 0) { | |
| 1101 ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->value(),
output); | |
| 1102 } | |
| 1103 | |
| 1104 // @@protoc_insertion_point(serialize_end:google.protobuf.UInt64Value) | |
| 1105 } | |
| 1106 | |
| 1107 ::google::protobuf::uint8* UInt64Value::SerializeWithCachedSizesToArray( | |
| 1108 ::google::protobuf::uint8* target) const { | |
| 1109 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.UInt64Val
ue) | |
| 1110 // optional uint64 value = 1; | |
| 1111 if (this->value() != 0) { | |
| 1112 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1,
this->value(), target); | |
| 1113 } | |
| 1114 | |
| 1115 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.UInt64Value
) | |
| 1116 return target; | |
| 1117 } | |
| 1118 | |
| 1119 int UInt64Value::ByteSize() const { | |
| 1120 int total_size = 0; | |
| 1121 | |
| 1122 // optional uint64 value = 1; | |
| 1123 if (this->value() != 0) { | |
| 1124 total_size += 1 + | |
| 1125 ::google::protobuf::internal::WireFormatLite::UInt64Size( | |
| 1126 this->value()); | |
| 1127 } | |
| 1128 | |
| 1129 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1130 _cached_size_ = total_size; | |
| 1131 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1132 return total_size; | |
| 1133 } | |
| 1134 | |
| 1135 void UInt64Value::MergeFrom(const ::google::protobuf::Message& from) { | |
| 1136 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 1137 const UInt64Value* source = | |
| 1138 ::google::protobuf::internal::DynamicCastToGenerated<const UInt64Value>( | |
| 1139 &from); | |
| 1140 if (source == NULL) { | |
| 1141 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 1142 } else { | |
| 1143 MergeFrom(*source); | |
| 1144 } | |
| 1145 } | |
| 1146 | |
| 1147 void UInt64Value::MergeFrom(const UInt64Value& from) { | |
| 1148 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 1149 if (from.value() != 0) { | |
| 1150 set_value(from.value()); | |
| 1151 } | |
| 1152 } | |
| 1153 | |
| 1154 void UInt64Value::CopyFrom(const ::google::protobuf::Message& from) { | |
| 1155 if (&from == this) return; | |
| 1156 Clear(); | |
| 1157 MergeFrom(from); | |
| 1158 } | |
| 1159 | |
| 1160 void UInt64Value::CopyFrom(const UInt64Value& from) { | |
| 1161 if (&from == this) return; | |
| 1162 Clear(); | |
| 1163 MergeFrom(from); | |
| 1164 } | |
| 1165 | |
| 1166 bool UInt64Value::IsInitialized() const { | |
| 1167 | |
| 1168 return true; | |
| 1169 } | |
| 1170 | |
| 1171 void UInt64Value::Swap(UInt64Value* other) { | |
| 1172 if (other == this) return; | |
| 1173 InternalSwap(other); | |
| 1174 } | |
| 1175 void UInt64Value::InternalSwap(UInt64Value* other) { | |
| 1176 std::swap(value_, other->value_); | |
| 1177 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 1178 std::swap(_cached_size_, other->_cached_size_); | |
| 1179 } | |
| 1180 | |
| 1181 ::google::protobuf::Metadata UInt64Value::GetMetadata() const { | |
| 1182 protobuf_AssignDescriptorsOnce(); | |
| 1183 ::google::protobuf::Metadata metadata; | |
| 1184 metadata.descriptor = UInt64Value_descriptor_; | |
| 1185 metadata.reflection = UInt64Value_reflection_; | |
| 1186 return metadata; | |
| 1187 } | |
| 1188 | |
| 1189 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 1190 // UInt64Value | |
| 1191 | |
| 1192 // optional uint64 value = 1; | |
| 1193 void UInt64Value::clear_value() { | |
| 1194 value_ = GOOGLE_ULONGLONG(0); | |
| 1195 } | |
| 1196 ::google::protobuf::uint64 UInt64Value::value() const { | |
| 1197 // @@protoc_insertion_point(field_get:google.protobuf.UInt64Value.value) | |
| 1198 return value_; | |
| 1199 } | |
| 1200 void UInt64Value::set_value(::google::protobuf::uint64 value) { | |
| 1201 | |
| 1202 value_ = value; | |
| 1203 // @@protoc_insertion_point(field_set:google.protobuf.UInt64Value.value) | |
| 1204 } | |
| 1205 | |
| 1206 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 1207 | |
| 1208 // =================================================================== | |
| 1209 | |
| 1210 #ifndef _MSC_VER | |
| 1211 const int Int32Value::kValueFieldNumber; | |
| 1212 #endif // !_MSC_VER | |
| 1213 | |
| 1214 Int32Value::Int32Value() | |
| 1215 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 1216 SharedCtor(); | |
| 1217 // @@protoc_insertion_point(constructor:google.protobuf.Int32Value) | |
| 1218 } | |
| 1219 | |
| 1220 void Int32Value::InitAsDefaultInstance() { | |
| 1221 _is_default_instance_ = true; | |
| 1222 } | |
| 1223 | |
| 1224 Int32Value::Int32Value(const Int32Value& from) | |
| 1225 : ::google::protobuf::Message(), | |
| 1226 _internal_metadata_(NULL) { | |
| 1227 SharedCtor(); | |
| 1228 MergeFrom(from); | |
| 1229 // @@protoc_insertion_point(copy_constructor:google.protobuf.Int32Value) | |
| 1230 } | |
| 1231 | |
| 1232 void Int32Value::SharedCtor() { | |
| 1233 _is_default_instance_ = false; | |
| 1234 _cached_size_ = 0; | |
| 1235 value_ = 0; | |
| 1236 } | |
| 1237 | |
| 1238 Int32Value::~Int32Value() { | |
| 1239 // @@protoc_insertion_point(destructor:google.protobuf.Int32Value) | |
| 1240 SharedDtor(); | |
| 1241 } | |
| 1242 | |
| 1243 void Int32Value::SharedDtor() { | |
| 1244 if (this != default_instance_) { | |
| 1245 } | |
| 1246 } | |
| 1247 | |
| 1248 void Int32Value::SetCachedSize(int size) const { | |
| 1249 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1250 _cached_size_ = size; | |
| 1251 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1252 } | |
| 1253 const ::google::protobuf::Descriptor* Int32Value::descriptor() { | |
| 1254 protobuf_AssignDescriptorsOnce(); | |
| 1255 return Int32Value_descriptor_; | |
| 1256 } | |
| 1257 | |
| 1258 const Int32Value& Int32Value::default_instance() { | |
| 1259 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 1260 return *default_instance_; | |
| 1261 } | |
| 1262 | |
| 1263 Int32Value* Int32Value::default_instance_ = NULL; | |
| 1264 | |
| 1265 Int32Value* Int32Value::New(::google::protobuf::Arena* arena) const { | |
| 1266 Int32Value* n = new Int32Value; | |
| 1267 if (arena != NULL) { | |
| 1268 arena->Own(n); | |
| 1269 } | |
| 1270 return n; | |
| 1271 } | |
| 1272 | |
| 1273 void Int32Value::Clear() { | |
| 1274 value_ = 0; | |
| 1275 } | |
| 1276 | |
| 1277 bool Int32Value::MergePartialFromCodedStream( | |
| 1278 ::google::protobuf::io::CodedInputStream* input) { | |
| 1279 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 1280 ::google::protobuf::uint32 tag; | |
| 1281 // @@protoc_insertion_point(parse_start:google.protobuf.Int32Value) | |
| 1282 for (;;) { | |
| 1283 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 1284 tag = p.first; | |
| 1285 if (!p.second) goto handle_unusual; | |
| 1286 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 1287 // optional int32 value = 1; | |
| 1288 case 1: { | |
| 1289 if (tag == 8) { | |
| 1290 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< | |
| 1291 ::google::protobuf::int32, ::google::protobuf::internal::Wire
FormatLite::TYPE_INT32>( | |
| 1292 input, &value_))); | |
| 1293 | |
| 1294 } else { | |
| 1295 goto handle_unusual; | |
| 1296 } | |
| 1297 if (input->ExpectAtEnd()) goto success; | |
| 1298 break; | |
| 1299 } | |
| 1300 | |
| 1301 default: { | |
| 1302 handle_unusual: | |
| 1303 if (tag == 0 || | |
| 1304 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 1305 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 1306 goto success; | |
| 1307 } | |
| 1308 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 1309 break; | |
| 1310 } | |
| 1311 } | |
| 1312 } | |
| 1313 success: | |
| 1314 // @@protoc_insertion_point(parse_success:google.protobuf.Int32Value) | |
| 1315 return true; | |
| 1316 failure: | |
| 1317 // @@protoc_insertion_point(parse_failure:google.protobuf.Int32Value) | |
| 1318 return false; | |
| 1319 #undef DO_ | |
| 1320 } | |
| 1321 | |
| 1322 void Int32Value::SerializeWithCachedSizes( | |
| 1323 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 1324 // @@protoc_insertion_point(serialize_start:google.protobuf.Int32Value) | |
| 1325 // optional int32 value = 1; | |
| 1326 if (this->value() != 0) { | |
| 1327 ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->value(), o
utput); | |
| 1328 } | |
| 1329 | |
| 1330 // @@protoc_insertion_point(serialize_end:google.protobuf.Int32Value) | |
| 1331 } | |
| 1332 | |
| 1333 ::google::protobuf::uint8* Int32Value::SerializeWithCachedSizesToArray( | |
| 1334 ::google::protobuf::uint8* target) const { | |
| 1335 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.Int32Valu
e) | |
| 1336 // optional int32 value = 1; | |
| 1337 if (this->value() != 0) { | |
| 1338 target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1,
this->value(), target); | |
| 1339 } | |
| 1340 | |
| 1341 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.Int32Value) | |
| 1342 return target; | |
| 1343 } | |
| 1344 | |
| 1345 int Int32Value::ByteSize() const { | |
| 1346 int total_size = 0; | |
| 1347 | |
| 1348 // optional int32 value = 1; | |
| 1349 if (this->value() != 0) { | |
| 1350 total_size += 1 + | |
| 1351 ::google::protobuf::internal::WireFormatLite::Int32Size( | |
| 1352 this->value()); | |
| 1353 } | |
| 1354 | |
| 1355 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1356 _cached_size_ = total_size; | |
| 1357 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1358 return total_size; | |
| 1359 } | |
| 1360 | |
| 1361 void Int32Value::MergeFrom(const ::google::protobuf::Message& from) { | |
| 1362 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 1363 const Int32Value* source = | |
| 1364 ::google::protobuf::internal::DynamicCastToGenerated<const Int32Value>( | |
| 1365 &from); | |
| 1366 if (source == NULL) { | |
| 1367 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 1368 } else { | |
| 1369 MergeFrom(*source); | |
| 1370 } | |
| 1371 } | |
| 1372 | |
| 1373 void Int32Value::MergeFrom(const Int32Value& from) { | |
| 1374 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 1375 if (from.value() != 0) { | |
| 1376 set_value(from.value()); | |
| 1377 } | |
| 1378 } | |
| 1379 | |
| 1380 void Int32Value::CopyFrom(const ::google::protobuf::Message& from) { | |
| 1381 if (&from == this) return; | |
| 1382 Clear(); | |
| 1383 MergeFrom(from); | |
| 1384 } | |
| 1385 | |
| 1386 void Int32Value::CopyFrom(const Int32Value& from) { | |
| 1387 if (&from == this) return; | |
| 1388 Clear(); | |
| 1389 MergeFrom(from); | |
| 1390 } | |
| 1391 | |
| 1392 bool Int32Value::IsInitialized() const { | |
| 1393 | |
| 1394 return true; | |
| 1395 } | |
| 1396 | |
| 1397 void Int32Value::Swap(Int32Value* other) { | |
| 1398 if (other == this) return; | |
| 1399 InternalSwap(other); | |
| 1400 } | |
| 1401 void Int32Value::InternalSwap(Int32Value* other) { | |
| 1402 std::swap(value_, other->value_); | |
| 1403 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 1404 std::swap(_cached_size_, other->_cached_size_); | |
| 1405 } | |
| 1406 | |
| 1407 ::google::protobuf::Metadata Int32Value::GetMetadata() const { | |
| 1408 protobuf_AssignDescriptorsOnce(); | |
| 1409 ::google::protobuf::Metadata metadata; | |
| 1410 metadata.descriptor = Int32Value_descriptor_; | |
| 1411 metadata.reflection = Int32Value_reflection_; | |
| 1412 return metadata; | |
| 1413 } | |
| 1414 | |
| 1415 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 1416 // Int32Value | |
| 1417 | |
| 1418 // optional int32 value = 1; | |
| 1419 void Int32Value::clear_value() { | |
| 1420 value_ = 0; | |
| 1421 } | |
| 1422 ::google::protobuf::int32 Int32Value::value() const { | |
| 1423 // @@protoc_insertion_point(field_get:google.protobuf.Int32Value.value) | |
| 1424 return value_; | |
| 1425 } | |
| 1426 void Int32Value::set_value(::google::protobuf::int32 value) { | |
| 1427 | |
| 1428 value_ = value; | |
| 1429 // @@protoc_insertion_point(field_set:google.protobuf.Int32Value.value) | |
| 1430 } | |
| 1431 | |
| 1432 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 1433 | |
| 1434 // =================================================================== | |
| 1435 | |
| 1436 #ifndef _MSC_VER | |
| 1437 const int UInt32Value::kValueFieldNumber; | |
| 1438 #endif // !_MSC_VER | |
| 1439 | |
| 1440 UInt32Value::UInt32Value() | |
| 1441 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 1442 SharedCtor(); | |
| 1443 // @@protoc_insertion_point(constructor:google.protobuf.UInt32Value) | |
| 1444 } | |
| 1445 | |
| 1446 void UInt32Value::InitAsDefaultInstance() { | |
| 1447 _is_default_instance_ = true; | |
| 1448 } | |
| 1449 | |
| 1450 UInt32Value::UInt32Value(const UInt32Value& from) | |
| 1451 : ::google::protobuf::Message(), | |
| 1452 _internal_metadata_(NULL) { | |
| 1453 SharedCtor(); | |
| 1454 MergeFrom(from); | |
| 1455 // @@protoc_insertion_point(copy_constructor:google.protobuf.UInt32Value) | |
| 1456 } | |
| 1457 | |
| 1458 void UInt32Value::SharedCtor() { | |
| 1459 _is_default_instance_ = false; | |
| 1460 _cached_size_ = 0; | |
| 1461 value_ = 0u; | |
| 1462 } | |
| 1463 | |
| 1464 UInt32Value::~UInt32Value() { | |
| 1465 // @@protoc_insertion_point(destructor:google.protobuf.UInt32Value) | |
| 1466 SharedDtor(); | |
| 1467 } | |
| 1468 | |
| 1469 void UInt32Value::SharedDtor() { | |
| 1470 if (this != default_instance_) { | |
| 1471 } | |
| 1472 } | |
| 1473 | |
| 1474 void UInt32Value::SetCachedSize(int size) const { | |
| 1475 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1476 _cached_size_ = size; | |
| 1477 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1478 } | |
| 1479 const ::google::protobuf::Descriptor* UInt32Value::descriptor() { | |
| 1480 protobuf_AssignDescriptorsOnce(); | |
| 1481 return UInt32Value_descriptor_; | |
| 1482 } | |
| 1483 | |
| 1484 const UInt32Value& UInt32Value::default_instance() { | |
| 1485 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 1486 return *default_instance_; | |
| 1487 } | |
| 1488 | |
| 1489 UInt32Value* UInt32Value::default_instance_ = NULL; | |
| 1490 | |
| 1491 UInt32Value* UInt32Value::New(::google::protobuf::Arena* arena) const { | |
| 1492 UInt32Value* n = new UInt32Value; | |
| 1493 if (arena != NULL) { | |
| 1494 arena->Own(n); | |
| 1495 } | |
| 1496 return n; | |
| 1497 } | |
| 1498 | |
| 1499 void UInt32Value::Clear() { | |
| 1500 value_ = 0u; | |
| 1501 } | |
| 1502 | |
| 1503 bool UInt32Value::MergePartialFromCodedStream( | |
| 1504 ::google::protobuf::io::CodedInputStream* input) { | |
| 1505 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 1506 ::google::protobuf::uint32 tag; | |
| 1507 // @@protoc_insertion_point(parse_start:google.protobuf.UInt32Value) | |
| 1508 for (;;) { | |
| 1509 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 1510 tag = p.first; | |
| 1511 if (!p.second) goto handle_unusual; | |
| 1512 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 1513 // optional uint32 value = 1; | |
| 1514 case 1: { | |
| 1515 if (tag == 8) { | |
| 1516 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< | |
| 1517 ::google::protobuf::uint32, ::google::protobuf::internal::Wir
eFormatLite::TYPE_UINT32>( | |
| 1518 input, &value_))); | |
| 1519 | |
| 1520 } else { | |
| 1521 goto handle_unusual; | |
| 1522 } | |
| 1523 if (input->ExpectAtEnd()) goto success; | |
| 1524 break; | |
| 1525 } | |
| 1526 | |
| 1527 default: { | |
| 1528 handle_unusual: | |
| 1529 if (tag == 0 || | |
| 1530 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 1531 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 1532 goto success; | |
| 1533 } | |
| 1534 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 1535 break; | |
| 1536 } | |
| 1537 } | |
| 1538 } | |
| 1539 success: | |
| 1540 // @@protoc_insertion_point(parse_success:google.protobuf.UInt32Value) | |
| 1541 return true; | |
| 1542 failure: | |
| 1543 // @@protoc_insertion_point(parse_failure:google.protobuf.UInt32Value) | |
| 1544 return false; | |
| 1545 #undef DO_ | |
| 1546 } | |
| 1547 | |
| 1548 void UInt32Value::SerializeWithCachedSizes( | |
| 1549 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 1550 // @@protoc_insertion_point(serialize_start:google.protobuf.UInt32Value) | |
| 1551 // optional uint32 value = 1; | |
| 1552 if (this->value() != 0) { | |
| 1553 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->value(),
output); | |
| 1554 } | |
| 1555 | |
| 1556 // @@protoc_insertion_point(serialize_end:google.protobuf.UInt32Value) | |
| 1557 } | |
| 1558 | |
| 1559 ::google::protobuf::uint8* UInt32Value::SerializeWithCachedSizesToArray( | |
| 1560 ::google::protobuf::uint8* target) const { | |
| 1561 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.UInt32Val
ue) | |
| 1562 // optional uint32 value = 1; | |
| 1563 if (this->value() != 0) { | |
| 1564 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1,
this->value(), target); | |
| 1565 } | |
| 1566 | |
| 1567 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.UInt32Value
) | |
| 1568 return target; | |
| 1569 } | |
| 1570 | |
| 1571 int UInt32Value::ByteSize() const { | |
| 1572 int total_size = 0; | |
| 1573 | |
| 1574 // optional uint32 value = 1; | |
| 1575 if (this->value() != 0) { | |
| 1576 total_size += 1 + | |
| 1577 ::google::protobuf::internal::WireFormatLite::UInt32Size( | |
| 1578 this->value()); | |
| 1579 } | |
| 1580 | |
| 1581 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1582 _cached_size_ = total_size; | |
| 1583 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1584 return total_size; | |
| 1585 } | |
| 1586 | |
| 1587 void UInt32Value::MergeFrom(const ::google::protobuf::Message& from) { | |
| 1588 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 1589 const UInt32Value* source = | |
| 1590 ::google::protobuf::internal::DynamicCastToGenerated<const UInt32Value>( | |
| 1591 &from); | |
| 1592 if (source == NULL) { | |
| 1593 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 1594 } else { | |
| 1595 MergeFrom(*source); | |
| 1596 } | |
| 1597 } | |
| 1598 | |
| 1599 void UInt32Value::MergeFrom(const UInt32Value& from) { | |
| 1600 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 1601 if (from.value() != 0) { | |
| 1602 set_value(from.value()); | |
| 1603 } | |
| 1604 } | |
| 1605 | |
| 1606 void UInt32Value::CopyFrom(const ::google::protobuf::Message& from) { | |
| 1607 if (&from == this) return; | |
| 1608 Clear(); | |
| 1609 MergeFrom(from); | |
| 1610 } | |
| 1611 | |
| 1612 void UInt32Value::CopyFrom(const UInt32Value& from) { | |
| 1613 if (&from == this) return; | |
| 1614 Clear(); | |
| 1615 MergeFrom(from); | |
| 1616 } | |
| 1617 | |
| 1618 bool UInt32Value::IsInitialized() const { | |
| 1619 | |
| 1620 return true; | |
| 1621 } | |
| 1622 | |
| 1623 void UInt32Value::Swap(UInt32Value* other) { | |
| 1624 if (other == this) return; | |
| 1625 InternalSwap(other); | |
| 1626 } | |
| 1627 void UInt32Value::InternalSwap(UInt32Value* other) { | |
| 1628 std::swap(value_, other->value_); | |
| 1629 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 1630 std::swap(_cached_size_, other->_cached_size_); | |
| 1631 } | |
| 1632 | |
| 1633 ::google::protobuf::Metadata UInt32Value::GetMetadata() const { | |
| 1634 protobuf_AssignDescriptorsOnce(); | |
| 1635 ::google::protobuf::Metadata metadata; | |
| 1636 metadata.descriptor = UInt32Value_descriptor_; | |
| 1637 metadata.reflection = UInt32Value_reflection_; | |
| 1638 return metadata; | |
| 1639 } | |
| 1640 | |
| 1641 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 1642 // UInt32Value | |
| 1643 | |
| 1644 // optional uint32 value = 1; | |
| 1645 void UInt32Value::clear_value() { | |
| 1646 value_ = 0u; | |
| 1647 } | |
| 1648 ::google::protobuf::uint32 UInt32Value::value() const { | |
| 1649 // @@protoc_insertion_point(field_get:google.protobuf.UInt32Value.value) | |
| 1650 return value_; | |
| 1651 } | |
| 1652 void UInt32Value::set_value(::google::protobuf::uint32 value) { | |
| 1653 | |
| 1654 value_ = value; | |
| 1655 // @@protoc_insertion_point(field_set:google.protobuf.UInt32Value.value) | |
| 1656 } | |
| 1657 | |
| 1658 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 1659 | |
| 1660 // =================================================================== | |
| 1661 | |
| 1662 #ifndef _MSC_VER | |
| 1663 const int BoolValue::kValueFieldNumber; | |
| 1664 #endif // !_MSC_VER | |
| 1665 | |
| 1666 BoolValue::BoolValue() | |
| 1667 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 1668 SharedCtor(); | |
| 1669 // @@protoc_insertion_point(constructor:google.protobuf.BoolValue) | |
| 1670 } | |
| 1671 | |
| 1672 void BoolValue::InitAsDefaultInstance() { | |
| 1673 _is_default_instance_ = true; | |
| 1674 } | |
| 1675 | |
| 1676 BoolValue::BoolValue(const BoolValue& from) | |
| 1677 : ::google::protobuf::Message(), | |
| 1678 _internal_metadata_(NULL) { | |
| 1679 SharedCtor(); | |
| 1680 MergeFrom(from); | |
| 1681 // @@protoc_insertion_point(copy_constructor:google.protobuf.BoolValue) | |
| 1682 } | |
| 1683 | |
| 1684 void BoolValue::SharedCtor() { | |
| 1685 _is_default_instance_ = false; | |
| 1686 _cached_size_ = 0; | |
| 1687 value_ = false; | |
| 1688 } | |
| 1689 | |
| 1690 BoolValue::~BoolValue() { | |
| 1691 // @@protoc_insertion_point(destructor:google.protobuf.BoolValue) | |
| 1692 SharedDtor(); | |
| 1693 } | |
| 1694 | |
| 1695 void BoolValue::SharedDtor() { | |
| 1696 if (this != default_instance_) { | |
| 1697 } | |
| 1698 } | |
| 1699 | |
| 1700 void BoolValue::SetCachedSize(int size) const { | |
| 1701 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1702 _cached_size_ = size; | |
| 1703 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1704 } | |
| 1705 const ::google::protobuf::Descriptor* BoolValue::descriptor() { | |
| 1706 protobuf_AssignDescriptorsOnce(); | |
| 1707 return BoolValue_descriptor_; | |
| 1708 } | |
| 1709 | |
| 1710 const BoolValue& BoolValue::default_instance() { | |
| 1711 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 1712 return *default_instance_; | |
| 1713 } | |
| 1714 | |
| 1715 BoolValue* BoolValue::default_instance_ = NULL; | |
| 1716 | |
| 1717 BoolValue* BoolValue::New(::google::protobuf::Arena* arena) const { | |
| 1718 BoolValue* n = new BoolValue; | |
| 1719 if (arena != NULL) { | |
| 1720 arena->Own(n); | |
| 1721 } | |
| 1722 return n; | |
| 1723 } | |
| 1724 | |
| 1725 void BoolValue::Clear() { | |
| 1726 value_ = false; | |
| 1727 } | |
| 1728 | |
| 1729 bool BoolValue::MergePartialFromCodedStream( | |
| 1730 ::google::protobuf::io::CodedInputStream* input) { | |
| 1731 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 1732 ::google::protobuf::uint32 tag; | |
| 1733 // @@protoc_insertion_point(parse_start:google.protobuf.BoolValue) | |
| 1734 for (;;) { | |
| 1735 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 1736 tag = p.first; | |
| 1737 if (!p.second) goto handle_unusual; | |
| 1738 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 1739 // optional bool value = 1; | |
| 1740 case 1: { | |
| 1741 if (tag == 8) { | |
| 1742 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< | |
| 1743 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL
>( | |
| 1744 input, &value_))); | |
| 1745 | |
| 1746 } else { | |
| 1747 goto handle_unusual; | |
| 1748 } | |
| 1749 if (input->ExpectAtEnd()) goto success; | |
| 1750 break; | |
| 1751 } | |
| 1752 | |
| 1753 default: { | |
| 1754 handle_unusual: | |
| 1755 if (tag == 0 || | |
| 1756 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 1757 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 1758 goto success; | |
| 1759 } | |
| 1760 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 1761 break; | |
| 1762 } | |
| 1763 } | |
| 1764 } | |
| 1765 success: | |
| 1766 // @@protoc_insertion_point(parse_success:google.protobuf.BoolValue) | |
| 1767 return true; | |
| 1768 failure: | |
| 1769 // @@protoc_insertion_point(parse_failure:google.protobuf.BoolValue) | |
| 1770 return false; | |
| 1771 #undef DO_ | |
| 1772 } | |
| 1773 | |
| 1774 void BoolValue::SerializeWithCachedSizes( | |
| 1775 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 1776 // @@protoc_insertion_point(serialize_start:google.protobuf.BoolValue) | |
| 1777 // optional bool value = 1; | |
| 1778 if (this->value() != 0) { | |
| 1779 ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->value(), ou
tput); | |
| 1780 } | |
| 1781 | |
| 1782 // @@protoc_insertion_point(serialize_end:google.protobuf.BoolValue) | |
| 1783 } | |
| 1784 | |
| 1785 ::google::protobuf::uint8* BoolValue::SerializeWithCachedSizesToArray( | |
| 1786 ::google::protobuf::uint8* target) const { | |
| 1787 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.BoolValue
) | |
| 1788 // optional bool value = 1; | |
| 1789 if (this->value() != 0) { | |
| 1790 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, t
his->value(), target); | |
| 1791 } | |
| 1792 | |
| 1793 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.BoolValue) | |
| 1794 return target; | |
| 1795 } | |
| 1796 | |
| 1797 int BoolValue::ByteSize() const { | |
| 1798 int total_size = 0; | |
| 1799 | |
| 1800 // optional bool value = 1; | |
| 1801 if (this->value() != 0) { | |
| 1802 total_size += 1 + 1; | |
| 1803 } | |
| 1804 | |
| 1805 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1806 _cached_size_ = total_size; | |
| 1807 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1808 return total_size; | |
| 1809 } | |
| 1810 | |
| 1811 void BoolValue::MergeFrom(const ::google::protobuf::Message& from) { | |
| 1812 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 1813 const BoolValue* source = | |
| 1814 ::google::protobuf::internal::DynamicCastToGenerated<const BoolValue>( | |
| 1815 &from); | |
| 1816 if (source == NULL) { | |
| 1817 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 1818 } else { | |
| 1819 MergeFrom(*source); | |
| 1820 } | |
| 1821 } | |
| 1822 | |
| 1823 void BoolValue::MergeFrom(const BoolValue& from) { | |
| 1824 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 1825 if (from.value() != 0) { | |
| 1826 set_value(from.value()); | |
| 1827 } | |
| 1828 } | |
| 1829 | |
| 1830 void BoolValue::CopyFrom(const ::google::protobuf::Message& from) { | |
| 1831 if (&from == this) return; | |
| 1832 Clear(); | |
| 1833 MergeFrom(from); | |
| 1834 } | |
| 1835 | |
| 1836 void BoolValue::CopyFrom(const BoolValue& from) { | |
| 1837 if (&from == this) return; | |
| 1838 Clear(); | |
| 1839 MergeFrom(from); | |
| 1840 } | |
| 1841 | |
| 1842 bool BoolValue::IsInitialized() const { | |
| 1843 | |
| 1844 return true; | |
| 1845 } | |
| 1846 | |
| 1847 void BoolValue::Swap(BoolValue* other) { | |
| 1848 if (other == this) return; | |
| 1849 InternalSwap(other); | |
| 1850 } | |
| 1851 void BoolValue::InternalSwap(BoolValue* other) { | |
| 1852 std::swap(value_, other->value_); | |
| 1853 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 1854 std::swap(_cached_size_, other->_cached_size_); | |
| 1855 } | |
| 1856 | |
| 1857 ::google::protobuf::Metadata BoolValue::GetMetadata() const { | |
| 1858 protobuf_AssignDescriptorsOnce(); | |
| 1859 ::google::protobuf::Metadata metadata; | |
| 1860 metadata.descriptor = BoolValue_descriptor_; | |
| 1861 metadata.reflection = BoolValue_reflection_; | |
| 1862 return metadata; | |
| 1863 } | |
| 1864 | |
| 1865 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 1866 // BoolValue | |
| 1867 | |
| 1868 // optional bool value = 1; | |
| 1869 void BoolValue::clear_value() { | |
| 1870 value_ = false; | |
| 1871 } | |
| 1872 bool BoolValue::value() const { | |
| 1873 // @@protoc_insertion_point(field_get:google.protobuf.BoolValue.value) | |
| 1874 return value_; | |
| 1875 } | |
| 1876 void BoolValue::set_value(bool value) { | |
| 1877 | |
| 1878 value_ = value; | |
| 1879 // @@protoc_insertion_point(field_set:google.protobuf.BoolValue.value) | |
| 1880 } | |
| 1881 | |
| 1882 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 1883 | |
| 1884 // =================================================================== | |
| 1885 | |
| 1886 #ifndef _MSC_VER | |
| 1887 const int StringValue::kValueFieldNumber; | |
| 1888 #endif // !_MSC_VER | |
| 1889 | |
| 1890 StringValue::StringValue() | |
| 1891 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 1892 SharedCtor(); | |
| 1893 // @@protoc_insertion_point(constructor:google.protobuf.StringValue) | |
| 1894 } | |
| 1895 | |
| 1896 void StringValue::InitAsDefaultInstance() { | |
| 1897 _is_default_instance_ = true; | |
| 1898 } | |
| 1899 | |
| 1900 StringValue::StringValue(const StringValue& from) | |
| 1901 : ::google::protobuf::Message(), | |
| 1902 _internal_metadata_(NULL) { | |
| 1903 SharedCtor(); | |
| 1904 MergeFrom(from); | |
| 1905 // @@protoc_insertion_point(copy_constructor:google.protobuf.StringValue) | |
| 1906 } | |
| 1907 | |
| 1908 void StringValue::SharedCtor() { | |
| 1909 _is_default_instance_ = false; | |
| 1910 ::google::protobuf::internal::GetEmptyString(); | |
| 1911 _cached_size_ = 0; | |
| 1912 value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyIn
ited()); | |
| 1913 } | |
| 1914 | |
| 1915 StringValue::~StringValue() { | |
| 1916 // @@protoc_insertion_point(destructor:google.protobuf.StringValue) | |
| 1917 SharedDtor(); | |
| 1918 } | |
| 1919 | |
| 1920 void StringValue::SharedDtor() { | |
| 1921 value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInit
ed()); | |
| 1922 if (this != default_instance_) { | |
| 1923 } | |
| 1924 } | |
| 1925 | |
| 1926 void StringValue::SetCachedSize(int size) const { | |
| 1927 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 1928 _cached_size_ = size; | |
| 1929 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 1930 } | |
| 1931 const ::google::protobuf::Descriptor* StringValue::descriptor() { | |
| 1932 protobuf_AssignDescriptorsOnce(); | |
| 1933 return StringValue_descriptor_; | |
| 1934 } | |
| 1935 | |
| 1936 const StringValue& StringValue::default_instance() { | |
| 1937 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 1938 return *default_instance_; | |
| 1939 } | |
| 1940 | |
| 1941 StringValue* StringValue::default_instance_ = NULL; | |
| 1942 | |
| 1943 StringValue* StringValue::New(::google::protobuf::Arena* arena) const { | |
| 1944 StringValue* n = new StringValue; | |
| 1945 if (arena != NULL) { | |
| 1946 arena->Own(n); | |
| 1947 } | |
| 1948 return n; | |
| 1949 } | |
| 1950 | |
| 1951 void StringValue::Clear() { | |
| 1952 value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlread
yInited()); | |
| 1953 } | |
| 1954 | |
| 1955 bool StringValue::MergePartialFromCodedStream( | |
| 1956 ::google::protobuf::io::CodedInputStream* input) { | |
| 1957 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 1958 ::google::protobuf::uint32 tag; | |
| 1959 // @@protoc_insertion_point(parse_start:google.protobuf.StringValue) | |
| 1960 for (;;) { | |
| 1961 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 1962 tag = p.first; | |
| 1963 if (!p.second) goto handle_unusual; | |
| 1964 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 1965 // optional string value = 1; | |
| 1966 case 1: { | |
| 1967 if (tag == 10) { | |
| 1968 DO_(::google::protobuf::internal::WireFormatLite::ReadString( | |
| 1969 input, this->mutable_value())); | |
| 1970 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( | |
| 1971 this->value().data(), this->value().length(), | |
| 1972 ::google::protobuf::internal::WireFormat::PARSE, | |
| 1973 "google.protobuf.StringValue.value"); | |
| 1974 } else { | |
| 1975 goto handle_unusual; | |
| 1976 } | |
| 1977 if (input->ExpectAtEnd()) goto success; | |
| 1978 break; | |
| 1979 } | |
| 1980 | |
| 1981 default: { | |
| 1982 handle_unusual: | |
| 1983 if (tag == 0 || | |
| 1984 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 1985 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 1986 goto success; | |
| 1987 } | |
| 1988 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 1989 break; | |
| 1990 } | |
| 1991 } | |
| 1992 } | |
| 1993 success: | |
| 1994 // @@protoc_insertion_point(parse_success:google.protobuf.StringValue) | |
| 1995 return true; | |
| 1996 failure: | |
| 1997 // @@protoc_insertion_point(parse_failure:google.protobuf.StringValue) | |
| 1998 return false; | |
| 1999 #undef DO_ | |
| 2000 } | |
| 2001 | |
| 2002 void StringValue::SerializeWithCachedSizes( | |
| 2003 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 2004 // @@protoc_insertion_point(serialize_start:google.protobuf.StringValue) | |
| 2005 // optional string value = 1; | |
| 2006 if (this->value().size() > 0) { | |
| 2007 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( | |
| 2008 this->value().data(), this->value().length(), | |
| 2009 ::google::protobuf::internal::WireFormat::SERIALIZE, | |
| 2010 "google.protobuf.StringValue.value"); | |
| 2011 ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( | |
| 2012 1, this->value(), output); | |
| 2013 } | |
| 2014 | |
| 2015 // @@protoc_insertion_point(serialize_end:google.protobuf.StringValue) | |
| 2016 } | |
| 2017 | |
| 2018 ::google::protobuf::uint8* StringValue::SerializeWithCachedSizesToArray( | |
| 2019 ::google::protobuf::uint8* target) const { | |
| 2020 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.StringVal
ue) | |
| 2021 // optional string value = 1; | |
| 2022 if (this->value().size() > 0) { | |
| 2023 ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField( | |
| 2024 this->value().data(), this->value().length(), | |
| 2025 ::google::protobuf::internal::WireFormat::SERIALIZE, | |
| 2026 "google.protobuf.StringValue.value"); | |
| 2027 target = | |
| 2028 ::google::protobuf::internal::WireFormatLite::WriteStringToArray( | |
| 2029 1, this->value(), target); | |
| 2030 } | |
| 2031 | |
| 2032 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.StringValue
) | |
| 2033 return target; | |
| 2034 } | |
| 2035 | |
| 2036 int StringValue::ByteSize() const { | |
| 2037 int total_size = 0; | |
| 2038 | |
| 2039 // optional string value = 1; | |
| 2040 if (this->value().size() > 0) { | |
| 2041 total_size += 1 + | |
| 2042 ::google::protobuf::internal::WireFormatLite::StringSize( | |
| 2043 this->value()); | |
| 2044 } | |
| 2045 | |
| 2046 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 2047 _cached_size_ = total_size; | |
| 2048 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 2049 return total_size; | |
| 2050 } | |
| 2051 | |
| 2052 void StringValue::MergeFrom(const ::google::protobuf::Message& from) { | |
| 2053 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 2054 const StringValue* source = | |
| 2055 ::google::protobuf::internal::DynamicCastToGenerated<const StringValue>( | |
| 2056 &from); | |
| 2057 if (source == NULL) { | |
| 2058 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 2059 } else { | |
| 2060 MergeFrom(*source); | |
| 2061 } | |
| 2062 } | |
| 2063 | |
| 2064 void StringValue::MergeFrom(const StringValue& from) { | |
| 2065 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 2066 if (from.value().size() > 0) { | |
| 2067 | |
| 2068 value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlread
yInited(), from.value_); | |
| 2069 } | |
| 2070 } | |
| 2071 | |
| 2072 void StringValue::CopyFrom(const ::google::protobuf::Message& from) { | |
| 2073 if (&from == this) return; | |
| 2074 Clear(); | |
| 2075 MergeFrom(from); | |
| 2076 } | |
| 2077 | |
| 2078 void StringValue::CopyFrom(const StringValue& from) { | |
| 2079 if (&from == this) return; | |
| 2080 Clear(); | |
| 2081 MergeFrom(from); | |
| 2082 } | |
| 2083 | |
| 2084 bool StringValue::IsInitialized() const { | |
| 2085 | |
| 2086 return true; | |
| 2087 } | |
| 2088 | |
| 2089 void StringValue::Swap(StringValue* other) { | |
| 2090 if (other == this) return; | |
| 2091 InternalSwap(other); | |
| 2092 } | |
| 2093 void StringValue::InternalSwap(StringValue* other) { | |
| 2094 value_.Swap(&other->value_); | |
| 2095 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 2096 std::swap(_cached_size_, other->_cached_size_); | |
| 2097 } | |
| 2098 | |
| 2099 ::google::protobuf::Metadata StringValue::GetMetadata() const { | |
| 2100 protobuf_AssignDescriptorsOnce(); | |
| 2101 ::google::protobuf::Metadata metadata; | |
| 2102 metadata.descriptor = StringValue_descriptor_; | |
| 2103 metadata.reflection = StringValue_reflection_; | |
| 2104 return metadata; | |
| 2105 } | |
| 2106 | |
| 2107 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 2108 // StringValue | |
| 2109 | |
| 2110 // optional string value = 1; | |
| 2111 void StringValue::clear_value() { | |
| 2112 value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlread
yInited()); | |
| 2113 } | |
| 2114 const ::std::string& StringValue::value() const { | |
| 2115 // @@protoc_insertion_point(field_get:google.protobuf.StringValue.value) | |
| 2116 return value_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyI
nited()); | |
| 2117 } | |
| 2118 void StringValue::set_value(const ::std::string& value) { | |
| 2119 | |
| 2120 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()
, value); | |
| 2121 // @@protoc_insertion_point(field_set:google.protobuf.StringValue.value) | |
| 2122 } | |
| 2123 void StringValue::set_value(const char* value) { | |
| 2124 | |
| 2125 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()
, ::std::string(value)); | |
| 2126 // @@protoc_insertion_point(field_set_char:google.protobuf.StringValue.value) | |
| 2127 } | |
| 2128 void StringValue::set_value(const char* value, size_t size) { | |
| 2129 | |
| 2130 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()
, | |
| 2131 ::std::string(reinterpret_cast<const char*>(value), size)); | |
| 2132 // @@protoc_insertion_point(field_set_pointer:google.protobuf.StringValue.valu
e) | |
| 2133 } | |
| 2134 ::std::string* StringValue::mutable_value() { | |
| 2135 | |
| 2136 // @@protoc_insertion_point(field_mutable:google.protobuf.StringValue.value) | |
| 2137 return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlre
adyInited()); | |
| 2138 } | |
| 2139 ::std::string* StringValue::release_value() { | |
| 2140 | |
| 2141 return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlre
adyInited()); | |
| 2142 } | |
| 2143 void StringValue::set_allocated_value(::std::string* value) { | |
| 2144 if (value != NULL) { | |
| 2145 | |
| 2146 } else { | |
| 2147 | |
| 2148 } | |
| 2149 value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlread
yInited(), value); | |
| 2150 // @@protoc_insertion_point(field_set_allocated:google.protobuf.StringValue.va
lue) | |
| 2151 } | |
| 2152 | |
| 2153 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 2154 | |
| 2155 // =================================================================== | |
| 2156 | |
| 2157 #ifndef _MSC_VER | |
| 2158 const int BytesValue::kValueFieldNumber; | |
| 2159 #endif // !_MSC_VER | |
| 2160 | |
| 2161 BytesValue::BytesValue() | |
| 2162 : ::google::protobuf::Message(), _internal_metadata_(NULL) { | |
| 2163 SharedCtor(); | |
| 2164 // @@protoc_insertion_point(constructor:google.protobuf.BytesValue) | |
| 2165 } | |
| 2166 | |
| 2167 void BytesValue::InitAsDefaultInstance() { | |
| 2168 _is_default_instance_ = true; | |
| 2169 } | |
| 2170 | |
| 2171 BytesValue::BytesValue(const BytesValue& from) | |
| 2172 : ::google::protobuf::Message(), | |
| 2173 _internal_metadata_(NULL) { | |
| 2174 SharedCtor(); | |
| 2175 MergeFrom(from); | |
| 2176 // @@protoc_insertion_point(copy_constructor:google.protobuf.BytesValue) | |
| 2177 } | |
| 2178 | |
| 2179 void BytesValue::SharedCtor() { | |
| 2180 _is_default_instance_ = false; | |
| 2181 ::google::protobuf::internal::GetEmptyString(); | |
| 2182 _cached_size_ = 0; | |
| 2183 value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyIn
ited()); | |
| 2184 } | |
| 2185 | |
| 2186 BytesValue::~BytesValue() { | |
| 2187 // @@protoc_insertion_point(destructor:google.protobuf.BytesValue) | |
| 2188 SharedDtor(); | |
| 2189 } | |
| 2190 | |
| 2191 void BytesValue::SharedDtor() { | |
| 2192 value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInit
ed()); | |
| 2193 if (this != default_instance_) { | |
| 2194 } | |
| 2195 } | |
| 2196 | |
| 2197 void BytesValue::SetCachedSize(int size) const { | |
| 2198 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 2199 _cached_size_ = size; | |
| 2200 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 2201 } | |
| 2202 const ::google::protobuf::Descriptor* BytesValue::descriptor() { | |
| 2203 protobuf_AssignDescriptorsOnce(); | |
| 2204 return BytesValue_descriptor_; | |
| 2205 } | |
| 2206 | |
| 2207 const BytesValue& BytesValue::default_instance() { | |
| 2208 if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fwrappers_2
eproto(); | |
| 2209 return *default_instance_; | |
| 2210 } | |
| 2211 | |
| 2212 BytesValue* BytesValue::default_instance_ = NULL; | |
| 2213 | |
| 2214 BytesValue* BytesValue::New(::google::protobuf::Arena* arena) const { | |
| 2215 BytesValue* n = new BytesValue; | |
| 2216 if (arena != NULL) { | |
| 2217 arena->Own(n); | |
| 2218 } | |
| 2219 return n; | |
| 2220 } | |
| 2221 | |
| 2222 void BytesValue::Clear() { | |
| 2223 value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlread
yInited()); | |
| 2224 } | |
| 2225 | |
| 2226 bool BytesValue::MergePartialFromCodedStream( | |
| 2227 ::google::protobuf::io::CodedInputStream* input) { | |
| 2228 #define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure | |
| 2229 ::google::protobuf::uint32 tag; | |
| 2230 // @@protoc_insertion_point(parse_start:google.protobuf.BytesValue) | |
| 2231 for (;;) { | |
| 2232 ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(
127); | |
| 2233 tag = p.first; | |
| 2234 if (!p.second) goto handle_unusual; | |
| 2235 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)
) { | |
| 2236 // optional bytes value = 1; | |
| 2237 case 1: { | |
| 2238 if (tag == 10) { | |
| 2239 DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( | |
| 2240 input, this->mutable_value())); | |
| 2241 } else { | |
| 2242 goto handle_unusual; | |
| 2243 } | |
| 2244 if (input->ExpectAtEnd()) goto success; | |
| 2245 break; | |
| 2246 } | |
| 2247 | |
| 2248 default: { | |
| 2249 handle_unusual: | |
| 2250 if (tag == 0 || | |
| 2251 ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == | |
| 2252 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { | |
| 2253 goto success; | |
| 2254 } | |
| 2255 DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag))
; | |
| 2256 break; | |
| 2257 } | |
| 2258 } | |
| 2259 } | |
| 2260 success: | |
| 2261 // @@protoc_insertion_point(parse_success:google.protobuf.BytesValue) | |
| 2262 return true; | |
| 2263 failure: | |
| 2264 // @@protoc_insertion_point(parse_failure:google.protobuf.BytesValue) | |
| 2265 return false; | |
| 2266 #undef DO_ | |
| 2267 } | |
| 2268 | |
| 2269 void BytesValue::SerializeWithCachedSizes( | |
| 2270 ::google::protobuf::io::CodedOutputStream* output) const { | |
| 2271 // @@protoc_insertion_point(serialize_start:google.protobuf.BytesValue) | |
| 2272 // optional bytes value = 1; | |
| 2273 if (this->value().size() > 0) { | |
| 2274 ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( | |
| 2275 1, this->value(), output); | |
| 2276 } | |
| 2277 | |
| 2278 // @@protoc_insertion_point(serialize_end:google.protobuf.BytesValue) | |
| 2279 } | |
| 2280 | |
| 2281 ::google::protobuf::uint8* BytesValue::SerializeWithCachedSizesToArray( | |
| 2282 ::google::protobuf::uint8* target) const { | |
| 2283 // @@protoc_insertion_point(serialize_to_array_start:google.protobuf.BytesValu
e) | |
| 2284 // optional bytes value = 1; | |
| 2285 if (this->value().size() > 0) { | |
| 2286 target = | |
| 2287 ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( | |
| 2288 1, this->value(), target); | |
| 2289 } | |
| 2290 | |
| 2291 // @@protoc_insertion_point(serialize_to_array_end:google.protobuf.BytesValue) | |
| 2292 return target; | |
| 2293 } | |
| 2294 | |
| 2295 int BytesValue::ByteSize() const { | |
| 2296 int total_size = 0; | |
| 2297 | |
| 2298 // optional bytes value = 1; | |
| 2299 if (this->value().size() > 0) { | |
| 2300 total_size += 1 + | |
| 2301 ::google::protobuf::internal::WireFormatLite::BytesSize( | |
| 2302 this->value()); | |
| 2303 } | |
| 2304 | |
| 2305 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); | |
| 2306 _cached_size_ = total_size; | |
| 2307 GOOGLE_SAFE_CONCURRENT_WRITES_END(); | |
| 2308 return total_size; | |
| 2309 } | |
| 2310 | |
| 2311 void BytesValue::MergeFrom(const ::google::protobuf::Message& from) { | |
| 2312 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 2313 const BytesValue* source = | |
| 2314 ::google::protobuf::internal::DynamicCastToGenerated<const BytesValue>( | |
| 2315 &from); | |
| 2316 if (source == NULL) { | |
| 2317 ::google::protobuf::internal::ReflectionOps::Merge(from, this); | |
| 2318 } else { | |
| 2319 MergeFrom(*source); | |
| 2320 } | |
| 2321 } | |
| 2322 | |
| 2323 void BytesValue::MergeFrom(const BytesValue& from) { | |
| 2324 if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__); | |
| 2325 if (from.value().size() > 0) { | |
| 2326 | |
| 2327 value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlread
yInited(), from.value_); | |
| 2328 } | |
| 2329 } | |
| 2330 | |
| 2331 void BytesValue::CopyFrom(const ::google::protobuf::Message& from) { | |
| 2332 if (&from == this) return; | |
| 2333 Clear(); | |
| 2334 MergeFrom(from); | |
| 2335 } | |
| 2336 | |
| 2337 void BytesValue::CopyFrom(const BytesValue& from) { | |
| 2338 if (&from == this) return; | |
| 2339 Clear(); | |
| 2340 MergeFrom(from); | |
| 2341 } | |
| 2342 | |
| 2343 bool BytesValue::IsInitialized() const { | |
| 2344 | |
| 2345 return true; | |
| 2346 } | |
| 2347 | |
| 2348 void BytesValue::Swap(BytesValue* other) { | |
| 2349 if (other == this) return; | |
| 2350 InternalSwap(other); | |
| 2351 } | |
| 2352 void BytesValue::InternalSwap(BytesValue* other) { | |
| 2353 value_.Swap(&other->value_); | |
| 2354 _internal_metadata_.Swap(&other->_internal_metadata_); | |
| 2355 std::swap(_cached_size_, other->_cached_size_); | |
| 2356 } | |
| 2357 | |
| 2358 ::google::protobuf::Metadata BytesValue::GetMetadata() const { | |
| 2359 protobuf_AssignDescriptorsOnce(); | |
| 2360 ::google::protobuf::Metadata metadata; | |
| 2361 metadata.descriptor = BytesValue_descriptor_; | |
| 2362 metadata.reflection = BytesValue_reflection_; | |
| 2363 return metadata; | |
| 2364 } | |
| 2365 | |
| 2366 #if PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 2367 // BytesValue | |
| 2368 | |
| 2369 // optional bytes value = 1; | |
| 2370 void BytesValue::clear_value() { | |
| 2371 value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlread
yInited()); | |
| 2372 } | |
| 2373 const ::std::string& BytesValue::value() const { | |
| 2374 // @@protoc_insertion_point(field_get:google.protobuf.BytesValue.value) | |
| 2375 return value_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyI
nited()); | |
| 2376 } | |
| 2377 void BytesValue::set_value(const ::std::string& value) { | |
| 2378 | |
| 2379 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()
, value); | |
| 2380 // @@protoc_insertion_point(field_set:google.protobuf.BytesValue.value) | |
| 2381 } | |
| 2382 void BytesValue::set_value(const char* value) { | |
| 2383 | |
| 2384 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()
, ::std::string(value)); | |
| 2385 // @@protoc_insertion_point(field_set_char:google.protobuf.BytesValue.value) | |
| 2386 } | |
| 2387 void BytesValue::set_value(const void* value, size_t size) { | |
| 2388 | |
| 2389 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()
, | |
| 2390 ::std::string(reinterpret_cast<const char*>(value), size)); | |
| 2391 // @@protoc_insertion_point(field_set_pointer:google.protobuf.BytesValue.value
) | |
| 2392 } | |
| 2393 ::std::string* BytesValue::mutable_value() { | |
| 2394 | |
| 2395 // @@protoc_insertion_point(field_mutable:google.protobuf.BytesValue.value) | |
| 2396 return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlre
adyInited()); | |
| 2397 } | |
| 2398 ::std::string* BytesValue::release_value() { | |
| 2399 | |
| 2400 return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlre
adyInited()); | |
| 2401 } | |
| 2402 void BytesValue::set_allocated_value(::std::string* value) { | |
| 2403 if (value != NULL) { | |
| 2404 | |
| 2405 } else { | |
| 2406 | |
| 2407 } | |
| 2408 value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlread
yInited(), value); | |
| 2409 // @@protoc_insertion_point(field_set_allocated:google.protobuf.BytesValue.val
ue) | |
| 2410 } | |
| 2411 | |
| 2412 #endif // PROTOBUF_INLINE_NOT_IN_HEADERS | |
| 2413 | |
| 2414 // @@protoc_insertion_point(namespace_scope) | |
| 2415 | |
| 2416 } // namespace protobuf | |
| 2417 } // namespace google | |
| 2418 | |
| 2419 // @@protoc_insertion_point(global_scope) | |
| OLD | NEW |