#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![cfg_attr(rustfmt, rustfmt_skip)]
use std::borrow::Cow;
use quick_protobuf::{MessageRead, MessageWrite, BytesReader, Writer, WriterBackend, Result};
use quick_protobuf::sizeofs::*;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct FulfillmentManagerInstruction<'a> {
pub instruction: mod_FulfillmentManagerInstruction::OneOfinstruction<'a>,
}
impl<'a> MessageRead<'a> for FulfillmentManagerInstruction<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.instruction = mod_FulfillmentManagerInstruction::OneOfinstruction::try_push_instruction(r.read_message::<mod_FulfillmentManagerInstruction::TryPush>(bytes)?),
Ok(18) => msg.instruction = mod_FulfillmentManagerInstruction::OneOfinstruction::snapshot_instruction(r.read_message::<mod_FulfillmentManagerInstruction::Snapshot>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for FulfillmentManagerInstruction<'a> {
fn get_size(&self) -> usize {
0
+ match self.instruction {
mod_FulfillmentManagerInstruction::OneOfinstruction::try_push_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_FulfillmentManagerInstruction::OneOfinstruction::snapshot_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_FulfillmentManagerInstruction::OneOfinstruction::None => 0,
} }
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
match self.instruction { mod_FulfillmentManagerInstruction::OneOfinstruction::try_push_instruction(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
mod_FulfillmentManagerInstruction::OneOfinstruction::snapshot_instruction(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
mod_FulfillmentManagerInstruction::OneOfinstruction::None => {},
} Ok(())
}
}
pub mod mod_FulfillmentManagerInstruction {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct TryPush<'a> {
pub node_pubkey: Cow<'a, [u8]>,
}
impl<'a> MessageRead<'a> for TryPush<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.node_pubkey = r.read_bytes(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for TryPush<'a> {
fn get_size(&self) -> usize {
0
+ if self.node_pubkey == Cow::Borrowed(b"") { 0 } else { 1 + sizeof_len((&self.node_pubkey).len()) }
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if self.node_pubkey != Cow::Borrowed(b"") { w.write_with_tag(10, |w| w.write_bytes(&**&self.node_pubkey))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Snapshot { }
impl<'a> MessageRead<'a> for Snapshot {
fn from_reader(r: &mut BytesReader, _: &[u8]) -> Result<Self> {
r.read_to_end();
Ok(Self::default())
}
}
impl MessageWrite for Snapshot { }
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfinstruction<'a> {
try_push_instruction(mod_FulfillmentManagerInstruction::TryPush<'a>),
snapshot_instruction(mod_FulfillmentManagerInstruction::Snapshot),
None,
}
impl<'a> Default for OneOfinstruction<'a> {
fn default() -> Self {
OneOfinstruction::None
}
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct AggregatorInstruction<'a> {
pub instruction: mod_AggregatorInstruction::OneOfinstruction<'a>,
}
impl<'a> MessageRead<'a> for AggregatorInstruction<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.instruction = mod_AggregatorInstruction::OneOfinstruction::register_source_instruction(r.read_message::<mod_AggregatorInstruction::RegisterSource>(bytes)?),
Ok(18) => msg.instruction = mod_AggregatorInstruction::OneOfinstruction::unregister_source_instruction(r.read_message::<mod_AggregatorInstruction::UnregisterSource>(bytes)?),
Ok(26) => msg.instruction = mod_AggregatorInstruction::OneOfinstruction::update_instruction(r.read_message::<mod_AggregatorInstruction::Update>(bytes)?),
Ok(34) => msg.instruction = mod_AggregatorInstruction::OneOfinstruction::get_instruction(r.read_message::<mod_AggregatorInstruction::Get>(bytes)?),
Ok(42) => msg.instruction = mod_AggregatorInstruction::OneOfinstruction::set_fulfillment_manager_instruction(r.read_message::<mod_AggregatorInstruction::SetFulfillmentManagerStateAccount>(bytes)?),
Ok(50) => msg.instruction = mod_AggregatorInstruction::OneOfinstruction::save_result_instruction(r.read_message::<mod_AggregatorInstruction::SaveResult>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for AggregatorInstruction<'a> {
fn get_size(&self) -> usize {
0
+ match self.instruction {
mod_AggregatorInstruction::OneOfinstruction::register_source_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_AggregatorInstruction::OneOfinstruction::unregister_source_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_AggregatorInstruction::OneOfinstruction::update_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_AggregatorInstruction::OneOfinstruction::get_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_AggregatorInstruction::OneOfinstruction::set_fulfillment_manager_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_AggregatorInstruction::OneOfinstruction::save_result_instruction(ref m) => 1 + sizeof_len((m).get_size()),
mod_AggregatorInstruction::OneOfinstruction::None => 0,
} }
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
match self.instruction { mod_AggregatorInstruction::OneOfinstruction::register_source_instruction(ref m) => { w.write_with_tag(10, |w| w.write_message(m))? },
mod_AggregatorInstruction::OneOfinstruction::unregister_source_instruction(ref m) => { w.write_with_tag(18, |w| w.write_message(m))? },
mod_AggregatorInstruction::OneOfinstruction::update_instruction(ref m) => { w.write_with_tag(26, |w| w.write_message(m))? },
mod_AggregatorInstruction::OneOfinstruction::get_instruction(ref m) => { w.write_with_tag(34, |w| w.write_message(m))? },
mod_AggregatorInstruction::OneOfinstruction::set_fulfillment_manager_instruction(ref m) => { w.write_with_tag(42, |w| w.write_message(m))? },
mod_AggregatorInstruction::OneOfinstruction::save_result_instruction(ref m) => { w.write_with_tag(50, |w| w.write_message(m))? },
mod_AggregatorInstruction::OneOfinstruction::None => {},
} Ok(())
}
}
pub mod mod_AggregatorInstruction {
use std::borrow::Cow;
use super::*;
#[derive(Debug, Default, PartialEq, Clone)]
pub struct RegisterSource<'a> {
pub job: Option<oracle_state::OracleJob<'a>>,
}
impl<'a> MessageRead<'a> for RegisterSource<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.job = Some(r.read_message::<oracle_state::OracleJob>(bytes)?),
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for RegisterSource<'a> {
fn get_size(&self) -> usize {
0
+ self.job.as_ref().map_or(0, |m| 1 + sizeof_len((m).get_size()))
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if let Some(ref s) = self.job { w.write_with_tag(10, |w| w.write_message(s))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct UnregisterSource<'a> {
pub job_pubkey: Cow<'a, [u8]>,
}
impl<'a> MessageRead<'a> for UnregisterSource<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.job_pubkey = r.read_bytes(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for UnregisterSource<'a> {
fn get_size(&self) -> usize {
0
+ if self.job_pubkey == Cow::Borrowed(b"") { 0 } else { 1 + sizeof_len((&self.job_pubkey).len()) }
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if self.job_pubkey != Cow::Borrowed(b"") { w.write_with_tag(10, |w| w.write_bytes(&**&self.job_pubkey))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Update<'a> {
pub fulfillment_pubkey: Cow<'a, [u8]>,
}
impl<'a> MessageRead<'a> for Update<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.fulfillment_pubkey = r.read_bytes(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Update<'a> {
fn get_size(&self) -> usize {
0
+ if self.fulfillment_pubkey == Cow::Borrowed(b"") { 0 } else { 1 + sizeof_len((&self.fulfillment_pubkey).len()) }
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if self.fulfillment_pubkey != Cow::Borrowed(b"") { w.write_with_tag(10, |w| w.write_bytes(&**&self.fulfillment_pubkey))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Get<'a> {
pub callback_pubkey: Cow<'a, [u8]>,
pub min_block_id: i32,
}
impl<'a> MessageRead<'a> for Get<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.callback_pubkey = r.read_bytes(bytes).map(Cow::Borrowed)?,
Ok(16) => msg.min_block_id = r.read_int32(bytes)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for Get<'a> {
fn get_size(&self) -> usize {
0
+ if self.callback_pubkey == Cow::Borrowed(b"") { 0 } else { 1 + sizeof_len((&self.callback_pubkey).len()) }
+ if self.min_block_id == 0i32 { 0 } else { 1 + sizeof_varint(*(&self.min_block_id) as u64) }
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if self.callback_pubkey != Cow::Borrowed(b"") { w.write_with_tag(10, |w| w.write_bytes(&**&self.callback_pubkey))?; }
if self.min_block_id != 0i32 { w.write_with_tag(16, |w| w.write_int32(*&self.min_block_id))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SetFulfillmentManagerStateAccount<'a> {
pub fulfillment_manager_state_pubkey: Cow<'a, [u8]>,
}
impl<'a> MessageRead<'a> for SetFulfillmentManagerStateAccount<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.fulfillment_manager_state_pubkey = r.read_bytes(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for SetFulfillmentManagerStateAccount<'a> {
fn get_size(&self) -> usize {
0
+ if self.fulfillment_manager_state_pubkey == Cow::Borrowed(b"") { 0 } else { 1 + sizeof_len((&self.fulfillment_manager_state_pubkey).len()) }
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if self.fulfillment_manager_state_pubkey != Cow::Borrowed(b"") { w.write_with_tag(10, |w| w.write_bytes(&**&self.fulfillment_manager_state_pubkey))?; }
Ok(())
}
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct SaveResult<'a> {
pub job_pubkey: Cow<'a, [u8]>,
pub result: f64,
pub error: Cow<'a, str>,
}
impl<'a> MessageRead<'a> for SaveResult<'a> {
fn from_reader(r: &mut BytesReader, bytes: &'a [u8]) -> Result<Self> {
let mut msg = Self::default();
while !r.is_eof() {
match r.next_tag(bytes) {
Ok(10) => msg.job_pubkey = r.read_bytes(bytes).map(Cow::Borrowed)?,
Ok(17) => msg.result = r.read_double(bytes)?,
Ok(26) => msg.error = r.read_string(bytes).map(Cow::Borrowed)?,
Ok(t) => { r.read_unknown(bytes, t)?; }
Err(e) => return Err(e),
}
}
Ok(msg)
}
}
impl<'a> MessageWrite for SaveResult<'a> {
fn get_size(&self) -> usize {
0
+ if self.job_pubkey == Cow::Borrowed(b"") { 0 } else { 1 + sizeof_len((&self.job_pubkey).len()) }
+ if self.result == 0f64 { 0 } else { 1 + 8 }
+ if self.error == "" { 0 } else { 1 + sizeof_len((&self.error).len()) }
}
fn write_message<W: WriterBackend>(&self, w: &mut Writer<W>) -> Result<()> {
if self.job_pubkey != Cow::Borrowed(b"") { w.write_with_tag(10, |w| w.write_bytes(&**&self.job_pubkey))?; }
if self.result != 0f64 { w.write_with_tag(17, |w| w.write_double(*&self.result))?; }
if self.error != "" { w.write_with_tag(26, |w| w.write_string(&**&self.error))?; }
Ok(())
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum OneOfinstruction<'a> {
register_source_instruction(mod_AggregatorInstruction::RegisterSource<'a>),
unregister_source_instruction(mod_AggregatorInstruction::UnregisterSource<'a>),
update_instruction(mod_AggregatorInstruction::Update<'a>),
get_instruction(mod_AggregatorInstruction::Get<'a>),
set_fulfillment_manager_instruction(mod_AggregatorInstruction::SetFulfillmentManagerStateAccount<'a>),
save_result_instruction(mod_AggregatorInstruction::SaveResult<'a>),
None,
}
impl<'a> Default for OneOfinstruction<'a> {
fn default() -> Self {
OneOfinstruction::None
}
}
}