impl serde::Serialize for AnyChainParams {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.params.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.AnyChainParams", len)?;
if let Some(v) = self.params.as_ref() {
match v {
any_chain_params::Params::Cardano(v) => {
struct_ser.serialize_field("cardano", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AnyChainParams {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"cardano",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Cardano,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"cardano" => Ok(GeneratedField::Cardano),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AnyChainParams;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.AnyChainParams")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AnyChainParams, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut params__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Cardano => {
if params__.is_some() {
return Err(serde::de::Error::duplicate_field("cardano"));
}
params__ = map_.next_value::<::std::option::Option<_>>()?.map(any_chain_params::Params::Cardano)
;
}
}
}
Ok(AnyChainParams {
params: params__,
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.AnyChainParams", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for AnyUtxoData {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.txo_ref.is_some() {
len += 1;
}
if !self.native_bytes.is_empty() {
len += 1;
}
if self.parsed_state.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.AnyUtxoData", len)?;
if let Some(v) = self.txo_ref.as_ref() {
struct_ser.serialize_field("txoRef", v)?;
}
if !self.native_bytes.is_empty() {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("nativeBytes", pbjson::private::base64::encode(&self.native_bytes).as_str())?;
}
if let Some(v) = self.parsed_state.as_ref() {
match v {
any_utxo_data::ParsedState::Cardano(v) => {
struct_ser.serialize_field("cardano", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AnyUtxoData {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"txo_ref",
"txoRef",
"native_bytes",
"nativeBytes",
"cardano",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
TxoRef,
NativeBytes,
Cardano,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"txoRef" | "txo_ref" => Ok(GeneratedField::TxoRef),
"nativeBytes" | "native_bytes" => Ok(GeneratedField::NativeBytes),
"cardano" => Ok(GeneratedField::Cardano),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AnyUtxoData;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.AnyUtxoData")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AnyUtxoData, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut txo_ref__ = None;
let mut native_bytes__ = None;
let mut parsed_state__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::TxoRef => {
if txo_ref__.is_some() {
return Err(serde::de::Error::duplicate_field("txoRef"));
}
txo_ref__ = map_.next_value()?;
}
GeneratedField::NativeBytes => {
if native_bytes__.is_some() {
return Err(serde::de::Error::duplicate_field("nativeBytes"));
}
native_bytes__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
GeneratedField::Cardano => {
if parsed_state__.is_some() {
return Err(serde::de::Error::duplicate_field("cardano"));
}
parsed_state__ = map_.next_value::<::std::option::Option<_>>()?.map(any_utxo_data::ParsedState::Cardano)
;
}
}
}
Ok(AnyUtxoData {
txo_ref: txo_ref__,
native_bytes: native_bytes__.unwrap_or_default(),
parsed_state: parsed_state__,
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.AnyUtxoData", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for AnyUtxoPattern {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.utxo_pattern.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.AnyUtxoPattern", len)?;
if let Some(v) = self.utxo_pattern.as_ref() {
match v {
any_utxo_pattern::UtxoPattern::Cardano(v) => {
struct_ser.serialize_field("cardano", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AnyUtxoPattern {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"cardano",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Cardano,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"cardano" => Ok(GeneratedField::Cardano),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AnyUtxoPattern;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.AnyUtxoPattern")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AnyUtxoPattern, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut utxo_pattern__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Cardano => {
if utxo_pattern__.is_some() {
return Err(serde::de::Error::duplicate_field("cardano"));
}
utxo_pattern__ = map_.next_value::<::std::option::Option<_>>()?.map(any_utxo_pattern::UtxoPattern::Cardano)
;
}
}
}
Ok(AnyUtxoPattern {
utxo_pattern: utxo_pattern__,
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.AnyUtxoPattern", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ChainPoint {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.slot != 0 {
len += 1;
}
if !self.hash.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.ChainPoint", len)?;
if self.slot != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("slot", ToString::to_string(&self.slot).as_str())?;
}
if !self.hash.is_empty() {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("hash", pbjson::private::base64::encode(&self.hash).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ChainPoint {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"slot",
"hash",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Slot,
Hash,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"slot" => Ok(GeneratedField::Slot),
"hash" => Ok(GeneratedField::Hash),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ChainPoint;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.ChainPoint")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChainPoint, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut slot__ = None;
let mut hash__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Slot => {
if slot__.is_some() {
return Err(serde::de::Error::duplicate_field("slot"));
}
slot__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Hash => {
if hash__.is_some() {
return Err(serde::de::Error::duplicate_field("hash"));
}
hash__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
}
}
Ok(ChainPoint {
slot: slot__.unwrap_or_default(),
hash: hash__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.ChainPoint", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ReadParamsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.field_mask.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.ReadParamsRequest", len)?;
if let Some(v) = self.field_mask.as_ref() {
struct_ser.serialize_field("fieldMask", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ReadParamsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"field_mask",
"fieldMask",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
FieldMask,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"fieldMask" | "field_mask" => Ok(GeneratedField::FieldMask),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ReadParamsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.ReadParamsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReadParamsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut field_mask__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::FieldMask => {
if field_mask__.is_some() {
return Err(serde::de::Error::duplicate_field("fieldMask"));
}
field_mask__ = map_.next_value()?;
}
}
}
Ok(ReadParamsRequest {
field_mask: field_mask__,
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.ReadParamsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ReadParamsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.values.is_some() {
len += 1;
}
if self.ledger_tip.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.ReadParamsResponse", len)?;
if let Some(v) = self.values.as_ref() {
struct_ser.serialize_field("values", v)?;
}
if let Some(v) = self.ledger_tip.as_ref() {
struct_ser.serialize_field("ledgerTip", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ReadParamsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"values",
"ledger_tip",
"ledgerTip",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Values,
LedgerTip,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"values" => Ok(GeneratedField::Values),
"ledgerTip" | "ledger_tip" => Ok(GeneratedField::LedgerTip),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ReadParamsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.ReadParamsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReadParamsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut values__ = None;
let mut ledger_tip__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = map_.next_value()?;
}
GeneratedField::LedgerTip => {
if ledger_tip__.is_some() {
return Err(serde::de::Error::duplicate_field("ledgerTip"));
}
ledger_tip__ = map_.next_value()?;
}
}
}
Ok(ReadParamsResponse {
values: values__,
ledger_tip: ledger_tip__,
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.ReadParamsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ReadUtxosRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.keys.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.ReadUtxosRequest", len)?;
if !self.keys.is_empty() {
struct_ser.serialize_field("keys", &self.keys)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ReadUtxosRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"keys",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Keys,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"keys" => Ok(GeneratedField::Keys),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ReadUtxosRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.ReadUtxosRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReadUtxosRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut keys__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Keys => {
if keys__.is_some() {
return Err(serde::de::Error::duplicate_field("keys"));
}
keys__ = Some(map_.next_value()?);
}
}
}
Ok(ReadUtxosRequest {
keys: keys__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.ReadUtxosRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ReadUtxosResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.items.is_empty() {
len += 1;
}
if self.ledger_tip.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.ReadUtxosResponse", len)?;
if !self.items.is_empty() {
struct_ser.serialize_field("items", &self.items)?;
}
if let Some(v) = self.ledger_tip.as_ref() {
struct_ser.serialize_field("ledgerTip", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ReadUtxosResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"items",
"ledger_tip",
"ledgerTip",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Items,
LedgerTip,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"items" => Ok(GeneratedField::Items),
"ledgerTip" | "ledger_tip" => Ok(GeneratedField::LedgerTip),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ReadUtxosResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.ReadUtxosResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ReadUtxosResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut items__ = None;
let mut ledger_tip__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Items => {
if items__.is_some() {
return Err(serde::de::Error::duplicate_field("items"));
}
items__ = Some(map_.next_value()?);
}
GeneratedField::LedgerTip => {
if ledger_tip__.is_some() {
return Err(serde::de::Error::duplicate_field("ledgerTip"));
}
ledger_tip__ = map_.next_value()?;
}
}
}
Ok(ReadUtxosResponse {
items: items__.unwrap_or_default(),
ledger_tip: ledger_tip__,
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.ReadUtxosResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for SearchUtxosRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.predicate.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.SearchUtxosRequest", len)?;
if let Some(v) = self.predicate.as_ref() {
struct_ser.serialize_field("predicate", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for SearchUtxosRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"predicate",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Predicate,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"predicate" => Ok(GeneratedField::Predicate),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = SearchUtxosRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.SearchUtxosRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<SearchUtxosRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut predicate__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Predicate => {
if predicate__.is_some() {
return Err(serde::de::Error::duplicate_field("predicate"));
}
predicate__ = map_.next_value()?;
}
}
}
Ok(SearchUtxosRequest {
predicate: predicate__,
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.SearchUtxosRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for SearchUtxosResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.items.is_empty() {
len += 1;
}
if self.ledger_tip.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.SearchUtxosResponse", len)?;
if !self.items.is_empty() {
struct_ser.serialize_field("items", &self.items)?;
}
if let Some(v) = self.ledger_tip.as_ref() {
struct_ser.serialize_field("ledgerTip", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for SearchUtxosResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"items",
"ledger_tip",
"ledgerTip",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Items,
LedgerTip,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"items" => Ok(GeneratedField::Items),
"ledgerTip" | "ledger_tip" => Ok(GeneratedField::LedgerTip),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = SearchUtxosResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.SearchUtxosResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<SearchUtxosResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut items__ = None;
let mut ledger_tip__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Items => {
if items__.is_some() {
return Err(serde::de::Error::duplicate_field("items"));
}
items__ = Some(map_.next_value()?);
}
GeneratedField::LedgerTip => {
if ledger_tip__.is_some() {
return Err(serde::de::Error::duplicate_field("ledgerTip"));
}
ledger_tip__ = map_.next_value()?;
}
}
}
Ok(SearchUtxosResponse {
items: items__.unwrap_or_default(),
ledger_tip: ledger_tip__,
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.SearchUtxosResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for TxoRef {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.hash.is_empty() {
len += 1;
}
if self.index != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.TxoRef", len)?;
if !self.hash.is_empty() {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field("hash", pbjson::private::base64::encode(&self.hash).as_str())?;
}
if self.index != 0 {
struct_ser.serialize_field("index", &self.index)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for TxoRef {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"hash",
"index",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Hash,
Index,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"hash" => Ok(GeneratedField::Hash),
"index" => Ok(GeneratedField::Index),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = TxoRef;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.TxoRef")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<TxoRef, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut hash__ = None;
let mut index__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Hash => {
if hash__.is_some() {
return Err(serde::de::Error::duplicate_field("hash"));
}
hash__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
GeneratedField::Index => {
if index__.is_some() {
return Err(serde::de::Error::duplicate_field("index"));
}
index__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(TxoRef {
hash: hash__.unwrap_or_default(),
index: index__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.TxoRef", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UtxoPredicate {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.r#match.is_some() {
len += 1;
}
if !self.not.is_empty() {
len += 1;
}
if !self.all_of.is_empty() {
len += 1;
}
if !self.any_of.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("utxorpc.v1alpha.query.UtxoPredicate", len)?;
if let Some(v) = self.r#match.as_ref() {
struct_ser.serialize_field("match", v)?;
}
if !self.not.is_empty() {
struct_ser.serialize_field("not", &self.not)?;
}
if !self.all_of.is_empty() {
struct_ser.serialize_field("allOf", &self.all_of)?;
}
if !self.any_of.is_empty() {
struct_ser.serialize_field("anyOf", &self.any_of)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UtxoPredicate {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"match",
"not",
"all_of",
"allOf",
"any_of",
"anyOf",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Match,
Not,
AllOf,
AnyOf,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"match" => Ok(GeneratedField::Match),
"not" => Ok(GeneratedField::Not),
"allOf" | "all_of" => Ok(GeneratedField::AllOf),
"anyOf" | "any_of" => Ok(GeneratedField::AnyOf),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UtxoPredicate;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct utxorpc.v1alpha.query.UtxoPredicate")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UtxoPredicate, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut r#match__ = None;
let mut not__ = None;
let mut all_of__ = None;
let mut any_of__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Match => {
if r#match__.is_some() {
return Err(serde::de::Error::duplicate_field("match"));
}
r#match__ = map_.next_value()?;
}
GeneratedField::Not => {
if not__.is_some() {
return Err(serde::de::Error::duplicate_field("not"));
}
not__ = Some(map_.next_value()?);
}
GeneratedField::AllOf => {
if all_of__.is_some() {
return Err(serde::de::Error::duplicate_field("allOf"));
}
all_of__ = Some(map_.next_value()?);
}
GeneratedField::AnyOf => {
if any_of__.is_some() {
return Err(serde::de::Error::duplicate_field("anyOf"));
}
any_of__ = Some(map_.next_value()?);
}
}
}
Ok(UtxoPredicate {
r#match: r#match__,
not: not__.unwrap_or_default(),
all_of: all_of__.unwrap_or_default(),
any_of: any_of__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("utxorpc.v1alpha.query.UtxoPredicate", FIELDS, GeneratedVisitor)
}
}