#[cfg(feature = "serde")]
impl serde::Serialize for AssetType {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Bitcoin => "Bitcoin",
};
serializer.serialize_str(variant)
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for AssetType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["Bitcoin"];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AssetType;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"Bitcoin" => Ok(AssetType::Bitcoin),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for Auction {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.id != 0 {
len += 1;
}
if self.deposited_asset.is_some() {
len += 1;
}
if !self.borrower.is_empty() {
len += 1;
}
if self.liquidated_price != 0 {
len += 1;
}
if self.liquidated_time.is_some() {
len += 1;
}
if self.expected_value != 0 {
len += 1;
}
if self.bidded_value != 0 {
len += 1;
}
if !self.payment_tx_id.is_empty() {
len += 1;
}
if self.status != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.Auction", len)?;
if self.id != 0 {
#[allow(clippy::needless_borrow)]
struct_ser
.serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?;
}
if let Some(v) = self.deposited_asset.as_ref() {
struct_ser.serialize_field("depositedAsset", v)?;
}
if !self.borrower.is_empty() {
struct_ser.serialize_field("borrower", &self.borrower)?;
}
if self.liquidated_price != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"liquidatedPrice",
alloc::string::ToString::to_string(&self.liquidated_price).as_str(),
)?;
}
if let Some(v) = self.liquidated_time.as_ref() {
struct_ser.serialize_field("liquidatedTime", v)?;
}
if self.expected_value != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"expectedValue",
alloc::string::ToString::to_string(&self.expected_value).as_str(),
)?;
}
if self.bidded_value != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"biddedValue",
alloc::string::ToString::to_string(&self.bidded_value).as_str(),
)?;
}
if !self.payment_tx_id.is_empty() {
struct_ser.serialize_field("paymentTxId", &self.payment_tx_id)?;
}
if self.status != 0 {
let v = AuctionStatus::try_from(self.status).map_err(|_| {
serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status))
})?;
struct_ser.serialize_field("status", &v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Auction {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"id",
"deposited_asset",
"depositedAsset",
"borrower",
"liquidated_price",
"liquidatedPrice",
"liquidated_time",
"liquidatedTime",
"expected_value",
"expectedValue",
"bidded_value",
"biddedValue",
"payment_tx_id",
"paymentTxId",
"status",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Id,
DepositedAsset,
Borrower,
LiquidatedPrice,
LiquidatedTime,
ExpectedValue,
BiddedValue,
PaymentTxId,
Status,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"id" => Ok(GeneratedField::Id),
"depositedAsset" | "deposited_asset" => {
Ok(GeneratedField::DepositedAsset)
}
"borrower" => Ok(GeneratedField::Borrower),
"liquidatedPrice" | "liquidated_price" => {
Ok(GeneratedField::LiquidatedPrice)
}
"liquidatedTime" | "liquidated_time" => {
Ok(GeneratedField::LiquidatedTime)
}
"expectedValue" | "expected_value" => Ok(GeneratedField::ExpectedValue),
"biddedValue" | "bidded_value" => Ok(GeneratedField::BiddedValue),
"paymentTxId" | "payment_tx_id" => Ok(GeneratedField::PaymentTxId),
"status" => Ok(GeneratedField::Status),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Auction;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.Auction")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<Auction, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut id__ = None;
let mut deposited_asset__ = None;
let mut borrower__ = None;
let mut liquidated_price__ = None;
let mut liquidated_time__ = None;
let mut expected_value__ = None;
let mut bidded_value__ = None;
let mut payment_tx_id__ = None;
let mut status__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Id => {
if id__.is_some() {
return Err(serde::de::Error::duplicate_field("id"));
}
id__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::DepositedAsset => {
if deposited_asset__.is_some() {
return Err(serde::de::Error::duplicate_field("depositedAsset"));
}
deposited_asset__ = map_.next_value()?;
}
GeneratedField::Borrower => {
if borrower__.is_some() {
return Err(serde::de::Error::duplicate_field("borrower"));
}
borrower__ = Some(map_.next_value()?);
}
GeneratedField::LiquidatedPrice => {
if liquidated_price__.is_some() {
return Err(serde::de::Error::duplicate_field("liquidatedPrice"));
}
liquidated_price__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::LiquidatedTime => {
if liquidated_time__.is_some() {
return Err(serde::de::Error::duplicate_field("liquidatedTime"));
}
liquidated_time__ = map_.next_value()?;
}
GeneratedField::ExpectedValue => {
if expected_value__.is_some() {
return Err(serde::de::Error::duplicate_field("expectedValue"));
}
expected_value__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::BiddedValue => {
if bidded_value__.is_some() {
return Err(serde::de::Error::duplicate_field("biddedValue"));
}
bidded_value__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::PaymentTxId => {
if payment_tx_id__.is_some() {
return Err(serde::de::Error::duplicate_field("paymentTxId"));
}
payment_tx_id__ = Some(map_.next_value()?);
}
GeneratedField::Status => {
if status__.is_some() {
return Err(serde::de::Error::duplicate_field("status"));
}
status__ = Some(map_.next_value::<AuctionStatus>()? as i32);
}
}
}
Ok(Auction {
id: id__.unwrap_or_default(),
deposited_asset: deposited_asset__,
borrower: borrower__.unwrap_or_default(),
liquidated_price: liquidated_price__.unwrap_or_default(),
liquidated_time: liquidated_time__,
expected_value: expected_value__.unwrap_or_default(),
bidded_value: bidded_value__.unwrap_or_default(),
payment_tx_id: payment_tx_id__.unwrap_or_default(),
status: status__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.auction.Auction", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for AuctionStatus {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::AuctionOpen => "AuctionOpen",
Self::AuctionClose => "AuctionClose",
};
serializer.serialize_str(variant)
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for AuctionStatus {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["AuctionOpen", "AuctionClose"];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AuctionStatus;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"AuctionOpen" => Ok(AuctionStatus::AuctionOpen),
"AuctionClose" => Ok(AuctionStatus::AuctionClose),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for Bid {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.id != 0 {
len += 1;
}
if self.auction_id != 0 {
len += 1;
}
if !self.bidder.is_empty() {
len += 1;
}
if self.bid_price != 0 {
len += 1;
}
if self.bid_amount.is_some() {
len += 1;
}
if self.status != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.Bid", len)?;
if self.id != 0 {
#[allow(clippy::needless_borrow)]
struct_ser
.serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?;
}
if self.auction_id != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"auctionId",
alloc::string::ToString::to_string(&self.auction_id).as_str(),
)?;
}
if !self.bidder.is_empty() {
struct_ser.serialize_field("bidder", &self.bidder)?;
}
if self.bid_price != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"bidPrice",
alloc::string::ToString::to_string(&self.bid_price).as_str(),
)?;
}
if let Some(v) = self.bid_amount.as_ref() {
struct_ser.serialize_field("bidAmount", v)?;
}
if self.status != 0 {
let v = BidStatus::try_from(self.status).map_err(|_| {
serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status))
})?;
struct_ser.serialize_field("status", &v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Bid {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"id",
"auction_id",
"auctionId",
"bidder",
"bid_price",
"bidPrice",
"bid_amount",
"bidAmount",
"status",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Id,
AuctionId,
Bidder,
BidPrice,
BidAmount,
Status,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"id" => Ok(GeneratedField::Id),
"auctionId" | "auction_id" => Ok(GeneratedField::AuctionId),
"bidder" => Ok(GeneratedField::Bidder),
"bidPrice" | "bid_price" => Ok(GeneratedField::BidPrice),
"bidAmount" | "bid_amount" => Ok(GeneratedField::BidAmount),
"status" => Ok(GeneratedField::Status),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Bid;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.Bid")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<Bid, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut id__ = None;
let mut auction_id__ = None;
let mut bidder__ = None;
let mut bid_price__ = None;
let mut bid_amount__ = None;
let mut status__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Id => {
if id__.is_some() {
return Err(serde::de::Error::duplicate_field("id"));
}
id__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::AuctionId => {
if auction_id__.is_some() {
return Err(serde::de::Error::duplicate_field("auctionId"));
}
auction_id__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::Bidder => {
if bidder__.is_some() {
return Err(serde::de::Error::duplicate_field("bidder"));
}
bidder__ = Some(map_.next_value()?);
}
GeneratedField::BidPrice => {
if bid_price__.is_some() {
return Err(serde::de::Error::duplicate_field("bidPrice"));
}
bid_price__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::BidAmount => {
if bid_amount__.is_some() {
return Err(serde::de::Error::duplicate_field("bidAmount"));
}
bid_amount__ = map_.next_value()?;
}
GeneratedField::Status => {
if status__.is_some() {
return Err(serde::de::Error::duplicate_field("status"));
}
status__ = Some(map_.next_value::<BidStatus>()? as i32);
}
}
}
Ok(Bid {
id: id__.unwrap_or_default(),
auction_id: auction_id__.unwrap_or_default(),
bidder: bidder__.unwrap_or_default(),
bid_price: bid_price__.unwrap_or_default(),
bid_amount: bid_amount__,
status: status__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.auction.Bid", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for BidStatus {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Bidding => "Bidding",
Self::Accepted => "Accepted",
Self::Rejected => "Rejected",
Self::Cancelled => "Cancelled",
};
serializer.serialize_str(variant)
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for BidStatus {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["Bidding", "Accepted", "Rejected", "Cancelled"];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BidStatus;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> core::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"Bidding" => Ok(BidStatus::Bidding),
"Accepted" => Ok(BidStatus::Accepted),
"Rejected" => Ok(BidStatus::Rejected),
"Cancelled" => Ok(BidStatus::Cancelled),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for GenesisState {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::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;
}
if !self.auctions.is_empty() {
len += 1;
}
if !self.bids.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.GenesisState", len)?;
if let Some(v) = self.params.as_ref() {
struct_ser.serialize_field("params", v)?;
}
if !self.auctions.is_empty() {
struct_ser.serialize_field("auctions", &self.auctions)?;
}
if !self.bids.is_empty() {
struct_ser.serialize_field("bids", &self.bids)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GenesisState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["params", "auctions", "bids"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Params,
Auctions,
Bids,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"params" => Ok(GeneratedField::Params),
"auctions" => Ok(GeneratedField::Auctions),
"bids" => Ok(GeneratedField::Bids),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GenesisState;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.GenesisState")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut params__ = None;
let mut auctions__ = None;
let mut bids__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Params => {
if params__.is_some() {
return Err(serde::de::Error::duplicate_field("params"));
}
params__ = map_.next_value()?;
}
GeneratedField::Auctions => {
if auctions__.is_some() {
return Err(serde::de::Error::duplicate_field("auctions"));
}
auctions__ = Some(map_.next_value()?);
}
GeneratedField::Bids => {
if bids__.is_some() {
return Err(serde::de::Error::duplicate_field("bids"));
}
bids__ = Some(map_.next_value()?);
}
}
}
Ok(GenesisState {
params: params__,
auctions: auctions__.unwrap_or_default(),
bids: bids__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.auction.GenesisState", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for MsgBid {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.sender.is_empty() {
len += 1;
}
if self.auction_id != 0 {
len += 1;
}
if self.price != 0 {
len += 1;
}
if self.amount.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.MsgBid", len)?;
if !self.sender.is_empty() {
struct_ser.serialize_field("sender", &self.sender)?;
}
if self.auction_id != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"auctionId",
alloc::string::ToString::to_string(&self.auction_id).as_str(),
)?;
}
if self.price != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"price",
alloc::string::ToString::to_string(&self.price).as_str(),
)?;
}
if let Some(v) = self.amount.as_ref() {
struct_ser.serialize_field("amount", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for MsgBid {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["sender", "auction_id", "auctionId", "price", "amount"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Sender,
AuctionId,
Price,
Amount,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"sender" => Ok(GeneratedField::Sender),
"auctionId" | "auction_id" => Ok(GeneratedField::AuctionId),
"price" => Ok(GeneratedField::Price),
"amount" => Ok(GeneratedField::Amount),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgBid;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.MsgBid")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgBid, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut sender__ = None;
let mut auction_id__ = None;
let mut price__ = None;
let mut amount__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Sender => {
if sender__.is_some() {
return Err(serde::de::Error::duplicate_field("sender"));
}
sender__ = Some(map_.next_value()?);
}
GeneratedField::AuctionId => {
if auction_id__.is_some() {
return Err(serde::de::Error::duplicate_field("auctionId"));
}
auction_id__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::Price => {
if price__.is_some() {
return Err(serde::de::Error::duplicate_field("price"));
}
price__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::Amount => {
if amount__.is_some() {
return Err(serde::de::Error::duplicate_field("amount"));
}
amount__ = map_.next_value()?;
}
}
}
Ok(MsgBid {
sender: sender__.unwrap_or_default(),
auction_id: auction_id__.unwrap_or_default(),
price: price__.unwrap_or_default(),
amount: amount__,
})
}
}
deserializer.deserialize_struct("side.auction.MsgBid", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for MsgBidResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("side.auction.MsgBidResponse", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for MsgBidResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgBidResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.MsgBidResponse")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgBidResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(MsgBidResponse {})
}
}
deserializer.deserialize_struct("side.auction.MsgBidResponse", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for MsgCancelBid {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.sender.is_empty() {
len += 1;
}
if self.id != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.MsgCancelBid", len)?;
if !self.sender.is_empty() {
struct_ser.serialize_field("sender", &self.sender)?;
}
if self.id != 0 {
#[allow(clippy::needless_borrow)]
struct_ser
.serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for MsgCancelBid {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["sender", "id"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Sender,
Id,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"sender" => Ok(GeneratedField::Sender),
"id" => Ok(GeneratedField::Id),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgCancelBid;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.MsgCancelBid")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCancelBid, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut sender__ = None;
let mut id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Sender => {
if sender__.is_some() {
return Err(serde::de::Error::duplicate_field("sender"));
}
sender__ = Some(map_.next_value()?);
}
GeneratedField::Id => {
if id__.is_some() {
return Err(serde::de::Error::duplicate_field("id"));
}
id__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
}
}
Ok(MsgCancelBid {
sender: sender__.unwrap_or_default(),
id: id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.auction.MsgCancelBid", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for MsgCancelBidResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("side.auction.MsgCancelBidResponse", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for MsgCancelBidResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgCancelBidResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.MsgCancelBidResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<MsgCancelBidResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(MsgCancelBidResponse {})
}
}
deserializer.deserialize_struct(
"side.auction.MsgCancelBidResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for MsgUpdateParams {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.authority.is_empty() {
len += 1;
}
if self.params.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.MsgUpdateParams", len)?;
if !self.authority.is_empty() {
struct_ser.serialize_field("authority", &self.authority)?;
}
if let Some(v) = self.params.as_ref() {
struct_ser.serialize_field("params", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["authority", "params"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Authority,
Params,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"authority" => Ok(GeneratedField::Authority),
"params" => Ok(GeneratedField::Params),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgUpdateParams;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.MsgUpdateParams")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut authority__ = None;
let mut params__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Authority => {
if authority__.is_some() {
return Err(serde::de::Error::duplicate_field("authority"));
}
authority__ = Some(map_.next_value()?);
}
GeneratedField::Params => {
if params__.is_some() {
return Err(serde::de::Error::duplicate_field("params"));
}
params__ = map_.next_value()?;
}
}
}
Ok(MsgUpdateParams {
authority: authority__.unwrap_or_default(),
params: params__,
})
}
}
deserializer.deserialize_struct("side.auction.MsgUpdateParams", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for MsgUpdateParamsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser =
serializer.serialize_struct("side.auction.MsgUpdateParamsResponse", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgUpdateParamsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.MsgUpdateParamsResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(MsgUpdateParamsResponse {})
}
}
deserializer.deserialize_struct(
"side.auction.MsgUpdateParamsResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for Params {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.price_drop_period.is_some() {
len += 1;
}
if self.initial_discount != 0 {
len += 1;
}
if self.fee_rate != 0 {
len += 1;
}
if self.min_bid_amount != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.Params", len)?;
if let Some(v) = self.price_drop_period.as_ref() {
struct_ser.serialize_field("priceDropPeriod", v)?;
}
if self.initial_discount != 0 {
struct_ser.serialize_field("initialDiscount", &self.initial_discount)?;
}
if self.fee_rate != 0 {
struct_ser.serialize_field("feeRate", &self.fee_rate)?;
}
if self.min_bid_amount != 0 {
#[allow(clippy::needless_borrow)]
struct_ser.serialize_field(
"minBidAmount",
alloc::string::ToString::to_string(&self.min_bid_amount).as_str(),
)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Params {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"price_drop_period",
"priceDropPeriod",
"initial_discount",
"initialDiscount",
"fee_rate",
"feeRate",
"min_bid_amount",
"minBidAmount",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PriceDropPeriod,
InitialDiscount,
FeeRate,
MinBidAmount,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"priceDropPeriod" | "price_drop_period" => {
Ok(GeneratedField::PriceDropPeriod)
}
"initialDiscount" | "initial_discount" => {
Ok(GeneratedField::InitialDiscount)
}
"feeRate" | "fee_rate" => Ok(GeneratedField::FeeRate),
"minBidAmount" | "min_bid_amount" => Ok(GeneratedField::MinBidAmount),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Params;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.Params")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut price_drop_period__ = None;
let mut initial_discount__ = None;
let mut fee_rate__ = None;
let mut min_bid_amount__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PriceDropPeriod => {
if price_drop_period__.is_some() {
return Err(serde::de::Error::duplicate_field("priceDropPeriod"));
}
price_drop_period__ = map_.next_value()?;
}
GeneratedField::InitialDiscount => {
if initial_discount__.is_some() {
return Err(serde::de::Error::duplicate_field("initialDiscount"));
}
initial_discount__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::FeeRate => {
if fee_rate__.is_some() {
return Err(serde::de::Error::duplicate_field("feeRate"));
}
fee_rate__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
GeneratedField::MinBidAmount => {
if min_bid_amount__.is_some() {
return Err(serde::de::Error::duplicate_field("minBidAmount"));
}
min_bid_amount__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
}
}
Ok(Params {
price_drop_period: price_drop_period__,
initial_discount: initial_discount__.unwrap_or_default(),
fee_rate: fee_rate__.unwrap_or_default(),
min_bid_amount: min_bid_amount__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.auction.Params", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryAuctionRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.id != 0 {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.auction.QueryAuctionRequest", len)?;
if self.id != 0 {
#[allow(clippy::needless_borrow)]
struct_ser
.serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryAuctionRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["id"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Id,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"id" => Ok(GeneratedField::Id),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryAuctionRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryAuctionRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryAuctionRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Id => {
if id__.is_some() {
return Err(serde::de::Error::duplicate_field("id"));
}
id__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
}
}
Ok(QueryAuctionRequest {
id: id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct(
"side.auction.QueryAuctionRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryAuctionResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.auction.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.auction.QueryAuctionResponse", len)?;
if let Some(v) = self.auction.as_ref() {
struct_ser.serialize_field("auction", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryAuctionResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["auction"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Auction,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"auction" => Ok(GeneratedField::Auction),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryAuctionResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryAuctionResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryAuctionResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut auction__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Auction => {
if auction__.is_some() {
return Err(serde::de::Error::duplicate_field("auction"));
}
auction__ = map_.next_value()?;
}
}
}
Ok(QueryAuctionResponse { auction: auction__ })
}
}
deserializer.deserialize_struct(
"side.auction.QueryAuctionResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryAuctionsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.status != 0 {
len += 1;
}
if self.pagination.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.auction.QueryAuctionsRequest", len)?;
if self.status != 0 {
let v = AuctionStatus::try_from(self.status).map_err(|_| {
serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status))
})?;
struct_ser.serialize_field("status", &v)?;
}
if let Some(v) = self.pagination.as_ref() {
struct_ser.serialize_field("pagination", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryAuctionsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["status", "pagination"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Status,
Pagination,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"status" => Ok(GeneratedField::Status),
"pagination" => Ok(GeneratedField::Pagination),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryAuctionsRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryAuctionsRequest")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryAuctionsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut status__ = None;
let mut pagination__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Status => {
if status__.is_some() {
return Err(serde::de::Error::duplicate_field("status"));
}
status__ = Some(map_.next_value::<AuctionStatus>()? as i32);
}
GeneratedField::Pagination => {
if pagination__.is_some() {
return Err(serde::de::Error::duplicate_field("pagination"));
}
pagination__ = map_.next_value()?;
}
}
}
Ok(QueryAuctionsRequest {
status: status__.unwrap_or_default(),
pagination: pagination__,
})
}
}
deserializer.deserialize_struct(
"side.auction.QueryAuctionsRequest",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryAuctionsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.auctions.is_empty() {
len += 1;
}
if self.pagination.is_some() {
len += 1;
}
let mut struct_ser =
serializer.serialize_struct("side.auction.QueryAuctionsResponse", len)?;
if !self.auctions.is_empty() {
struct_ser.serialize_field("auctions", &self.auctions)?;
}
if let Some(v) = self.pagination.as_ref() {
struct_ser.serialize_field("pagination", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryAuctionsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["auctions", "pagination"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Auctions,
Pagination,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"auctions" => Ok(GeneratedField::Auctions),
"pagination" => Ok(GeneratedField::Pagination),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryAuctionsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryAuctionsResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryAuctionsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut auctions__ = None;
let mut pagination__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Auctions => {
if auctions__.is_some() {
return Err(serde::de::Error::duplicate_field("auctions"));
}
auctions__ = Some(map_.next_value()?);
}
GeneratedField::Pagination => {
if pagination__.is_some() {
return Err(serde::de::Error::duplicate_field("pagination"));
}
pagination__ = map_.next_value()?;
}
}
}
Ok(QueryAuctionsResponse {
auctions: auctions__.unwrap_or_default(),
pagination: pagination__,
})
}
}
deserializer.deserialize_struct(
"side.auction.QueryAuctionsResponse",
FIELDS,
GeneratedVisitor,
)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBidRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.id != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.QueryBidRequest", len)?;
if self.id != 0 {
#[allow(clippy::needless_borrow)]
struct_ser
.serialize_field("id", alloc::string::ToString::to_string(&self.id).as_str())?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBidRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["id"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Id,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"id" => Ok(GeneratedField::Id),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBidRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryBidRequest")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryBidRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Id => {
if id__.is_some() {
return Err(serde::de::Error::duplicate_field("id"));
}
id__ = Some(
map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?
.0,
);
}
}
}
Ok(QueryBidRequest {
id: id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("side.auction.QueryBidRequest", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBidResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.bid.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.QueryBidResponse", len)?;
if let Some(v) = self.bid.as_ref() {
struct_ser.serialize_field("bid", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBidResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["bid"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Bid,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"bid" => Ok(GeneratedField::Bid),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBidResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryBidResponse")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryBidResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut bid__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Bid => {
if bid__.is_some() {
return Err(serde::de::Error::duplicate_field("bid"));
}
bid__ = map_.next_value()?;
}
}
}
Ok(QueryBidResponse { bid: bid__ })
}
}
deserializer.deserialize_struct("side.auction.QueryBidResponse", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBidsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.status != 0 {
len += 1;
}
if self.pagination.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.QueryBidsRequest", len)?;
if self.status != 0 {
let v = BidStatus::try_from(self.status).map_err(|_| {
serde::ser::Error::custom(alloc::format!("Invalid variant {}", self.status))
})?;
struct_ser.serialize_field("status", &v)?;
}
if let Some(v) = self.pagination.as_ref() {
struct_ser.serialize_field("pagination", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBidsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["status", "pagination"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Status,
Pagination,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"status" => Ok(GeneratedField::Status),
"pagination" => Ok(GeneratedField::Pagination),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBidsRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryBidsRequest")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryBidsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut status__ = None;
let mut pagination__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Status => {
if status__.is_some() {
return Err(serde::de::Error::duplicate_field("status"));
}
status__ = Some(map_.next_value::<BidStatus>()? as i32);
}
GeneratedField::Pagination => {
if pagination__.is_some() {
return Err(serde::de::Error::duplicate_field("pagination"));
}
pagination__ = map_.next_value()?;
}
}
}
Ok(QueryBidsRequest {
status: status__.unwrap_or_default(),
pagination: pagination__,
})
}
}
deserializer.deserialize_struct("side.auction.QueryBidsRequest", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryBidsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.bids.is_empty() {
len += 1;
}
if self.pagination.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("side.auction.QueryBidsResponse", len)?;
if !self.bids.is_empty() {
struct_ser.serialize_field("bids", &self.bids)?;
}
if let Some(v) = self.pagination.as_ref() {
struct_ser.serialize_field("pagination", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryBidsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["bids", "pagination"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Bids,
Pagination,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"bids" => Ok(GeneratedField::Bids),
"pagination" => Ok(GeneratedField::Pagination),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryBidsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryBidsResponse")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryBidsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut bids__ = None;
let mut pagination__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Bids => {
if bids__.is_some() {
return Err(serde::de::Error::duplicate_field("bids"));
}
bids__ = Some(map_.next_value()?);
}
GeneratedField::Pagination => {
if pagination__.is_some() {
return Err(serde::de::Error::duplicate_field("pagination"));
}
pagination__ = map_.next_value()?;
}
}
}
Ok(QueryBidsResponse {
bids: bids__.unwrap_or_default(),
pagination: pagination__,
})
}
}
deserializer.deserialize_struct("side.auction.QueryBidsResponse", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryParamsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("side.auction.QueryParamsRequest", len)?;
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryParamsRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryParamsRequest")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(QueryParamsRequest {})
}
}
deserializer.deserialize_struct("side.auction.QueryParamsRequest", FIELDS, GeneratedVisitor)
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for QueryParamsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::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("side.auction.QueryParamsResponse", len)?;
if let Some(v) = self.params.as_ref() {
struct_ser.serialize_field("params", v)?;
}
struct_ser.end()
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &["params"];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Params,
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::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 core::fmt::Formatter<'_>,
) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"params" => Ok(GeneratedField::Params),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryParamsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct side.auction.QueryParamsResponse")
}
fn visit_map<V>(
self,
mut map_: V,
) -> core::result::Result<QueryParamsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut params__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Params => {
if params__.is_some() {
return Err(serde::de::Error::duplicate_field("params"));
}
params__ = map_.next_value()?;
}
}
}
Ok(QueryParamsResponse { params: params__ })
}
}
deserializer.deserialize_struct(
"side.auction.QueryParamsResponse",
FIELDS,
GeneratedVisitor,
)
}
}