github.com/igggame/nebulas-go@v2.1.0+incompatible/nbre/fs/proto/block.pb.h (about) 1 // Generated by the protocol buffer compiler. DO NOT EDIT! 2 // source: block.proto 3 4 #ifndef PROTOBUF_INCLUDED_block_2eproto 5 #define PROTOBUF_INCLUDED_block_2eproto 6 7 #include <string> 8 9 #include <google/protobuf/stubs/common.h> 10 11 #if GOOGLE_PROTOBUF_VERSION < 3006001 12 #error This file was generated by a newer version of protoc which is 13 #error incompatible with your Protocol Buffer headers. Please update 14 #error your headers. 15 #endif 16 #if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION 17 #error This file was generated by an older version of protoc which is 18 #error incompatible with your Protocol Buffer headers. Please 19 #error regenerate this file with a newer version of protoc. 20 #endif 21 22 #include <google/protobuf/io/coded_stream.h> 23 #include <google/protobuf/arena.h> 24 #include <google/protobuf/arenastring.h> 25 #include <google/protobuf/generated_message_table_driven.h> 26 #include <google/protobuf/generated_message_util.h> 27 #include <google/protobuf/inlined_string_field.h> 28 #include <google/protobuf/metadata.h> 29 #include <google/protobuf/message.h> 30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export 31 #include <google/protobuf/extension_set.h> // IWYU pragma: export 32 #include <google/protobuf/unknown_field_set.h> 33 #include "dag.pb.h" 34 #include "state.pb.h" 35 // @@protoc_insertion_point(includes) 36 #define PROTOBUF_INTERNAL_EXPORT_protobuf_block_2eproto 37 38 namespace protobuf_block_2eproto { 39 // Internal implementation detail -- do not use these members. 40 struct TableStruct { 41 static const ::google::protobuf::internal::ParseTableField entries[]; 42 static const ::google::protobuf::internal::AuxillaryParseTableField aux[]; 43 static const ::google::protobuf::internal::ParseTable schema[10]; 44 static const ::google::protobuf::internal::FieldMetadata field_metadata[]; 45 static const ::google::protobuf::internal::SerializationTable serialization_table[]; 46 static const ::google::protobuf::uint32 offsets[]; 47 }; 48 void AddDescriptors(); 49 } // namespace protobuf_block_2eproto 50 namespace corepb { 51 class Account; 52 class AccountDefaultTypeInternal; 53 extern AccountDefaultTypeInternal _Account_default_instance_; 54 class Block; 55 class BlockDefaultTypeInternal; 56 extern BlockDefaultTypeInternal _Block_default_instance_; 57 class BlockHeader; 58 class BlockHeaderDefaultTypeInternal; 59 extern BlockHeaderDefaultTypeInternal _BlockHeader_default_instance_; 60 class ContractMeta; 61 class ContractMetaDefaultTypeInternal; 62 extern ContractMetaDefaultTypeInternal _ContractMeta_default_instance_; 63 class Data; 64 class DataDefaultTypeInternal; 65 extern DataDefaultTypeInternal _Data_default_instance_; 66 class DownloadBlock; 67 class DownloadBlockDefaultTypeInternal; 68 extern DownloadBlockDefaultTypeInternal _DownloadBlock_default_instance_; 69 class NetBlock; 70 class NetBlockDefaultTypeInternal; 71 extern NetBlockDefaultTypeInternal _NetBlock_default_instance_; 72 class NetBlocks; 73 class NetBlocksDefaultTypeInternal; 74 extern NetBlocksDefaultTypeInternal _NetBlocks_default_instance_; 75 class Random; 76 class RandomDefaultTypeInternal; 77 extern RandomDefaultTypeInternal _Random_default_instance_; 78 class Transaction; 79 class TransactionDefaultTypeInternal; 80 extern TransactionDefaultTypeInternal _Transaction_default_instance_; 81 } // namespace corepb 82 namespace google { 83 namespace protobuf { 84 template<> ::corepb::Account* Arena::CreateMaybeMessage<::corepb::Account>(Arena*); 85 template<> ::corepb::Block* Arena::CreateMaybeMessage<::corepb::Block>(Arena*); 86 template<> ::corepb::BlockHeader* Arena::CreateMaybeMessage<::corepb::BlockHeader>(Arena*); 87 template<> ::corepb::ContractMeta* Arena::CreateMaybeMessage<::corepb::ContractMeta>(Arena*); 88 template<> ::corepb::Data* Arena::CreateMaybeMessage<::corepb::Data>(Arena*); 89 template<> ::corepb::DownloadBlock* Arena::CreateMaybeMessage<::corepb::DownloadBlock>(Arena*); 90 template<> ::corepb::NetBlock* Arena::CreateMaybeMessage<::corepb::NetBlock>(Arena*); 91 template<> ::corepb::NetBlocks* Arena::CreateMaybeMessage<::corepb::NetBlocks>(Arena*); 92 template<> ::corepb::Random* Arena::CreateMaybeMessage<::corepb::Random>(Arena*); 93 template<> ::corepb::Transaction* Arena::CreateMaybeMessage<::corepb::Transaction>(Arena*); 94 } // namespace protobuf 95 } // namespace google 96 namespace corepb { 97 98 // =================================================================== 99 100 class Account : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.Account) */ { 101 public: 102 Account(); 103 virtual ~Account(); 104 105 Account(const Account& from); 106 107 inline Account& operator=(const Account& from) { 108 CopyFrom(from); 109 return *this; 110 } 111 #if LANG_CXX11 112 Account(Account&& from) noexcept 113 : Account() { 114 *this = ::std::move(from); 115 } 116 117 inline Account& operator=(Account&& from) noexcept { 118 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 119 if (this != &from) InternalSwap(&from); 120 } else { 121 CopyFrom(from); 122 } 123 return *this; 124 } 125 #endif 126 static const ::google::protobuf::Descriptor* descriptor(); 127 static const Account& default_instance(); 128 129 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 130 static inline const Account* internal_default_instance() { 131 return reinterpret_cast<const Account*>( 132 &_Account_default_instance_); 133 } 134 static constexpr int kIndexInFileMessages = 135 0; 136 137 void Swap(Account* other); 138 friend void swap(Account& a, Account& b) { 139 a.Swap(&b); 140 } 141 142 // implements Message ---------------------------------------------- 143 144 inline Account* New() const final { 145 return CreateMaybeMessage<Account>(NULL); 146 } 147 148 Account* New(::google::protobuf::Arena* arena) const final { 149 return CreateMaybeMessage<Account>(arena); 150 } 151 void CopyFrom(const ::google::protobuf::Message& from) final; 152 void MergeFrom(const ::google::protobuf::Message& from) final; 153 void CopyFrom(const Account& from); 154 void MergeFrom(const Account& from); 155 void Clear() final; 156 bool IsInitialized() const final; 157 158 size_t ByteSizeLong() const final; 159 bool MergePartialFromCodedStream( 160 ::google::protobuf::io::CodedInputStream* input) final; 161 void SerializeWithCachedSizes( 162 ::google::protobuf::io::CodedOutputStream* output) const final; 163 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 164 bool deterministic, ::google::protobuf::uint8* target) const final; 165 int GetCachedSize() const final { return _cached_size_.Get(); } 166 167 private: 168 void SharedCtor(); 169 void SharedDtor(); 170 void SetCachedSize(int size) const final; 171 void InternalSwap(Account* other); 172 private: 173 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 174 return NULL; 175 } 176 inline void* MaybeArenaPtr() const { 177 return NULL; 178 } 179 public: 180 181 ::google::protobuf::Metadata GetMetadata() const final; 182 183 // nested types ---------------------------------------------------- 184 185 // accessors ------------------------------------------------------- 186 187 // bytes address = 1; 188 void clear_address(); 189 static const int kAddressFieldNumber = 1; 190 const ::std::string& address() const; 191 void set_address(const ::std::string& value); 192 #if LANG_CXX11 193 void set_address(::std::string&& value); 194 #endif 195 void set_address(const char* value); 196 void set_address(const void* value, size_t size); 197 ::std::string* mutable_address(); 198 ::std::string* release_address(); 199 void set_allocated_address(::std::string* address); 200 201 // bytes balance = 2; 202 void clear_balance(); 203 static const int kBalanceFieldNumber = 2; 204 const ::std::string& balance() const; 205 void set_balance(const ::std::string& value); 206 #if LANG_CXX11 207 void set_balance(::std::string&& value); 208 #endif 209 void set_balance(const char* value); 210 void set_balance(const void* value, size_t size); 211 ::std::string* mutable_balance(); 212 ::std::string* release_balance(); 213 void set_allocated_balance(::std::string* balance); 214 215 // bytes vars_hash = 4; 216 void clear_vars_hash(); 217 static const int kVarsHashFieldNumber = 4; 218 const ::std::string& vars_hash() const; 219 void set_vars_hash(const ::std::string& value); 220 #if LANG_CXX11 221 void set_vars_hash(::std::string&& value); 222 #endif 223 void set_vars_hash(const char* value); 224 void set_vars_hash(const void* value, size_t size); 225 ::std::string* mutable_vars_hash(); 226 ::std::string* release_vars_hash(); 227 void set_allocated_vars_hash(::std::string* vars_hash); 228 229 // bytes birth_place = 5; 230 void clear_birth_place(); 231 static const int kBirthPlaceFieldNumber = 5; 232 const ::std::string& birth_place() const; 233 void set_birth_place(const ::std::string& value); 234 #if LANG_CXX11 235 void set_birth_place(::std::string&& value); 236 #endif 237 void set_birth_place(const char* value); 238 void set_birth_place(const void* value, size_t size); 239 ::std::string* mutable_birth_place(); 240 ::std::string* release_birth_place(); 241 void set_allocated_birth_place(::std::string* birth_place); 242 243 // .corepb.ContractMeta contract_meta = 6; 244 bool has_contract_meta() const; 245 void clear_contract_meta(); 246 static const int kContractMetaFieldNumber = 6; 247 private: 248 const ::corepb::ContractMeta& _internal_contract_meta() const; 249 public: 250 const ::corepb::ContractMeta& contract_meta() const; 251 ::corepb::ContractMeta* release_contract_meta(); 252 ::corepb::ContractMeta* mutable_contract_meta(); 253 void set_allocated_contract_meta(::corepb::ContractMeta* contract_meta); 254 255 // uint64 nonce = 3; 256 void clear_nonce(); 257 static const int kNonceFieldNumber = 3; 258 ::google::protobuf::uint64 nonce() const; 259 void set_nonce(::google::protobuf::uint64 value); 260 261 // @@protoc_insertion_point(class_scope:corepb.Account) 262 private: 263 264 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 265 ::google::protobuf::internal::ArenaStringPtr address_; 266 ::google::protobuf::internal::ArenaStringPtr balance_; 267 ::google::protobuf::internal::ArenaStringPtr vars_hash_; 268 ::google::protobuf::internal::ArenaStringPtr birth_place_; 269 ::corepb::ContractMeta* contract_meta_; 270 ::google::protobuf::uint64 nonce_; 271 mutable ::google::protobuf::internal::CachedSize _cached_size_; 272 friend struct ::protobuf_block_2eproto::TableStruct; 273 }; 274 // ------------------------------------------------------------------- 275 276 class ContractMeta : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.ContractMeta) */ { 277 public: 278 ContractMeta(); 279 virtual ~ContractMeta(); 280 281 ContractMeta(const ContractMeta& from); 282 283 inline ContractMeta& operator=(const ContractMeta& from) { 284 CopyFrom(from); 285 return *this; 286 } 287 #if LANG_CXX11 288 ContractMeta(ContractMeta&& from) noexcept 289 : ContractMeta() { 290 *this = ::std::move(from); 291 } 292 293 inline ContractMeta& operator=(ContractMeta&& from) noexcept { 294 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 295 if (this != &from) InternalSwap(&from); 296 } else { 297 CopyFrom(from); 298 } 299 return *this; 300 } 301 #endif 302 static const ::google::protobuf::Descriptor* descriptor(); 303 static const ContractMeta& default_instance(); 304 305 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 306 static inline const ContractMeta* internal_default_instance() { 307 return reinterpret_cast<const ContractMeta*>( 308 &_ContractMeta_default_instance_); 309 } 310 static constexpr int kIndexInFileMessages = 311 1; 312 313 void Swap(ContractMeta* other); 314 friend void swap(ContractMeta& a, ContractMeta& b) { 315 a.Swap(&b); 316 } 317 318 // implements Message ---------------------------------------------- 319 320 inline ContractMeta* New() const final { 321 return CreateMaybeMessage<ContractMeta>(NULL); 322 } 323 324 ContractMeta* New(::google::protobuf::Arena* arena) const final { 325 return CreateMaybeMessage<ContractMeta>(arena); 326 } 327 void CopyFrom(const ::google::protobuf::Message& from) final; 328 void MergeFrom(const ::google::protobuf::Message& from) final; 329 void CopyFrom(const ContractMeta& from); 330 void MergeFrom(const ContractMeta& from); 331 void Clear() final; 332 bool IsInitialized() const final; 333 334 size_t ByteSizeLong() const final; 335 bool MergePartialFromCodedStream( 336 ::google::protobuf::io::CodedInputStream* input) final; 337 void SerializeWithCachedSizes( 338 ::google::protobuf::io::CodedOutputStream* output) const final; 339 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 340 bool deterministic, ::google::protobuf::uint8* target) const final; 341 int GetCachedSize() const final { return _cached_size_.Get(); } 342 343 private: 344 void SharedCtor(); 345 void SharedDtor(); 346 void SetCachedSize(int size) const final; 347 void InternalSwap(ContractMeta* other); 348 private: 349 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 350 return NULL; 351 } 352 inline void* MaybeArenaPtr() const { 353 return NULL; 354 } 355 public: 356 357 ::google::protobuf::Metadata GetMetadata() const final; 358 359 // nested types ---------------------------------------------------- 360 361 // accessors ------------------------------------------------------- 362 363 // string version = 1; 364 void clear_version(); 365 static const int kVersionFieldNumber = 1; 366 const ::std::string& version() const; 367 void set_version(const ::std::string& value); 368 #if LANG_CXX11 369 void set_version(::std::string&& value); 370 #endif 371 void set_version(const char* value); 372 void set_version(const char* value, size_t size); 373 ::std::string* mutable_version(); 374 ::std::string* release_version(); 375 void set_allocated_version(::std::string* version); 376 377 // @@protoc_insertion_point(class_scope:corepb.ContractMeta) 378 private: 379 380 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 381 ::google::protobuf::internal::ArenaStringPtr version_; 382 mutable ::google::protobuf::internal::CachedSize _cached_size_; 383 friend struct ::protobuf_block_2eproto::TableStruct; 384 }; 385 // ------------------------------------------------------------------- 386 387 class Data : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.Data) */ { 388 public: 389 Data(); 390 virtual ~Data(); 391 392 Data(const Data& from); 393 394 inline Data& operator=(const Data& from) { 395 CopyFrom(from); 396 return *this; 397 } 398 #if LANG_CXX11 399 Data(Data&& from) noexcept 400 : Data() { 401 *this = ::std::move(from); 402 } 403 404 inline Data& operator=(Data&& from) noexcept { 405 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 406 if (this != &from) InternalSwap(&from); 407 } else { 408 CopyFrom(from); 409 } 410 return *this; 411 } 412 #endif 413 static const ::google::protobuf::Descriptor* descriptor(); 414 static const Data& default_instance(); 415 416 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 417 static inline const Data* internal_default_instance() { 418 return reinterpret_cast<const Data*>( 419 &_Data_default_instance_); 420 } 421 static constexpr int kIndexInFileMessages = 422 2; 423 424 void Swap(Data* other); 425 friend void swap(Data& a, Data& b) { 426 a.Swap(&b); 427 } 428 429 // implements Message ---------------------------------------------- 430 431 inline Data* New() const final { 432 return CreateMaybeMessage<Data>(NULL); 433 } 434 435 Data* New(::google::protobuf::Arena* arena) const final { 436 return CreateMaybeMessage<Data>(arena); 437 } 438 void CopyFrom(const ::google::protobuf::Message& from) final; 439 void MergeFrom(const ::google::protobuf::Message& from) final; 440 void CopyFrom(const Data& from); 441 void MergeFrom(const Data& from); 442 void Clear() final; 443 bool IsInitialized() const final; 444 445 size_t ByteSizeLong() const final; 446 bool MergePartialFromCodedStream( 447 ::google::protobuf::io::CodedInputStream* input) final; 448 void SerializeWithCachedSizes( 449 ::google::protobuf::io::CodedOutputStream* output) const final; 450 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 451 bool deterministic, ::google::protobuf::uint8* target) const final; 452 int GetCachedSize() const final { return _cached_size_.Get(); } 453 454 private: 455 void SharedCtor(); 456 void SharedDtor(); 457 void SetCachedSize(int size) const final; 458 void InternalSwap(Data* other); 459 private: 460 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 461 return NULL; 462 } 463 inline void* MaybeArenaPtr() const { 464 return NULL; 465 } 466 public: 467 468 ::google::protobuf::Metadata GetMetadata() const final; 469 470 // nested types ---------------------------------------------------- 471 472 // accessors ------------------------------------------------------- 473 474 // string type = 1; 475 void clear_type(); 476 static const int kTypeFieldNumber = 1; 477 const ::std::string& type() const; 478 void set_type(const ::std::string& value); 479 #if LANG_CXX11 480 void set_type(::std::string&& value); 481 #endif 482 void set_type(const char* value); 483 void set_type(const char* value, size_t size); 484 ::std::string* mutable_type(); 485 ::std::string* release_type(); 486 void set_allocated_type(::std::string* type); 487 488 // bytes payload = 2; 489 void clear_payload(); 490 static const int kPayloadFieldNumber = 2; 491 const ::std::string& payload() const; 492 void set_payload(const ::std::string& value); 493 #if LANG_CXX11 494 void set_payload(::std::string&& value); 495 #endif 496 void set_payload(const char* value); 497 void set_payload(const void* value, size_t size); 498 ::std::string* mutable_payload(); 499 ::std::string* release_payload(); 500 void set_allocated_payload(::std::string* payload); 501 502 // @@protoc_insertion_point(class_scope:corepb.Data) 503 private: 504 505 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 506 ::google::protobuf::internal::ArenaStringPtr type_; 507 ::google::protobuf::internal::ArenaStringPtr payload_; 508 mutable ::google::protobuf::internal::CachedSize _cached_size_; 509 friend struct ::protobuf_block_2eproto::TableStruct; 510 }; 511 // ------------------------------------------------------------------- 512 513 class Transaction : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.Transaction) */ { 514 public: 515 Transaction(); 516 virtual ~Transaction(); 517 518 Transaction(const Transaction& from); 519 520 inline Transaction& operator=(const Transaction& from) { 521 CopyFrom(from); 522 return *this; 523 } 524 #if LANG_CXX11 525 Transaction(Transaction&& from) noexcept 526 : Transaction() { 527 *this = ::std::move(from); 528 } 529 530 inline Transaction& operator=(Transaction&& from) noexcept { 531 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 532 if (this != &from) InternalSwap(&from); 533 } else { 534 CopyFrom(from); 535 } 536 return *this; 537 } 538 #endif 539 static const ::google::protobuf::Descriptor* descriptor(); 540 static const Transaction& default_instance(); 541 542 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 543 static inline const Transaction* internal_default_instance() { 544 return reinterpret_cast<const Transaction*>( 545 &_Transaction_default_instance_); 546 } 547 static constexpr int kIndexInFileMessages = 548 3; 549 550 void Swap(Transaction* other); 551 friend void swap(Transaction& a, Transaction& b) { 552 a.Swap(&b); 553 } 554 555 // implements Message ---------------------------------------------- 556 557 inline Transaction* New() const final { 558 return CreateMaybeMessage<Transaction>(NULL); 559 } 560 561 Transaction* New(::google::protobuf::Arena* arena) const final { 562 return CreateMaybeMessage<Transaction>(arena); 563 } 564 void CopyFrom(const ::google::protobuf::Message& from) final; 565 void MergeFrom(const ::google::protobuf::Message& from) final; 566 void CopyFrom(const Transaction& from); 567 void MergeFrom(const Transaction& from); 568 void Clear() final; 569 bool IsInitialized() const final; 570 571 size_t ByteSizeLong() const final; 572 bool MergePartialFromCodedStream( 573 ::google::protobuf::io::CodedInputStream* input) final; 574 void SerializeWithCachedSizes( 575 ::google::protobuf::io::CodedOutputStream* output) const final; 576 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 577 bool deterministic, ::google::protobuf::uint8* target) const final; 578 int GetCachedSize() const final { return _cached_size_.Get(); } 579 580 private: 581 void SharedCtor(); 582 void SharedDtor(); 583 void SetCachedSize(int size) const final; 584 void InternalSwap(Transaction* other); 585 private: 586 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 587 return NULL; 588 } 589 inline void* MaybeArenaPtr() const { 590 return NULL; 591 } 592 public: 593 594 ::google::protobuf::Metadata GetMetadata() const final; 595 596 // nested types ---------------------------------------------------- 597 598 // accessors ------------------------------------------------------- 599 600 // bytes hash = 1; 601 void clear_hash(); 602 static const int kHashFieldNumber = 1; 603 const ::std::string& hash() const; 604 void set_hash(const ::std::string& value); 605 #if LANG_CXX11 606 void set_hash(::std::string&& value); 607 #endif 608 void set_hash(const char* value); 609 void set_hash(const void* value, size_t size); 610 ::std::string* mutable_hash(); 611 ::std::string* release_hash(); 612 void set_allocated_hash(::std::string* hash); 613 614 // bytes from = 2; 615 void clear_from(); 616 static const int kFromFieldNumber = 2; 617 const ::std::string& from() const; 618 void set_from(const ::std::string& value); 619 #if LANG_CXX11 620 void set_from(::std::string&& value); 621 #endif 622 void set_from(const char* value); 623 void set_from(const void* value, size_t size); 624 ::std::string* mutable_from(); 625 ::std::string* release_from(); 626 void set_allocated_from(::std::string* from); 627 628 // bytes to = 3; 629 void clear_to(); 630 static const int kToFieldNumber = 3; 631 const ::std::string& to() const; 632 void set_to(const ::std::string& value); 633 #if LANG_CXX11 634 void set_to(::std::string&& value); 635 #endif 636 void set_to(const char* value); 637 void set_to(const void* value, size_t size); 638 ::std::string* mutable_to(); 639 ::std::string* release_to(); 640 void set_allocated_to(::std::string* to); 641 642 // bytes value = 4; 643 void clear_value(); 644 static const int kValueFieldNumber = 4; 645 const ::std::string& value() const; 646 void set_value(const ::std::string& value); 647 #if LANG_CXX11 648 void set_value(::std::string&& value); 649 #endif 650 void set_value(const char* value); 651 void set_value(const void* value, size_t size); 652 ::std::string* mutable_value(); 653 ::std::string* release_value(); 654 void set_allocated_value(::std::string* value); 655 656 // bytes gas_price = 9; 657 void clear_gas_price(); 658 static const int kGasPriceFieldNumber = 9; 659 const ::std::string& gas_price() const; 660 void set_gas_price(const ::std::string& value); 661 #if LANG_CXX11 662 void set_gas_price(::std::string&& value); 663 #endif 664 void set_gas_price(const char* value); 665 void set_gas_price(const void* value, size_t size); 666 ::std::string* mutable_gas_price(); 667 ::std::string* release_gas_price(); 668 void set_allocated_gas_price(::std::string* gas_price); 669 670 // bytes gas_limit = 10; 671 void clear_gas_limit(); 672 static const int kGasLimitFieldNumber = 10; 673 const ::std::string& gas_limit() const; 674 void set_gas_limit(const ::std::string& value); 675 #if LANG_CXX11 676 void set_gas_limit(::std::string&& value); 677 #endif 678 void set_gas_limit(const char* value); 679 void set_gas_limit(const void* value, size_t size); 680 ::std::string* mutable_gas_limit(); 681 ::std::string* release_gas_limit(); 682 void set_allocated_gas_limit(::std::string* gas_limit); 683 684 // bytes sign = 12; 685 void clear_sign(); 686 static const int kSignFieldNumber = 12; 687 const ::std::string& sign() const; 688 void set_sign(const ::std::string& value); 689 #if LANG_CXX11 690 void set_sign(::std::string&& value); 691 #endif 692 void set_sign(const char* value); 693 void set_sign(const void* value, size_t size); 694 ::std::string* mutable_sign(); 695 ::std::string* release_sign(); 696 void set_allocated_sign(::std::string* sign); 697 698 // .corepb.Data data = 7; 699 bool has_data() const; 700 void clear_data(); 701 static const int kDataFieldNumber = 7; 702 private: 703 const ::corepb::Data& _internal_data() const; 704 public: 705 const ::corepb::Data& data() const; 706 ::corepb::Data* release_data(); 707 ::corepb::Data* mutable_data(); 708 void set_allocated_data(::corepb::Data* data); 709 710 // uint64 nonce = 5; 711 void clear_nonce(); 712 static const int kNonceFieldNumber = 5; 713 ::google::protobuf::uint64 nonce() const; 714 void set_nonce(::google::protobuf::uint64 value); 715 716 // int64 timestamp = 6; 717 void clear_timestamp(); 718 static const int kTimestampFieldNumber = 6; 719 ::google::protobuf::int64 timestamp() const; 720 void set_timestamp(::google::protobuf::int64 value); 721 722 // uint32 chain_id = 8; 723 void clear_chain_id(); 724 static const int kChainIdFieldNumber = 8; 725 ::google::protobuf::uint32 chain_id() const; 726 void set_chain_id(::google::protobuf::uint32 value); 727 728 // uint32 alg = 11; 729 void clear_alg(); 730 static const int kAlgFieldNumber = 11; 731 ::google::protobuf::uint32 alg() const; 732 void set_alg(::google::protobuf::uint32 value); 733 734 // @@protoc_insertion_point(class_scope:corepb.Transaction) 735 private: 736 737 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 738 ::google::protobuf::internal::ArenaStringPtr hash_; 739 ::google::protobuf::internal::ArenaStringPtr from_; 740 ::google::protobuf::internal::ArenaStringPtr to_; 741 ::google::protobuf::internal::ArenaStringPtr value_; 742 ::google::protobuf::internal::ArenaStringPtr gas_price_; 743 ::google::protobuf::internal::ArenaStringPtr gas_limit_; 744 ::google::protobuf::internal::ArenaStringPtr sign_; 745 ::corepb::Data* data_; 746 ::google::protobuf::uint64 nonce_; 747 ::google::protobuf::int64 timestamp_; 748 ::google::protobuf::uint32 chain_id_; 749 ::google::protobuf::uint32 alg_; 750 mutable ::google::protobuf::internal::CachedSize _cached_size_; 751 friend struct ::protobuf_block_2eproto::TableStruct; 752 }; 753 // ------------------------------------------------------------------- 754 755 class BlockHeader : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.BlockHeader) */ { 756 public: 757 BlockHeader(); 758 virtual ~BlockHeader(); 759 760 BlockHeader(const BlockHeader& from); 761 762 inline BlockHeader& operator=(const BlockHeader& from) { 763 CopyFrom(from); 764 return *this; 765 } 766 #if LANG_CXX11 767 BlockHeader(BlockHeader&& from) noexcept 768 : BlockHeader() { 769 *this = ::std::move(from); 770 } 771 772 inline BlockHeader& operator=(BlockHeader&& from) noexcept { 773 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 774 if (this != &from) InternalSwap(&from); 775 } else { 776 CopyFrom(from); 777 } 778 return *this; 779 } 780 #endif 781 static const ::google::protobuf::Descriptor* descriptor(); 782 static const BlockHeader& default_instance(); 783 784 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 785 static inline const BlockHeader* internal_default_instance() { 786 return reinterpret_cast<const BlockHeader*>( 787 &_BlockHeader_default_instance_); 788 } 789 static constexpr int kIndexInFileMessages = 790 4; 791 792 void Swap(BlockHeader* other); 793 friend void swap(BlockHeader& a, BlockHeader& b) { 794 a.Swap(&b); 795 } 796 797 // implements Message ---------------------------------------------- 798 799 inline BlockHeader* New() const final { 800 return CreateMaybeMessage<BlockHeader>(NULL); 801 } 802 803 BlockHeader* New(::google::protobuf::Arena* arena) const final { 804 return CreateMaybeMessage<BlockHeader>(arena); 805 } 806 void CopyFrom(const ::google::protobuf::Message& from) final; 807 void MergeFrom(const ::google::protobuf::Message& from) final; 808 void CopyFrom(const BlockHeader& from); 809 void MergeFrom(const BlockHeader& from); 810 void Clear() final; 811 bool IsInitialized() const final; 812 813 size_t ByteSizeLong() const final; 814 bool MergePartialFromCodedStream( 815 ::google::protobuf::io::CodedInputStream* input) final; 816 void SerializeWithCachedSizes( 817 ::google::protobuf::io::CodedOutputStream* output) const final; 818 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 819 bool deterministic, ::google::protobuf::uint8* target) const final; 820 int GetCachedSize() const final { return _cached_size_.Get(); } 821 822 private: 823 void SharedCtor(); 824 void SharedDtor(); 825 void SetCachedSize(int size) const final; 826 void InternalSwap(BlockHeader* other); 827 private: 828 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 829 return NULL; 830 } 831 inline void* MaybeArenaPtr() const { 832 return NULL; 833 } 834 public: 835 836 ::google::protobuf::Metadata GetMetadata() const final; 837 838 // nested types ---------------------------------------------------- 839 840 // accessors ------------------------------------------------------- 841 842 // bytes hash = 1; 843 void clear_hash(); 844 static const int kHashFieldNumber = 1; 845 const ::std::string& hash() const; 846 void set_hash(const ::std::string& value); 847 #if LANG_CXX11 848 void set_hash(::std::string&& value); 849 #endif 850 void set_hash(const char* value); 851 void set_hash(const void* value, size_t size); 852 ::std::string* mutable_hash(); 853 ::std::string* release_hash(); 854 void set_allocated_hash(::std::string* hash); 855 856 // bytes parent_hash = 2; 857 void clear_parent_hash(); 858 static const int kParentHashFieldNumber = 2; 859 const ::std::string& parent_hash() const; 860 void set_parent_hash(const ::std::string& value); 861 #if LANG_CXX11 862 void set_parent_hash(::std::string&& value); 863 #endif 864 void set_parent_hash(const char* value); 865 void set_parent_hash(const void* value, size_t size); 866 ::std::string* mutable_parent_hash(); 867 ::std::string* release_parent_hash(); 868 void set_allocated_parent_hash(::std::string* parent_hash); 869 870 // bytes coinbase = 4; 871 void clear_coinbase(); 872 static const int kCoinbaseFieldNumber = 4; 873 const ::std::string& coinbase() const; 874 void set_coinbase(const ::std::string& value); 875 #if LANG_CXX11 876 void set_coinbase(::std::string&& value); 877 #endif 878 void set_coinbase(const char* value); 879 void set_coinbase(const void* value, size_t size); 880 ::std::string* mutable_coinbase(); 881 ::std::string* release_coinbase(); 882 void set_allocated_coinbase(::std::string* coinbase); 883 884 // bytes sign = 8; 885 void clear_sign(); 886 static const int kSignFieldNumber = 8; 887 const ::std::string& sign() const; 888 void set_sign(const ::std::string& value); 889 #if LANG_CXX11 890 void set_sign(::std::string&& value); 891 #endif 892 void set_sign(const char* value); 893 void set_sign(const void* value, size_t size); 894 ::std::string* mutable_sign(); 895 ::std::string* release_sign(); 896 void set_allocated_sign(::std::string* sign); 897 898 // bytes state_root = 9; 899 void clear_state_root(); 900 static const int kStateRootFieldNumber = 9; 901 const ::std::string& state_root() const; 902 void set_state_root(const ::std::string& value); 903 #if LANG_CXX11 904 void set_state_root(::std::string&& value); 905 #endif 906 void set_state_root(const char* value); 907 void set_state_root(const void* value, size_t size); 908 ::std::string* mutable_state_root(); 909 ::std::string* release_state_root(); 910 void set_allocated_state_root(::std::string* state_root); 911 912 // bytes txs_root = 10; 913 void clear_txs_root(); 914 static const int kTxsRootFieldNumber = 10; 915 const ::std::string& txs_root() const; 916 void set_txs_root(const ::std::string& value); 917 #if LANG_CXX11 918 void set_txs_root(::std::string&& value); 919 #endif 920 void set_txs_root(const char* value); 921 void set_txs_root(const void* value, size_t size); 922 ::std::string* mutable_txs_root(); 923 ::std::string* release_txs_root(); 924 void set_allocated_txs_root(::std::string* txs_root); 925 926 // bytes events_root = 11; 927 void clear_events_root(); 928 static const int kEventsRootFieldNumber = 11; 929 const ::std::string& events_root() const; 930 void set_events_root(const ::std::string& value); 931 #if LANG_CXX11 932 void set_events_root(::std::string&& value); 933 #endif 934 void set_events_root(const char* value); 935 void set_events_root(const void* value, size_t size); 936 ::std::string* mutable_events_root(); 937 ::std::string* release_events_root(); 938 void set_allocated_events_root(::std::string* events_root); 939 940 // .consensuspb.ConsensusRoot consensus_root = 12; 941 bool has_consensus_root() const; 942 void clear_consensus_root(); 943 static const int kConsensusRootFieldNumber = 12; 944 private: 945 const ::consensuspb::ConsensusRoot& _internal_consensus_root() const; 946 public: 947 const ::consensuspb::ConsensusRoot& consensus_root() const; 948 ::consensuspb::ConsensusRoot* release_consensus_root(); 949 ::consensuspb::ConsensusRoot* mutable_consensus_root(); 950 void set_allocated_consensus_root(::consensuspb::ConsensusRoot* consensus_root); 951 952 // .corepb.Random random = 13; 953 bool has_random() const; 954 void clear_random(); 955 static const int kRandomFieldNumber = 13; 956 private: 957 const ::corepb::Random& _internal_random() const; 958 public: 959 const ::corepb::Random& random() const; 960 ::corepb::Random* release_random(); 961 ::corepb::Random* mutable_random(); 962 void set_allocated_random(::corepb::Random* random); 963 964 // int64 timestamp = 5; 965 void clear_timestamp(); 966 static const int kTimestampFieldNumber = 5; 967 ::google::protobuf::int64 timestamp() const; 968 void set_timestamp(::google::protobuf::int64 value); 969 970 // uint32 chain_id = 6; 971 void clear_chain_id(); 972 static const int kChainIdFieldNumber = 6; 973 ::google::protobuf::uint32 chain_id() const; 974 void set_chain_id(::google::protobuf::uint32 value); 975 976 // uint32 alg = 7; 977 void clear_alg(); 978 static const int kAlgFieldNumber = 7; 979 ::google::protobuf::uint32 alg() const; 980 void set_alg(::google::protobuf::uint32 value); 981 982 // @@protoc_insertion_point(class_scope:corepb.BlockHeader) 983 private: 984 985 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 986 ::google::protobuf::internal::ArenaStringPtr hash_; 987 ::google::protobuf::internal::ArenaStringPtr parent_hash_; 988 ::google::protobuf::internal::ArenaStringPtr coinbase_; 989 ::google::protobuf::internal::ArenaStringPtr sign_; 990 ::google::protobuf::internal::ArenaStringPtr state_root_; 991 ::google::protobuf::internal::ArenaStringPtr txs_root_; 992 ::google::protobuf::internal::ArenaStringPtr events_root_; 993 ::consensuspb::ConsensusRoot* consensus_root_; 994 ::corepb::Random* random_; 995 ::google::protobuf::int64 timestamp_; 996 ::google::protobuf::uint32 chain_id_; 997 ::google::protobuf::uint32 alg_; 998 mutable ::google::protobuf::internal::CachedSize _cached_size_; 999 friend struct ::protobuf_block_2eproto::TableStruct; 1000 }; 1001 // ------------------------------------------------------------------- 1002 1003 class Block : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.Block) */ { 1004 public: 1005 Block(); 1006 virtual ~Block(); 1007 1008 Block(const Block& from); 1009 1010 inline Block& operator=(const Block& from) { 1011 CopyFrom(from); 1012 return *this; 1013 } 1014 #if LANG_CXX11 1015 Block(Block&& from) noexcept 1016 : Block() { 1017 *this = ::std::move(from); 1018 } 1019 1020 inline Block& operator=(Block&& from) noexcept { 1021 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 1022 if (this != &from) InternalSwap(&from); 1023 } else { 1024 CopyFrom(from); 1025 } 1026 return *this; 1027 } 1028 #endif 1029 static const ::google::protobuf::Descriptor* descriptor(); 1030 static const Block& default_instance(); 1031 1032 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 1033 static inline const Block* internal_default_instance() { 1034 return reinterpret_cast<const Block*>( 1035 &_Block_default_instance_); 1036 } 1037 static constexpr int kIndexInFileMessages = 1038 5; 1039 1040 void Swap(Block* other); 1041 friend void swap(Block& a, Block& b) { 1042 a.Swap(&b); 1043 } 1044 1045 // implements Message ---------------------------------------------- 1046 1047 inline Block* New() const final { 1048 return CreateMaybeMessage<Block>(NULL); 1049 } 1050 1051 Block* New(::google::protobuf::Arena* arena) const final { 1052 return CreateMaybeMessage<Block>(arena); 1053 } 1054 void CopyFrom(const ::google::protobuf::Message& from) final; 1055 void MergeFrom(const ::google::protobuf::Message& from) final; 1056 void CopyFrom(const Block& from); 1057 void MergeFrom(const Block& from); 1058 void Clear() final; 1059 bool IsInitialized() const final; 1060 1061 size_t ByteSizeLong() const final; 1062 bool MergePartialFromCodedStream( 1063 ::google::protobuf::io::CodedInputStream* input) final; 1064 void SerializeWithCachedSizes( 1065 ::google::protobuf::io::CodedOutputStream* output) const final; 1066 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 1067 bool deterministic, ::google::protobuf::uint8* target) const final; 1068 int GetCachedSize() const final { return _cached_size_.Get(); } 1069 1070 private: 1071 void SharedCtor(); 1072 void SharedDtor(); 1073 void SetCachedSize(int size) const final; 1074 void InternalSwap(Block* other); 1075 private: 1076 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 1077 return NULL; 1078 } 1079 inline void* MaybeArenaPtr() const { 1080 return NULL; 1081 } 1082 public: 1083 1084 ::google::protobuf::Metadata GetMetadata() const final; 1085 1086 // nested types ---------------------------------------------------- 1087 1088 // accessors ------------------------------------------------------- 1089 1090 // repeated .corepb.Transaction transactions = 2; 1091 int transactions_size() const; 1092 void clear_transactions(); 1093 static const int kTransactionsFieldNumber = 2; 1094 ::corepb::Transaction* mutable_transactions(int index); 1095 ::google::protobuf::RepeatedPtrField< ::corepb::Transaction >* 1096 mutable_transactions(); 1097 const ::corepb::Transaction& transactions(int index) const; 1098 ::corepb::Transaction* add_transactions(); 1099 const ::google::protobuf::RepeatedPtrField< ::corepb::Transaction >& 1100 transactions() const; 1101 1102 // .corepb.BlockHeader header = 1; 1103 bool has_header() const; 1104 void clear_header(); 1105 static const int kHeaderFieldNumber = 1; 1106 private: 1107 const ::corepb::BlockHeader& _internal_header() const; 1108 public: 1109 const ::corepb::BlockHeader& header() const; 1110 ::corepb::BlockHeader* release_header(); 1111 ::corepb::BlockHeader* mutable_header(); 1112 void set_allocated_header(::corepb::BlockHeader* header); 1113 1114 // .dagpb.Dag dependency = 3; 1115 bool has_dependency() const; 1116 void clear_dependency(); 1117 static const int kDependencyFieldNumber = 3; 1118 private: 1119 const ::dagpb::Dag& _internal_dependency() const; 1120 public: 1121 const ::dagpb::Dag& dependency() const; 1122 ::dagpb::Dag* release_dependency(); 1123 ::dagpb::Dag* mutable_dependency(); 1124 void set_allocated_dependency(::dagpb::Dag* dependency); 1125 1126 // uint64 height = 4; 1127 void clear_height(); 1128 static const int kHeightFieldNumber = 4; 1129 ::google::protobuf::uint64 height() const; 1130 void set_height(::google::protobuf::uint64 value); 1131 1132 // @@protoc_insertion_point(class_scope:corepb.Block) 1133 private: 1134 1135 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 1136 ::google::protobuf::RepeatedPtrField< ::corepb::Transaction > transactions_; 1137 ::corepb::BlockHeader* header_; 1138 ::dagpb::Dag* dependency_; 1139 ::google::protobuf::uint64 height_; 1140 mutable ::google::protobuf::internal::CachedSize _cached_size_; 1141 friend struct ::protobuf_block_2eproto::TableStruct; 1142 }; 1143 // ------------------------------------------------------------------- 1144 1145 class NetBlocks : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.NetBlocks) */ { 1146 public: 1147 NetBlocks(); 1148 virtual ~NetBlocks(); 1149 1150 NetBlocks(const NetBlocks& from); 1151 1152 inline NetBlocks& operator=(const NetBlocks& from) { 1153 CopyFrom(from); 1154 return *this; 1155 } 1156 #if LANG_CXX11 1157 NetBlocks(NetBlocks&& from) noexcept 1158 : NetBlocks() { 1159 *this = ::std::move(from); 1160 } 1161 1162 inline NetBlocks& operator=(NetBlocks&& from) noexcept { 1163 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 1164 if (this != &from) InternalSwap(&from); 1165 } else { 1166 CopyFrom(from); 1167 } 1168 return *this; 1169 } 1170 #endif 1171 static const ::google::protobuf::Descriptor* descriptor(); 1172 static const NetBlocks& default_instance(); 1173 1174 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 1175 static inline const NetBlocks* internal_default_instance() { 1176 return reinterpret_cast<const NetBlocks*>( 1177 &_NetBlocks_default_instance_); 1178 } 1179 static constexpr int kIndexInFileMessages = 1180 6; 1181 1182 void Swap(NetBlocks* other); 1183 friend void swap(NetBlocks& a, NetBlocks& b) { 1184 a.Swap(&b); 1185 } 1186 1187 // implements Message ---------------------------------------------- 1188 1189 inline NetBlocks* New() const final { 1190 return CreateMaybeMessage<NetBlocks>(NULL); 1191 } 1192 1193 NetBlocks* New(::google::protobuf::Arena* arena) const final { 1194 return CreateMaybeMessage<NetBlocks>(arena); 1195 } 1196 void CopyFrom(const ::google::protobuf::Message& from) final; 1197 void MergeFrom(const ::google::protobuf::Message& from) final; 1198 void CopyFrom(const NetBlocks& from); 1199 void MergeFrom(const NetBlocks& from); 1200 void Clear() final; 1201 bool IsInitialized() const final; 1202 1203 size_t ByteSizeLong() const final; 1204 bool MergePartialFromCodedStream( 1205 ::google::protobuf::io::CodedInputStream* input) final; 1206 void SerializeWithCachedSizes( 1207 ::google::protobuf::io::CodedOutputStream* output) const final; 1208 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 1209 bool deterministic, ::google::protobuf::uint8* target) const final; 1210 int GetCachedSize() const final { return _cached_size_.Get(); } 1211 1212 private: 1213 void SharedCtor(); 1214 void SharedDtor(); 1215 void SetCachedSize(int size) const final; 1216 void InternalSwap(NetBlocks* other); 1217 private: 1218 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 1219 return NULL; 1220 } 1221 inline void* MaybeArenaPtr() const { 1222 return NULL; 1223 } 1224 public: 1225 1226 ::google::protobuf::Metadata GetMetadata() const final; 1227 1228 // nested types ---------------------------------------------------- 1229 1230 // accessors ------------------------------------------------------- 1231 1232 // repeated .corepb.Block blocks = 3; 1233 int blocks_size() const; 1234 void clear_blocks(); 1235 static const int kBlocksFieldNumber = 3; 1236 ::corepb::Block* mutable_blocks(int index); 1237 ::google::protobuf::RepeatedPtrField< ::corepb::Block >* 1238 mutable_blocks(); 1239 const ::corepb::Block& blocks(int index) const; 1240 ::corepb::Block* add_blocks(); 1241 const ::google::protobuf::RepeatedPtrField< ::corepb::Block >& 1242 blocks() const; 1243 1244 // string from = 1; 1245 void clear_from(); 1246 static const int kFromFieldNumber = 1; 1247 const ::std::string& from() const; 1248 void set_from(const ::std::string& value); 1249 #if LANG_CXX11 1250 void set_from(::std::string&& value); 1251 #endif 1252 void set_from(const char* value); 1253 void set_from(const char* value, size_t size); 1254 ::std::string* mutable_from(); 1255 ::std::string* release_from(); 1256 void set_allocated_from(::std::string* from); 1257 1258 // uint64 batch = 2; 1259 void clear_batch(); 1260 static const int kBatchFieldNumber = 2; 1261 ::google::protobuf::uint64 batch() const; 1262 void set_batch(::google::protobuf::uint64 value); 1263 1264 // @@protoc_insertion_point(class_scope:corepb.NetBlocks) 1265 private: 1266 1267 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 1268 ::google::protobuf::RepeatedPtrField< ::corepb::Block > blocks_; 1269 ::google::protobuf::internal::ArenaStringPtr from_; 1270 ::google::protobuf::uint64 batch_; 1271 mutable ::google::protobuf::internal::CachedSize _cached_size_; 1272 friend struct ::protobuf_block_2eproto::TableStruct; 1273 }; 1274 // ------------------------------------------------------------------- 1275 1276 class NetBlock : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.NetBlock) */ { 1277 public: 1278 NetBlock(); 1279 virtual ~NetBlock(); 1280 1281 NetBlock(const NetBlock& from); 1282 1283 inline NetBlock& operator=(const NetBlock& from) { 1284 CopyFrom(from); 1285 return *this; 1286 } 1287 #if LANG_CXX11 1288 NetBlock(NetBlock&& from) noexcept 1289 : NetBlock() { 1290 *this = ::std::move(from); 1291 } 1292 1293 inline NetBlock& operator=(NetBlock&& from) noexcept { 1294 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 1295 if (this != &from) InternalSwap(&from); 1296 } else { 1297 CopyFrom(from); 1298 } 1299 return *this; 1300 } 1301 #endif 1302 static const ::google::protobuf::Descriptor* descriptor(); 1303 static const NetBlock& default_instance(); 1304 1305 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 1306 static inline const NetBlock* internal_default_instance() { 1307 return reinterpret_cast<const NetBlock*>( 1308 &_NetBlock_default_instance_); 1309 } 1310 static constexpr int kIndexInFileMessages = 1311 7; 1312 1313 void Swap(NetBlock* other); 1314 friend void swap(NetBlock& a, NetBlock& b) { 1315 a.Swap(&b); 1316 } 1317 1318 // implements Message ---------------------------------------------- 1319 1320 inline NetBlock* New() const final { 1321 return CreateMaybeMessage<NetBlock>(NULL); 1322 } 1323 1324 NetBlock* New(::google::protobuf::Arena* arena) const final { 1325 return CreateMaybeMessage<NetBlock>(arena); 1326 } 1327 void CopyFrom(const ::google::protobuf::Message& from) final; 1328 void MergeFrom(const ::google::protobuf::Message& from) final; 1329 void CopyFrom(const NetBlock& from); 1330 void MergeFrom(const NetBlock& from); 1331 void Clear() final; 1332 bool IsInitialized() const final; 1333 1334 size_t ByteSizeLong() const final; 1335 bool MergePartialFromCodedStream( 1336 ::google::protobuf::io::CodedInputStream* input) final; 1337 void SerializeWithCachedSizes( 1338 ::google::protobuf::io::CodedOutputStream* output) const final; 1339 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 1340 bool deterministic, ::google::protobuf::uint8* target) const final; 1341 int GetCachedSize() const final { return _cached_size_.Get(); } 1342 1343 private: 1344 void SharedCtor(); 1345 void SharedDtor(); 1346 void SetCachedSize(int size) const final; 1347 void InternalSwap(NetBlock* other); 1348 private: 1349 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 1350 return NULL; 1351 } 1352 inline void* MaybeArenaPtr() const { 1353 return NULL; 1354 } 1355 public: 1356 1357 ::google::protobuf::Metadata GetMetadata() const final; 1358 1359 // nested types ---------------------------------------------------- 1360 1361 // accessors ------------------------------------------------------- 1362 1363 // string from = 1; 1364 void clear_from(); 1365 static const int kFromFieldNumber = 1; 1366 const ::std::string& from() const; 1367 void set_from(const ::std::string& value); 1368 #if LANG_CXX11 1369 void set_from(::std::string&& value); 1370 #endif 1371 void set_from(const char* value); 1372 void set_from(const char* value, size_t size); 1373 ::std::string* mutable_from(); 1374 ::std::string* release_from(); 1375 void set_allocated_from(::std::string* from); 1376 1377 // .corepb.Block block = 3; 1378 bool has_block() const; 1379 void clear_block(); 1380 static const int kBlockFieldNumber = 3; 1381 private: 1382 const ::corepb::Block& _internal_block() const; 1383 public: 1384 const ::corepb::Block& block() const; 1385 ::corepb::Block* release_block(); 1386 ::corepb::Block* mutable_block(); 1387 void set_allocated_block(::corepb::Block* block); 1388 1389 // uint64 batch = 2; 1390 void clear_batch(); 1391 static const int kBatchFieldNumber = 2; 1392 ::google::protobuf::uint64 batch() const; 1393 void set_batch(::google::protobuf::uint64 value); 1394 1395 // @@protoc_insertion_point(class_scope:corepb.NetBlock) 1396 private: 1397 1398 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 1399 ::google::protobuf::internal::ArenaStringPtr from_; 1400 ::corepb::Block* block_; 1401 ::google::protobuf::uint64 batch_; 1402 mutable ::google::protobuf::internal::CachedSize _cached_size_; 1403 friend struct ::protobuf_block_2eproto::TableStruct; 1404 }; 1405 // ------------------------------------------------------------------- 1406 1407 class DownloadBlock : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.DownloadBlock) */ { 1408 public: 1409 DownloadBlock(); 1410 virtual ~DownloadBlock(); 1411 1412 DownloadBlock(const DownloadBlock& from); 1413 1414 inline DownloadBlock& operator=(const DownloadBlock& from) { 1415 CopyFrom(from); 1416 return *this; 1417 } 1418 #if LANG_CXX11 1419 DownloadBlock(DownloadBlock&& from) noexcept 1420 : DownloadBlock() { 1421 *this = ::std::move(from); 1422 } 1423 1424 inline DownloadBlock& operator=(DownloadBlock&& from) noexcept { 1425 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 1426 if (this != &from) InternalSwap(&from); 1427 } else { 1428 CopyFrom(from); 1429 } 1430 return *this; 1431 } 1432 #endif 1433 static const ::google::protobuf::Descriptor* descriptor(); 1434 static const DownloadBlock& default_instance(); 1435 1436 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 1437 static inline const DownloadBlock* internal_default_instance() { 1438 return reinterpret_cast<const DownloadBlock*>( 1439 &_DownloadBlock_default_instance_); 1440 } 1441 static constexpr int kIndexInFileMessages = 1442 8; 1443 1444 void Swap(DownloadBlock* other); 1445 friend void swap(DownloadBlock& a, DownloadBlock& b) { 1446 a.Swap(&b); 1447 } 1448 1449 // implements Message ---------------------------------------------- 1450 1451 inline DownloadBlock* New() const final { 1452 return CreateMaybeMessage<DownloadBlock>(NULL); 1453 } 1454 1455 DownloadBlock* New(::google::protobuf::Arena* arena) const final { 1456 return CreateMaybeMessage<DownloadBlock>(arena); 1457 } 1458 void CopyFrom(const ::google::protobuf::Message& from) final; 1459 void MergeFrom(const ::google::protobuf::Message& from) final; 1460 void CopyFrom(const DownloadBlock& from); 1461 void MergeFrom(const DownloadBlock& from); 1462 void Clear() final; 1463 bool IsInitialized() const final; 1464 1465 size_t ByteSizeLong() const final; 1466 bool MergePartialFromCodedStream( 1467 ::google::protobuf::io::CodedInputStream* input) final; 1468 void SerializeWithCachedSizes( 1469 ::google::protobuf::io::CodedOutputStream* output) const final; 1470 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 1471 bool deterministic, ::google::protobuf::uint8* target) const final; 1472 int GetCachedSize() const final { return _cached_size_.Get(); } 1473 1474 private: 1475 void SharedCtor(); 1476 void SharedDtor(); 1477 void SetCachedSize(int size) const final; 1478 void InternalSwap(DownloadBlock* other); 1479 private: 1480 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 1481 return NULL; 1482 } 1483 inline void* MaybeArenaPtr() const { 1484 return NULL; 1485 } 1486 public: 1487 1488 ::google::protobuf::Metadata GetMetadata() const final; 1489 1490 // nested types ---------------------------------------------------- 1491 1492 // accessors ------------------------------------------------------- 1493 1494 // bytes hash = 1; 1495 void clear_hash(); 1496 static const int kHashFieldNumber = 1; 1497 const ::std::string& hash() const; 1498 void set_hash(const ::std::string& value); 1499 #if LANG_CXX11 1500 void set_hash(::std::string&& value); 1501 #endif 1502 void set_hash(const char* value); 1503 void set_hash(const void* value, size_t size); 1504 ::std::string* mutable_hash(); 1505 ::std::string* release_hash(); 1506 void set_allocated_hash(::std::string* hash); 1507 1508 // bytes sign = 2; 1509 void clear_sign(); 1510 static const int kSignFieldNumber = 2; 1511 const ::std::string& sign() const; 1512 void set_sign(const ::std::string& value); 1513 #if LANG_CXX11 1514 void set_sign(::std::string&& value); 1515 #endif 1516 void set_sign(const char* value); 1517 void set_sign(const void* value, size_t size); 1518 ::std::string* mutable_sign(); 1519 ::std::string* release_sign(); 1520 void set_allocated_sign(::std::string* sign); 1521 1522 // @@protoc_insertion_point(class_scope:corepb.DownloadBlock) 1523 private: 1524 1525 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 1526 ::google::protobuf::internal::ArenaStringPtr hash_; 1527 ::google::protobuf::internal::ArenaStringPtr sign_; 1528 mutable ::google::protobuf::internal::CachedSize _cached_size_; 1529 friend struct ::protobuf_block_2eproto::TableStruct; 1530 }; 1531 // ------------------------------------------------------------------- 1532 1533 class Random : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:corepb.Random) */ { 1534 public: 1535 Random(); 1536 virtual ~Random(); 1537 1538 Random(const Random& from); 1539 1540 inline Random& operator=(const Random& from) { 1541 CopyFrom(from); 1542 return *this; 1543 } 1544 #if LANG_CXX11 1545 Random(Random&& from) noexcept 1546 : Random() { 1547 *this = ::std::move(from); 1548 } 1549 1550 inline Random& operator=(Random&& from) noexcept { 1551 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { 1552 if (this != &from) InternalSwap(&from); 1553 } else { 1554 CopyFrom(from); 1555 } 1556 return *this; 1557 } 1558 #endif 1559 static const ::google::protobuf::Descriptor* descriptor(); 1560 static const Random& default_instance(); 1561 1562 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY 1563 static inline const Random* internal_default_instance() { 1564 return reinterpret_cast<const Random*>( 1565 &_Random_default_instance_); 1566 } 1567 static constexpr int kIndexInFileMessages = 1568 9; 1569 1570 void Swap(Random* other); 1571 friend void swap(Random& a, Random& b) { 1572 a.Swap(&b); 1573 } 1574 1575 // implements Message ---------------------------------------------- 1576 1577 inline Random* New() const final { 1578 return CreateMaybeMessage<Random>(NULL); 1579 } 1580 1581 Random* New(::google::protobuf::Arena* arena) const final { 1582 return CreateMaybeMessage<Random>(arena); 1583 } 1584 void CopyFrom(const ::google::protobuf::Message& from) final; 1585 void MergeFrom(const ::google::protobuf::Message& from) final; 1586 void CopyFrom(const Random& from); 1587 void MergeFrom(const Random& from); 1588 void Clear() final; 1589 bool IsInitialized() const final; 1590 1591 size_t ByteSizeLong() const final; 1592 bool MergePartialFromCodedStream( 1593 ::google::protobuf::io::CodedInputStream* input) final; 1594 void SerializeWithCachedSizes( 1595 ::google::protobuf::io::CodedOutputStream* output) const final; 1596 ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( 1597 bool deterministic, ::google::protobuf::uint8* target) const final; 1598 int GetCachedSize() const final { return _cached_size_.Get(); } 1599 1600 private: 1601 void SharedCtor(); 1602 void SharedDtor(); 1603 void SetCachedSize(int size) const final; 1604 void InternalSwap(Random* other); 1605 private: 1606 inline ::google::protobuf::Arena* GetArenaNoVirtual() const { 1607 return NULL; 1608 } 1609 inline void* MaybeArenaPtr() const { 1610 return NULL; 1611 } 1612 public: 1613 1614 ::google::protobuf::Metadata GetMetadata() const final; 1615 1616 // nested types ---------------------------------------------------- 1617 1618 // accessors ------------------------------------------------------- 1619 1620 // bytes vrf_seed = 1; 1621 void clear_vrf_seed(); 1622 static const int kVrfSeedFieldNumber = 1; 1623 const ::std::string& vrf_seed() const; 1624 void set_vrf_seed(const ::std::string& value); 1625 #if LANG_CXX11 1626 void set_vrf_seed(::std::string&& value); 1627 #endif 1628 void set_vrf_seed(const char* value); 1629 void set_vrf_seed(const void* value, size_t size); 1630 ::std::string* mutable_vrf_seed(); 1631 ::std::string* release_vrf_seed(); 1632 void set_allocated_vrf_seed(::std::string* vrf_seed); 1633 1634 // bytes vrf_proof = 2; 1635 void clear_vrf_proof(); 1636 static const int kVrfProofFieldNumber = 2; 1637 const ::std::string& vrf_proof() const; 1638 void set_vrf_proof(const ::std::string& value); 1639 #if LANG_CXX11 1640 void set_vrf_proof(::std::string&& value); 1641 #endif 1642 void set_vrf_proof(const char* value); 1643 void set_vrf_proof(const void* value, size_t size); 1644 ::std::string* mutable_vrf_proof(); 1645 ::std::string* release_vrf_proof(); 1646 void set_allocated_vrf_proof(::std::string* vrf_proof); 1647 1648 // @@protoc_insertion_point(class_scope:corepb.Random) 1649 private: 1650 1651 ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; 1652 ::google::protobuf::internal::ArenaStringPtr vrf_seed_; 1653 ::google::protobuf::internal::ArenaStringPtr vrf_proof_; 1654 mutable ::google::protobuf::internal::CachedSize _cached_size_; 1655 friend struct ::protobuf_block_2eproto::TableStruct; 1656 }; 1657 // =================================================================== 1658 1659 1660 // =================================================================== 1661 1662 #ifdef __GNUC__ 1663 #pragma GCC diagnostic push 1664 #pragma GCC diagnostic ignored "-Wstrict-aliasing" 1665 #endif // __GNUC__ 1666 // Account 1667 1668 // bytes address = 1; 1669 inline void Account::clear_address() { 1670 address_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1671 } 1672 inline const ::std::string& Account::address() const { 1673 // @@protoc_insertion_point(field_get:corepb.Account.address) 1674 return address_.GetNoArena(); 1675 } 1676 inline void Account::set_address(const ::std::string& value) { 1677 1678 address_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 1679 // @@protoc_insertion_point(field_set:corepb.Account.address) 1680 } 1681 #if LANG_CXX11 1682 inline void Account::set_address(::std::string&& value) { 1683 1684 address_.SetNoArena( 1685 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 1686 // @@protoc_insertion_point(field_set_rvalue:corepb.Account.address) 1687 } 1688 #endif 1689 inline void Account::set_address(const char* value) { 1690 GOOGLE_DCHECK(value != NULL); 1691 1692 address_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 1693 // @@protoc_insertion_point(field_set_char:corepb.Account.address) 1694 } 1695 inline void Account::set_address(const void* value, size_t size) { 1696 1697 address_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 1698 ::std::string(reinterpret_cast<const char*>(value), size)); 1699 // @@protoc_insertion_point(field_set_pointer:corepb.Account.address) 1700 } 1701 inline ::std::string* Account::mutable_address() { 1702 1703 // @@protoc_insertion_point(field_mutable:corepb.Account.address) 1704 return address_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1705 } 1706 inline ::std::string* Account::release_address() { 1707 // @@protoc_insertion_point(field_release:corepb.Account.address) 1708 1709 return address_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1710 } 1711 inline void Account::set_allocated_address(::std::string* address) { 1712 if (address != NULL) { 1713 1714 } else { 1715 1716 } 1717 address_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), address); 1718 // @@protoc_insertion_point(field_set_allocated:corepb.Account.address) 1719 } 1720 1721 // bytes balance = 2; 1722 inline void Account::clear_balance() { 1723 balance_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1724 } 1725 inline const ::std::string& Account::balance() const { 1726 // @@protoc_insertion_point(field_get:corepb.Account.balance) 1727 return balance_.GetNoArena(); 1728 } 1729 inline void Account::set_balance(const ::std::string& value) { 1730 1731 balance_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 1732 // @@protoc_insertion_point(field_set:corepb.Account.balance) 1733 } 1734 #if LANG_CXX11 1735 inline void Account::set_balance(::std::string&& value) { 1736 1737 balance_.SetNoArena( 1738 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 1739 // @@protoc_insertion_point(field_set_rvalue:corepb.Account.balance) 1740 } 1741 #endif 1742 inline void Account::set_balance(const char* value) { 1743 GOOGLE_DCHECK(value != NULL); 1744 1745 balance_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 1746 // @@protoc_insertion_point(field_set_char:corepb.Account.balance) 1747 } 1748 inline void Account::set_balance(const void* value, size_t size) { 1749 1750 balance_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 1751 ::std::string(reinterpret_cast<const char*>(value), size)); 1752 // @@protoc_insertion_point(field_set_pointer:corepb.Account.balance) 1753 } 1754 inline ::std::string* Account::mutable_balance() { 1755 1756 // @@protoc_insertion_point(field_mutable:corepb.Account.balance) 1757 return balance_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1758 } 1759 inline ::std::string* Account::release_balance() { 1760 // @@protoc_insertion_point(field_release:corepb.Account.balance) 1761 1762 return balance_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1763 } 1764 inline void Account::set_allocated_balance(::std::string* balance) { 1765 if (balance != NULL) { 1766 1767 } else { 1768 1769 } 1770 balance_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), balance); 1771 // @@protoc_insertion_point(field_set_allocated:corepb.Account.balance) 1772 } 1773 1774 // uint64 nonce = 3; 1775 inline void Account::clear_nonce() { 1776 nonce_ = GOOGLE_ULONGLONG(0); 1777 } 1778 inline ::google::protobuf::uint64 Account::nonce() const { 1779 // @@protoc_insertion_point(field_get:corepb.Account.nonce) 1780 return nonce_; 1781 } 1782 inline void Account::set_nonce(::google::protobuf::uint64 value) { 1783 1784 nonce_ = value; 1785 // @@protoc_insertion_point(field_set:corepb.Account.nonce) 1786 } 1787 1788 // bytes vars_hash = 4; 1789 inline void Account::clear_vars_hash() { 1790 vars_hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1791 } 1792 inline const ::std::string& Account::vars_hash() const { 1793 // @@protoc_insertion_point(field_get:corepb.Account.vars_hash) 1794 return vars_hash_.GetNoArena(); 1795 } 1796 inline void Account::set_vars_hash(const ::std::string& value) { 1797 1798 vars_hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 1799 // @@protoc_insertion_point(field_set:corepb.Account.vars_hash) 1800 } 1801 #if LANG_CXX11 1802 inline void Account::set_vars_hash(::std::string&& value) { 1803 1804 vars_hash_.SetNoArena( 1805 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 1806 // @@protoc_insertion_point(field_set_rvalue:corepb.Account.vars_hash) 1807 } 1808 #endif 1809 inline void Account::set_vars_hash(const char* value) { 1810 GOOGLE_DCHECK(value != NULL); 1811 1812 vars_hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 1813 // @@protoc_insertion_point(field_set_char:corepb.Account.vars_hash) 1814 } 1815 inline void Account::set_vars_hash(const void* value, size_t size) { 1816 1817 vars_hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 1818 ::std::string(reinterpret_cast<const char*>(value), size)); 1819 // @@protoc_insertion_point(field_set_pointer:corepb.Account.vars_hash) 1820 } 1821 inline ::std::string* Account::mutable_vars_hash() { 1822 1823 // @@protoc_insertion_point(field_mutable:corepb.Account.vars_hash) 1824 return vars_hash_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1825 } 1826 inline ::std::string* Account::release_vars_hash() { 1827 // @@protoc_insertion_point(field_release:corepb.Account.vars_hash) 1828 1829 return vars_hash_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1830 } 1831 inline void Account::set_allocated_vars_hash(::std::string* vars_hash) { 1832 if (vars_hash != NULL) { 1833 1834 } else { 1835 1836 } 1837 vars_hash_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), vars_hash); 1838 // @@protoc_insertion_point(field_set_allocated:corepb.Account.vars_hash) 1839 } 1840 1841 // bytes birth_place = 5; 1842 inline void Account::clear_birth_place() { 1843 birth_place_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1844 } 1845 inline const ::std::string& Account::birth_place() const { 1846 // @@protoc_insertion_point(field_get:corepb.Account.birth_place) 1847 return birth_place_.GetNoArena(); 1848 } 1849 inline void Account::set_birth_place(const ::std::string& value) { 1850 1851 birth_place_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 1852 // @@protoc_insertion_point(field_set:corepb.Account.birth_place) 1853 } 1854 #if LANG_CXX11 1855 inline void Account::set_birth_place(::std::string&& value) { 1856 1857 birth_place_.SetNoArena( 1858 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 1859 // @@protoc_insertion_point(field_set_rvalue:corepb.Account.birth_place) 1860 } 1861 #endif 1862 inline void Account::set_birth_place(const char* value) { 1863 GOOGLE_DCHECK(value != NULL); 1864 1865 birth_place_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 1866 // @@protoc_insertion_point(field_set_char:corepb.Account.birth_place) 1867 } 1868 inline void Account::set_birth_place(const void* value, size_t size) { 1869 1870 birth_place_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 1871 ::std::string(reinterpret_cast<const char*>(value), size)); 1872 // @@protoc_insertion_point(field_set_pointer:corepb.Account.birth_place) 1873 } 1874 inline ::std::string* Account::mutable_birth_place() { 1875 1876 // @@protoc_insertion_point(field_mutable:corepb.Account.birth_place) 1877 return birth_place_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1878 } 1879 inline ::std::string* Account::release_birth_place() { 1880 // @@protoc_insertion_point(field_release:corepb.Account.birth_place) 1881 1882 return birth_place_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1883 } 1884 inline void Account::set_allocated_birth_place(::std::string* birth_place) { 1885 if (birth_place != NULL) { 1886 1887 } else { 1888 1889 } 1890 birth_place_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), birth_place); 1891 // @@protoc_insertion_point(field_set_allocated:corepb.Account.birth_place) 1892 } 1893 1894 // .corepb.ContractMeta contract_meta = 6; 1895 inline bool Account::has_contract_meta() const { 1896 return this != internal_default_instance() && contract_meta_ != NULL; 1897 } 1898 inline void Account::clear_contract_meta() { 1899 if (GetArenaNoVirtual() == NULL && contract_meta_ != NULL) { 1900 delete contract_meta_; 1901 } 1902 contract_meta_ = NULL; 1903 } 1904 inline const ::corepb::ContractMeta& Account::_internal_contract_meta() const { 1905 return *contract_meta_; 1906 } 1907 inline const ::corepb::ContractMeta& Account::contract_meta() const { 1908 const ::corepb::ContractMeta* p = contract_meta_; 1909 // @@protoc_insertion_point(field_get:corepb.Account.contract_meta) 1910 return p != NULL ? *p : *reinterpret_cast<const ::corepb::ContractMeta*>( 1911 &::corepb::_ContractMeta_default_instance_); 1912 } 1913 inline ::corepb::ContractMeta* Account::release_contract_meta() { 1914 // @@protoc_insertion_point(field_release:corepb.Account.contract_meta) 1915 1916 ::corepb::ContractMeta* temp = contract_meta_; 1917 contract_meta_ = NULL; 1918 return temp; 1919 } 1920 inline ::corepb::ContractMeta* Account::mutable_contract_meta() { 1921 1922 if (contract_meta_ == NULL) { 1923 auto* p = CreateMaybeMessage<::corepb::ContractMeta>(GetArenaNoVirtual()); 1924 contract_meta_ = p; 1925 } 1926 // @@protoc_insertion_point(field_mutable:corepb.Account.contract_meta) 1927 return contract_meta_; 1928 } 1929 inline void Account::set_allocated_contract_meta(::corepb::ContractMeta* contract_meta) { 1930 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); 1931 if (message_arena == NULL) { 1932 delete contract_meta_; 1933 } 1934 if (contract_meta) { 1935 ::google::protobuf::Arena* submessage_arena = NULL; 1936 if (message_arena != submessage_arena) { 1937 contract_meta = ::google::protobuf::internal::GetOwnedMessage( 1938 message_arena, contract_meta, submessage_arena); 1939 } 1940 1941 } else { 1942 1943 } 1944 contract_meta_ = contract_meta; 1945 // @@protoc_insertion_point(field_set_allocated:corepb.Account.contract_meta) 1946 } 1947 1948 // ------------------------------------------------------------------- 1949 1950 // ContractMeta 1951 1952 // string version = 1; 1953 inline void ContractMeta::clear_version() { 1954 version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1955 } 1956 inline const ::std::string& ContractMeta::version() const { 1957 // @@protoc_insertion_point(field_get:corepb.ContractMeta.version) 1958 return version_.GetNoArena(); 1959 } 1960 inline void ContractMeta::set_version(const ::std::string& value) { 1961 1962 version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 1963 // @@protoc_insertion_point(field_set:corepb.ContractMeta.version) 1964 } 1965 #if LANG_CXX11 1966 inline void ContractMeta::set_version(::std::string&& value) { 1967 1968 version_.SetNoArena( 1969 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 1970 // @@protoc_insertion_point(field_set_rvalue:corepb.ContractMeta.version) 1971 } 1972 #endif 1973 inline void ContractMeta::set_version(const char* value) { 1974 GOOGLE_DCHECK(value != NULL); 1975 1976 version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 1977 // @@protoc_insertion_point(field_set_char:corepb.ContractMeta.version) 1978 } 1979 inline void ContractMeta::set_version(const char* value, size_t size) { 1980 1981 version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 1982 ::std::string(reinterpret_cast<const char*>(value), size)); 1983 // @@protoc_insertion_point(field_set_pointer:corepb.ContractMeta.version) 1984 } 1985 inline ::std::string* ContractMeta::mutable_version() { 1986 1987 // @@protoc_insertion_point(field_mutable:corepb.ContractMeta.version) 1988 return version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1989 } 1990 inline ::std::string* ContractMeta::release_version() { 1991 // @@protoc_insertion_point(field_release:corepb.ContractMeta.version) 1992 1993 return version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 1994 } 1995 inline void ContractMeta::set_allocated_version(::std::string* version) { 1996 if (version != NULL) { 1997 1998 } else { 1999 2000 } 2001 version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), version); 2002 // @@protoc_insertion_point(field_set_allocated:corepb.ContractMeta.version) 2003 } 2004 2005 // ------------------------------------------------------------------- 2006 2007 // Data 2008 2009 // string type = 1; 2010 inline void Data::clear_type() { 2011 type_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2012 } 2013 inline const ::std::string& Data::type() const { 2014 // @@protoc_insertion_point(field_get:corepb.Data.type) 2015 return type_.GetNoArena(); 2016 } 2017 inline void Data::set_type(const ::std::string& value) { 2018 2019 type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2020 // @@protoc_insertion_point(field_set:corepb.Data.type) 2021 } 2022 #if LANG_CXX11 2023 inline void Data::set_type(::std::string&& value) { 2024 2025 type_.SetNoArena( 2026 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2027 // @@protoc_insertion_point(field_set_rvalue:corepb.Data.type) 2028 } 2029 #endif 2030 inline void Data::set_type(const char* value) { 2031 GOOGLE_DCHECK(value != NULL); 2032 2033 type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2034 // @@protoc_insertion_point(field_set_char:corepb.Data.type) 2035 } 2036 inline void Data::set_type(const char* value, size_t size) { 2037 2038 type_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2039 ::std::string(reinterpret_cast<const char*>(value), size)); 2040 // @@protoc_insertion_point(field_set_pointer:corepb.Data.type) 2041 } 2042 inline ::std::string* Data::mutable_type() { 2043 2044 // @@protoc_insertion_point(field_mutable:corepb.Data.type) 2045 return type_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2046 } 2047 inline ::std::string* Data::release_type() { 2048 // @@protoc_insertion_point(field_release:corepb.Data.type) 2049 2050 return type_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2051 } 2052 inline void Data::set_allocated_type(::std::string* type) { 2053 if (type != NULL) { 2054 2055 } else { 2056 2057 } 2058 type_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type); 2059 // @@protoc_insertion_point(field_set_allocated:corepb.Data.type) 2060 } 2061 2062 // bytes payload = 2; 2063 inline void Data::clear_payload() { 2064 payload_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2065 } 2066 inline const ::std::string& Data::payload() const { 2067 // @@protoc_insertion_point(field_get:corepb.Data.payload) 2068 return payload_.GetNoArena(); 2069 } 2070 inline void Data::set_payload(const ::std::string& value) { 2071 2072 payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2073 // @@protoc_insertion_point(field_set:corepb.Data.payload) 2074 } 2075 #if LANG_CXX11 2076 inline void Data::set_payload(::std::string&& value) { 2077 2078 payload_.SetNoArena( 2079 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2080 // @@protoc_insertion_point(field_set_rvalue:corepb.Data.payload) 2081 } 2082 #endif 2083 inline void Data::set_payload(const char* value) { 2084 GOOGLE_DCHECK(value != NULL); 2085 2086 payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2087 // @@protoc_insertion_point(field_set_char:corepb.Data.payload) 2088 } 2089 inline void Data::set_payload(const void* value, size_t size) { 2090 2091 payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2092 ::std::string(reinterpret_cast<const char*>(value), size)); 2093 // @@protoc_insertion_point(field_set_pointer:corepb.Data.payload) 2094 } 2095 inline ::std::string* Data::mutable_payload() { 2096 2097 // @@protoc_insertion_point(field_mutable:corepb.Data.payload) 2098 return payload_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2099 } 2100 inline ::std::string* Data::release_payload() { 2101 // @@protoc_insertion_point(field_release:corepb.Data.payload) 2102 2103 return payload_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2104 } 2105 inline void Data::set_allocated_payload(::std::string* payload) { 2106 if (payload != NULL) { 2107 2108 } else { 2109 2110 } 2111 payload_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), payload); 2112 // @@protoc_insertion_point(field_set_allocated:corepb.Data.payload) 2113 } 2114 2115 // ------------------------------------------------------------------- 2116 2117 // Transaction 2118 2119 // bytes hash = 1; 2120 inline void Transaction::clear_hash() { 2121 hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2122 } 2123 inline const ::std::string& Transaction::hash() const { 2124 // @@protoc_insertion_point(field_get:corepb.Transaction.hash) 2125 return hash_.GetNoArena(); 2126 } 2127 inline void Transaction::set_hash(const ::std::string& value) { 2128 2129 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2130 // @@protoc_insertion_point(field_set:corepb.Transaction.hash) 2131 } 2132 #if LANG_CXX11 2133 inline void Transaction::set_hash(::std::string&& value) { 2134 2135 hash_.SetNoArena( 2136 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2137 // @@protoc_insertion_point(field_set_rvalue:corepb.Transaction.hash) 2138 } 2139 #endif 2140 inline void Transaction::set_hash(const char* value) { 2141 GOOGLE_DCHECK(value != NULL); 2142 2143 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2144 // @@protoc_insertion_point(field_set_char:corepb.Transaction.hash) 2145 } 2146 inline void Transaction::set_hash(const void* value, size_t size) { 2147 2148 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2149 ::std::string(reinterpret_cast<const char*>(value), size)); 2150 // @@protoc_insertion_point(field_set_pointer:corepb.Transaction.hash) 2151 } 2152 inline ::std::string* Transaction::mutable_hash() { 2153 2154 // @@protoc_insertion_point(field_mutable:corepb.Transaction.hash) 2155 return hash_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2156 } 2157 inline ::std::string* Transaction::release_hash() { 2158 // @@protoc_insertion_point(field_release:corepb.Transaction.hash) 2159 2160 return hash_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2161 } 2162 inline void Transaction::set_allocated_hash(::std::string* hash) { 2163 if (hash != NULL) { 2164 2165 } else { 2166 2167 } 2168 hash_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), hash); 2169 // @@protoc_insertion_point(field_set_allocated:corepb.Transaction.hash) 2170 } 2171 2172 // bytes from = 2; 2173 inline void Transaction::clear_from() { 2174 from_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2175 } 2176 inline const ::std::string& Transaction::from() const { 2177 // @@protoc_insertion_point(field_get:corepb.Transaction.from) 2178 return from_.GetNoArena(); 2179 } 2180 inline void Transaction::set_from(const ::std::string& value) { 2181 2182 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2183 // @@protoc_insertion_point(field_set:corepb.Transaction.from) 2184 } 2185 #if LANG_CXX11 2186 inline void Transaction::set_from(::std::string&& value) { 2187 2188 from_.SetNoArena( 2189 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2190 // @@protoc_insertion_point(field_set_rvalue:corepb.Transaction.from) 2191 } 2192 #endif 2193 inline void Transaction::set_from(const char* value) { 2194 GOOGLE_DCHECK(value != NULL); 2195 2196 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2197 // @@protoc_insertion_point(field_set_char:corepb.Transaction.from) 2198 } 2199 inline void Transaction::set_from(const void* value, size_t size) { 2200 2201 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2202 ::std::string(reinterpret_cast<const char*>(value), size)); 2203 // @@protoc_insertion_point(field_set_pointer:corepb.Transaction.from) 2204 } 2205 inline ::std::string* Transaction::mutable_from() { 2206 2207 // @@protoc_insertion_point(field_mutable:corepb.Transaction.from) 2208 return from_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2209 } 2210 inline ::std::string* Transaction::release_from() { 2211 // @@protoc_insertion_point(field_release:corepb.Transaction.from) 2212 2213 return from_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2214 } 2215 inline void Transaction::set_allocated_from(::std::string* from) { 2216 if (from != NULL) { 2217 2218 } else { 2219 2220 } 2221 from_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from); 2222 // @@protoc_insertion_point(field_set_allocated:corepb.Transaction.from) 2223 } 2224 2225 // bytes to = 3; 2226 inline void Transaction::clear_to() { 2227 to_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2228 } 2229 inline const ::std::string& Transaction::to() const { 2230 // @@protoc_insertion_point(field_get:corepb.Transaction.to) 2231 return to_.GetNoArena(); 2232 } 2233 inline void Transaction::set_to(const ::std::string& value) { 2234 2235 to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2236 // @@protoc_insertion_point(field_set:corepb.Transaction.to) 2237 } 2238 #if LANG_CXX11 2239 inline void Transaction::set_to(::std::string&& value) { 2240 2241 to_.SetNoArena( 2242 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2243 // @@protoc_insertion_point(field_set_rvalue:corepb.Transaction.to) 2244 } 2245 #endif 2246 inline void Transaction::set_to(const char* value) { 2247 GOOGLE_DCHECK(value != NULL); 2248 2249 to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2250 // @@protoc_insertion_point(field_set_char:corepb.Transaction.to) 2251 } 2252 inline void Transaction::set_to(const void* value, size_t size) { 2253 2254 to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2255 ::std::string(reinterpret_cast<const char*>(value), size)); 2256 // @@protoc_insertion_point(field_set_pointer:corepb.Transaction.to) 2257 } 2258 inline ::std::string* Transaction::mutable_to() { 2259 2260 // @@protoc_insertion_point(field_mutable:corepb.Transaction.to) 2261 return to_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2262 } 2263 inline ::std::string* Transaction::release_to() { 2264 // @@protoc_insertion_point(field_release:corepb.Transaction.to) 2265 2266 return to_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2267 } 2268 inline void Transaction::set_allocated_to(::std::string* to) { 2269 if (to != NULL) { 2270 2271 } else { 2272 2273 } 2274 to_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), to); 2275 // @@protoc_insertion_point(field_set_allocated:corepb.Transaction.to) 2276 } 2277 2278 // bytes value = 4; 2279 inline void Transaction::clear_value() { 2280 value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2281 } 2282 inline const ::std::string& Transaction::value() const { 2283 // @@protoc_insertion_point(field_get:corepb.Transaction.value) 2284 return value_.GetNoArena(); 2285 } 2286 inline void Transaction::set_value(const ::std::string& value) { 2287 2288 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2289 // @@protoc_insertion_point(field_set:corepb.Transaction.value) 2290 } 2291 #if LANG_CXX11 2292 inline void Transaction::set_value(::std::string&& value) { 2293 2294 value_.SetNoArena( 2295 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2296 // @@protoc_insertion_point(field_set_rvalue:corepb.Transaction.value) 2297 } 2298 #endif 2299 inline void Transaction::set_value(const char* value) { 2300 GOOGLE_DCHECK(value != NULL); 2301 2302 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2303 // @@protoc_insertion_point(field_set_char:corepb.Transaction.value) 2304 } 2305 inline void Transaction::set_value(const void* value, size_t size) { 2306 2307 value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2308 ::std::string(reinterpret_cast<const char*>(value), size)); 2309 // @@protoc_insertion_point(field_set_pointer:corepb.Transaction.value) 2310 } 2311 inline ::std::string* Transaction::mutable_value() { 2312 2313 // @@protoc_insertion_point(field_mutable:corepb.Transaction.value) 2314 return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2315 } 2316 inline ::std::string* Transaction::release_value() { 2317 // @@protoc_insertion_point(field_release:corepb.Transaction.value) 2318 2319 return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2320 } 2321 inline void Transaction::set_allocated_value(::std::string* value) { 2322 if (value != NULL) { 2323 2324 } else { 2325 2326 } 2327 value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2328 // @@protoc_insertion_point(field_set_allocated:corepb.Transaction.value) 2329 } 2330 2331 // uint64 nonce = 5; 2332 inline void Transaction::clear_nonce() { 2333 nonce_ = GOOGLE_ULONGLONG(0); 2334 } 2335 inline ::google::protobuf::uint64 Transaction::nonce() const { 2336 // @@protoc_insertion_point(field_get:corepb.Transaction.nonce) 2337 return nonce_; 2338 } 2339 inline void Transaction::set_nonce(::google::protobuf::uint64 value) { 2340 2341 nonce_ = value; 2342 // @@protoc_insertion_point(field_set:corepb.Transaction.nonce) 2343 } 2344 2345 // int64 timestamp = 6; 2346 inline void Transaction::clear_timestamp() { 2347 timestamp_ = GOOGLE_LONGLONG(0); 2348 } 2349 inline ::google::protobuf::int64 Transaction::timestamp() const { 2350 // @@protoc_insertion_point(field_get:corepb.Transaction.timestamp) 2351 return timestamp_; 2352 } 2353 inline void Transaction::set_timestamp(::google::protobuf::int64 value) { 2354 2355 timestamp_ = value; 2356 // @@protoc_insertion_point(field_set:corepb.Transaction.timestamp) 2357 } 2358 2359 // .corepb.Data data = 7; 2360 inline bool Transaction::has_data() const { 2361 return this != internal_default_instance() && data_ != NULL; 2362 } 2363 inline void Transaction::clear_data() { 2364 if (GetArenaNoVirtual() == NULL && data_ != NULL) { 2365 delete data_; 2366 } 2367 data_ = NULL; 2368 } 2369 inline const ::corepb::Data& Transaction::_internal_data() const { 2370 return *data_; 2371 } 2372 inline const ::corepb::Data& Transaction::data() const { 2373 const ::corepb::Data* p = data_; 2374 // @@protoc_insertion_point(field_get:corepb.Transaction.data) 2375 return p != NULL ? *p : *reinterpret_cast<const ::corepb::Data*>( 2376 &::corepb::_Data_default_instance_); 2377 } 2378 inline ::corepb::Data* Transaction::release_data() { 2379 // @@protoc_insertion_point(field_release:corepb.Transaction.data) 2380 2381 ::corepb::Data* temp = data_; 2382 data_ = NULL; 2383 return temp; 2384 } 2385 inline ::corepb::Data* Transaction::mutable_data() { 2386 2387 if (data_ == NULL) { 2388 auto* p = CreateMaybeMessage<::corepb::Data>(GetArenaNoVirtual()); 2389 data_ = p; 2390 } 2391 // @@protoc_insertion_point(field_mutable:corepb.Transaction.data) 2392 return data_; 2393 } 2394 inline void Transaction::set_allocated_data(::corepb::Data* data) { 2395 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); 2396 if (message_arena == NULL) { 2397 delete data_; 2398 } 2399 if (data) { 2400 ::google::protobuf::Arena* submessage_arena = NULL; 2401 if (message_arena != submessage_arena) { 2402 data = ::google::protobuf::internal::GetOwnedMessage( 2403 message_arena, data, submessage_arena); 2404 } 2405 2406 } else { 2407 2408 } 2409 data_ = data; 2410 // @@protoc_insertion_point(field_set_allocated:corepb.Transaction.data) 2411 } 2412 2413 // uint32 chain_id = 8; 2414 inline void Transaction::clear_chain_id() { 2415 chain_id_ = 0u; 2416 } 2417 inline ::google::protobuf::uint32 Transaction::chain_id() const { 2418 // @@protoc_insertion_point(field_get:corepb.Transaction.chain_id) 2419 return chain_id_; 2420 } 2421 inline void Transaction::set_chain_id(::google::protobuf::uint32 value) { 2422 2423 chain_id_ = value; 2424 // @@protoc_insertion_point(field_set:corepb.Transaction.chain_id) 2425 } 2426 2427 // bytes gas_price = 9; 2428 inline void Transaction::clear_gas_price() { 2429 gas_price_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2430 } 2431 inline const ::std::string& Transaction::gas_price() const { 2432 // @@protoc_insertion_point(field_get:corepb.Transaction.gas_price) 2433 return gas_price_.GetNoArena(); 2434 } 2435 inline void Transaction::set_gas_price(const ::std::string& value) { 2436 2437 gas_price_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2438 // @@protoc_insertion_point(field_set:corepb.Transaction.gas_price) 2439 } 2440 #if LANG_CXX11 2441 inline void Transaction::set_gas_price(::std::string&& value) { 2442 2443 gas_price_.SetNoArena( 2444 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2445 // @@protoc_insertion_point(field_set_rvalue:corepb.Transaction.gas_price) 2446 } 2447 #endif 2448 inline void Transaction::set_gas_price(const char* value) { 2449 GOOGLE_DCHECK(value != NULL); 2450 2451 gas_price_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2452 // @@protoc_insertion_point(field_set_char:corepb.Transaction.gas_price) 2453 } 2454 inline void Transaction::set_gas_price(const void* value, size_t size) { 2455 2456 gas_price_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2457 ::std::string(reinterpret_cast<const char*>(value), size)); 2458 // @@protoc_insertion_point(field_set_pointer:corepb.Transaction.gas_price) 2459 } 2460 inline ::std::string* Transaction::mutable_gas_price() { 2461 2462 // @@protoc_insertion_point(field_mutable:corepb.Transaction.gas_price) 2463 return gas_price_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2464 } 2465 inline ::std::string* Transaction::release_gas_price() { 2466 // @@protoc_insertion_point(field_release:corepb.Transaction.gas_price) 2467 2468 return gas_price_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2469 } 2470 inline void Transaction::set_allocated_gas_price(::std::string* gas_price) { 2471 if (gas_price != NULL) { 2472 2473 } else { 2474 2475 } 2476 gas_price_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), gas_price); 2477 // @@protoc_insertion_point(field_set_allocated:corepb.Transaction.gas_price) 2478 } 2479 2480 // bytes gas_limit = 10; 2481 inline void Transaction::clear_gas_limit() { 2482 gas_limit_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2483 } 2484 inline const ::std::string& Transaction::gas_limit() const { 2485 // @@protoc_insertion_point(field_get:corepb.Transaction.gas_limit) 2486 return gas_limit_.GetNoArena(); 2487 } 2488 inline void Transaction::set_gas_limit(const ::std::string& value) { 2489 2490 gas_limit_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2491 // @@protoc_insertion_point(field_set:corepb.Transaction.gas_limit) 2492 } 2493 #if LANG_CXX11 2494 inline void Transaction::set_gas_limit(::std::string&& value) { 2495 2496 gas_limit_.SetNoArena( 2497 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2498 // @@protoc_insertion_point(field_set_rvalue:corepb.Transaction.gas_limit) 2499 } 2500 #endif 2501 inline void Transaction::set_gas_limit(const char* value) { 2502 GOOGLE_DCHECK(value != NULL); 2503 2504 gas_limit_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2505 // @@protoc_insertion_point(field_set_char:corepb.Transaction.gas_limit) 2506 } 2507 inline void Transaction::set_gas_limit(const void* value, size_t size) { 2508 2509 gas_limit_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2510 ::std::string(reinterpret_cast<const char*>(value), size)); 2511 // @@protoc_insertion_point(field_set_pointer:corepb.Transaction.gas_limit) 2512 } 2513 inline ::std::string* Transaction::mutable_gas_limit() { 2514 2515 // @@protoc_insertion_point(field_mutable:corepb.Transaction.gas_limit) 2516 return gas_limit_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2517 } 2518 inline ::std::string* Transaction::release_gas_limit() { 2519 // @@protoc_insertion_point(field_release:corepb.Transaction.gas_limit) 2520 2521 return gas_limit_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2522 } 2523 inline void Transaction::set_allocated_gas_limit(::std::string* gas_limit) { 2524 if (gas_limit != NULL) { 2525 2526 } else { 2527 2528 } 2529 gas_limit_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), gas_limit); 2530 // @@protoc_insertion_point(field_set_allocated:corepb.Transaction.gas_limit) 2531 } 2532 2533 // uint32 alg = 11; 2534 inline void Transaction::clear_alg() { 2535 alg_ = 0u; 2536 } 2537 inline ::google::protobuf::uint32 Transaction::alg() const { 2538 // @@protoc_insertion_point(field_get:corepb.Transaction.alg) 2539 return alg_; 2540 } 2541 inline void Transaction::set_alg(::google::protobuf::uint32 value) { 2542 2543 alg_ = value; 2544 // @@protoc_insertion_point(field_set:corepb.Transaction.alg) 2545 } 2546 2547 // bytes sign = 12; 2548 inline void Transaction::clear_sign() { 2549 sign_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2550 } 2551 inline const ::std::string& Transaction::sign() const { 2552 // @@protoc_insertion_point(field_get:corepb.Transaction.sign) 2553 return sign_.GetNoArena(); 2554 } 2555 inline void Transaction::set_sign(const ::std::string& value) { 2556 2557 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2558 // @@protoc_insertion_point(field_set:corepb.Transaction.sign) 2559 } 2560 #if LANG_CXX11 2561 inline void Transaction::set_sign(::std::string&& value) { 2562 2563 sign_.SetNoArena( 2564 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2565 // @@protoc_insertion_point(field_set_rvalue:corepb.Transaction.sign) 2566 } 2567 #endif 2568 inline void Transaction::set_sign(const char* value) { 2569 GOOGLE_DCHECK(value != NULL); 2570 2571 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2572 // @@protoc_insertion_point(field_set_char:corepb.Transaction.sign) 2573 } 2574 inline void Transaction::set_sign(const void* value, size_t size) { 2575 2576 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2577 ::std::string(reinterpret_cast<const char*>(value), size)); 2578 // @@protoc_insertion_point(field_set_pointer:corepb.Transaction.sign) 2579 } 2580 inline ::std::string* Transaction::mutable_sign() { 2581 2582 // @@protoc_insertion_point(field_mutable:corepb.Transaction.sign) 2583 return sign_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2584 } 2585 inline ::std::string* Transaction::release_sign() { 2586 // @@protoc_insertion_point(field_release:corepb.Transaction.sign) 2587 2588 return sign_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2589 } 2590 inline void Transaction::set_allocated_sign(::std::string* sign) { 2591 if (sign != NULL) { 2592 2593 } else { 2594 2595 } 2596 sign_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), sign); 2597 // @@protoc_insertion_point(field_set_allocated:corepb.Transaction.sign) 2598 } 2599 2600 // ------------------------------------------------------------------- 2601 2602 // BlockHeader 2603 2604 // bytes hash = 1; 2605 inline void BlockHeader::clear_hash() { 2606 hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2607 } 2608 inline const ::std::string& BlockHeader::hash() const { 2609 // @@protoc_insertion_point(field_get:corepb.BlockHeader.hash) 2610 return hash_.GetNoArena(); 2611 } 2612 inline void BlockHeader::set_hash(const ::std::string& value) { 2613 2614 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2615 // @@protoc_insertion_point(field_set:corepb.BlockHeader.hash) 2616 } 2617 #if LANG_CXX11 2618 inline void BlockHeader::set_hash(::std::string&& value) { 2619 2620 hash_.SetNoArena( 2621 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2622 // @@protoc_insertion_point(field_set_rvalue:corepb.BlockHeader.hash) 2623 } 2624 #endif 2625 inline void BlockHeader::set_hash(const char* value) { 2626 GOOGLE_DCHECK(value != NULL); 2627 2628 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2629 // @@protoc_insertion_point(field_set_char:corepb.BlockHeader.hash) 2630 } 2631 inline void BlockHeader::set_hash(const void* value, size_t size) { 2632 2633 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2634 ::std::string(reinterpret_cast<const char*>(value), size)); 2635 // @@protoc_insertion_point(field_set_pointer:corepb.BlockHeader.hash) 2636 } 2637 inline ::std::string* BlockHeader::mutable_hash() { 2638 2639 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.hash) 2640 return hash_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2641 } 2642 inline ::std::string* BlockHeader::release_hash() { 2643 // @@protoc_insertion_point(field_release:corepb.BlockHeader.hash) 2644 2645 return hash_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2646 } 2647 inline void BlockHeader::set_allocated_hash(::std::string* hash) { 2648 if (hash != NULL) { 2649 2650 } else { 2651 2652 } 2653 hash_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), hash); 2654 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.hash) 2655 } 2656 2657 // bytes parent_hash = 2; 2658 inline void BlockHeader::clear_parent_hash() { 2659 parent_hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2660 } 2661 inline const ::std::string& BlockHeader::parent_hash() const { 2662 // @@protoc_insertion_point(field_get:corepb.BlockHeader.parent_hash) 2663 return parent_hash_.GetNoArena(); 2664 } 2665 inline void BlockHeader::set_parent_hash(const ::std::string& value) { 2666 2667 parent_hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2668 // @@protoc_insertion_point(field_set:corepb.BlockHeader.parent_hash) 2669 } 2670 #if LANG_CXX11 2671 inline void BlockHeader::set_parent_hash(::std::string&& value) { 2672 2673 parent_hash_.SetNoArena( 2674 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2675 // @@protoc_insertion_point(field_set_rvalue:corepb.BlockHeader.parent_hash) 2676 } 2677 #endif 2678 inline void BlockHeader::set_parent_hash(const char* value) { 2679 GOOGLE_DCHECK(value != NULL); 2680 2681 parent_hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2682 // @@protoc_insertion_point(field_set_char:corepb.BlockHeader.parent_hash) 2683 } 2684 inline void BlockHeader::set_parent_hash(const void* value, size_t size) { 2685 2686 parent_hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2687 ::std::string(reinterpret_cast<const char*>(value), size)); 2688 // @@protoc_insertion_point(field_set_pointer:corepb.BlockHeader.parent_hash) 2689 } 2690 inline ::std::string* BlockHeader::mutable_parent_hash() { 2691 2692 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.parent_hash) 2693 return parent_hash_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2694 } 2695 inline ::std::string* BlockHeader::release_parent_hash() { 2696 // @@protoc_insertion_point(field_release:corepb.BlockHeader.parent_hash) 2697 2698 return parent_hash_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2699 } 2700 inline void BlockHeader::set_allocated_parent_hash(::std::string* parent_hash) { 2701 if (parent_hash != NULL) { 2702 2703 } else { 2704 2705 } 2706 parent_hash_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), parent_hash); 2707 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.parent_hash) 2708 } 2709 2710 // bytes coinbase = 4; 2711 inline void BlockHeader::clear_coinbase() { 2712 coinbase_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2713 } 2714 inline const ::std::string& BlockHeader::coinbase() const { 2715 // @@protoc_insertion_point(field_get:corepb.BlockHeader.coinbase) 2716 return coinbase_.GetNoArena(); 2717 } 2718 inline void BlockHeader::set_coinbase(const ::std::string& value) { 2719 2720 coinbase_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2721 // @@protoc_insertion_point(field_set:corepb.BlockHeader.coinbase) 2722 } 2723 #if LANG_CXX11 2724 inline void BlockHeader::set_coinbase(::std::string&& value) { 2725 2726 coinbase_.SetNoArena( 2727 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2728 // @@protoc_insertion_point(field_set_rvalue:corepb.BlockHeader.coinbase) 2729 } 2730 #endif 2731 inline void BlockHeader::set_coinbase(const char* value) { 2732 GOOGLE_DCHECK(value != NULL); 2733 2734 coinbase_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2735 // @@protoc_insertion_point(field_set_char:corepb.BlockHeader.coinbase) 2736 } 2737 inline void BlockHeader::set_coinbase(const void* value, size_t size) { 2738 2739 coinbase_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2740 ::std::string(reinterpret_cast<const char*>(value), size)); 2741 // @@protoc_insertion_point(field_set_pointer:corepb.BlockHeader.coinbase) 2742 } 2743 inline ::std::string* BlockHeader::mutable_coinbase() { 2744 2745 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.coinbase) 2746 return coinbase_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2747 } 2748 inline ::std::string* BlockHeader::release_coinbase() { 2749 // @@protoc_insertion_point(field_release:corepb.BlockHeader.coinbase) 2750 2751 return coinbase_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2752 } 2753 inline void BlockHeader::set_allocated_coinbase(::std::string* coinbase) { 2754 if (coinbase != NULL) { 2755 2756 } else { 2757 2758 } 2759 coinbase_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), coinbase); 2760 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.coinbase) 2761 } 2762 2763 // int64 timestamp = 5; 2764 inline void BlockHeader::clear_timestamp() { 2765 timestamp_ = GOOGLE_LONGLONG(0); 2766 } 2767 inline ::google::protobuf::int64 BlockHeader::timestamp() const { 2768 // @@protoc_insertion_point(field_get:corepb.BlockHeader.timestamp) 2769 return timestamp_; 2770 } 2771 inline void BlockHeader::set_timestamp(::google::protobuf::int64 value) { 2772 2773 timestamp_ = value; 2774 // @@protoc_insertion_point(field_set:corepb.BlockHeader.timestamp) 2775 } 2776 2777 // uint32 chain_id = 6; 2778 inline void BlockHeader::clear_chain_id() { 2779 chain_id_ = 0u; 2780 } 2781 inline ::google::protobuf::uint32 BlockHeader::chain_id() const { 2782 // @@protoc_insertion_point(field_get:corepb.BlockHeader.chain_id) 2783 return chain_id_; 2784 } 2785 inline void BlockHeader::set_chain_id(::google::protobuf::uint32 value) { 2786 2787 chain_id_ = value; 2788 // @@protoc_insertion_point(field_set:corepb.BlockHeader.chain_id) 2789 } 2790 2791 // uint32 alg = 7; 2792 inline void BlockHeader::clear_alg() { 2793 alg_ = 0u; 2794 } 2795 inline ::google::protobuf::uint32 BlockHeader::alg() const { 2796 // @@protoc_insertion_point(field_get:corepb.BlockHeader.alg) 2797 return alg_; 2798 } 2799 inline void BlockHeader::set_alg(::google::protobuf::uint32 value) { 2800 2801 alg_ = value; 2802 // @@protoc_insertion_point(field_set:corepb.BlockHeader.alg) 2803 } 2804 2805 // bytes sign = 8; 2806 inline void BlockHeader::clear_sign() { 2807 sign_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2808 } 2809 inline const ::std::string& BlockHeader::sign() const { 2810 // @@protoc_insertion_point(field_get:corepb.BlockHeader.sign) 2811 return sign_.GetNoArena(); 2812 } 2813 inline void BlockHeader::set_sign(const ::std::string& value) { 2814 2815 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2816 // @@protoc_insertion_point(field_set:corepb.BlockHeader.sign) 2817 } 2818 #if LANG_CXX11 2819 inline void BlockHeader::set_sign(::std::string&& value) { 2820 2821 sign_.SetNoArena( 2822 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2823 // @@protoc_insertion_point(field_set_rvalue:corepb.BlockHeader.sign) 2824 } 2825 #endif 2826 inline void BlockHeader::set_sign(const char* value) { 2827 GOOGLE_DCHECK(value != NULL); 2828 2829 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2830 // @@protoc_insertion_point(field_set_char:corepb.BlockHeader.sign) 2831 } 2832 inline void BlockHeader::set_sign(const void* value, size_t size) { 2833 2834 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2835 ::std::string(reinterpret_cast<const char*>(value), size)); 2836 // @@protoc_insertion_point(field_set_pointer:corepb.BlockHeader.sign) 2837 } 2838 inline ::std::string* BlockHeader::mutable_sign() { 2839 2840 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.sign) 2841 return sign_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2842 } 2843 inline ::std::string* BlockHeader::release_sign() { 2844 // @@protoc_insertion_point(field_release:corepb.BlockHeader.sign) 2845 2846 return sign_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2847 } 2848 inline void BlockHeader::set_allocated_sign(::std::string* sign) { 2849 if (sign != NULL) { 2850 2851 } else { 2852 2853 } 2854 sign_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), sign); 2855 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.sign) 2856 } 2857 2858 // bytes state_root = 9; 2859 inline void BlockHeader::clear_state_root() { 2860 state_root_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2861 } 2862 inline const ::std::string& BlockHeader::state_root() const { 2863 // @@protoc_insertion_point(field_get:corepb.BlockHeader.state_root) 2864 return state_root_.GetNoArena(); 2865 } 2866 inline void BlockHeader::set_state_root(const ::std::string& value) { 2867 2868 state_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2869 // @@protoc_insertion_point(field_set:corepb.BlockHeader.state_root) 2870 } 2871 #if LANG_CXX11 2872 inline void BlockHeader::set_state_root(::std::string&& value) { 2873 2874 state_root_.SetNoArena( 2875 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2876 // @@protoc_insertion_point(field_set_rvalue:corepb.BlockHeader.state_root) 2877 } 2878 #endif 2879 inline void BlockHeader::set_state_root(const char* value) { 2880 GOOGLE_DCHECK(value != NULL); 2881 2882 state_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2883 // @@protoc_insertion_point(field_set_char:corepb.BlockHeader.state_root) 2884 } 2885 inline void BlockHeader::set_state_root(const void* value, size_t size) { 2886 2887 state_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2888 ::std::string(reinterpret_cast<const char*>(value), size)); 2889 // @@protoc_insertion_point(field_set_pointer:corepb.BlockHeader.state_root) 2890 } 2891 inline ::std::string* BlockHeader::mutable_state_root() { 2892 2893 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.state_root) 2894 return state_root_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2895 } 2896 inline ::std::string* BlockHeader::release_state_root() { 2897 // @@protoc_insertion_point(field_release:corepb.BlockHeader.state_root) 2898 2899 return state_root_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2900 } 2901 inline void BlockHeader::set_allocated_state_root(::std::string* state_root) { 2902 if (state_root != NULL) { 2903 2904 } else { 2905 2906 } 2907 state_root_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), state_root); 2908 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.state_root) 2909 } 2910 2911 // bytes txs_root = 10; 2912 inline void BlockHeader::clear_txs_root() { 2913 txs_root_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2914 } 2915 inline const ::std::string& BlockHeader::txs_root() const { 2916 // @@protoc_insertion_point(field_get:corepb.BlockHeader.txs_root) 2917 return txs_root_.GetNoArena(); 2918 } 2919 inline void BlockHeader::set_txs_root(const ::std::string& value) { 2920 2921 txs_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2922 // @@protoc_insertion_point(field_set:corepb.BlockHeader.txs_root) 2923 } 2924 #if LANG_CXX11 2925 inline void BlockHeader::set_txs_root(::std::string&& value) { 2926 2927 txs_root_.SetNoArena( 2928 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2929 // @@protoc_insertion_point(field_set_rvalue:corepb.BlockHeader.txs_root) 2930 } 2931 #endif 2932 inline void BlockHeader::set_txs_root(const char* value) { 2933 GOOGLE_DCHECK(value != NULL); 2934 2935 txs_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2936 // @@protoc_insertion_point(field_set_char:corepb.BlockHeader.txs_root) 2937 } 2938 inline void BlockHeader::set_txs_root(const void* value, size_t size) { 2939 2940 txs_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2941 ::std::string(reinterpret_cast<const char*>(value), size)); 2942 // @@protoc_insertion_point(field_set_pointer:corepb.BlockHeader.txs_root) 2943 } 2944 inline ::std::string* BlockHeader::mutable_txs_root() { 2945 2946 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.txs_root) 2947 return txs_root_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2948 } 2949 inline ::std::string* BlockHeader::release_txs_root() { 2950 // @@protoc_insertion_point(field_release:corepb.BlockHeader.txs_root) 2951 2952 return txs_root_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2953 } 2954 inline void BlockHeader::set_allocated_txs_root(::std::string* txs_root) { 2955 if (txs_root != NULL) { 2956 2957 } else { 2958 2959 } 2960 txs_root_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), txs_root); 2961 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.txs_root) 2962 } 2963 2964 // bytes events_root = 11; 2965 inline void BlockHeader::clear_events_root() { 2966 events_root_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 2967 } 2968 inline const ::std::string& BlockHeader::events_root() const { 2969 // @@protoc_insertion_point(field_get:corepb.BlockHeader.events_root) 2970 return events_root_.GetNoArena(); 2971 } 2972 inline void BlockHeader::set_events_root(const ::std::string& value) { 2973 2974 events_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 2975 // @@protoc_insertion_point(field_set:corepb.BlockHeader.events_root) 2976 } 2977 #if LANG_CXX11 2978 inline void BlockHeader::set_events_root(::std::string&& value) { 2979 2980 events_root_.SetNoArena( 2981 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 2982 // @@protoc_insertion_point(field_set_rvalue:corepb.BlockHeader.events_root) 2983 } 2984 #endif 2985 inline void BlockHeader::set_events_root(const char* value) { 2986 GOOGLE_DCHECK(value != NULL); 2987 2988 events_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 2989 // @@protoc_insertion_point(field_set_char:corepb.BlockHeader.events_root) 2990 } 2991 inline void BlockHeader::set_events_root(const void* value, size_t size) { 2992 2993 events_root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 2994 ::std::string(reinterpret_cast<const char*>(value), size)); 2995 // @@protoc_insertion_point(field_set_pointer:corepb.BlockHeader.events_root) 2996 } 2997 inline ::std::string* BlockHeader::mutable_events_root() { 2998 2999 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.events_root) 3000 return events_root_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3001 } 3002 inline ::std::string* BlockHeader::release_events_root() { 3003 // @@protoc_insertion_point(field_release:corepb.BlockHeader.events_root) 3004 3005 return events_root_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3006 } 3007 inline void BlockHeader::set_allocated_events_root(::std::string* events_root) { 3008 if (events_root != NULL) { 3009 3010 } else { 3011 3012 } 3013 events_root_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), events_root); 3014 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.events_root) 3015 } 3016 3017 // .consensuspb.ConsensusRoot consensus_root = 12; 3018 inline bool BlockHeader::has_consensus_root() const { 3019 return this != internal_default_instance() && consensus_root_ != NULL; 3020 } 3021 inline const ::consensuspb::ConsensusRoot& BlockHeader::_internal_consensus_root() const { 3022 return *consensus_root_; 3023 } 3024 inline const ::consensuspb::ConsensusRoot& BlockHeader::consensus_root() const { 3025 const ::consensuspb::ConsensusRoot* p = consensus_root_; 3026 // @@protoc_insertion_point(field_get:corepb.BlockHeader.consensus_root) 3027 return p != NULL ? *p : *reinterpret_cast<const ::consensuspb::ConsensusRoot*>( 3028 &::consensuspb::_ConsensusRoot_default_instance_); 3029 } 3030 inline ::consensuspb::ConsensusRoot* BlockHeader::release_consensus_root() { 3031 // @@protoc_insertion_point(field_release:corepb.BlockHeader.consensus_root) 3032 3033 ::consensuspb::ConsensusRoot* temp = consensus_root_; 3034 consensus_root_ = NULL; 3035 return temp; 3036 } 3037 inline ::consensuspb::ConsensusRoot* BlockHeader::mutable_consensus_root() { 3038 3039 if (consensus_root_ == NULL) { 3040 auto* p = CreateMaybeMessage<::consensuspb::ConsensusRoot>(GetArenaNoVirtual()); 3041 consensus_root_ = p; 3042 } 3043 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.consensus_root) 3044 return consensus_root_; 3045 } 3046 inline void BlockHeader::set_allocated_consensus_root(::consensuspb::ConsensusRoot* consensus_root) { 3047 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); 3048 if (message_arena == NULL) { 3049 delete reinterpret_cast< ::google::protobuf::MessageLite*>(consensus_root_); 3050 } 3051 if (consensus_root) { 3052 ::google::protobuf::Arena* submessage_arena = NULL; 3053 if (message_arena != submessage_arena) { 3054 consensus_root = ::google::protobuf::internal::GetOwnedMessage( 3055 message_arena, consensus_root, submessage_arena); 3056 } 3057 3058 } else { 3059 3060 } 3061 consensus_root_ = consensus_root; 3062 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.consensus_root) 3063 } 3064 3065 // .corepb.Random random = 13; 3066 inline bool BlockHeader::has_random() const { 3067 return this != internal_default_instance() && random_ != NULL; 3068 } 3069 inline void BlockHeader::clear_random() { 3070 if (GetArenaNoVirtual() == NULL && random_ != NULL) { 3071 delete random_; 3072 } 3073 random_ = NULL; 3074 } 3075 inline const ::corepb::Random& BlockHeader::_internal_random() const { 3076 return *random_; 3077 } 3078 inline const ::corepb::Random& BlockHeader::random() const { 3079 const ::corepb::Random* p = random_; 3080 // @@protoc_insertion_point(field_get:corepb.BlockHeader.random) 3081 return p != NULL ? *p : *reinterpret_cast<const ::corepb::Random*>( 3082 &::corepb::_Random_default_instance_); 3083 } 3084 inline ::corepb::Random* BlockHeader::release_random() { 3085 // @@protoc_insertion_point(field_release:corepb.BlockHeader.random) 3086 3087 ::corepb::Random* temp = random_; 3088 random_ = NULL; 3089 return temp; 3090 } 3091 inline ::corepb::Random* BlockHeader::mutable_random() { 3092 3093 if (random_ == NULL) { 3094 auto* p = CreateMaybeMessage<::corepb::Random>(GetArenaNoVirtual()); 3095 random_ = p; 3096 } 3097 // @@protoc_insertion_point(field_mutable:corepb.BlockHeader.random) 3098 return random_; 3099 } 3100 inline void BlockHeader::set_allocated_random(::corepb::Random* random) { 3101 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); 3102 if (message_arena == NULL) { 3103 delete random_; 3104 } 3105 if (random) { 3106 ::google::protobuf::Arena* submessage_arena = NULL; 3107 if (message_arena != submessage_arena) { 3108 random = ::google::protobuf::internal::GetOwnedMessage( 3109 message_arena, random, submessage_arena); 3110 } 3111 3112 } else { 3113 3114 } 3115 random_ = random; 3116 // @@protoc_insertion_point(field_set_allocated:corepb.BlockHeader.random) 3117 } 3118 3119 // ------------------------------------------------------------------- 3120 3121 // Block 3122 3123 // .corepb.BlockHeader header = 1; 3124 inline bool Block::has_header() const { 3125 return this != internal_default_instance() && header_ != NULL; 3126 } 3127 inline void Block::clear_header() { 3128 if (GetArenaNoVirtual() == NULL && header_ != NULL) { 3129 delete header_; 3130 } 3131 header_ = NULL; 3132 } 3133 inline const ::corepb::BlockHeader& Block::_internal_header() const { 3134 return *header_; 3135 } 3136 inline const ::corepb::BlockHeader& Block::header() const { 3137 const ::corepb::BlockHeader* p = header_; 3138 // @@protoc_insertion_point(field_get:corepb.Block.header) 3139 return p != NULL ? *p : *reinterpret_cast<const ::corepb::BlockHeader*>( 3140 &::corepb::_BlockHeader_default_instance_); 3141 } 3142 inline ::corepb::BlockHeader* Block::release_header() { 3143 // @@protoc_insertion_point(field_release:corepb.Block.header) 3144 3145 ::corepb::BlockHeader* temp = header_; 3146 header_ = NULL; 3147 return temp; 3148 } 3149 inline ::corepb::BlockHeader* Block::mutable_header() { 3150 3151 if (header_ == NULL) { 3152 auto* p = CreateMaybeMessage<::corepb::BlockHeader>(GetArenaNoVirtual()); 3153 header_ = p; 3154 } 3155 // @@protoc_insertion_point(field_mutable:corepb.Block.header) 3156 return header_; 3157 } 3158 inline void Block::set_allocated_header(::corepb::BlockHeader* header) { 3159 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); 3160 if (message_arena == NULL) { 3161 delete header_; 3162 } 3163 if (header) { 3164 ::google::protobuf::Arena* submessage_arena = NULL; 3165 if (message_arena != submessage_arena) { 3166 header = ::google::protobuf::internal::GetOwnedMessage( 3167 message_arena, header, submessage_arena); 3168 } 3169 3170 } else { 3171 3172 } 3173 header_ = header; 3174 // @@protoc_insertion_point(field_set_allocated:corepb.Block.header) 3175 } 3176 3177 // repeated .corepb.Transaction transactions = 2; 3178 inline int Block::transactions_size() const { 3179 return transactions_.size(); 3180 } 3181 inline void Block::clear_transactions() { 3182 transactions_.Clear(); 3183 } 3184 inline ::corepb::Transaction* Block::mutable_transactions(int index) { 3185 // @@protoc_insertion_point(field_mutable:corepb.Block.transactions) 3186 return transactions_.Mutable(index); 3187 } 3188 inline ::google::protobuf::RepeatedPtrField< ::corepb::Transaction >* 3189 Block::mutable_transactions() { 3190 // @@protoc_insertion_point(field_mutable_list:corepb.Block.transactions) 3191 return &transactions_; 3192 } 3193 inline const ::corepb::Transaction& Block::transactions(int index) const { 3194 // @@protoc_insertion_point(field_get:corepb.Block.transactions) 3195 return transactions_.Get(index); 3196 } 3197 inline ::corepb::Transaction* Block::add_transactions() { 3198 // @@protoc_insertion_point(field_add:corepb.Block.transactions) 3199 return transactions_.Add(); 3200 } 3201 inline const ::google::protobuf::RepeatedPtrField< ::corepb::Transaction >& 3202 Block::transactions() const { 3203 // @@protoc_insertion_point(field_list:corepb.Block.transactions) 3204 return transactions_; 3205 } 3206 3207 // .dagpb.Dag dependency = 3; 3208 inline bool Block::has_dependency() const { 3209 return this != internal_default_instance() && dependency_ != NULL; 3210 } 3211 inline const ::dagpb::Dag& Block::_internal_dependency() const { 3212 return *dependency_; 3213 } 3214 inline const ::dagpb::Dag& Block::dependency() const { 3215 const ::dagpb::Dag* p = dependency_; 3216 // @@protoc_insertion_point(field_get:corepb.Block.dependency) 3217 return p != NULL ? *p : *reinterpret_cast<const ::dagpb::Dag*>( 3218 &::dagpb::_Dag_default_instance_); 3219 } 3220 inline ::dagpb::Dag* Block::release_dependency() { 3221 // @@protoc_insertion_point(field_release:corepb.Block.dependency) 3222 3223 ::dagpb::Dag* temp = dependency_; 3224 dependency_ = NULL; 3225 return temp; 3226 } 3227 inline ::dagpb::Dag* Block::mutable_dependency() { 3228 3229 if (dependency_ == NULL) { 3230 auto* p = CreateMaybeMessage<::dagpb::Dag>(GetArenaNoVirtual()); 3231 dependency_ = p; 3232 } 3233 // @@protoc_insertion_point(field_mutable:corepb.Block.dependency) 3234 return dependency_; 3235 } 3236 inline void Block::set_allocated_dependency(::dagpb::Dag* dependency) { 3237 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); 3238 if (message_arena == NULL) { 3239 delete reinterpret_cast< ::google::protobuf::MessageLite*>(dependency_); 3240 } 3241 if (dependency) { 3242 ::google::protobuf::Arena* submessage_arena = NULL; 3243 if (message_arena != submessage_arena) { 3244 dependency = ::google::protobuf::internal::GetOwnedMessage( 3245 message_arena, dependency, submessage_arena); 3246 } 3247 3248 } else { 3249 3250 } 3251 dependency_ = dependency; 3252 // @@protoc_insertion_point(field_set_allocated:corepb.Block.dependency) 3253 } 3254 3255 // uint64 height = 4; 3256 inline void Block::clear_height() { 3257 height_ = GOOGLE_ULONGLONG(0); 3258 } 3259 inline ::google::protobuf::uint64 Block::height() const { 3260 // @@protoc_insertion_point(field_get:corepb.Block.height) 3261 return height_; 3262 } 3263 inline void Block::set_height(::google::protobuf::uint64 value) { 3264 3265 height_ = value; 3266 // @@protoc_insertion_point(field_set:corepb.Block.height) 3267 } 3268 3269 // ------------------------------------------------------------------- 3270 3271 // NetBlocks 3272 3273 // string from = 1; 3274 inline void NetBlocks::clear_from() { 3275 from_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3276 } 3277 inline const ::std::string& NetBlocks::from() const { 3278 // @@protoc_insertion_point(field_get:corepb.NetBlocks.from) 3279 return from_.GetNoArena(); 3280 } 3281 inline void NetBlocks::set_from(const ::std::string& value) { 3282 3283 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 3284 // @@protoc_insertion_point(field_set:corepb.NetBlocks.from) 3285 } 3286 #if LANG_CXX11 3287 inline void NetBlocks::set_from(::std::string&& value) { 3288 3289 from_.SetNoArena( 3290 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 3291 // @@protoc_insertion_point(field_set_rvalue:corepb.NetBlocks.from) 3292 } 3293 #endif 3294 inline void NetBlocks::set_from(const char* value) { 3295 GOOGLE_DCHECK(value != NULL); 3296 3297 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 3298 // @@protoc_insertion_point(field_set_char:corepb.NetBlocks.from) 3299 } 3300 inline void NetBlocks::set_from(const char* value, size_t size) { 3301 3302 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 3303 ::std::string(reinterpret_cast<const char*>(value), size)); 3304 // @@protoc_insertion_point(field_set_pointer:corepb.NetBlocks.from) 3305 } 3306 inline ::std::string* NetBlocks::mutable_from() { 3307 3308 // @@protoc_insertion_point(field_mutable:corepb.NetBlocks.from) 3309 return from_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3310 } 3311 inline ::std::string* NetBlocks::release_from() { 3312 // @@protoc_insertion_point(field_release:corepb.NetBlocks.from) 3313 3314 return from_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3315 } 3316 inline void NetBlocks::set_allocated_from(::std::string* from) { 3317 if (from != NULL) { 3318 3319 } else { 3320 3321 } 3322 from_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from); 3323 // @@protoc_insertion_point(field_set_allocated:corepb.NetBlocks.from) 3324 } 3325 3326 // uint64 batch = 2; 3327 inline void NetBlocks::clear_batch() { 3328 batch_ = GOOGLE_ULONGLONG(0); 3329 } 3330 inline ::google::protobuf::uint64 NetBlocks::batch() const { 3331 // @@protoc_insertion_point(field_get:corepb.NetBlocks.batch) 3332 return batch_; 3333 } 3334 inline void NetBlocks::set_batch(::google::protobuf::uint64 value) { 3335 3336 batch_ = value; 3337 // @@protoc_insertion_point(field_set:corepb.NetBlocks.batch) 3338 } 3339 3340 // repeated .corepb.Block blocks = 3; 3341 inline int NetBlocks::blocks_size() const { 3342 return blocks_.size(); 3343 } 3344 inline void NetBlocks::clear_blocks() { 3345 blocks_.Clear(); 3346 } 3347 inline ::corepb::Block* NetBlocks::mutable_blocks(int index) { 3348 // @@protoc_insertion_point(field_mutable:corepb.NetBlocks.blocks) 3349 return blocks_.Mutable(index); 3350 } 3351 inline ::google::protobuf::RepeatedPtrField< ::corepb::Block >* 3352 NetBlocks::mutable_blocks() { 3353 // @@protoc_insertion_point(field_mutable_list:corepb.NetBlocks.blocks) 3354 return &blocks_; 3355 } 3356 inline const ::corepb::Block& NetBlocks::blocks(int index) const { 3357 // @@protoc_insertion_point(field_get:corepb.NetBlocks.blocks) 3358 return blocks_.Get(index); 3359 } 3360 inline ::corepb::Block* NetBlocks::add_blocks() { 3361 // @@protoc_insertion_point(field_add:corepb.NetBlocks.blocks) 3362 return blocks_.Add(); 3363 } 3364 inline const ::google::protobuf::RepeatedPtrField< ::corepb::Block >& 3365 NetBlocks::blocks() const { 3366 // @@protoc_insertion_point(field_list:corepb.NetBlocks.blocks) 3367 return blocks_; 3368 } 3369 3370 // ------------------------------------------------------------------- 3371 3372 // NetBlock 3373 3374 // string from = 1; 3375 inline void NetBlock::clear_from() { 3376 from_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3377 } 3378 inline const ::std::string& NetBlock::from() const { 3379 // @@protoc_insertion_point(field_get:corepb.NetBlock.from) 3380 return from_.GetNoArena(); 3381 } 3382 inline void NetBlock::set_from(const ::std::string& value) { 3383 3384 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 3385 // @@protoc_insertion_point(field_set:corepb.NetBlock.from) 3386 } 3387 #if LANG_CXX11 3388 inline void NetBlock::set_from(::std::string&& value) { 3389 3390 from_.SetNoArena( 3391 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 3392 // @@protoc_insertion_point(field_set_rvalue:corepb.NetBlock.from) 3393 } 3394 #endif 3395 inline void NetBlock::set_from(const char* value) { 3396 GOOGLE_DCHECK(value != NULL); 3397 3398 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 3399 // @@protoc_insertion_point(field_set_char:corepb.NetBlock.from) 3400 } 3401 inline void NetBlock::set_from(const char* value, size_t size) { 3402 3403 from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 3404 ::std::string(reinterpret_cast<const char*>(value), size)); 3405 // @@protoc_insertion_point(field_set_pointer:corepb.NetBlock.from) 3406 } 3407 inline ::std::string* NetBlock::mutable_from() { 3408 3409 // @@protoc_insertion_point(field_mutable:corepb.NetBlock.from) 3410 return from_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3411 } 3412 inline ::std::string* NetBlock::release_from() { 3413 // @@protoc_insertion_point(field_release:corepb.NetBlock.from) 3414 3415 return from_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3416 } 3417 inline void NetBlock::set_allocated_from(::std::string* from) { 3418 if (from != NULL) { 3419 3420 } else { 3421 3422 } 3423 from_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from); 3424 // @@protoc_insertion_point(field_set_allocated:corepb.NetBlock.from) 3425 } 3426 3427 // uint64 batch = 2; 3428 inline void NetBlock::clear_batch() { 3429 batch_ = GOOGLE_ULONGLONG(0); 3430 } 3431 inline ::google::protobuf::uint64 NetBlock::batch() const { 3432 // @@protoc_insertion_point(field_get:corepb.NetBlock.batch) 3433 return batch_; 3434 } 3435 inline void NetBlock::set_batch(::google::protobuf::uint64 value) { 3436 3437 batch_ = value; 3438 // @@protoc_insertion_point(field_set:corepb.NetBlock.batch) 3439 } 3440 3441 // .corepb.Block block = 3; 3442 inline bool NetBlock::has_block() const { 3443 return this != internal_default_instance() && block_ != NULL; 3444 } 3445 inline void NetBlock::clear_block() { 3446 if (GetArenaNoVirtual() == NULL && block_ != NULL) { 3447 delete block_; 3448 } 3449 block_ = NULL; 3450 } 3451 inline const ::corepb::Block& NetBlock::_internal_block() const { 3452 return *block_; 3453 } 3454 inline const ::corepb::Block& NetBlock::block() const { 3455 const ::corepb::Block* p = block_; 3456 // @@protoc_insertion_point(field_get:corepb.NetBlock.block) 3457 return p != NULL ? *p : *reinterpret_cast<const ::corepb::Block*>( 3458 &::corepb::_Block_default_instance_); 3459 } 3460 inline ::corepb::Block* NetBlock::release_block() { 3461 // @@protoc_insertion_point(field_release:corepb.NetBlock.block) 3462 3463 ::corepb::Block* temp = block_; 3464 block_ = NULL; 3465 return temp; 3466 } 3467 inline ::corepb::Block* NetBlock::mutable_block() { 3468 3469 if (block_ == NULL) { 3470 auto* p = CreateMaybeMessage<::corepb::Block>(GetArenaNoVirtual()); 3471 block_ = p; 3472 } 3473 // @@protoc_insertion_point(field_mutable:corepb.NetBlock.block) 3474 return block_; 3475 } 3476 inline void NetBlock::set_allocated_block(::corepb::Block* block) { 3477 ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); 3478 if (message_arena == NULL) { 3479 delete block_; 3480 } 3481 if (block) { 3482 ::google::protobuf::Arena* submessage_arena = NULL; 3483 if (message_arena != submessage_arena) { 3484 block = ::google::protobuf::internal::GetOwnedMessage( 3485 message_arena, block, submessage_arena); 3486 } 3487 3488 } else { 3489 3490 } 3491 block_ = block; 3492 // @@protoc_insertion_point(field_set_allocated:corepb.NetBlock.block) 3493 } 3494 3495 // ------------------------------------------------------------------- 3496 3497 // DownloadBlock 3498 3499 // bytes hash = 1; 3500 inline void DownloadBlock::clear_hash() { 3501 hash_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3502 } 3503 inline const ::std::string& DownloadBlock::hash() const { 3504 // @@protoc_insertion_point(field_get:corepb.DownloadBlock.hash) 3505 return hash_.GetNoArena(); 3506 } 3507 inline void DownloadBlock::set_hash(const ::std::string& value) { 3508 3509 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 3510 // @@protoc_insertion_point(field_set:corepb.DownloadBlock.hash) 3511 } 3512 #if LANG_CXX11 3513 inline void DownloadBlock::set_hash(::std::string&& value) { 3514 3515 hash_.SetNoArena( 3516 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 3517 // @@protoc_insertion_point(field_set_rvalue:corepb.DownloadBlock.hash) 3518 } 3519 #endif 3520 inline void DownloadBlock::set_hash(const char* value) { 3521 GOOGLE_DCHECK(value != NULL); 3522 3523 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 3524 // @@protoc_insertion_point(field_set_char:corepb.DownloadBlock.hash) 3525 } 3526 inline void DownloadBlock::set_hash(const void* value, size_t size) { 3527 3528 hash_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 3529 ::std::string(reinterpret_cast<const char*>(value), size)); 3530 // @@protoc_insertion_point(field_set_pointer:corepb.DownloadBlock.hash) 3531 } 3532 inline ::std::string* DownloadBlock::mutable_hash() { 3533 3534 // @@protoc_insertion_point(field_mutable:corepb.DownloadBlock.hash) 3535 return hash_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3536 } 3537 inline ::std::string* DownloadBlock::release_hash() { 3538 // @@protoc_insertion_point(field_release:corepb.DownloadBlock.hash) 3539 3540 return hash_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3541 } 3542 inline void DownloadBlock::set_allocated_hash(::std::string* hash) { 3543 if (hash != NULL) { 3544 3545 } else { 3546 3547 } 3548 hash_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), hash); 3549 // @@protoc_insertion_point(field_set_allocated:corepb.DownloadBlock.hash) 3550 } 3551 3552 // bytes sign = 2; 3553 inline void DownloadBlock::clear_sign() { 3554 sign_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3555 } 3556 inline const ::std::string& DownloadBlock::sign() const { 3557 // @@protoc_insertion_point(field_get:corepb.DownloadBlock.sign) 3558 return sign_.GetNoArena(); 3559 } 3560 inline void DownloadBlock::set_sign(const ::std::string& value) { 3561 3562 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 3563 // @@protoc_insertion_point(field_set:corepb.DownloadBlock.sign) 3564 } 3565 #if LANG_CXX11 3566 inline void DownloadBlock::set_sign(::std::string&& value) { 3567 3568 sign_.SetNoArena( 3569 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 3570 // @@protoc_insertion_point(field_set_rvalue:corepb.DownloadBlock.sign) 3571 } 3572 #endif 3573 inline void DownloadBlock::set_sign(const char* value) { 3574 GOOGLE_DCHECK(value != NULL); 3575 3576 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 3577 // @@protoc_insertion_point(field_set_char:corepb.DownloadBlock.sign) 3578 } 3579 inline void DownloadBlock::set_sign(const void* value, size_t size) { 3580 3581 sign_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 3582 ::std::string(reinterpret_cast<const char*>(value), size)); 3583 // @@protoc_insertion_point(field_set_pointer:corepb.DownloadBlock.sign) 3584 } 3585 inline ::std::string* DownloadBlock::mutable_sign() { 3586 3587 // @@protoc_insertion_point(field_mutable:corepb.DownloadBlock.sign) 3588 return sign_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3589 } 3590 inline ::std::string* DownloadBlock::release_sign() { 3591 // @@protoc_insertion_point(field_release:corepb.DownloadBlock.sign) 3592 3593 return sign_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3594 } 3595 inline void DownloadBlock::set_allocated_sign(::std::string* sign) { 3596 if (sign != NULL) { 3597 3598 } else { 3599 3600 } 3601 sign_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), sign); 3602 // @@protoc_insertion_point(field_set_allocated:corepb.DownloadBlock.sign) 3603 } 3604 3605 // ------------------------------------------------------------------- 3606 3607 // Random 3608 3609 // bytes vrf_seed = 1; 3610 inline void Random::clear_vrf_seed() { 3611 vrf_seed_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3612 } 3613 inline const ::std::string& Random::vrf_seed() const { 3614 // @@protoc_insertion_point(field_get:corepb.Random.vrf_seed) 3615 return vrf_seed_.GetNoArena(); 3616 } 3617 inline void Random::set_vrf_seed(const ::std::string& value) { 3618 3619 vrf_seed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 3620 // @@protoc_insertion_point(field_set:corepb.Random.vrf_seed) 3621 } 3622 #if LANG_CXX11 3623 inline void Random::set_vrf_seed(::std::string&& value) { 3624 3625 vrf_seed_.SetNoArena( 3626 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 3627 // @@protoc_insertion_point(field_set_rvalue:corepb.Random.vrf_seed) 3628 } 3629 #endif 3630 inline void Random::set_vrf_seed(const char* value) { 3631 GOOGLE_DCHECK(value != NULL); 3632 3633 vrf_seed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 3634 // @@protoc_insertion_point(field_set_char:corepb.Random.vrf_seed) 3635 } 3636 inline void Random::set_vrf_seed(const void* value, size_t size) { 3637 3638 vrf_seed_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 3639 ::std::string(reinterpret_cast<const char*>(value), size)); 3640 // @@protoc_insertion_point(field_set_pointer:corepb.Random.vrf_seed) 3641 } 3642 inline ::std::string* Random::mutable_vrf_seed() { 3643 3644 // @@protoc_insertion_point(field_mutable:corepb.Random.vrf_seed) 3645 return vrf_seed_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3646 } 3647 inline ::std::string* Random::release_vrf_seed() { 3648 // @@protoc_insertion_point(field_release:corepb.Random.vrf_seed) 3649 3650 return vrf_seed_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3651 } 3652 inline void Random::set_allocated_vrf_seed(::std::string* vrf_seed) { 3653 if (vrf_seed != NULL) { 3654 3655 } else { 3656 3657 } 3658 vrf_seed_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), vrf_seed); 3659 // @@protoc_insertion_point(field_set_allocated:corepb.Random.vrf_seed) 3660 } 3661 3662 // bytes vrf_proof = 2; 3663 inline void Random::clear_vrf_proof() { 3664 vrf_proof_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3665 } 3666 inline const ::std::string& Random::vrf_proof() const { 3667 // @@protoc_insertion_point(field_get:corepb.Random.vrf_proof) 3668 return vrf_proof_.GetNoArena(); 3669 } 3670 inline void Random::set_vrf_proof(const ::std::string& value) { 3671 3672 vrf_proof_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); 3673 // @@protoc_insertion_point(field_set:corepb.Random.vrf_proof) 3674 } 3675 #if LANG_CXX11 3676 inline void Random::set_vrf_proof(::std::string&& value) { 3677 3678 vrf_proof_.SetNoArena( 3679 &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); 3680 // @@protoc_insertion_point(field_set_rvalue:corepb.Random.vrf_proof) 3681 } 3682 #endif 3683 inline void Random::set_vrf_proof(const char* value) { 3684 GOOGLE_DCHECK(value != NULL); 3685 3686 vrf_proof_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); 3687 // @@protoc_insertion_point(field_set_char:corepb.Random.vrf_proof) 3688 } 3689 inline void Random::set_vrf_proof(const void* value, size_t size) { 3690 3691 vrf_proof_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), 3692 ::std::string(reinterpret_cast<const char*>(value), size)); 3693 // @@protoc_insertion_point(field_set_pointer:corepb.Random.vrf_proof) 3694 } 3695 inline ::std::string* Random::mutable_vrf_proof() { 3696 3697 // @@protoc_insertion_point(field_mutable:corepb.Random.vrf_proof) 3698 return vrf_proof_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3699 } 3700 inline ::std::string* Random::release_vrf_proof() { 3701 // @@protoc_insertion_point(field_release:corepb.Random.vrf_proof) 3702 3703 return vrf_proof_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); 3704 } 3705 inline void Random::set_allocated_vrf_proof(::std::string* vrf_proof) { 3706 if (vrf_proof != NULL) { 3707 3708 } else { 3709 3710 } 3711 vrf_proof_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), vrf_proof); 3712 // @@protoc_insertion_point(field_set_allocated:corepb.Random.vrf_proof) 3713 } 3714 3715 #ifdef __GNUC__ 3716 #pragma GCC diagnostic pop 3717 #endif // __GNUC__ 3718 // ------------------------------------------------------------------- 3719 3720 // ------------------------------------------------------------------- 3721 3722 // ------------------------------------------------------------------- 3723 3724 // ------------------------------------------------------------------- 3725 3726 // ------------------------------------------------------------------- 3727 3728 // ------------------------------------------------------------------- 3729 3730 // ------------------------------------------------------------------- 3731 3732 // ------------------------------------------------------------------- 3733 3734 // ------------------------------------------------------------------- 3735 3736 3737 // @@protoc_insertion_point(namespace_scope) 3738 3739 } // namespace corepb 3740 3741 // @@protoc_insertion_point(global_scope) 3742 3743 #endif // PROTOBUF_INCLUDED_block_2eproto