#![allow(unknown_lints)]
#![allow(clippy::all)]
#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unsafe_code)]
#![allow(unused_imports)]
#![allow(unused_results)]
use protobuf::Message as Message_imported_for_functions;
use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct SignedMessage {
pub payload: ::std::vec::Vec<u8>,
pub author: ::protobuf::SingularPtrField<super::types::PublicKey>,
pub signature: ::protobuf::SingularPtrField<super::types::Signature>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SignedMessage {
fn default() -> &'a SignedMessage {
<SignedMessage as ::protobuf::Message>::default_instance()
}
}
impl SignedMessage {
pub fn new() -> SignedMessage {
::std::default::Default::default()
}
pub fn get_payload(&self) -> &[u8] {
&self.payload
}
pub fn clear_payload(&mut self) {
self.payload.clear();
}
pub fn set_payload(&mut self, v: ::std::vec::Vec<u8>) {
self.payload = v;
}
pub fn mut_payload(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.payload
}
pub fn take_payload(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.payload, ::std::vec::Vec::new())
}
pub fn get_author(&self) -> &super::types::PublicKey {
self.author.as_ref().unwrap_or_else(|| super::types::PublicKey::default_instance())
}
pub fn clear_author(&mut self) {
self.author.clear();
}
pub fn has_author(&self) -> bool {
self.author.is_some()
}
pub fn set_author(&mut self, v: super::types::PublicKey) {
self.author = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_author(&mut self) -> &mut super::types::PublicKey {
if self.author.is_none() {
self.author.set_default();
}
self.author.as_mut().unwrap()
}
pub fn take_author(&mut self) -> super::types::PublicKey {
self.author.take().unwrap_or_else(|| super::types::PublicKey::new())
}
pub fn get_signature(&self) -> &super::types::Signature {
self.signature.as_ref().unwrap_or_else(|| super::types::Signature::default_instance())
}
pub fn clear_signature(&mut self) {
self.signature.clear();
}
pub fn has_signature(&self) -> bool {
self.signature.is_some()
}
pub fn set_signature(&mut self, v: super::types::Signature) {
self.signature = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_signature(&mut self) -> &mut super::types::Signature {
if self.signature.is_none() {
self.signature.set_default();
}
self.signature.as_mut().unwrap()
}
pub fn take_signature(&mut self) -> super::types::Signature {
self.signature.take().unwrap_or_else(|| super::types::Signature::new())
}
}
impl ::protobuf::Message for SignedMessage {
fn is_initialized(&self) -> bool {
for v in &self.author {
if !v.is_initialized() {
return false;
}
};
for v in &self.signature {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.payload)?;
},
2 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.author)?;
},
3 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.signature)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.payload.is_empty() {
my_size += ::protobuf::rt::bytes_size(1, &self.payload);
}
if let Some(ref v) = self.author.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.signature.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.payload.is_empty() {
os.write_bytes(1, &self.payload)?;
}
if let Some(ref v) = self.author.as_ref() {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.signature.as_ref() {
os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> SignedMessage {
SignedMessage::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"payload",
|m: &SignedMessage| { &m.payload },
|m: &mut SignedMessage| { &mut m.payload },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::types::PublicKey>>(
"author",
|m: &SignedMessage| { &m.author },
|m: &mut SignedMessage| { &mut m.author },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::types::Signature>>(
"signature",
|m: &SignedMessage| { &m.signature },
|m: &mut SignedMessage| { &mut m.signature },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SignedMessage>(
"SignedMessage",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static SignedMessage {
static mut instance: ::protobuf::lazy::Lazy<SignedMessage> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(SignedMessage::new)
}
}
}
impl ::protobuf::Clear for SignedMessage {
fn clear(&mut self) {
self.payload.clear();
self.author.clear();
self.signature.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SignedMessage {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SignedMessage {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct CoreMessage {
pub kind: ::std::option::Option<CoreMessage_oneof_kind>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a CoreMessage {
fn default() -> &'a CoreMessage {
<CoreMessage as ::protobuf::Message>::default_instance()
}
}
#[derive(Clone,PartialEq,Debug)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub enum CoreMessage_oneof_kind {
any_tx(super::base::AnyTx),
precommit(Precommit),
}
impl CoreMessage {
pub fn new() -> CoreMessage {
::std::default::Default::default()
}
pub fn get_any_tx(&self) -> &super::base::AnyTx {
match self.kind {
::std::option::Option::Some(CoreMessage_oneof_kind::any_tx(ref v)) => v,
_ => super::base::AnyTx::default_instance(),
}
}
pub fn clear_any_tx(&mut self) {
self.kind = ::std::option::Option::None;
}
pub fn has_any_tx(&self) -> bool {
match self.kind {
::std::option::Option::Some(CoreMessage_oneof_kind::any_tx(..)) => true,
_ => false,
}
}
pub fn set_any_tx(&mut self, v: super::base::AnyTx) {
self.kind = ::std::option::Option::Some(CoreMessage_oneof_kind::any_tx(v))
}
pub fn mut_any_tx(&mut self) -> &mut super::base::AnyTx {
if let ::std::option::Option::Some(CoreMessage_oneof_kind::any_tx(_)) = self.kind {
} else {
self.kind = ::std::option::Option::Some(CoreMessage_oneof_kind::any_tx(super::base::AnyTx::new()));
}
match self.kind {
::std::option::Option::Some(CoreMessage_oneof_kind::any_tx(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_any_tx(&mut self) -> super::base::AnyTx {
if self.has_any_tx() {
match self.kind.take() {
::std::option::Option::Some(CoreMessage_oneof_kind::any_tx(v)) => v,
_ => panic!(),
}
} else {
super::base::AnyTx::new()
}
}
pub fn get_precommit(&self) -> &Precommit {
match self.kind {
::std::option::Option::Some(CoreMessage_oneof_kind::precommit(ref v)) => v,
_ => Precommit::default_instance(),
}
}
pub fn clear_precommit(&mut self) {
self.kind = ::std::option::Option::None;
}
pub fn has_precommit(&self) -> bool {
match self.kind {
::std::option::Option::Some(CoreMessage_oneof_kind::precommit(..)) => true,
_ => false,
}
}
pub fn set_precommit(&mut self, v: Precommit) {
self.kind = ::std::option::Option::Some(CoreMessage_oneof_kind::precommit(v))
}
pub fn mut_precommit(&mut self) -> &mut Precommit {
if let ::std::option::Option::Some(CoreMessage_oneof_kind::precommit(_)) = self.kind {
} else {
self.kind = ::std::option::Option::Some(CoreMessage_oneof_kind::precommit(Precommit::new()));
}
match self.kind {
::std::option::Option::Some(CoreMessage_oneof_kind::precommit(ref mut v)) => v,
_ => panic!(),
}
}
pub fn take_precommit(&mut self) -> Precommit {
if self.has_precommit() {
match self.kind.take() {
::std::option::Option::Some(CoreMessage_oneof_kind::precommit(v)) => v,
_ => panic!(),
}
} else {
Precommit::new()
}
}
}
impl ::protobuf::Message for CoreMessage {
fn is_initialized(&self) -> bool {
if let Some(CoreMessage_oneof_kind::any_tx(ref v)) = self.kind {
if !v.is_initialized() {
return false;
}
}
if let Some(CoreMessage_oneof_kind::precommit(ref v)) = self.kind {
if !v.is_initialized() {
return false;
}
}
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.kind = ::std::option::Option::Some(CoreMessage_oneof_kind::any_tx(is.read_message()?));
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeLengthDelimited {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
self.kind = ::std::option::Option::Some(CoreMessage_oneof_kind::precommit(is.read_message()?));
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if let ::std::option::Option::Some(ref v) = self.kind {
match v {
&CoreMessage_oneof_kind::any_tx(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
&CoreMessage_oneof_kind::precommit(ref v) => {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
},
};
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if let ::std::option::Option::Some(ref v) = self.kind {
match v {
&CoreMessage_oneof_kind::any_tx(ref v) => {
os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
&CoreMessage_oneof_kind::precommit(ref v) => {
os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
},
};
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> CoreMessage {
CoreMessage::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, super::base::AnyTx>(
"any_tx",
CoreMessage::has_any_tx,
CoreMessage::get_any_tx,
));
fields.push(::protobuf::reflect::accessor::make_singular_message_accessor::<_, Precommit>(
"precommit",
CoreMessage::has_precommit,
CoreMessage::get_precommit,
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<CoreMessage>(
"CoreMessage",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static CoreMessage {
static mut instance: ::protobuf::lazy::Lazy<CoreMessage> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(CoreMessage::new)
}
}
}
impl ::protobuf::Clear for CoreMessage {
fn clear(&mut self) {
self.kind = ::std::option::Option::None;
self.kind = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for CoreMessage {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for CoreMessage {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
#[cfg_attr(feature = "with-serde", derive(Serialize, Deserialize))]
pub struct Precommit {
pub validator: u32,
pub epoch: u64,
pub round: u32,
pub propose_hash: ::protobuf::SingularPtrField<super::types::Hash>,
pub block_hash: ::protobuf::SingularPtrField<super::types::Hash>,
pub time: ::protobuf::SingularPtrField<::protobuf::well_known_types::Timestamp>,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub unknown_fields: ::protobuf::UnknownFields,
#[cfg_attr(feature = "with-serde", serde(skip))]
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a Precommit {
fn default() -> &'a Precommit {
<Precommit as ::protobuf::Message>::default_instance()
}
}
impl Precommit {
pub fn new() -> Precommit {
::std::default::Default::default()
}
pub fn get_validator(&self) -> u32 {
self.validator
}
pub fn clear_validator(&mut self) {
self.validator = 0;
}
pub fn set_validator(&mut self, v: u32) {
self.validator = v;
}
pub fn get_epoch(&self) -> u64 {
self.epoch
}
pub fn clear_epoch(&mut self) {
self.epoch = 0;
}
pub fn set_epoch(&mut self, v: u64) {
self.epoch = v;
}
pub fn get_round(&self) -> u32 {
self.round
}
pub fn clear_round(&mut self) {
self.round = 0;
}
pub fn set_round(&mut self, v: u32) {
self.round = v;
}
pub fn get_propose_hash(&self) -> &super::types::Hash {
self.propose_hash.as_ref().unwrap_or_else(|| super::types::Hash::default_instance())
}
pub fn clear_propose_hash(&mut self) {
self.propose_hash.clear();
}
pub fn has_propose_hash(&self) -> bool {
self.propose_hash.is_some()
}
pub fn set_propose_hash(&mut self, v: super::types::Hash) {
self.propose_hash = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_propose_hash(&mut self) -> &mut super::types::Hash {
if self.propose_hash.is_none() {
self.propose_hash.set_default();
}
self.propose_hash.as_mut().unwrap()
}
pub fn take_propose_hash(&mut self) -> super::types::Hash {
self.propose_hash.take().unwrap_or_else(|| super::types::Hash::new())
}
pub fn get_block_hash(&self) -> &super::types::Hash {
self.block_hash.as_ref().unwrap_or_else(|| super::types::Hash::default_instance())
}
pub fn clear_block_hash(&mut self) {
self.block_hash.clear();
}
pub fn has_block_hash(&self) -> bool {
self.block_hash.is_some()
}
pub fn set_block_hash(&mut self, v: super::types::Hash) {
self.block_hash = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_block_hash(&mut self) -> &mut super::types::Hash {
if self.block_hash.is_none() {
self.block_hash.set_default();
}
self.block_hash.as_mut().unwrap()
}
pub fn take_block_hash(&mut self) -> super::types::Hash {
self.block_hash.take().unwrap_or_else(|| super::types::Hash::new())
}
pub fn get_time(&self) -> &::protobuf::well_known_types::Timestamp {
self.time.as_ref().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::default_instance())
}
pub fn clear_time(&mut self) {
self.time.clear();
}
pub fn has_time(&self) -> bool {
self.time.is_some()
}
pub fn set_time(&mut self, v: ::protobuf::well_known_types::Timestamp) {
self.time = ::protobuf::SingularPtrField::some(v);
}
pub fn mut_time(&mut self) -> &mut ::protobuf::well_known_types::Timestamp {
if self.time.is_none() {
self.time.set_default();
}
self.time.as_mut().unwrap()
}
pub fn take_time(&mut self) -> ::protobuf::well_known_types::Timestamp {
self.time.take().unwrap_or_else(|| ::protobuf::well_known_types::Timestamp::new())
}
}
impl ::protobuf::Message for Precommit {
fn is_initialized(&self) -> bool {
for v in &self.propose_hash {
if !v.is_initialized() {
return false;
}
};
for v in &self.block_hash {
if !v.is_initialized() {
return false;
}
};
for v in &self.time {
if !v.is_initialized() {
return false;
}
};
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.validator = tmp;
},
2 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.epoch = tmp;
},
3 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint32()?;
self.round = tmp;
},
4 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.propose_hash)?;
},
5 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.block_hash)?;
},
6 => {
::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.time)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if self.validator != 0 {
my_size += ::protobuf::rt::value_size(1, self.validator, ::protobuf::wire_format::WireTypeVarint);
}
if self.epoch != 0 {
my_size += ::protobuf::rt::value_size(2, self.epoch, ::protobuf::wire_format::WireTypeVarint);
}
if self.round != 0 {
my_size += ::protobuf::rt::value_size(3, self.round, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.propose_hash.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.block_hash.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
if let Some(ref v) = self.time.as_ref() {
let len = v.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if self.validator != 0 {
os.write_uint32(1, self.validator)?;
}
if self.epoch != 0 {
os.write_uint64(2, self.epoch)?;
}
if self.round != 0 {
os.write_uint32(3, self.round)?;
}
if let Some(ref v) = self.propose_hash.as_ref() {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.block_hash.as_ref() {
os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
if let Some(ref v) = self.time.as_ref() {
os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> Precommit {
Precommit::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy::INIT;
unsafe {
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"validator",
|m: &Precommit| { &m.validator },
|m: &mut Precommit| { &mut m.validator },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"epoch",
|m: &Precommit| { &m.epoch },
|m: &mut Precommit| { &mut m.epoch },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"round",
|m: &Precommit| { &m.round },
|m: &mut Precommit| { &mut m.round },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::types::Hash>>(
"propose_hash",
|m: &Precommit| { &m.propose_hash },
|m: &mut Precommit| { &mut m.propose_hash },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<super::types::Hash>>(
"block_hash",
|m: &Precommit| { &m.block_hash },
|m: &mut Precommit| { &mut m.block_hash },
));
fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<::protobuf::well_known_types::Timestamp>>(
"time",
|m: &Precommit| { &m.time },
|m: &mut Precommit| { &mut m.time },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<Precommit>(
"Precommit",
fields,
file_descriptor_proto()
)
})
}
}
fn default_instance() -> &'static Precommit {
static mut instance: ::protobuf::lazy::Lazy<Precommit> = ::protobuf::lazy::Lazy::INIT;
unsafe {
instance.get(Precommit::new)
}
}
}
impl ::protobuf::Clear for Precommit {
fn clear(&mut self) {
self.validator = 0;
self.epoch = 0;
self.round = 0;
self.propose_hash.clear();
self.block_hash.clear();
self.time.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for Precommit {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for Precommit {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x15exonum/messages.proto\x12\x06exonum\x1a\x19exonum/crypto/types.pro\
to\x1a\x19exonum/runtime/base.proto\x1a\x1fgoogle/protobuf/timestamp.pro\
to\"\x93\x01\n\rSignedMessage\x12\x18\n\x07payload\x18\x01\x20\x01(\x0cR\
\x07payload\x120\n\x06author\x18\x02\x20\x01(\x0b2\x18.exonum.crypto.Pub\
licKeyR\x06author\x126\n\tsignature\x18\x03\x20\x01(\x0b2\x18.exonum.cry\
pto.SignatureR\tsignature\"x\n\x0bCoreMessage\x12.\n\x06any_tx\x18\x01\
\x20\x01(\x0b2\x15.exonum.runtime.AnyTxH\0R\x05anyTx\x121\n\tprecommit\
\x18\x02\x20\x01(\x0b2\x11.exonum.PrecommitH\0R\tprecommitB\x06\n\x04kin\
d\"\xf1\x01\n\tPrecommit\x12\x1c\n\tvalidator\x18\x01\x20\x01(\rR\tvalid\
ator\x12\x14\n\x05epoch\x18\x02\x20\x01(\x04R\x05epoch\x12\x14\n\x05roun\
d\x18\x03\x20\x01(\rR\x05round\x126\n\x0cpropose_hash\x18\x04\x20\x01(\
\x0b2\x13.exonum.crypto.HashR\x0bproposeHash\x122\n\nblock_hash\x18\x05\
\x20\x01(\x0b2\x13.exonum.crypto.HashR\tblockHash\x12.\n\x04time\x18\x06\
\x20\x01(\x0b2\x1a.google.protobuf.TimestampR\x04timeB\x1a\n\x18com.exon\
um.messages.coreb\x06proto3\
";
static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
unsafe {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
}
}