2677 lines
88 KiB
C++
2677 lines
88 KiB
C++
// Generated by the protocol buffer compiler. DO NOT EDIT!
|
|
// source: result.proto
|
|
|
|
#ifndef GOOGLE_PROTOBUF_INCLUDED_result_2eproto
|
|
#define GOOGLE_PROTOBUF_INCLUDED_result_2eproto
|
|
|
|
#include <limits>
|
|
#include <string>
|
|
|
|
#include <google/protobuf/port_def.inc>
|
|
#if PROTOBUF_VERSION < 3012000
|
|
#error This file was generated by a newer version of protoc which is
|
|
#error incompatible with your Protocol Buffer headers. Please update
|
|
#error your headers.
|
|
#endif
|
|
#if 3012004 < PROTOBUF_MIN_PROTOC_VERSION
|
|
#error This file was generated by an older version of protoc which is
|
|
#error incompatible with your Protocol Buffer headers. Please
|
|
#error regenerate this file with a newer version of protoc.
|
|
#endif
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#include <google/protobuf/io/coded_stream.h>
|
|
#include <google/protobuf/arena.h>
|
|
#include <google/protobuf/arenastring.h>
|
|
#include <google/protobuf/generated_message_table_driven.h>
|
|
#include <google/protobuf/generated_message_util.h>
|
|
#include <google/protobuf/inlined_string_field.h>
|
|
#include <google/protobuf/metadata_lite.h>
|
|
#include <google/protobuf/generated_message_reflection.h>
|
|
#include <google/protobuf/message.h>
|
|
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
|
|
#include <google/protobuf/extension_set.h> // IWYU pragma: export
|
|
#include <google/protobuf/generated_enum_reflection.h>
|
|
#include <google/protobuf/unknown_field_set.h>
|
|
// @@protoc_insertion_point(includes)
|
|
#include <google/protobuf/port_def.inc>
|
|
#define PROTOBUF_INTERNAL_EXPORT_result_2eproto
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
namespace internal {
|
|
class AnyMetadata;
|
|
} // namespace internal
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// Internal implementation detail -- do not use these members.
|
|
struct TableStruct_result_2eproto {
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
|
|
PROTOBUF_SECTION_VARIABLE(protodesc_cold);
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
|
|
static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
|
|
static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
|
|
};
|
|
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_result_2eproto;
|
|
namespace pb {
|
|
class Blocked;
|
|
class BlockedDefaultTypeInternal;
|
|
extern BlockedDefaultTypeInternal _Blocked_default_instance_;
|
|
class ClaimMeta;
|
|
class ClaimMetaDefaultTypeInternal;
|
|
extern ClaimMetaDefaultTypeInternal _ClaimMeta_default_instance_;
|
|
class Error;
|
|
class ErrorDefaultTypeInternal;
|
|
extern ErrorDefaultTypeInternal _Error_default_instance_;
|
|
class Output;
|
|
class OutputDefaultTypeInternal;
|
|
extern OutputDefaultTypeInternal _Output_default_instance_;
|
|
class Outputs;
|
|
class OutputsDefaultTypeInternal;
|
|
extern OutputsDefaultTypeInternal _Outputs_default_instance_;
|
|
} // namespace pb
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
template<> ::pb::Blocked* Arena::CreateMaybeMessage<::pb::Blocked>(Arena*);
|
|
template<> ::pb::ClaimMeta* Arena::CreateMaybeMessage<::pb::ClaimMeta>(Arena*);
|
|
template<> ::pb::Error* Arena::CreateMaybeMessage<::pb::Error>(Arena*);
|
|
template<> ::pb::Output* Arena::CreateMaybeMessage<::pb::Output>(Arena*);
|
|
template<> ::pb::Outputs* Arena::CreateMaybeMessage<::pb::Outputs>(Arena*);
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
namespace pb {
|
|
|
|
enum Error_Code : int {
|
|
Error_Code_UNKNOWN_CODE = 0,
|
|
Error_Code_NOT_FOUND = 1,
|
|
Error_Code_INVALID = 2,
|
|
Error_Code_BLOCKED = 3,
|
|
Error_Code_Error_Code_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
|
|
Error_Code_Error_Code_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
|
|
};
|
|
bool Error_Code_IsValid(int value);
|
|
constexpr Error_Code Error_Code_Code_MIN = Error_Code_UNKNOWN_CODE;
|
|
constexpr Error_Code Error_Code_Code_MAX = Error_Code_BLOCKED;
|
|
constexpr int Error_Code_Code_ARRAYSIZE = Error_Code_Code_MAX + 1;
|
|
|
|
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Error_Code_descriptor();
|
|
template<typename T>
|
|
inline const std::string& Error_Code_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, Error_Code>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function Error_Code_Name.");
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
|
|
Error_Code_descriptor(), enum_t_value);
|
|
}
|
|
inline bool Error_Code_Parse(
|
|
const std::string& name, Error_Code* value) {
|
|
return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Error_Code>(
|
|
Error_Code_descriptor(), name, value);
|
|
}
|
|
// ===================================================================
|
|
|
|
class Outputs PROTOBUF_FINAL :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.Outputs) */ {
|
|
public:
|
|
inline Outputs() : Outputs(nullptr) {};
|
|
virtual ~Outputs();
|
|
|
|
Outputs(const Outputs& from);
|
|
Outputs(Outputs&& from) noexcept
|
|
: Outputs() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Outputs& operator=(const Outputs& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Outputs& operator=(Outputs&& from) noexcept {
|
|
if (GetArena() == from.GetArena()) {
|
|
if (this != &from) InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return GetMetadataStatic().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return GetMetadataStatic().reflection;
|
|
}
|
|
static const Outputs& default_instance();
|
|
|
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
|
static inline const Outputs* internal_default_instance() {
|
|
return reinterpret_cast<const Outputs*>(
|
|
&_Outputs_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
0;
|
|
|
|
friend void swap(Outputs& a, Outputs& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Outputs* other) {
|
|
if (other == this) return;
|
|
if (GetArena() == other->GetArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Outputs* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetArena() == other->GetArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Outputs* New() const final {
|
|
return CreateMaybeMessage<Outputs>(nullptr);
|
|
}
|
|
|
|
Outputs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<Outputs>(arena);
|
|
}
|
|
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void CopyFrom(const Outputs& from);
|
|
void MergeFrom(const Outputs& from);
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
inline void SharedCtor();
|
|
inline void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(Outputs* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "pb.Outputs";
|
|
}
|
|
protected:
|
|
explicit Outputs(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
private:
|
|
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_result_2eproto);
|
|
return ::descriptor_table_result_2eproto.file_level_metadata[kIndexInFileMessages];
|
|
}
|
|
|
|
public:
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kTxosFieldNumber = 1,
|
|
kExtraTxosFieldNumber = 2,
|
|
kBlockedFieldNumber = 5,
|
|
kTotalFieldNumber = 3,
|
|
kOffsetFieldNumber = 4,
|
|
kBlockedTotalFieldNumber = 6,
|
|
};
|
|
// repeated .pb.Output txos = 1;
|
|
int txos_size() const;
|
|
private:
|
|
int _internal_txos_size() const;
|
|
public:
|
|
void clear_txos();
|
|
::pb::Output* mutable_txos(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >*
|
|
mutable_txos();
|
|
private:
|
|
const ::pb::Output& _internal_txos(int index) const;
|
|
::pb::Output* _internal_add_txos();
|
|
public:
|
|
const ::pb::Output& txos(int index) const;
|
|
::pb::Output* add_txos();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >&
|
|
txos() const;
|
|
|
|
// repeated .pb.Output extra_txos = 2;
|
|
int extra_txos_size() const;
|
|
private:
|
|
int _internal_extra_txos_size() const;
|
|
public:
|
|
void clear_extra_txos();
|
|
::pb::Output* mutable_extra_txos(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >*
|
|
mutable_extra_txos();
|
|
private:
|
|
const ::pb::Output& _internal_extra_txos(int index) const;
|
|
::pb::Output* _internal_add_extra_txos();
|
|
public:
|
|
const ::pb::Output& extra_txos(int index) const;
|
|
::pb::Output* add_extra_txos();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >&
|
|
extra_txos() const;
|
|
|
|
// repeated .pb.Blocked blocked = 5;
|
|
int blocked_size() const;
|
|
private:
|
|
int _internal_blocked_size() const;
|
|
public:
|
|
void clear_blocked();
|
|
::pb::Blocked* mutable_blocked(int index);
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked >*
|
|
mutable_blocked();
|
|
private:
|
|
const ::pb::Blocked& _internal_blocked(int index) const;
|
|
::pb::Blocked* _internal_add_blocked();
|
|
public:
|
|
const ::pb::Blocked& blocked(int index) const;
|
|
::pb::Blocked* add_blocked();
|
|
const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked >&
|
|
blocked() const;
|
|
|
|
// uint32 total = 3;
|
|
void clear_total();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 total() const;
|
|
void set_total(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_total() const;
|
|
void _internal_set_total(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 offset = 4;
|
|
void clear_offset();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 offset() const;
|
|
void set_offset(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_offset() const;
|
|
void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 blocked_total = 6;
|
|
void clear_blocked_total();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 blocked_total() const;
|
|
void set_blocked_total(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_blocked_total() const;
|
|
void _internal_set_blocked_total(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:pb.Outputs)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output > txos_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output > extra_txos_;
|
|
::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked > blocked_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 total_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 offset_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 blocked_total_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
friend struct ::TableStruct_result_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Output PROTOBUF_FINAL :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.Output) */ {
|
|
public:
|
|
inline Output() : Output(nullptr) {};
|
|
virtual ~Output();
|
|
|
|
Output(const Output& from);
|
|
Output(Output&& from) noexcept
|
|
: Output() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Output& operator=(const Output& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Output& operator=(Output&& from) noexcept {
|
|
if (GetArena() == from.GetArena()) {
|
|
if (this != &from) InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return GetMetadataStatic().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return GetMetadataStatic().reflection;
|
|
}
|
|
static const Output& default_instance();
|
|
|
|
enum MetaCase {
|
|
kClaim = 7,
|
|
kError = 15,
|
|
META_NOT_SET = 0,
|
|
};
|
|
|
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
|
static inline const Output* internal_default_instance() {
|
|
return reinterpret_cast<const Output*>(
|
|
&_Output_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
1;
|
|
|
|
friend void swap(Output& a, Output& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Output* other) {
|
|
if (other == this) return;
|
|
if (GetArena() == other->GetArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Output* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetArena() == other->GetArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Output* New() const final {
|
|
return CreateMaybeMessage<Output>(nullptr);
|
|
}
|
|
|
|
Output* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<Output>(arena);
|
|
}
|
|
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void CopyFrom(const Output& from);
|
|
void MergeFrom(const Output& from);
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
inline void SharedCtor();
|
|
inline void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(Output* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "pb.Output";
|
|
}
|
|
protected:
|
|
explicit Output(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
private:
|
|
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_result_2eproto);
|
|
return ::descriptor_table_result_2eproto.file_level_metadata[kIndexInFileMessages];
|
|
}
|
|
|
|
public:
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kTxHashFieldNumber = 1,
|
|
kNoutFieldNumber = 2,
|
|
kHeightFieldNumber = 3,
|
|
kClaimFieldNumber = 7,
|
|
kErrorFieldNumber = 15,
|
|
};
|
|
// bytes tx_hash = 1;
|
|
void clear_tx_hash();
|
|
const std::string& tx_hash() const;
|
|
void set_tx_hash(const std::string& value);
|
|
void set_tx_hash(std::string&& value);
|
|
void set_tx_hash(const char* value);
|
|
void set_tx_hash(const void* value, size_t size);
|
|
std::string* mutable_tx_hash();
|
|
std::string* release_tx_hash();
|
|
void set_allocated_tx_hash(std::string* tx_hash);
|
|
GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
|
|
" string fields are deprecated and will be removed in a"
|
|
" future release.")
|
|
std::string* unsafe_arena_release_tx_hash();
|
|
GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
|
|
" string fields are deprecated and will be removed in a"
|
|
" future release.")
|
|
void unsafe_arena_set_allocated_tx_hash(
|
|
std::string* tx_hash);
|
|
private:
|
|
const std::string& _internal_tx_hash() const;
|
|
void _internal_set_tx_hash(const std::string& value);
|
|
std::string* _internal_mutable_tx_hash();
|
|
public:
|
|
|
|
// uint32 nout = 2;
|
|
void clear_nout();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 nout() const;
|
|
void set_nout(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_nout() const;
|
|
void _internal_set_nout(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 height = 3;
|
|
void clear_height();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 height() const;
|
|
void set_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_height() const;
|
|
void _internal_set_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// .pb.ClaimMeta claim = 7;
|
|
bool has_claim() const;
|
|
private:
|
|
bool _internal_has_claim() const;
|
|
public:
|
|
void clear_claim();
|
|
const ::pb::ClaimMeta& claim() const;
|
|
::pb::ClaimMeta* release_claim();
|
|
::pb::ClaimMeta* mutable_claim();
|
|
void set_allocated_claim(::pb::ClaimMeta* claim);
|
|
private:
|
|
const ::pb::ClaimMeta& _internal_claim() const;
|
|
::pb::ClaimMeta* _internal_mutable_claim();
|
|
public:
|
|
void unsafe_arena_set_allocated_claim(
|
|
::pb::ClaimMeta* claim);
|
|
::pb::ClaimMeta* unsafe_arena_release_claim();
|
|
|
|
// .pb.Error error = 15;
|
|
bool has_error() const;
|
|
private:
|
|
bool _internal_has_error() const;
|
|
public:
|
|
void clear_error();
|
|
const ::pb::Error& error() const;
|
|
::pb::Error* release_error();
|
|
::pb::Error* mutable_error();
|
|
void set_allocated_error(::pb::Error* error);
|
|
private:
|
|
const ::pb::Error& _internal_error() const;
|
|
::pb::Error* _internal_mutable_error();
|
|
public:
|
|
void unsafe_arena_set_allocated_error(
|
|
::pb::Error* error);
|
|
::pb::Error* unsafe_arena_release_error();
|
|
|
|
void clear_meta();
|
|
MetaCase meta_case() const;
|
|
// @@protoc_insertion_point(class_scope:pb.Output)
|
|
private:
|
|
class _Internal;
|
|
void set_has_claim();
|
|
void set_has_error();
|
|
|
|
inline bool has_meta() const;
|
|
inline void clear_has_meta();
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tx_hash_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 nout_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 height_;
|
|
union MetaUnion {
|
|
MetaUnion() {}
|
|
::pb::ClaimMeta* claim_;
|
|
::pb::Error* error_;
|
|
} meta_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
|
|
|
|
friend struct ::TableStruct_result_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class ClaimMeta PROTOBUF_FINAL :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.ClaimMeta) */ {
|
|
public:
|
|
inline ClaimMeta() : ClaimMeta(nullptr) {};
|
|
virtual ~ClaimMeta();
|
|
|
|
ClaimMeta(const ClaimMeta& from);
|
|
ClaimMeta(ClaimMeta&& from) noexcept
|
|
: ClaimMeta() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline ClaimMeta& operator=(const ClaimMeta& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline ClaimMeta& operator=(ClaimMeta&& from) noexcept {
|
|
if (GetArena() == from.GetArena()) {
|
|
if (this != &from) InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return GetMetadataStatic().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return GetMetadataStatic().reflection;
|
|
}
|
|
static const ClaimMeta& default_instance();
|
|
|
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
|
static inline const ClaimMeta* internal_default_instance() {
|
|
return reinterpret_cast<const ClaimMeta*>(
|
|
&_ClaimMeta_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
2;
|
|
|
|
friend void swap(ClaimMeta& a, ClaimMeta& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(ClaimMeta* other) {
|
|
if (other == this) return;
|
|
if (GetArena() == other->GetArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(ClaimMeta* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetArena() == other->GetArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline ClaimMeta* New() const final {
|
|
return CreateMaybeMessage<ClaimMeta>(nullptr);
|
|
}
|
|
|
|
ClaimMeta* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<ClaimMeta>(arena);
|
|
}
|
|
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void CopyFrom(const ClaimMeta& from);
|
|
void MergeFrom(const ClaimMeta& from);
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
inline void SharedCtor();
|
|
inline void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(ClaimMeta* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "pb.ClaimMeta";
|
|
}
|
|
protected:
|
|
explicit ClaimMeta(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
private:
|
|
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_result_2eproto);
|
|
return ::descriptor_table_result_2eproto.file_level_metadata[kIndexInFileMessages];
|
|
}
|
|
|
|
public:
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kShortUrlFieldNumber = 3,
|
|
kCanonicalUrlFieldNumber = 4,
|
|
kChannelFieldNumber = 1,
|
|
kRepostFieldNumber = 2,
|
|
kIsControllingFieldNumber = 5,
|
|
kTakeOverHeightFieldNumber = 6,
|
|
kCreationHeightFieldNumber = 7,
|
|
kActivationHeightFieldNumber = 8,
|
|
kExpirationHeightFieldNumber = 9,
|
|
kClaimsInChannelFieldNumber = 10,
|
|
kRepostedFieldNumber = 11,
|
|
kTrendingGroupFieldNumber = 22,
|
|
kTrendingGlobalFieldNumber = 25,
|
|
kEffectiveAmountFieldNumber = 20,
|
|
kSupportAmountFieldNumber = 21,
|
|
kTrendingMixedFieldNumber = 23,
|
|
kTrendingLocalFieldNumber = 24,
|
|
};
|
|
// string short_url = 3;
|
|
void clear_short_url();
|
|
const std::string& short_url() const;
|
|
void set_short_url(const std::string& value);
|
|
void set_short_url(std::string&& value);
|
|
void set_short_url(const char* value);
|
|
void set_short_url(const char* value, size_t size);
|
|
std::string* mutable_short_url();
|
|
std::string* release_short_url();
|
|
void set_allocated_short_url(std::string* short_url);
|
|
GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
|
|
" string fields are deprecated and will be removed in a"
|
|
" future release.")
|
|
std::string* unsafe_arena_release_short_url();
|
|
GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
|
|
" string fields are deprecated and will be removed in a"
|
|
" future release.")
|
|
void unsafe_arena_set_allocated_short_url(
|
|
std::string* short_url);
|
|
private:
|
|
const std::string& _internal_short_url() const;
|
|
void _internal_set_short_url(const std::string& value);
|
|
std::string* _internal_mutable_short_url();
|
|
public:
|
|
|
|
// string canonical_url = 4;
|
|
void clear_canonical_url();
|
|
const std::string& canonical_url() const;
|
|
void set_canonical_url(const std::string& value);
|
|
void set_canonical_url(std::string&& value);
|
|
void set_canonical_url(const char* value);
|
|
void set_canonical_url(const char* value, size_t size);
|
|
std::string* mutable_canonical_url();
|
|
std::string* release_canonical_url();
|
|
void set_allocated_canonical_url(std::string* canonical_url);
|
|
GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
|
|
" string fields are deprecated and will be removed in a"
|
|
" future release.")
|
|
std::string* unsafe_arena_release_canonical_url();
|
|
GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
|
|
" string fields are deprecated and will be removed in a"
|
|
" future release.")
|
|
void unsafe_arena_set_allocated_canonical_url(
|
|
std::string* canonical_url);
|
|
private:
|
|
const std::string& _internal_canonical_url() const;
|
|
void _internal_set_canonical_url(const std::string& value);
|
|
std::string* _internal_mutable_canonical_url();
|
|
public:
|
|
|
|
// .pb.Output channel = 1;
|
|
bool has_channel() const;
|
|
private:
|
|
bool _internal_has_channel() const;
|
|
public:
|
|
void clear_channel();
|
|
const ::pb::Output& channel() const;
|
|
::pb::Output* release_channel();
|
|
::pb::Output* mutable_channel();
|
|
void set_allocated_channel(::pb::Output* channel);
|
|
private:
|
|
const ::pb::Output& _internal_channel() const;
|
|
::pb::Output* _internal_mutable_channel();
|
|
public:
|
|
void unsafe_arena_set_allocated_channel(
|
|
::pb::Output* channel);
|
|
::pb::Output* unsafe_arena_release_channel();
|
|
|
|
// .pb.Output repost = 2;
|
|
bool has_repost() const;
|
|
private:
|
|
bool _internal_has_repost() const;
|
|
public:
|
|
void clear_repost();
|
|
const ::pb::Output& repost() const;
|
|
::pb::Output* release_repost();
|
|
::pb::Output* mutable_repost();
|
|
void set_allocated_repost(::pb::Output* repost);
|
|
private:
|
|
const ::pb::Output& _internal_repost() const;
|
|
::pb::Output* _internal_mutable_repost();
|
|
public:
|
|
void unsafe_arena_set_allocated_repost(
|
|
::pb::Output* repost);
|
|
::pb::Output* unsafe_arena_release_repost();
|
|
|
|
// bool is_controlling = 5;
|
|
void clear_is_controlling();
|
|
bool is_controlling() const;
|
|
void set_is_controlling(bool value);
|
|
private:
|
|
bool _internal_is_controlling() const;
|
|
void _internal_set_is_controlling(bool value);
|
|
public:
|
|
|
|
// uint32 take_over_height = 6;
|
|
void clear_take_over_height();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 take_over_height() const;
|
|
void set_take_over_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_take_over_height() const;
|
|
void _internal_set_take_over_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 creation_height = 7;
|
|
void clear_creation_height();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 creation_height() const;
|
|
void set_creation_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_height() const;
|
|
void _internal_set_creation_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 activation_height = 8;
|
|
void clear_activation_height();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 activation_height() const;
|
|
void set_activation_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_activation_height() const;
|
|
void _internal_set_activation_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 expiration_height = 9;
|
|
void clear_expiration_height();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 expiration_height() const;
|
|
void set_expiration_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_expiration_height() const;
|
|
void _internal_set_expiration_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 claims_in_channel = 10;
|
|
void clear_claims_in_channel();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 claims_in_channel() const;
|
|
void set_claims_in_channel(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_claims_in_channel() const;
|
|
void _internal_set_claims_in_channel(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 reposted = 11;
|
|
void clear_reposted();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 reposted() const;
|
|
void set_reposted(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_reposted() const;
|
|
void _internal_set_reposted(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// uint32 trending_group = 22;
|
|
void clear_trending_group();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 trending_group() const;
|
|
void set_trending_group(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_trending_group() const;
|
|
void _internal_set_trending_group(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// float trending_global = 25;
|
|
void clear_trending_global();
|
|
float trending_global() const;
|
|
void set_trending_global(float value);
|
|
private:
|
|
float _internal_trending_global() const;
|
|
void _internal_set_trending_global(float value);
|
|
public:
|
|
|
|
// uint64 effective_amount = 20;
|
|
void clear_effective_amount();
|
|
::PROTOBUF_NAMESPACE_ID::uint64 effective_amount() const;
|
|
void set_effective_amount(::PROTOBUF_NAMESPACE_ID::uint64 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint64 _internal_effective_amount() const;
|
|
void _internal_set_effective_amount(::PROTOBUF_NAMESPACE_ID::uint64 value);
|
|
public:
|
|
|
|
// uint64 support_amount = 21;
|
|
void clear_support_amount();
|
|
::PROTOBUF_NAMESPACE_ID::uint64 support_amount() const;
|
|
void set_support_amount(::PROTOBUF_NAMESPACE_ID::uint64 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint64 _internal_support_amount() const;
|
|
void _internal_set_support_amount(::PROTOBUF_NAMESPACE_ID::uint64 value);
|
|
public:
|
|
|
|
// float trending_mixed = 23;
|
|
void clear_trending_mixed();
|
|
float trending_mixed() const;
|
|
void set_trending_mixed(float value);
|
|
private:
|
|
float _internal_trending_mixed() const;
|
|
void _internal_set_trending_mixed(float value);
|
|
public:
|
|
|
|
// float trending_local = 24;
|
|
void clear_trending_local();
|
|
float trending_local() const;
|
|
void set_trending_local(float value);
|
|
private:
|
|
float _internal_trending_local() const;
|
|
void _internal_set_trending_local(float value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:pb.ClaimMeta)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr short_url_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonical_url_;
|
|
::pb::Output* channel_;
|
|
::pb::Output* repost_;
|
|
bool is_controlling_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 take_over_height_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 creation_height_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 activation_height_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 expiration_height_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 claims_in_channel_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 reposted_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 trending_group_;
|
|
float trending_global_;
|
|
::PROTOBUF_NAMESPACE_ID::uint64 effective_amount_;
|
|
::PROTOBUF_NAMESPACE_ID::uint64 support_amount_;
|
|
float trending_mixed_;
|
|
float trending_local_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
friend struct ::TableStruct_result_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Error PROTOBUF_FINAL :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.Error) */ {
|
|
public:
|
|
inline Error() : Error(nullptr) {};
|
|
virtual ~Error();
|
|
|
|
Error(const Error& from);
|
|
Error(Error&& from) noexcept
|
|
: Error() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Error& operator=(const Error& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Error& operator=(Error&& from) noexcept {
|
|
if (GetArena() == from.GetArena()) {
|
|
if (this != &from) InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return GetMetadataStatic().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return GetMetadataStatic().reflection;
|
|
}
|
|
static const Error& default_instance();
|
|
|
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
|
static inline const Error* internal_default_instance() {
|
|
return reinterpret_cast<const Error*>(
|
|
&_Error_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
3;
|
|
|
|
friend void swap(Error& a, Error& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Error* other) {
|
|
if (other == this) return;
|
|
if (GetArena() == other->GetArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Error* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetArena() == other->GetArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Error* New() const final {
|
|
return CreateMaybeMessage<Error>(nullptr);
|
|
}
|
|
|
|
Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<Error>(arena);
|
|
}
|
|
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void CopyFrom(const Error& from);
|
|
void MergeFrom(const Error& from);
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
inline void SharedCtor();
|
|
inline void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(Error* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "pb.Error";
|
|
}
|
|
protected:
|
|
explicit Error(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
private:
|
|
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_result_2eproto);
|
|
return ::descriptor_table_result_2eproto.file_level_metadata[kIndexInFileMessages];
|
|
}
|
|
|
|
public:
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
typedef Error_Code Code;
|
|
static constexpr Code UNKNOWN_CODE =
|
|
Error_Code_UNKNOWN_CODE;
|
|
static constexpr Code NOT_FOUND =
|
|
Error_Code_NOT_FOUND;
|
|
static constexpr Code INVALID =
|
|
Error_Code_INVALID;
|
|
static constexpr Code BLOCKED =
|
|
Error_Code_BLOCKED;
|
|
static inline bool Code_IsValid(int value) {
|
|
return Error_Code_IsValid(value);
|
|
}
|
|
static constexpr Code Code_MIN =
|
|
Error_Code_Code_MIN;
|
|
static constexpr Code Code_MAX =
|
|
Error_Code_Code_MAX;
|
|
static constexpr int Code_ARRAYSIZE =
|
|
Error_Code_Code_ARRAYSIZE;
|
|
static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
|
|
Code_descriptor() {
|
|
return Error_Code_descriptor();
|
|
}
|
|
template<typename T>
|
|
static inline const std::string& Code_Name(T enum_t_value) {
|
|
static_assert(::std::is_same<T, Code>::value ||
|
|
::std::is_integral<T>::value,
|
|
"Incorrect type passed to function Code_Name.");
|
|
return Error_Code_Name(enum_t_value);
|
|
}
|
|
static inline bool Code_Parse(const std::string& name,
|
|
Code* value) {
|
|
return Error_Code_Parse(name, value);
|
|
}
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kTextFieldNumber = 2,
|
|
kBlockedFieldNumber = 3,
|
|
kCodeFieldNumber = 1,
|
|
};
|
|
// string text = 2;
|
|
void clear_text();
|
|
const std::string& text() const;
|
|
void set_text(const std::string& value);
|
|
void set_text(std::string&& value);
|
|
void set_text(const char* value);
|
|
void set_text(const char* value, size_t size);
|
|
std::string* mutable_text();
|
|
std::string* release_text();
|
|
void set_allocated_text(std::string* text);
|
|
GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
|
|
" string fields are deprecated and will be removed in a"
|
|
" future release.")
|
|
std::string* unsafe_arena_release_text();
|
|
GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
|
|
" string fields are deprecated and will be removed in a"
|
|
" future release.")
|
|
void unsafe_arena_set_allocated_text(
|
|
std::string* text);
|
|
private:
|
|
const std::string& _internal_text() const;
|
|
void _internal_set_text(const std::string& value);
|
|
std::string* _internal_mutable_text();
|
|
public:
|
|
|
|
// .pb.Blocked blocked = 3;
|
|
bool has_blocked() const;
|
|
private:
|
|
bool _internal_has_blocked() const;
|
|
public:
|
|
void clear_blocked();
|
|
const ::pb::Blocked& blocked() const;
|
|
::pb::Blocked* release_blocked();
|
|
::pb::Blocked* mutable_blocked();
|
|
void set_allocated_blocked(::pb::Blocked* blocked);
|
|
private:
|
|
const ::pb::Blocked& _internal_blocked() const;
|
|
::pb::Blocked* _internal_mutable_blocked();
|
|
public:
|
|
void unsafe_arena_set_allocated_blocked(
|
|
::pb::Blocked* blocked);
|
|
::pb::Blocked* unsafe_arena_release_blocked();
|
|
|
|
// .pb.Error.Code code = 1;
|
|
void clear_code();
|
|
::pb::Error_Code code() const;
|
|
void set_code(::pb::Error_Code value);
|
|
private:
|
|
::pb::Error_Code _internal_code() const;
|
|
void _internal_set_code(::pb::Error_Code value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:pb.Error)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
|
|
::pb::Blocked* blocked_;
|
|
int code_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
friend struct ::TableStruct_result_2eproto;
|
|
};
|
|
// -------------------------------------------------------------------
|
|
|
|
class Blocked PROTOBUF_FINAL :
|
|
public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.Blocked) */ {
|
|
public:
|
|
inline Blocked() : Blocked(nullptr) {};
|
|
virtual ~Blocked();
|
|
|
|
Blocked(const Blocked& from);
|
|
Blocked(Blocked&& from) noexcept
|
|
: Blocked() {
|
|
*this = ::std::move(from);
|
|
}
|
|
|
|
inline Blocked& operator=(const Blocked& from) {
|
|
CopyFrom(from);
|
|
return *this;
|
|
}
|
|
inline Blocked& operator=(Blocked&& from) noexcept {
|
|
if (GetArena() == from.GetArena()) {
|
|
if (this != &from) InternalSwap(&from);
|
|
} else {
|
|
CopyFrom(from);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
|
|
return GetDescriptor();
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
|
|
return GetMetadataStatic().descriptor;
|
|
}
|
|
static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
|
|
return GetMetadataStatic().reflection;
|
|
}
|
|
static const Blocked& default_instance();
|
|
|
|
static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
|
|
static inline const Blocked* internal_default_instance() {
|
|
return reinterpret_cast<const Blocked*>(
|
|
&_Blocked_default_instance_);
|
|
}
|
|
static constexpr int kIndexInFileMessages =
|
|
4;
|
|
|
|
friend void swap(Blocked& a, Blocked& b) {
|
|
a.Swap(&b);
|
|
}
|
|
inline void Swap(Blocked* other) {
|
|
if (other == this) return;
|
|
if (GetArena() == other->GetArena()) {
|
|
InternalSwap(other);
|
|
} else {
|
|
::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
|
|
}
|
|
}
|
|
void UnsafeArenaSwap(Blocked* other) {
|
|
if (other == this) return;
|
|
GOOGLE_DCHECK(GetArena() == other->GetArena());
|
|
InternalSwap(other);
|
|
}
|
|
|
|
// implements Message ----------------------------------------------
|
|
|
|
inline Blocked* New() const final {
|
|
return CreateMaybeMessage<Blocked>(nullptr);
|
|
}
|
|
|
|
Blocked* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
|
|
return CreateMaybeMessage<Blocked>(arena);
|
|
}
|
|
void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
|
|
void CopyFrom(const Blocked& from);
|
|
void MergeFrom(const Blocked& from);
|
|
PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
|
|
bool IsInitialized() const final;
|
|
|
|
size_t ByteSizeLong() const final;
|
|
const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
|
|
::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
|
|
::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
|
|
int GetCachedSize() const final { return _cached_size_.Get(); }
|
|
|
|
private:
|
|
inline void SharedCtor();
|
|
inline void SharedDtor();
|
|
void SetCachedSize(int size) const final;
|
|
void InternalSwap(Blocked* other);
|
|
friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
|
|
static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
|
|
return "pb.Blocked";
|
|
}
|
|
protected:
|
|
explicit Blocked(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
private:
|
|
static void ArenaDtor(void* object);
|
|
inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
|
|
public:
|
|
|
|
::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
|
|
private:
|
|
static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
|
|
::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_result_2eproto);
|
|
return ::descriptor_table_result_2eproto.file_level_metadata[kIndexInFileMessages];
|
|
}
|
|
|
|
public:
|
|
|
|
// nested types ----------------------------------------------------
|
|
|
|
// accessors -------------------------------------------------------
|
|
|
|
enum : int {
|
|
kChannelFieldNumber = 2,
|
|
kCountFieldNumber = 1,
|
|
};
|
|
// .pb.Output channel = 2;
|
|
bool has_channel() const;
|
|
private:
|
|
bool _internal_has_channel() const;
|
|
public:
|
|
void clear_channel();
|
|
const ::pb::Output& channel() const;
|
|
::pb::Output* release_channel();
|
|
::pb::Output* mutable_channel();
|
|
void set_allocated_channel(::pb::Output* channel);
|
|
private:
|
|
const ::pb::Output& _internal_channel() const;
|
|
::pb::Output* _internal_mutable_channel();
|
|
public:
|
|
void unsafe_arena_set_allocated_channel(
|
|
::pb::Output* channel);
|
|
::pb::Output* unsafe_arena_release_channel();
|
|
|
|
// uint32 count = 1;
|
|
void clear_count();
|
|
::PROTOBUF_NAMESPACE_ID::uint32 count() const;
|
|
void set_count(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
private:
|
|
::PROTOBUF_NAMESPACE_ID::uint32 _internal_count() const;
|
|
void _internal_set_count(::PROTOBUF_NAMESPACE_ID::uint32 value);
|
|
public:
|
|
|
|
// @@protoc_insertion_point(class_scope:pb.Blocked)
|
|
private:
|
|
class _Internal;
|
|
|
|
template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
|
|
typedef void InternalArenaConstructable_;
|
|
typedef void DestructorSkippable_;
|
|
::pb::Output* channel_;
|
|
::PROTOBUF_NAMESPACE_ID::uint32 count_;
|
|
mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
|
|
friend struct ::TableStruct_result_2eproto;
|
|
};
|
|
// ===================================================================
|
|
|
|
|
|
// ===================================================================
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
|
|
#endif // __GNUC__
|
|
// Outputs
|
|
|
|
// repeated .pb.Output txos = 1;
|
|
inline int Outputs::_internal_txos_size() const {
|
|
return txos_.size();
|
|
}
|
|
inline int Outputs::txos_size() const {
|
|
return _internal_txos_size();
|
|
}
|
|
inline void Outputs::clear_txos() {
|
|
txos_.Clear();
|
|
}
|
|
inline ::pb::Output* Outputs::mutable_txos(int index) {
|
|
// @@protoc_insertion_point(field_mutable:pb.Outputs.txos)
|
|
return txos_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >*
|
|
Outputs::mutable_txos() {
|
|
// @@protoc_insertion_point(field_mutable_list:pb.Outputs.txos)
|
|
return &txos_;
|
|
}
|
|
inline const ::pb::Output& Outputs::_internal_txos(int index) const {
|
|
return txos_.Get(index);
|
|
}
|
|
inline const ::pb::Output& Outputs::txos(int index) const {
|
|
// @@protoc_insertion_point(field_get:pb.Outputs.txos)
|
|
return _internal_txos(index);
|
|
}
|
|
inline ::pb::Output* Outputs::_internal_add_txos() {
|
|
return txos_.Add();
|
|
}
|
|
inline ::pb::Output* Outputs::add_txos() {
|
|
// @@protoc_insertion_point(field_add:pb.Outputs.txos)
|
|
return _internal_add_txos();
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >&
|
|
Outputs::txos() const {
|
|
// @@protoc_insertion_point(field_list:pb.Outputs.txos)
|
|
return txos_;
|
|
}
|
|
|
|
// repeated .pb.Output extra_txos = 2;
|
|
inline int Outputs::_internal_extra_txos_size() const {
|
|
return extra_txos_.size();
|
|
}
|
|
inline int Outputs::extra_txos_size() const {
|
|
return _internal_extra_txos_size();
|
|
}
|
|
inline void Outputs::clear_extra_txos() {
|
|
extra_txos_.Clear();
|
|
}
|
|
inline ::pb::Output* Outputs::mutable_extra_txos(int index) {
|
|
// @@protoc_insertion_point(field_mutable:pb.Outputs.extra_txos)
|
|
return extra_txos_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >*
|
|
Outputs::mutable_extra_txos() {
|
|
// @@protoc_insertion_point(field_mutable_list:pb.Outputs.extra_txos)
|
|
return &extra_txos_;
|
|
}
|
|
inline const ::pb::Output& Outputs::_internal_extra_txos(int index) const {
|
|
return extra_txos_.Get(index);
|
|
}
|
|
inline const ::pb::Output& Outputs::extra_txos(int index) const {
|
|
// @@protoc_insertion_point(field_get:pb.Outputs.extra_txos)
|
|
return _internal_extra_txos(index);
|
|
}
|
|
inline ::pb::Output* Outputs::_internal_add_extra_txos() {
|
|
return extra_txos_.Add();
|
|
}
|
|
inline ::pb::Output* Outputs::add_extra_txos() {
|
|
// @@protoc_insertion_point(field_add:pb.Outputs.extra_txos)
|
|
return _internal_add_extra_txos();
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >&
|
|
Outputs::extra_txos() const {
|
|
// @@protoc_insertion_point(field_list:pb.Outputs.extra_txos)
|
|
return extra_txos_;
|
|
}
|
|
|
|
// uint32 total = 3;
|
|
inline void Outputs::clear_total() {
|
|
total_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::_internal_total() const {
|
|
return total_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::total() const {
|
|
// @@protoc_insertion_point(field_get:pb.Outputs.total)
|
|
return _internal_total();
|
|
}
|
|
inline void Outputs::_internal_set_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
total_ = value;
|
|
}
|
|
inline void Outputs::set_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_total(value);
|
|
// @@protoc_insertion_point(field_set:pb.Outputs.total)
|
|
}
|
|
|
|
// uint32 offset = 4;
|
|
inline void Outputs::clear_offset() {
|
|
offset_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::_internal_offset() const {
|
|
return offset_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::offset() const {
|
|
// @@protoc_insertion_point(field_get:pb.Outputs.offset)
|
|
return _internal_offset();
|
|
}
|
|
inline void Outputs::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
offset_ = value;
|
|
}
|
|
inline void Outputs::set_offset(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_offset(value);
|
|
// @@protoc_insertion_point(field_set:pb.Outputs.offset)
|
|
}
|
|
|
|
// repeated .pb.Blocked blocked = 5;
|
|
inline int Outputs::_internal_blocked_size() const {
|
|
return blocked_.size();
|
|
}
|
|
inline int Outputs::blocked_size() const {
|
|
return _internal_blocked_size();
|
|
}
|
|
inline void Outputs::clear_blocked() {
|
|
blocked_.Clear();
|
|
}
|
|
inline ::pb::Blocked* Outputs::mutable_blocked(int index) {
|
|
// @@protoc_insertion_point(field_mutable:pb.Outputs.blocked)
|
|
return blocked_.Mutable(index);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked >*
|
|
Outputs::mutable_blocked() {
|
|
// @@protoc_insertion_point(field_mutable_list:pb.Outputs.blocked)
|
|
return &blocked_;
|
|
}
|
|
inline const ::pb::Blocked& Outputs::_internal_blocked(int index) const {
|
|
return blocked_.Get(index);
|
|
}
|
|
inline const ::pb::Blocked& Outputs::blocked(int index) const {
|
|
// @@protoc_insertion_point(field_get:pb.Outputs.blocked)
|
|
return _internal_blocked(index);
|
|
}
|
|
inline ::pb::Blocked* Outputs::_internal_add_blocked() {
|
|
return blocked_.Add();
|
|
}
|
|
inline ::pb::Blocked* Outputs::add_blocked() {
|
|
// @@protoc_insertion_point(field_add:pb.Outputs.blocked)
|
|
return _internal_add_blocked();
|
|
}
|
|
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked >&
|
|
Outputs::blocked() const {
|
|
// @@protoc_insertion_point(field_list:pb.Outputs.blocked)
|
|
return blocked_;
|
|
}
|
|
|
|
// uint32 blocked_total = 6;
|
|
inline void Outputs::clear_blocked_total() {
|
|
blocked_total_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::_internal_blocked_total() const {
|
|
return blocked_total_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::blocked_total() const {
|
|
// @@protoc_insertion_point(field_get:pb.Outputs.blocked_total)
|
|
return _internal_blocked_total();
|
|
}
|
|
inline void Outputs::_internal_set_blocked_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
blocked_total_ = value;
|
|
}
|
|
inline void Outputs::set_blocked_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_blocked_total(value);
|
|
// @@protoc_insertion_point(field_set:pb.Outputs.blocked_total)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Output
|
|
|
|
// bytes tx_hash = 1;
|
|
inline void Output::clear_tx_hash() {
|
|
tx_hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline const std::string& Output::tx_hash() const {
|
|
// @@protoc_insertion_point(field_get:pb.Output.tx_hash)
|
|
return _internal_tx_hash();
|
|
}
|
|
inline void Output::set_tx_hash(const std::string& value) {
|
|
_internal_set_tx_hash(value);
|
|
// @@protoc_insertion_point(field_set:pb.Output.tx_hash)
|
|
}
|
|
inline std::string* Output::mutable_tx_hash() {
|
|
// @@protoc_insertion_point(field_mutable:pb.Output.tx_hash)
|
|
return _internal_mutable_tx_hash();
|
|
}
|
|
inline const std::string& Output::_internal_tx_hash() const {
|
|
return tx_hash_.Get();
|
|
}
|
|
inline void Output::_internal_set_tx_hash(const std::string& value) {
|
|
|
|
tx_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
|
|
}
|
|
inline void Output::set_tx_hash(std::string&& value) {
|
|
|
|
tx_hash_.Set(
|
|
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
|
|
// @@protoc_insertion_point(field_set_rvalue:pb.Output.tx_hash)
|
|
}
|
|
inline void Output::set_tx_hash(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
|
|
tx_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
|
|
GetArena());
|
|
// @@protoc_insertion_point(field_set_char:pb.Output.tx_hash)
|
|
}
|
|
inline void Output::set_tx_hash(const void* value,
|
|
size_t size) {
|
|
|
|
tx_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
|
|
reinterpret_cast<const char*>(value), size), GetArena());
|
|
// @@protoc_insertion_point(field_set_pointer:pb.Output.tx_hash)
|
|
}
|
|
inline std::string* Output::_internal_mutable_tx_hash() {
|
|
|
|
return tx_hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline std::string* Output::release_tx_hash() {
|
|
// @@protoc_insertion_point(field_release:pb.Output.tx_hash)
|
|
return tx_hash_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline void Output::set_allocated_tx_hash(std::string* tx_hash) {
|
|
if (tx_hash != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
tx_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tx_hash,
|
|
GetArena());
|
|
// @@protoc_insertion_point(field_set_allocated:pb.Output.tx_hash)
|
|
}
|
|
inline std::string* Output::unsafe_arena_release_tx_hash() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:pb.Output.tx_hash)
|
|
GOOGLE_DCHECK(GetArena() != nullptr);
|
|
|
|
return tx_hash_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArena());
|
|
}
|
|
inline void Output::unsafe_arena_set_allocated_tx_hash(
|
|
std::string* tx_hash) {
|
|
GOOGLE_DCHECK(GetArena() != nullptr);
|
|
if (tx_hash != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
tx_hash_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
tx_hash, GetArena());
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Output.tx_hash)
|
|
}
|
|
|
|
// uint32 nout = 2;
|
|
inline void Output::clear_nout() {
|
|
nout_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Output::_internal_nout() const {
|
|
return nout_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Output::nout() const {
|
|
// @@protoc_insertion_point(field_get:pb.Output.nout)
|
|
return _internal_nout();
|
|
}
|
|
inline void Output::_internal_set_nout(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
nout_ = value;
|
|
}
|
|
inline void Output::set_nout(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_nout(value);
|
|
// @@protoc_insertion_point(field_set:pb.Output.nout)
|
|
}
|
|
|
|
// uint32 height = 3;
|
|
inline void Output::clear_height() {
|
|
height_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Output::_internal_height() const {
|
|
return height_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Output::height() const {
|
|
// @@protoc_insertion_point(field_get:pb.Output.height)
|
|
return _internal_height();
|
|
}
|
|
inline void Output::_internal_set_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
height_ = value;
|
|
}
|
|
inline void Output::set_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_height(value);
|
|
// @@protoc_insertion_point(field_set:pb.Output.height)
|
|
}
|
|
|
|
// .pb.ClaimMeta claim = 7;
|
|
inline bool Output::_internal_has_claim() const {
|
|
return meta_case() == kClaim;
|
|
}
|
|
inline bool Output::has_claim() const {
|
|
return _internal_has_claim();
|
|
}
|
|
inline void Output::set_has_claim() {
|
|
_oneof_case_[0] = kClaim;
|
|
}
|
|
inline void Output::clear_claim() {
|
|
if (_internal_has_claim()) {
|
|
if (GetArena() == nullptr) {
|
|
delete meta_.claim_;
|
|
}
|
|
clear_has_meta();
|
|
}
|
|
}
|
|
inline ::pb::ClaimMeta* Output::release_claim() {
|
|
// @@protoc_insertion_point(field_release:pb.Output.claim)
|
|
if (_internal_has_claim()) {
|
|
clear_has_meta();
|
|
::pb::ClaimMeta* temp = meta_.claim_;
|
|
if (GetArena() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
meta_.claim_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::pb::ClaimMeta& Output::_internal_claim() const {
|
|
return _internal_has_claim()
|
|
? *meta_.claim_
|
|
: *reinterpret_cast< ::pb::ClaimMeta*>(&::pb::_ClaimMeta_default_instance_);
|
|
}
|
|
inline const ::pb::ClaimMeta& Output::claim() const {
|
|
// @@protoc_insertion_point(field_get:pb.Output.claim)
|
|
return _internal_claim();
|
|
}
|
|
inline ::pb::ClaimMeta* Output::unsafe_arena_release_claim() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:pb.Output.claim)
|
|
if (_internal_has_claim()) {
|
|
clear_has_meta();
|
|
::pb::ClaimMeta* temp = meta_.claim_;
|
|
meta_.claim_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Output::unsafe_arena_set_allocated_claim(::pb::ClaimMeta* claim) {
|
|
clear_meta();
|
|
if (claim) {
|
|
set_has_claim();
|
|
meta_.claim_ = claim;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Output.claim)
|
|
}
|
|
inline ::pb::ClaimMeta* Output::_internal_mutable_claim() {
|
|
if (!_internal_has_claim()) {
|
|
clear_meta();
|
|
set_has_claim();
|
|
meta_.claim_ = CreateMaybeMessage< ::pb::ClaimMeta >(GetArena());
|
|
}
|
|
return meta_.claim_;
|
|
}
|
|
inline ::pb::ClaimMeta* Output::mutable_claim() {
|
|
// @@protoc_insertion_point(field_mutable:pb.Output.claim)
|
|
return _internal_mutable_claim();
|
|
}
|
|
|
|
// .pb.Error error = 15;
|
|
inline bool Output::_internal_has_error() const {
|
|
return meta_case() == kError;
|
|
}
|
|
inline bool Output::has_error() const {
|
|
return _internal_has_error();
|
|
}
|
|
inline void Output::set_has_error() {
|
|
_oneof_case_[0] = kError;
|
|
}
|
|
inline void Output::clear_error() {
|
|
if (_internal_has_error()) {
|
|
if (GetArena() == nullptr) {
|
|
delete meta_.error_;
|
|
}
|
|
clear_has_meta();
|
|
}
|
|
}
|
|
inline ::pb::Error* Output::release_error() {
|
|
// @@protoc_insertion_point(field_release:pb.Output.error)
|
|
if (_internal_has_error()) {
|
|
clear_has_meta();
|
|
::pb::Error* temp = meta_.error_;
|
|
if (GetArena() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
meta_.error_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline const ::pb::Error& Output::_internal_error() const {
|
|
return _internal_has_error()
|
|
? *meta_.error_
|
|
: *reinterpret_cast< ::pb::Error*>(&::pb::_Error_default_instance_);
|
|
}
|
|
inline const ::pb::Error& Output::error() const {
|
|
// @@protoc_insertion_point(field_get:pb.Output.error)
|
|
return _internal_error();
|
|
}
|
|
inline ::pb::Error* Output::unsafe_arena_release_error() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:pb.Output.error)
|
|
if (_internal_has_error()) {
|
|
clear_has_meta();
|
|
::pb::Error* temp = meta_.error_;
|
|
meta_.error_ = nullptr;
|
|
return temp;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
inline void Output::unsafe_arena_set_allocated_error(::pb::Error* error) {
|
|
clear_meta();
|
|
if (error) {
|
|
set_has_error();
|
|
meta_.error_ = error;
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Output.error)
|
|
}
|
|
inline ::pb::Error* Output::_internal_mutable_error() {
|
|
if (!_internal_has_error()) {
|
|
clear_meta();
|
|
set_has_error();
|
|
meta_.error_ = CreateMaybeMessage< ::pb::Error >(GetArena());
|
|
}
|
|
return meta_.error_;
|
|
}
|
|
inline ::pb::Error* Output::mutable_error() {
|
|
// @@protoc_insertion_point(field_mutable:pb.Output.error)
|
|
return _internal_mutable_error();
|
|
}
|
|
|
|
inline bool Output::has_meta() const {
|
|
return meta_case() != META_NOT_SET;
|
|
}
|
|
inline void Output::clear_has_meta() {
|
|
_oneof_case_[0] = META_NOT_SET;
|
|
}
|
|
inline Output::MetaCase Output::meta_case() const {
|
|
return Output::MetaCase(_oneof_case_[0]);
|
|
}
|
|
// -------------------------------------------------------------------
|
|
|
|
// ClaimMeta
|
|
|
|
// .pb.Output channel = 1;
|
|
inline bool ClaimMeta::_internal_has_channel() const {
|
|
return this != internal_default_instance() && channel_ != nullptr;
|
|
}
|
|
inline bool ClaimMeta::has_channel() const {
|
|
return _internal_has_channel();
|
|
}
|
|
inline void ClaimMeta::clear_channel() {
|
|
if (GetArena() == nullptr && channel_ != nullptr) {
|
|
delete channel_;
|
|
}
|
|
channel_ = nullptr;
|
|
}
|
|
inline const ::pb::Output& ClaimMeta::_internal_channel() const {
|
|
const ::pb::Output* p = channel_;
|
|
return p != nullptr ? *p : *reinterpret_cast<const ::pb::Output*>(
|
|
&::pb::_Output_default_instance_);
|
|
}
|
|
inline const ::pb::Output& ClaimMeta::channel() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.channel)
|
|
return _internal_channel();
|
|
}
|
|
inline void ClaimMeta::unsafe_arena_set_allocated_channel(
|
|
::pb::Output* channel) {
|
|
if (GetArena() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(channel_);
|
|
}
|
|
channel_ = channel;
|
|
if (channel) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.ClaimMeta.channel)
|
|
}
|
|
inline ::pb::Output* ClaimMeta::release_channel() {
|
|
auto temp = unsafe_arena_release_channel();
|
|
if (GetArena() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
return temp;
|
|
}
|
|
inline ::pb::Output* ClaimMeta::unsafe_arena_release_channel() {
|
|
// @@protoc_insertion_point(field_release:pb.ClaimMeta.channel)
|
|
|
|
::pb::Output* temp = channel_;
|
|
channel_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::pb::Output* ClaimMeta::_internal_mutable_channel() {
|
|
|
|
if (channel_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::pb::Output>(GetArena());
|
|
channel_ = p;
|
|
}
|
|
return channel_;
|
|
}
|
|
inline ::pb::Output* ClaimMeta::mutable_channel() {
|
|
// @@protoc_insertion_point(field_mutable:pb.ClaimMeta.channel)
|
|
return _internal_mutable_channel();
|
|
}
|
|
inline void ClaimMeta::set_allocated_channel(::pb::Output* channel) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
|
|
if (message_arena == nullptr) {
|
|
delete channel_;
|
|
}
|
|
if (channel) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(channel);
|
|
if (message_arena != submessage_arena) {
|
|
channel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, channel, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
channel_ = channel;
|
|
// @@protoc_insertion_point(field_set_allocated:pb.ClaimMeta.channel)
|
|
}
|
|
|
|
// .pb.Output repost = 2;
|
|
inline bool ClaimMeta::_internal_has_repost() const {
|
|
return this != internal_default_instance() && repost_ != nullptr;
|
|
}
|
|
inline bool ClaimMeta::has_repost() const {
|
|
return _internal_has_repost();
|
|
}
|
|
inline void ClaimMeta::clear_repost() {
|
|
if (GetArena() == nullptr && repost_ != nullptr) {
|
|
delete repost_;
|
|
}
|
|
repost_ = nullptr;
|
|
}
|
|
inline const ::pb::Output& ClaimMeta::_internal_repost() const {
|
|
const ::pb::Output* p = repost_;
|
|
return p != nullptr ? *p : *reinterpret_cast<const ::pb::Output*>(
|
|
&::pb::_Output_default_instance_);
|
|
}
|
|
inline const ::pb::Output& ClaimMeta::repost() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.repost)
|
|
return _internal_repost();
|
|
}
|
|
inline void ClaimMeta::unsafe_arena_set_allocated_repost(
|
|
::pb::Output* repost) {
|
|
if (GetArena() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(repost_);
|
|
}
|
|
repost_ = repost;
|
|
if (repost) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.ClaimMeta.repost)
|
|
}
|
|
inline ::pb::Output* ClaimMeta::release_repost() {
|
|
auto temp = unsafe_arena_release_repost();
|
|
if (GetArena() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
return temp;
|
|
}
|
|
inline ::pb::Output* ClaimMeta::unsafe_arena_release_repost() {
|
|
// @@protoc_insertion_point(field_release:pb.ClaimMeta.repost)
|
|
|
|
::pb::Output* temp = repost_;
|
|
repost_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::pb::Output* ClaimMeta::_internal_mutable_repost() {
|
|
|
|
if (repost_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::pb::Output>(GetArena());
|
|
repost_ = p;
|
|
}
|
|
return repost_;
|
|
}
|
|
inline ::pb::Output* ClaimMeta::mutable_repost() {
|
|
// @@protoc_insertion_point(field_mutable:pb.ClaimMeta.repost)
|
|
return _internal_mutable_repost();
|
|
}
|
|
inline void ClaimMeta::set_allocated_repost(::pb::Output* repost) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
|
|
if (message_arena == nullptr) {
|
|
delete repost_;
|
|
}
|
|
if (repost) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(repost);
|
|
if (message_arena != submessage_arena) {
|
|
repost = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, repost, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
repost_ = repost;
|
|
// @@protoc_insertion_point(field_set_allocated:pb.ClaimMeta.repost)
|
|
}
|
|
|
|
// string short_url = 3;
|
|
inline void ClaimMeta::clear_short_url() {
|
|
short_url_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline const std::string& ClaimMeta::short_url() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.short_url)
|
|
return _internal_short_url();
|
|
}
|
|
inline void ClaimMeta::set_short_url(const std::string& value) {
|
|
_internal_set_short_url(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.short_url)
|
|
}
|
|
inline std::string* ClaimMeta::mutable_short_url() {
|
|
// @@protoc_insertion_point(field_mutable:pb.ClaimMeta.short_url)
|
|
return _internal_mutable_short_url();
|
|
}
|
|
inline const std::string& ClaimMeta::_internal_short_url() const {
|
|
return short_url_.Get();
|
|
}
|
|
inline void ClaimMeta::_internal_set_short_url(const std::string& value) {
|
|
|
|
short_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
|
|
}
|
|
inline void ClaimMeta::set_short_url(std::string&& value) {
|
|
|
|
short_url_.Set(
|
|
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
|
|
// @@protoc_insertion_point(field_set_rvalue:pb.ClaimMeta.short_url)
|
|
}
|
|
inline void ClaimMeta::set_short_url(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
|
|
short_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
|
|
GetArena());
|
|
// @@protoc_insertion_point(field_set_char:pb.ClaimMeta.short_url)
|
|
}
|
|
inline void ClaimMeta::set_short_url(const char* value,
|
|
size_t size) {
|
|
|
|
short_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
|
|
reinterpret_cast<const char*>(value), size), GetArena());
|
|
// @@protoc_insertion_point(field_set_pointer:pb.ClaimMeta.short_url)
|
|
}
|
|
inline std::string* ClaimMeta::_internal_mutable_short_url() {
|
|
|
|
return short_url_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline std::string* ClaimMeta::release_short_url() {
|
|
// @@protoc_insertion_point(field_release:pb.ClaimMeta.short_url)
|
|
return short_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline void ClaimMeta::set_allocated_short_url(std::string* short_url) {
|
|
if (short_url != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
short_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), short_url,
|
|
GetArena());
|
|
// @@protoc_insertion_point(field_set_allocated:pb.ClaimMeta.short_url)
|
|
}
|
|
inline std::string* ClaimMeta::unsafe_arena_release_short_url() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:pb.ClaimMeta.short_url)
|
|
GOOGLE_DCHECK(GetArena() != nullptr);
|
|
|
|
return short_url_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArena());
|
|
}
|
|
inline void ClaimMeta::unsafe_arena_set_allocated_short_url(
|
|
std::string* short_url) {
|
|
GOOGLE_DCHECK(GetArena() != nullptr);
|
|
if (short_url != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
short_url_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
short_url, GetArena());
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.ClaimMeta.short_url)
|
|
}
|
|
|
|
// string canonical_url = 4;
|
|
inline void ClaimMeta::clear_canonical_url() {
|
|
canonical_url_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline const std::string& ClaimMeta::canonical_url() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.canonical_url)
|
|
return _internal_canonical_url();
|
|
}
|
|
inline void ClaimMeta::set_canonical_url(const std::string& value) {
|
|
_internal_set_canonical_url(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.canonical_url)
|
|
}
|
|
inline std::string* ClaimMeta::mutable_canonical_url() {
|
|
// @@protoc_insertion_point(field_mutable:pb.ClaimMeta.canonical_url)
|
|
return _internal_mutable_canonical_url();
|
|
}
|
|
inline const std::string& ClaimMeta::_internal_canonical_url() const {
|
|
return canonical_url_.Get();
|
|
}
|
|
inline void ClaimMeta::_internal_set_canonical_url(const std::string& value) {
|
|
|
|
canonical_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
|
|
}
|
|
inline void ClaimMeta::set_canonical_url(std::string&& value) {
|
|
|
|
canonical_url_.Set(
|
|
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
|
|
// @@protoc_insertion_point(field_set_rvalue:pb.ClaimMeta.canonical_url)
|
|
}
|
|
inline void ClaimMeta::set_canonical_url(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
|
|
canonical_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
|
|
GetArena());
|
|
// @@protoc_insertion_point(field_set_char:pb.ClaimMeta.canonical_url)
|
|
}
|
|
inline void ClaimMeta::set_canonical_url(const char* value,
|
|
size_t size) {
|
|
|
|
canonical_url_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
|
|
reinterpret_cast<const char*>(value), size), GetArena());
|
|
// @@protoc_insertion_point(field_set_pointer:pb.ClaimMeta.canonical_url)
|
|
}
|
|
inline std::string* ClaimMeta::_internal_mutable_canonical_url() {
|
|
|
|
return canonical_url_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline std::string* ClaimMeta::release_canonical_url() {
|
|
// @@protoc_insertion_point(field_release:pb.ClaimMeta.canonical_url)
|
|
return canonical_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline void ClaimMeta::set_allocated_canonical_url(std::string* canonical_url) {
|
|
if (canonical_url != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
canonical_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), canonical_url,
|
|
GetArena());
|
|
// @@protoc_insertion_point(field_set_allocated:pb.ClaimMeta.canonical_url)
|
|
}
|
|
inline std::string* ClaimMeta::unsafe_arena_release_canonical_url() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:pb.ClaimMeta.canonical_url)
|
|
GOOGLE_DCHECK(GetArena() != nullptr);
|
|
|
|
return canonical_url_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArena());
|
|
}
|
|
inline void ClaimMeta::unsafe_arena_set_allocated_canonical_url(
|
|
std::string* canonical_url) {
|
|
GOOGLE_DCHECK(GetArena() != nullptr);
|
|
if (canonical_url != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
canonical_url_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
canonical_url, GetArena());
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.ClaimMeta.canonical_url)
|
|
}
|
|
|
|
// bool is_controlling = 5;
|
|
inline void ClaimMeta::clear_is_controlling() {
|
|
is_controlling_ = false;
|
|
}
|
|
inline bool ClaimMeta::_internal_is_controlling() const {
|
|
return is_controlling_;
|
|
}
|
|
inline bool ClaimMeta::is_controlling() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.is_controlling)
|
|
return _internal_is_controlling();
|
|
}
|
|
inline void ClaimMeta::_internal_set_is_controlling(bool value) {
|
|
|
|
is_controlling_ = value;
|
|
}
|
|
inline void ClaimMeta::set_is_controlling(bool value) {
|
|
_internal_set_is_controlling(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.is_controlling)
|
|
}
|
|
|
|
// uint32 take_over_height = 6;
|
|
inline void ClaimMeta::clear_take_over_height() {
|
|
take_over_height_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_take_over_height() const {
|
|
return take_over_height_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::take_over_height() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.take_over_height)
|
|
return _internal_take_over_height();
|
|
}
|
|
inline void ClaimMeta::_internal_set_take_over_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
take_over_height_ = value;
|
|
}
|
|
inline void ClaimMeta::set_take_over_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_take_over_height(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.take_over_height)
|
|
}
|
|
|
|
// uint32 creation_height = 7;
|
|
inline void ClaimMeta::clear_creation_height() {
|
|
creation_height_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_creation_height() const {
|
|
return creation_height_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::creation_height() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.creation_height)
|
|
return _internal_creation_height();
|
|
}
|
|
inline void ClaimMeta::_internal_set_creation_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
creation_height_ = value;
|
|
}
|
|
inline void ClaimMeta::set_creation_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_creation_height(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.creation_height)
|
|
}
|
|
|
|
// uint32 activation_height = 8;
|
|
inline void ClaimMeta::clear_activation_height() {
|
|
activation_height_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_activation_height() const {
|
|
return activation_height_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::activation_height() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.activation_height)
|
|
return _internal_activation_height();
|
|
}
|
|
inline void ClaimMeta::_internal_set_activation_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
activation_height_ = value;
|
|
}
|
|
inline void ClaimMeta::set_activation_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_activation_height(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.activation_height)
|
|
}
|
|
|
|
// uint32 expiration_height = 9;
|
|
inline void ClaimMeta::clear_expiration_height() {
|
|
expiration_height_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_expiration_height() const {
|
|
return expiration_height_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::expiration_height() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.expiration_height)
|
|
return _internal_expiration_height();
|
|
}
|
|
inline void ClaimMeta::_internal_set_expiration_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
expiration_height_ = value;
|
|
}
|
|
inline void ClaimMeta::set_expiration_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_expiration_height(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.expiration_height)
|
|
}
|
|
|
|
// uint32 claims_in_channel = 10;
|
|
inline void ClaimMeta::clear_claims_in_channel() {
|
|
claims_in_channel_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_claims_in_channel() const {
|
|
return claims_in_channel_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::claims_in_channel() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.claims_in_channel)
|
|
return _internal_claims_in_channel();
|
|
}
|
|
inline void ClaimMeta::_internal_set_claims_in_channel(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
claims_in_channel_ = value;
|
|
}
|
|
inline void ClaimMeta::set_claims_in_channel(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_claims_in_channel(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.claims_in_channel)
|
|
}
|
|
|
|
// uint32 reposted = 11;
|
|
inline void ClaimMeta::clear_reposted() {
|
|
reposted_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_reposted() const {
|
|
return reposted_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::reposted() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.reposted)
|
|
return _internal_reposted();
|
|
}
|
|
inline void ClaimMeta::_internal_set_reposted(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
reposted_ = value;
|
|
}
|
|
inline void ClaimMeta::set_reposted(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_reposted(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.reposted)
|
|
}
|
|
|
|
// uint64 effective_amount = 20;
|
|
inline void ClaimMeta::clear_effective_amount() {
|
|
effective_amount_ = PROTOBUF_ULONGLONG(0);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint64 ClaimMeta::_internal_effective_amount() const {
|
|
return effective_amount_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint64 ClaimMeta::effective_amount() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.effective_amount)
|
|
return _internal_effective_amount();
|
|
}
|
|
inline void ClaimMeta::_internal_set_effective_amount(::PROTOBUF_NAMESPACE_ID::uint64 value) {
|
|
|
|
effective_amount_ = value;
|
|
}
|
|
inline void ClaimMeta::set_effective_amount(::PROTOBUF_NAMESPACE_ID::uint64 value) {
|
|
_internal_set_effective_amount(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.effective_amount)
|
|
}
|
|
|
|
// uint64 support_amount = 21;
|
|
inline void ClaimMeta::clear_support_amount() {
|
|
support_amount_ = PROTOBUF_ULONGLONG(0);
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint64 ClaimMeta::_internal_support_amount() const {
|
|
return support_amount_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint64 ClaimMeta::support_amount() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.support_amount)
|
|
return _internal_support_amount();
|
|
}
|
|
inline void ClaimMeta::_internal_set_support_amount(::PROTOBUF_NAMESPACE_ID::uint64 value) {
|
|
|
|
support_amount_ = value;
|
|
}
|
|
inline void ClaimMeta::set_support_amount(::PROTOBUF_NAMESPACE_ID::uint64 value) {
|
|
_internal_set_support_amount(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.support_amount)
|
|
}
|
|
|
|
// uint32 trending_group = 22;
|
|
inline void ClaimMeta::clear_trending_group() {
|
|
trending_group_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_trending_group() const {
|
|
return trending_group_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::trending_group() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.trending_group)
|
|
return _internal_trending_group();
|
|
}
|
|
inline void ClaimMeta::_internal_set_trending_group(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
trending_group_ = value;
|
|
}
|
|
inline void ClaimMeta::set_trending_group(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_trending_group(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.trending_group)
|
|
}
|
|
|
|
// float trending_mixed = 23;
|
|
inline void ClaimMeta::clear_trending_mixed() {
|
|
trending_mixed_ = 0;
|
|
}
|
|
inline float ClaimMeta::_internal_trending_mixed() const {
|
|
return trending_mixed_;
|
|
}
|
|
inline float ClaimMeta::trending_mixed() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.trending_mixed)
|
|
return _internal_trending_mixed();
|
|
}
|
|
inline void ClaimMeta::_internal_set_trending_mixed(float value) {
|
|
|
|
trending_mixed_ = value;
|
|
}
|
|
inline void ClaimMeta::set_trending_mixed(float value) {
|
|
_internal_set_trending_mixed(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.trending_mixed)
|
|
}
|
|
|
|
// float trending_local = 24;
|
|
inline void ClaimMeta::clear_trending_local() {
|
|
trending_local_ = 0;
|
|
}
|
|
inline float ClaimMeta::_internal_trending_local() const {
|
|
return trending_local_;
|
|
}
|
|
inline float ClaimMeta::trending_local() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.trending_local)
|
|
return _internal_trending_local();
|
|
}
|
|
inline void ClaimMeta::_internal_set_trending_local(float value) {
|
|
|
|
trending_local_ = value;
|
|
}
|
|
inline void ClaimMeta::set_trending_local(float value) {
|
|
_internal_set_trending_local(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.trending_local)
|
|
}
|
|
|
|
// float trending_global = 25;
|
|
inline void ClaimMeta::clear_trending_global() {
|
|
trending_global_ = 0;
|
|
}
|
|
inline float ClaimMeta::_internal_trending_global() const {
|
|
return trending_global_;
|
|
}
|
|
inline float ClaimMeta::trending_global() const {
|
|
// @@protoc_insertion_point(field_get:pb.ClaimMeta.trending_global)
|
|
return _internal_trending_global();
|
|
}
|
|
inline void ClaimMeta::_internal_set_trending_global(float value) {
|
|
|
|
trending_global_ = value;
|
|
}
|
|
inline void ClaimMeta::set_trending_global(float value) {
|
|
_internal_set_trending_global(value);
|
|
// @@protoc_insertion_point(field_set:pb.ClaimMeta.trending_global)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Error
|
|
|
|
// .pb.Error.Code code = 1;
|
|
inline void Error::clear_code() {
|
|
code_ = 0;
|
|
}
|
|
inline ::pb::Error_Code Error::_internal_code() const {
|
|
return static_cast< ::pb::Error_Code >(code_);
|
|
}
|
|
inline ::pb::Error_Code Error::code() const {
|
|
// @@protoc_insertion_point(field_get:pb.Error.code)
|
|
return _internal_code();
|
|
}
|
|
inline void Error::_internal_set_code(::pb::Error_Code value) {
|
|
|
|
code_ = value;
|
|
}
|
|
inline void Error::set_code(::pb::Error_Code value) {
|
|
_internal_set_code(value);
|
|
// @@protoc_insertion_point(field_set:pb.Error.code)
|
|
}
|
|
|
|
// string text = 2;
|
|
inline void Error::clear_text() {
|
|
text_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline const std::string& Error::text() const {
|
|
// @@protoc_insertion_point(field_get:pb.Error.text)
|
|
return _internal_text();
|
|
}
|
|
inline void Error::set_text(const std::string& value) {
|
|
_internal_set_text(value);
|
|
// @@protoc_insertion_point(field_set:pb.Error.text)
|
|
}
|
|
inline std::string* Error::mutable_text() {
|
|
// @@protoc_insertion_point(field_mutable:pb.Error.text)
|
|
return _internal_mutable_text();
|
|
}
|
|
inline const std::string& Error::_internal_text() const {
|
|
return text_.Get();
|
|
}
|
|
inline void Error::_internal_set_text(const std::string& value) {
|
|
|
|
text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
|
|
}
|
|
inline void Error::set_text(std::string&& value) {
|
|
|
|
text_.Set(
|
|
&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
|
|
// @@protoc_insertion_point(field_set_rvalue:pb.Error.text)
|
|
}
|
|
inline void Error::set_text(const char* value) {
|
|
GOOGLE_DCHECK(value != nullptr);
|
|
|
|
text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
|
|
GetArena());
|
|
// @@protoc_insertion_point(field_set_char:pb.Error.text)
|
|
}
|
|
inline void Error::set_text(const char* value,
|
|
size_t size) {
|
|
|
|
text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
|
|
reinterpret_cast<const char*>(value), size), GetArena());
|
|
// @@protoc_insertion_point(field_set_pointer:pb.Error.text)
|
|
}
|
|
inline std::string* Error::_internal_mutable_text() {
|
|
|
|
return text_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline std::string* Error::release_text() {
|
|
// @@protoc_insertion_point(field_release:pb.Error.text)
|
|
return text_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
|
|
}
|
|
inline void Error::set_allocated_text(std::string* text) {
|
|
if (text != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), text,
|
|
GetArena());
|
|
// @@protoc_insertion_point(field_set_allocated:pb.Error.text)
|
|
}
|
|
inline std::string* Error::unsafe_arena_release_text() {
|
|
// @@protoc_insertion_point(field_unsafe_arena_release:pb.Error.text)
|
|
GOOGLE_DCHECK(GetArena() != nullptr);
|
|
|
|
return text_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
GetArena());
|
|
}
|
|
inline void Error::unsafe_arena_set_allocated_text(
|
|
std::string* text) {
|
|
GOOGLE_DCHECK(GetArena() != nullptr);
|
|
if (text != nullptr) {
|
|
|
|
} else {
|
|
|
|
}
|
|
text_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
|
|
text, GetArena());
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Error.text)
|
|
}
|
|
|
|
// .pb.Blocked blocked = 3;
|
|
inline bool Error::_internal_has_blocked() const {
|
|
return this != internal_default_instance() && blocked_ != nullptr;
|
|
}
|
|
inline bool Error::has_blocked() const {
|
|
return _internal_has_blocked();
|
|
}
|
|
inline void Error::clear_blocked() {
|
|
if (GetArena() == nullptr && blocked_ != nullptr) {
|
|
delete blocked_;
|
|
}
|
|
blocked_ = nullptr;
|
|
}
|
|
inline const ::pb::Blocked& Error::_internal_blocked() const {
|
|
const ::pb::Blocked* p = blocked_;
|
|
return p != nullptr ? *p : *reinterpret_cast<const ::pb::Blocked*>(
|
|
&::pb::_Blocked_default_instance_);
|
|
}
|
|
inline const ::pb::Blocked& Error::blocked() const {
|
|
// @@protoc_insertion_point(field_get:pb.Error.blocked)
|
|
return _internal_blocked();
|
|
}
|
|
inline void Error::unsafe_arena_set_allocated_blocked(
|
|
::pb::Blocked* blocked) {
|
|
if (GetArena() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(blocked_);
|
|
}
|
|
blocked_ = blocked;
|
|
if (blocked) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Error.blocked)
|
|
}
|
|
inline ::pb::Blocked* Error::release_blocked() {
|
|
auto temp = unsafe_arena_release_blocked();
|
|
if (GetArena() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
return temp;
|
|
}
|
|
inline ::pb::Blocked* Error::unsafe_arena_release_blocked() {
|
|
// @@protoc_insertion_point(field_release:pb.Error.blocked)
|
|
|
|
::pb::Blocked* temp = blocked_;
|
|
blocked_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::pb::Blocked* Error::_internal_mutable_blocked() {
|
|
|
|
if (blocked_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::pb::Blocked>(GetArena());
|
|
blocked_ = p;
|
|
}
|
|
return blocked_;
|
|
}
|
|
inline ::pb::Blocked* Error::mutable_blocked() {
|
|
// @@protoc_insertion_point(field_mutable:pb.Error.blocked)
|
|
return _internal_mutable_blocked();
|
|
}
|
|
inline void Error::set_allocated_blocked(::pb::Blocked* blocked) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
|
|
if (message_arena == nullptr) {
|
|
delete blocked_;
|
|
}
|
|
if (blocked) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(blocked);
|
|
if (message_arena != submessage_arena) {
|
|
blocked = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, blocked, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
blocked_ = blocked;
|
|
// @@protoc_insertion_point(field_set_allocated:pb.Error.blocked)
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// Blocked
|
|
|
|
// uint32 count = 1;
|
|
inline void Blocked::clear_count() {
|
|
count_ = 0u;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Blocked::_internal_count() const {
|
|
return count_;
|
|
}
|
|
inline ::PROTOBUF_NAMESPACE_ID::uint32 Blocked::count() const {
|
|
// @@protoc_insertion_point(field_get:pb.Blocked.count)
|
|
return _internal_count();
|
|
}
|
|
inline void Blocked::_internal_set_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
|
|
count_ = value;
|
|
}
|
|
inline void Blocked::set_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
|
|
_internal_set_count(value);
|
|
// @@protoc_insertion_point(field_set:pb.Blocked.count)
|
|
}
|
|
|
|
// .pb.Output channel = 2;
|
|
inline bool Blocked::_internal_has_channel() const {
|
|
return this != internal_default_instance() && channel_ != nullptr;
|
|
}
|
|
inline bool Blocked::has_channel() const {
|
|
return _internal_has_channel();
|
|
}
|
|
inline void Blocked::clear_channel() {
|
|
if (GetArena() == nullptr && channel_ != nullptr) {
|
|
delete channel_;
|
|
}
|
|
channel_ = nullptr;
|
|
}
|
|
inline const ::pb::Output& Blocked::_internal_channel() const {
|
|
const ::pb::Output* p = channel_;
|
|
return p != nullptr ? *p : *reinterpret_cast<const ::pb::Output*>(
|
|
&::pb::_Output_default_instance_);
|
|
}
|
|
inline const ::pb::Output& Blocked::channel() const {
|
|
// @@protoc_insertion_point(field_get:pb.Blocked.channel)
|
|
return _internal_channel();
|
|
}
|
|
inline void Blocked::unsafe_arena_set_allocated_channel(
|
|
::pb::Output* channel) {
|
|
if (GetArena() == nullptr) {
|
|
delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(channel_);
|
|
}
|
|
channel_ = channel;
|
|
if (channel) {
|
|
|
|
} else {
|
|
|
|
}
|
|
// @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Blocked.channel)
|
|
}
|
|
inline ::pb::Output* Blocked::release_channel() {
|
|
auto temp = unsafe_arena_release_channel();
|
|
if (GetArena() != nullptr) {
|
|
temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
|
|
}
|
|
return temp;
|
|
}
|
|
inline ::pb::Output* Blocked::unsafe_arena_release_channel() {
|
|
// @@protoc_insertion_point(field_release:pb.Blocked.channel)
|
|
|
|
::pb::Output* temp = channel_;
|
|
channel_ = nullptr;
|
|
return temp;
|
|
}
|
|
inline ::pb::Output* Blocked::_internal_mutable_channel() {
|
|
|
|
if (channel_ == nullptr) {
|
|
auto* p = CreateMaybeMessage<::pb::Output>(GetArena());
|
|
channel_ = p;
|
|
}
|
|
return channel_;
|
|
}
|
|
inline ::pb::Output* Blocked::mutable_channel() {
|
|
// @@protoc_insertion_point(field_mutable:pb.Blocked.channel)
|
|
return _internal_mutable_channel();
|
|
}
|
|
inline void Blocked::set_allocated_channel(::pb::Output* channel) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
|
|
if (message_arena == nullptr) {
|
|
delete channel_;
|
|
}
|
|
if (channel) {
|
|
::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
|
|
::PROTOBUF_NAMESPACE_ID::Arena::GetArena(channel);
|
|
if (message_arena != submessage_arena) {
|
|
channel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
|
|
message_arena, channel, submessage_arena);
|
|
}
|
|
|
|
} else {
|
|
|
|
}
|
|
channel_ = channel;
|
|
// @@protoc_insertion_point(field_set_allocated:pb.Blocked.channel)
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
#pragma GCC diagnostic pop
|
|
#endif // __GNUC__
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
// -------------------------------------------------------------------
|
|
|
|
|
|
// @@protoc_insertion_point(namespace_scope)
|
|
|
|
} // namespace pb
|
|
|
|
PROTOBUF_NAMESPACE_OPEN
|
|
|
|
template <> struct is_proto_enum< ::pb::Error_Code> : ::std::true_type {};
|
|
template <>
|
|
inline const EnumDescriptor* GetEnumDescriptor< ::pb::Error_Code>() {
|
|
return ::pb::Error_Code_descriptor();
|
|
}
|
|
|
|
PROTOBUF_NAMESPACE_CLOSE
|
|
|
|
// @@protoc_insertion_point(global_scope)
|
|
|
|
#include <google/protobuf/port_undef.inc>
|
|
#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_result_2eproto
|