impl serde::Serialize for CreateMmRequest {
#[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 true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.CreateMmRequest", len)?;
if let Some(v) = self.mm.as_ref() {
struct_ser.serialize_field("mm", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateMmRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"mm",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Mm,
__SkipField__,
}
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 {
"mm" => Ok(GeneratedField::Mm),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.CreateMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut mm__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Mm => {
if mm__.is_some() {
return Err(serde::de::Error::duplicate_field("mm"));
}
mm__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(CreateMmRequest {
mm: mm__,
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.CreateMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for EtfPricing {
#[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.method.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.EtfPricing", len)?;
if let Some(v) = self.method.as_ref() {
match v {
etf_pricing::Method::PdfNavHedge(v) => {
struct_ser.serialize_field("pdf_nav_hedge", v)?;
}
etf_pricing::Method::IndexTrackingHedge(v) => {
struct_ser.serialize_field("index_tracking_hedge", v)?;
}
etf_pricing::Method::FutureBasis(v) => {
struct_ser.serialize_field("future_basis", v)?;
}
etf_pricing::Method::LeverageFuture(v) => {
struct_ser.serialize_field("leverage_future", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for EtfPricing {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"pdf_nav_hedge",
"pdfNavHedge",
"index_tracking_hedge",
"indexTrackingHedge",
"future_basis",
"futureBasis",
"leverage_future",
"leverageFuture",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PdfNavHedge,
IndexTrackingHedge,
FutureBasis,
LeverageFuture,
__SkipField__,
}
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 {
"pdfNavHedge" | "pdf_nav_hedge" => Ok(GeneratedField::PdfNavHedge),
"indexTrackingHedge" | "index_tracking_hedge" => Ok(GeneratedField::IndexTrackingHedge),
"futureBasis" | "future_basis" => Ok(GeneratedField::FutureBasis),
"leverageFuture" | "leverage_future" => Ok(GeneratedField::LeverageFuture),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = EtfPricing;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.EtfPricing")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<EtfPricing, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut method__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PdfNavHedge => {
if method__.is_some() {
return Err(serde::de::Error::duplicate_field("pdfNavHedge"));
}
method__ = map_.next_value::<::std::option::Option<_>>()?.map(etf_pricing::Method::PdfNavHedge)
;
}
GeneratedField::IndexTrackingHedge => {
if method__.is_some() {
return Err(serde::de::Error::duplicate_field("indexTrackingHedge"));
}
method__ = map_.next_value::<::std::option::Option<_>>()?.map(etf_pricing::Method::IndexTrackingHedge)
;
}
GeneratedField::FutureBasis => {
if method__.is_some() {
return Err(serde::de::Error::duplicate_field("futureBasis"));
}
method__ = map_.next_value::<::std::option::Option<_>>()?.map(etf_pricing::Method::FutureBasis)
;
}
GeneratedField::LeverageFuture => {
if method__.is_some() {
return Err(serde::de::Error::duplicate_field("leverageFuture"));
}
method__ = map_.next_value::<::std::option::Option<_>>()?.map(etf_pricing::Method::LeverageFuture)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(EtfPricing {
method: method__,
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.EtfPricing", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for FillStatistics {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.FillStatistics", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("buy_filled_quantity", ToString::to_string(&self.buy_filled_quantity).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("sell_filled_quantity", ToString::to_string(&self.sell_filled_quantity).as_str())?;
}
if true {
struct_ser.serialize_field("buy_total_amount", &self.buy_total_amount)?;
}
if true {
struct_ser.serialize_field("sell_total_amount", &self.sell_total_amount)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for FillStatistics {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"buy_filled_quantity",
"buyFilledQuantity",
"sell_filled_quantity",
"sellFilledQuantity",
"buy_total_amount",
"buyTotalAmount",
"sell_total_amount",
"sellTotalAmount",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
BuyFilledQuantity,
SellFilledQuantity,
BuyTotalAmount,
SellTotalAmount,
__SkipField__,
}
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 {
"buyFilledQuantity" | "buy_filled_quantity" => Ok(GeneratedField::BuyFilledQuantity),
"sellFilledQuantity" | "sell_filled_quantity" => Ok(GeneratedField::SellFilledQuantity),
"buyTotalAmount" | "buy_total_amount" => Ok(GeneratedField::BuyTotalAmount),
"sellTotalAmount" | "sell_total_amount" => Ok(GeneratedField::SellTotalAmount),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = FillStatistics;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.FillStatistics")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<FillStatistics, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut buy_filled_quantity__ = None;
let mut sell_filled_quantity__ = None;
let mut buy_total_amount__ = None;
let mut sell_total_amount__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::BuyFilledQuantity => {
if buy_filled_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("buyFilledQuantity"));
}
buy_filled_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::SellFilledQuantity => {
if sell_filled_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("sellFilledQuantity"));
}
sell_filled_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::BuyTotalAmount => {
if buy_total_amount__.is_some() {
return Err(serde::de::Error::duplicate_field("buyTotalAmount"));
}
buy_total_amount__ = Some(map_.next_value()?);
}
GeneratedField::SellTotalAmount => {
if sell_total_amount__.is_some() {
return Err(serde::de::Error::duplicate_field("sellTotalAmount"));
}
sell_total_amount__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(FillStatistics {
buy_filled_quantity: buy_filled_quantity__.unwrap_or_default(),
sell_filled_quantity: sell_filled_quantity__.unwrap_or_default(),
buy_total_amount: buy_total_amount__.unwrap_or_default(),
sell_total_amount: sell_total_amount__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.FillStatistics", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for FutureBasis {
#[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 true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.FutureBasis", len)?;
if true {
struct_ser.serialize_field("prev_index", &self.prev_index)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for FutureBasis {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"prev_index",
"prevIndex",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PrevIndex,
__SkipField__,
}
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 {
"prevIndex" | "prev_index" => Ok(GeneratedField::PrevIndex),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = FutureBasis;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.FutureBasis")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<FutureBasis, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut prev_index__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PrevIndex => {
if prev_index__.is_some() {
return Err(serde::de::Error::duplicate_field("prevIndex"));
}
prev_index__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(FutureBasis {
prev_index: prev_index__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.FutureBasis", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetMmRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.GetMmRequest", len)?;
if true {
struct_ser.serialize_field("etf", &self.etf)?;
}
if true {
struct_ser.serialize_field("fund", &self.fund)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetMmRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf",
"fund",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Etf,
Fund,
__SkipField__,
}
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 {
"etf" => Ok(GeneratedField::Etf),
"fund" => Ok(GeneratedField::Fund),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.GetMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf__ = None;
let mut fund__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Etf => {
if etf__.is_some() {
return Err(serde::de::Error::duplicate_field("etf"));
}
etf__ = Some(map_.next_value()?);
}
GeneratedField::Fund => {
if fund__.is_some() {
return Err(serde::de::Error::duplicate_field("fund"));
}
fund__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetMmRequest {
etf: etf__.unwrap_or_default(),
fund: fund__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.GetMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetMmStatusRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.GetMmStatusRequest", len)?;
if true {
struct_ser.serialize_field("etf", &self.etf)?;
}
if true {
struct_ser.serialize_field("fund", &self.fund)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetMmStatusRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf",
"fund",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Etf,
Fund,
__SkipField__,
}
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 {
"etf" => Ok(GeneratedField::Etf),
"fund" => Ok(GeneratedField::Fund),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetMmStatusRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.GetMmStatusRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMmStatusRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf__ = None;
let mut fund__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Etf => {
if etf__.is_some() {
return Err(serde::de::Error::duplicate_field("etf"));
}
etf__ = Some(map_.next_value()?);
}
GeneratedField::Fund => {
if fund__.is_some() {
return Err(serde::de::Error::duplicate_field("fund"));
}
fund__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetMmStatusRequest {
etf: etf__.unwrap_or_default(),
fund: fund__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.GetMmStatusRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetUserOrderBookRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.GetUserOrderBookRequest", len)?;
if true {
struct_ser.serialize_field("etf", &self.etf)?;
}
if true {
struct_ser.serialize_field("fund", &self.fund)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetUserOrderBookRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf",
"fund",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Etf,
Fund,
__SkipField__,
}
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 {
"etf" => Ok(GeneratedField::Etf),
"fund" => Ok(GeneratedField::Fund),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetUserOrderBookRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.GetUserOrderBookRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetUserOrderBookRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf__ = None;
let mut fund__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Etf => {
if etf__.is_some() {
return Err(serde::de::Error::duplicate_field("etf"));
}
etf__ = Some(map_.next_value()?);
}
GeneratedField::Fund => {
if fund__.is_some() {
return Err(serde::de::Error::duplicate_field("fund"));
}
fund__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetUserOrderBookRequest {
etf: etf__.unwrap_or_default(),
fund: fund__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.GetUserOrderBookRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for IndexTrackingHedgePricing {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("kdo.v1.lp.IndexTrackingHedgePricing", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for IndexTrackingHedgePricing {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
__SkipField__,
}
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,
{
Ok(GeneratedField::__SkipField__)
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = IndexTrackingHedgePricing;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.IndexTrackingHedgePricing")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<IndexTrackingHedgePricing, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(IndexTrackingHedgePricing {
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.IndexTrackingHedgePricing", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for LeverageFuturePricing {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.LeverageFuturePricing", len)?;
if true {
struct_ser.serialize_field("prev_index", &self.prev_index)?;
}
if true {
struct_ser.serialize_field("prev_future", &self.prev_future)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for LeverageFuturePricing {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"prev_index",
"prevIndex",
"prev_future",
"prevFuture",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PrevIndex,
PrevFuture,
__SkipField__,
}
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 {
"prevIndex" | "prev_index" => Ok(GeneratedField::PrevIndex),
"prevFuture" | "prev_future" => Ok(GeneratedField::PrevFuture),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = LeverageFuturePricing;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.LeverageFuturePricing")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<LeverageFuturePricing, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut prev_index__ = None;
let mut prev_future__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PrevIndex => {
if prev_index__.is_some() {
return Err(serde::de::Error::duplicate_field("prevIndex"));
}
prev_index__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::PrevFuture => {
if prev_future__.is_some() {
return Err(serde::de::Error::duplicate_field("prevFuture"));
}
prev_future__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(LeverageFuturePricing {
prev_index: prev_index__.unwrap_or_default(),
prev_future: prev_future__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.LeverageFuturePricing", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListMmStatusesRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.ListMmStatusesRequest", len)?;
if let Some(v) = self.page_size.as_ref() {
struct_ser.serialize_field("page_size", v)?;
}
if let Some(v) = self.page_token.as_ref() {
struct_ser.serialize_field("page_token", v)?;
}
if true {
struct_ser.serialize_field("filter", &self.filter)?;
}
if true {
struct_ser.serialize_field("order_by", &self.order_by)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListMmStatusesRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"page_size",
"pageSize",
"page_token",
"pageToken",
"filter",
"order_by",
"orderBy",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PageSize,
PageToken,
Filter,
OrderBy,
__SkipField__,
}
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 {
"pageSize" | "page_size" => Ok(GeneratedField::PageSize),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"filter" => Ok(GeneratedField::Filter),
"orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListMmStatusesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.ListMmStatusesRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListMmStatusesRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut page_size__ = None;
let mut page_token__ = None;
let mut filter__ = None;
let mut order_by__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PageSize => {
if page_size__.is_some() {
return Err(serde::de::Error::duplicate_field("pageSize"));
}
page_size__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::PageToken => {
if page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("pageToken"));
}
page_token__ = map_.next_value()?;
}
GeneratedField::Filter => {
if filter__.is_some() {
return Err(serde::de::Error::duplicate_field("filter"));
}
filter__ = Some(map_.next_value()?);
}
GeneratedField::OrderBy => {
if order_by__.is_some() {
return Err(serde::de::Error::duplicate_field("orderBy"));
}
order_by__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListMmStatusesRequest {
page_size: page_size__,
page_token: page_token__,
filter: filter__.unwrap_or_default(),
order_by: order_by__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.ListMmStatusesRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListMmStatusesResponse {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.ListMmStatusesResponse", len)?;
if true {
struct_ser.serialize_field("mm_statuses", &self.mm_statuses)?;
}
if true {
struct_ser.serialize_field("next_page_token", &self.next_page_token)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListMmStatusesResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"mm_statuses",
"mmStatuses",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
MmStatuses,
NextPageToken,
__SkipField__,
}
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 {
"mmStatuses" | "mm_statuses" => Ok(GeneratedField::MmStatuses),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListMmStatusesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.ListMmStatusesResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListMmStatusesResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut mm_statuses__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::MmStatuses => {
if mm_statuses__.is_some() {
return Err(serde::de::Error::duplicate_field("mmStatuses"));
}
mm_statuses__ = Some(map_.next_value()?);
}
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListMmStatusesResponse {
mm_statuses: mm_statuses__.unwrap_or_default(),
next_page_token: next_page_token__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.ListMmStatusesResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListMmsRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.ListMmsRequest", len)?;
if let Some(v) = self.page_size.as_ref() {
struct_ser.serialize_field("page_size", v)?;
}
if let Some(v) = self.page_token.as_ref() {
struct_ser.serialize_field("page_token", v)?;
}
if true {
struct_ser.serialize_field("filter", &self.filter)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListMmsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"page_size",
"pageSize",
"page_token",
"pageToken",
"filter",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PageSize,
PageToken,
Filter,
__SkipField__,
}
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 {
"pageSize" | "page_size" => Ok(GeneratedField::PageSize),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"filter" => Ok(GeneratedField::Filter),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListMmsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.ListMmsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListMmsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut page_size__ = None;
let mut page_token__ = None;
let mut filter__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PageSize => {
if page_size__.is_some() {
return Err(serde::de::Error::duplicate_field("pageSize"));
}
page_size__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::PageToken => {
if page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("pageToken"));
}
page_token__ = map_.next_value()?;
}
GeneratedField::Filter => {
if filter__.is_some() {
return Err(serde::de::Error::duplicate_field("filter"));
}
filter__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListMmsRequest {
page_size: page_size__,
page_token: page_token__,
filter: filter__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.ListMmsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListMmsResponse {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.ListMmsResponse", len)?;
if true {
struct_ser.serialize_field("mms", &self.mms)?;
}
if true {
struct_ser.serialize_field("next_page_token", &self.next_page_token)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListMmsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"mms",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Mms,
NextPageToken,
__SkipField__,
}
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 {
"mms" => Ok(GeneratedField::Mms),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListMmsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.ListMmsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListMmsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut mms__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Mms => {
if mms__.is_some() {
return Err(serde::de::Error::duplicate_field("mms"));
}
mms__ = Some(map_.next_value()?);
}
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListMmsResponse {
mms: mms__.unwrap_or_default(),
next_page_token: next_page_token__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.ListMmsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for LpPricing {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.LpPricing", len)?;
if true {
struct_ser.serialize_field("etf_ask_quote", &self.etf_ask_quote)?;
}
if true {
struct_ser.serialize_field("etf_bid_quote", &self.etf_bid_quote)?;
}
if true {
struct_ser.serialize_field("etf_ask_nav", &self.etf_ask_nav)?;
}
if true {
struct_ser.serialize_field("etf_bid_nav", &self.etf_bid_nav)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for LpPricing {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf_ask_quote",
"etfAskQuote",
"etf_bid_quote",
"etfBidQuote",
"etf_ask_nav",
"etfAskNav",
"etf_bid_nav",
"etfBidNav",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
EtfAskQuote,
EtfBidQuote,
EtfAskNav,
EtfBidNav,
__SkipField__,
}
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 {
"etfAskQuote" | "etf_ask_quote" => Ok(GeneratedField::EtfAskQuote),
"etfBidQuote" | "etf_bid_quote" => Ok(GeneratedField::EtfBidQuote),
"etfAskNav" | "etf_ask_nav" => Ok(GeneratedField::EtfAskNav),
"etfBidNav" | "etf_bid_nav" => Ok(GeneratedField::EtfBidNav),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = LpPricing;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.LpPricing")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<LpPricing, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf_ask_quote__ = None;
let mut etf_bid_quote__ = None;
let mut etf_ask_nav__ = None;
let mut etf_bid_nav__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::EtfAskQuote => {
if etf_ask_quote__.is_some() {
return Err(serde::de::Error::duplicate_field("etfAskQuote"));
}
etf_ask_quote__ = Some(map_.next_value()?);
}
GeneratedField::EtfBidQuote => {
if etf_bid_quote__.is_some() {
return Err(serde::de::Error::duplicate_field("etfBidQuote"));
}
etf_bid_quote__ = Some(map_.next_value()?);
}
GeneratedField::EtfAskNav => {
if etf_ask_nav__.is_some() {
return Err(serde::de::Error::duplicate_field("etfAskNav"));
}
etf_ask_nav__ = Some(map_.next_value()?);
}
GeneratedField::EtfBidNav => {
if etf_bid_nav__.is_some() {
return Err(serde::de::Error::duplicate_field("etfBidNav"));
}
etf_bid_nav__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(LpPricing {
etf_ask_quote: etf_ask_quote__.unwrap_or_default(),
etf_bid_quote: etf_bid_quote__.unwrap_or_default(),
etf_ask_nav: etf_ask_nav__.unwrap_or_default(),
etf_bid_nav: etf_bid_nav__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.LpPricing", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Mm {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.Mm", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
if true {
struct_ser.serialize_field("ask_basis", &self.ask_basis)?;
}
if true {
struct_ser.serialize_field("bid_basis", &self.bid_basis)?;
}
if true {
struct_ser.serialize_field("depth", &self.depth)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("tick_size", ToString::to_string(&self.tick_size).as_str())?;
}
if let Some(v) = self.offset.as_ref() {
struct_ser.serialize_field("offset", v)?;
}
if true {
struct_ser.serialize_field("enabled", &self.enabled)?;
}
if let Some(v) = self.pricing_method.as_ref() {
struct_ser.serialize_field("pricing_method", v)?;
}
if let Some(v) = self.bid_adjustment.as_ref() {
struct_ser.serialize_field("bid_adjustment", v)?;
}
if let Some(v) = self.ask_adjustment.as_ref() {
struct_ser.serialize_field("ask_adjustment", v)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("bid_quantity", ToString::to_string(&self.bid_quantity).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("ask_quantity", ToString::to_string(&self.ask_quantity).as_str())?;
}
if let Some(v) = self.momentum_enabled.as_ref() {
struct_ser.serialize_field("momentum_enabled", v)?;
}
if let Some(v) = self.momentum_window.as_ref() {
struct_ser.serialize_field("momentum_window", v)?;
}
if let Some(v) = self.momentum_sensitivity.as_ref() {
struct_ser.serialize_field("momentum_sensitivity", v)?;
}
if let Some(v) = self.quantity_limit.as_ref() {
struct_ser.serialize_field("quantity_limit", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Mm {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
"fund_code",
"fundCode",
"ask_basis",
"askBasis",
"bid_basis",
"bidBasis",
"depth",
"tick_size",
"tickSize",
"offset",
"enabled",
"pricing_method",
"pricingMethod",
"bid_adjustment",
"bidAdjustment",
"ask_adjustment",
"askAdjustment",
"bid_quantity",
"bidQuantity",
"ask_quantity",
"askQuantity",
"momentum_enabled",
"momentumEnabled",
"momentum_window",
"momentumWindow",
"momentum_sensitivity",
"momentumSensitivity",
"quantity_limit",
"quantityLimit",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
FundCode,
AskBasis,
BidBasis,
Depth,
TickSize,
Offset,
Enabled,
PricingMethod,
BidAdjustment,
AskAdjustment,
BidQuantity,
AskQuantity,
MomentumEnabled,
MomentumWindow,
MomentumSensitivity,
QuantityLimit,
__SkipField__,
}
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 {
"symbol" => Ok(GeneratedField::Symbol),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
"askBasis" | "ask_basis" => Ok(GeneratedField::AskBasis),
"bidBasis" | "bid_basis" => Ok(GeneratedField::BidBasis),
"depth" => Ok(GeneratedField::Depth),
"tickSize" | "tick_size" => Ok(GeneratedField::TickSize),
"offset" => Ok(GeneratedField::Offset),
"enabled" => Ok(GeneratedField::Enabled),
"pricingMethod" | "pricing_method" => Ok(GeneratedField::PricingMethod),
"bidAdjustment" | "bid_adjustment" => Ok(GeneratedField::BidAdjustment),
"askAdjustment" | "ask_adjustment" => Ok(GeneratedField::AskAdjustment),
"bidQuantity" | "bid_quantity" => Ok(GeneratedField::BidQuantity),
"askQuantity" | "ask_quantity" => Ok(GeneratedField::AskQuantity),
"momentumEnabled" | "momentum_enabled" => Ok(GeneratedField::MomentumEnabled),
"momentumWindow" | "momentum_window" => Ok(GeneratedField::MomentumWindow),
"momentumSensitivity" | "momentum_sensitivity" => Ok(GeneratedField::MomentumSensitivity),
"quantityLimit" | "quantity_limit" => Ok(GeneratedField::QuantityLimit),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Mm;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.Mm")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Mm, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut fund_code__ = None;
let mut ask_basis__ = None;
let mut bid_basis__ = None;
let mut depth__ = None;
let mut tick_size__ = None;
let mut offset__ = None;
let mut enabled__ = None;
let mut pricing_method__ = None;
let mut bid_adjustment__ = None;
let mut ask_adjustment__ = None;
let mut bid_quantity__ = None;
let mut ask_quantity__ = None;
let mut momentum_enabled__ = None;
let mut momentum_window__ = None;
let mut momentum_sensitivity__ = None;
let mut quantity_limit__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::FundCode => {
if fund_code__.is_some() {
return Err(serde::de::Error::duplicate_field("fundCode"));
}
fund_code__ = Some(map_.next_value()?);
}
GeneratedField::AskBasis => {
if ask_basis__.is_some() {
return Err(serde::de::Error::duplicate_field("askBasis"));
}
ask_basis__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::BidBasis => {
if bid_basis__.is_some() {
return Err(serde::de::Error::duplicate_field("bidBasis"));
}
bid_basis__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Depth => {
if depth__.is_some() {
return Err(serde::de::Error::duplicate_field("depth"));
}
depth__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::TickSize => {
if tick_size__.is_some() {
return Err(serde::de::Error::duplicate_field("tickSize"));
}
tick_size__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Offset => {
if offset__.is_some() {
return Err(serde::de::Error::duplicate_field("offset"));
}
offset__ = map_.next_value()?;
}
GeneratedField::Enabled => {
if enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("enabled"));
}
enabled__ = Some(map_.next_value()?);
}
GeneratedField::PricingMethod => {
if pricing_method__.is_some() {
return Err(serde::de::Error::duplicate_field("pricingMethod"));
}
pricing_method__ = map_.next_value()?;
}
GeneratedField::BidAdjustment => {
if bid_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("bidAdjustment"));
}
bid_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::AskAdjustment => {
if ask_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("askAdjustment"));
}
ask_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::BidQuantity => {
if bid_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("bidQuantity"));
}
bid_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::AskQuantity => {
if ask_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("askQuantity"));
}
ask_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MomentumEnabled => {
if momentum_enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumEnabled"));
}
momentum_enabled__ = map_.next_value()?;
}
GeneratedField::MomentumWindow => {
if momentum_window__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumWindow"));
}
momentum_window__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumSensitivity => {
if momentum_sensitivity__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumSensitivity"));
}
momentum_sensitivity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::QuantityLimit => {
if quantity_limit__.is_some() {
return Err(serde::de::Error::duplicate_field("quantityLimit"));
}
quantity_limit__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(Mm {
symbol: symbol__.unwrap_or_default(),
fund_code: fund_code__.unwrap_or_default(),
ask_basis: ask_basis__.unwrap_or_default(),
bid_basis: bid_basis__.unwrap_or_default(),
depth: depth__.unwrap_or_default(),
tick_size: tick_size__.unwrap_or_default(),
offset: offset__,
enabled: enabled__.unwrap_or_default(),
pricing_method: pricing_method__,
bid_adjustment: bid_adjustment__,
ask_adjustment: ask_adjustment__,
bid_quantity: bid_quantity__.unwrap_or_default(),
ask_quantity: ask_quantity__.unwrap_or_default(),
momentum_enabled: momentum_enabled__,
momentum_window: momentum_window__,
momentum_sensitivity: momentum_sensitivity__,
quantity_limit: quantity_limit__,
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.Mm", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmHedge {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.MmHedge", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
struct_ser.serialize_field("fund", &self.fund)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("filled_quantity_per_hedge", ToString::to_string(&self.filled_quantity_per_hedge).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmHedge {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
"fund",
"filled_quantity_per_hedge",
"filledQuantityPerHedge",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
Fund,
FilledQuantityPerHedge,
__SkipField__,
}
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 {
"symbol" => Ok(GeneratedField::Symbol),
"fund" => Ok(GeneratedField::Fund),
"filledQuantityPerHedge" | "filled_quantity_per_hedge" => Ok(GeneratedField::FilledQuantityPerHedge),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmHedge;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.MmHedge")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmHedge, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut fund__ = None;
let mut filled_quantity_per_hedge__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::Fund => {
if fund__.is_some() {
return Err(serde::de::Error::duplicate_field("fund"));
}
fund__ = Some(map_.next_value()?);
}
GeneratedField::FilledQuantityPerHedge => {
if filled_quantity_per_hedge__.is_some() {
return Err(serde::de::Error::duplicate_field("filledQuantityPerHedge"));
}
filled_quantity_per_hedge__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmHedge {
symbol: symbol__.unwrap_or_default(),
fund: fund__.unwrap_or_default(),
filled_quantity_per_hedge: filled_quantity_per_hedge__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.MmHedge", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmOffset {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.MmOffset", len)?;
if true {
struct_ser.serialize_field("bid_offset", &self.bid_offset)?;
}
if true {
struct_ser.serialize_field("ask_offset", &self.ask_offset)?;
}
if true {
struct_ser.serialize_field("min_offset", &self.min_offset)?;
}
if true {
struct_ser.serialize_field("max_offset", &self.max_offset)?;
}
if true {
struct_ser.serialize_field("time_adjustment_enabled", &self.time_adjustment_enabled)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("adjustment_interval_secs", ToString::to_string(&self.adjustment_interval_secs).as_str())?;
}
if true {
struct_ser.serialize_field("adjustment_step", &self.adjustment_step)?;
}
if true {
struct_ser.serialize_field("reset_on_fill", &self.reset_on_fill)?;
}
if true {
struct_ser.serialize_field("position_adjustment_enabled", &self.position_adjustment_enabled)?;
}
if true {
let v = PositionAdjustmentStrategy::try_from(self.position_strategy)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.position_strategy)))?;
struct_ser.serialize_field("position_strategy", &v)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("position_threshold", ToString::to_string(&self.position_threshold).as_str())?;
}
if true {
struct_ser.serialize_field("position_adjustment_step", &self.position_adjustment_step)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmOffset {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"bid_offset",
"bidOffset",
"ask_offset",
"askOffset",
"min_offset",
"minOffset",
"max_offset",
"maxOffset",
"time_adjustment_enabled",
"timeAdjustmentEnabled",
"adjustment_interval_secs",
"adjustmentIntervalSecs",
"adjustment_step",
"adjustmentStep",
"reset_on_fill",
"resetOnFill",
"position_adjustment_enabled",
"positionAdjustmentEnabled",
"position_strategy",
"positionStrategy",
"position_threshold",
"positionThreshold",
"position_adjustment_step",
"positionAdjustmentStep",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
BidOffset,
AskOffset,
MinOffset,
MaxOffset,
TimeAdjustmentEnabled,
AdjustmentIntervalSecs,
AdjustmentStep,
ResetOnFill,
PositionAdjustmentEnabled,
PositionStrategy,
PositionThreshold,
PositionAdjustmentStep,
__SkipField__,
}
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 {
"bidOffset" | "bid_offset" => Ok(GeneratedField::BidOffset),
"askOffset" | "ask_offset" => Ok(GeneratedField::AskOffset),
"minOffset" | "min_offset" => Ok(GeneratedField::MinOffset),
"maxOffset" | "max_offset" => Ok(GeneratedField::MaxOffset),
"timeAdjustmentEnabled" | "time_adjustment_enabled" => Ok(GeneratedField::TimeAdjustmentEnabled),
"adjustmentIntervalSecs" | "adjustment_interval_secs" => Ok(GeneratedField::AdjustmentIntervalSecs),
"adjustmentStep" | "adjustment_step" => Ok(GeneratedField::AdjustmentStep),
"resetOnFill" | "reset_on_fill" => Ok(GeneratedField::ResetOnFill),
"positionAdjustmentEnabled" | "position_adjustment_enabled" => Ok(GeneratedField::PositionAdjustmentEnabled),
"positionStrategy" | "position_strategy" => Ok(GeneratedField::PositionStrategy),
"positionThreshold" | "position_threshold" => Ok(GeneratedField::PositionThreshold),
"positionAdjustmentStep" | "position_adjustment_step" => Ok(GeneratedField::PositionAdjustmentStep),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmOffset;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.MmOffset")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmOffset, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut bid_offset__ = None;
let mut ask_offset__ = None;
let mut min_offset__ = None;
let mut max_offset__ = None;
let mut time_adjustment_enabled__ = None;
let mut adjustment_interval_secs__ = None;
let mut adjustment_step__ = None;
let mut reset_on_fill__ = None;
let mut position_adjustment_enabled__ = None;
let mut position_strategy__ = None;
let mut position_threshold__ = None;
let mut position_adjustment_step__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::BidOffset => {
if bid_offset__.is_some() {
return Err(serde::de::Error::duplicate_field("bidOffset"));
}
bid_offset__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::AskOffset => {
if ask_offset__.is_some() {
return Err(serde::de::Error::duplicate_field("askOffset"));
}
ask_offset__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MinOffset => {
if min_offset__.is_some() {
return Err(serde::de::Error::duplicate_field("minOffset"));
}
min_offset__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MaxOffset => {
if max_offset__.is_some() {
return Err(serde::de::Error::duplicate_field("maxOffset"));
}
max_offset__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::TimeAdjustmentEnabled => {
if time_adjustment_enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("timeAdjustmentEnabled"));
}
time_adjustment_enabled__ = Some(map_.next_value()?);
}
GeneratedField::AdjustmentIntervalSecs => {
if adjustment_interval_secs__.is_some() {
return Err(serde::de::Error::duplicate_field("adjustmentIntervalSecs"));
}
adjustment_interval_secs__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::AdjustmentStep => {
if adjustment_step__.is_some() {
return Err(serde::de::Error::duplicate_field("adjustmentStep"));
}
adjustment_step__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::ResetOnFill => {
if reset_on_fill__.is_some() {
return Err(serde::de::Error::duplicate_field("resetOnFill"));
}
reset_on_fill__ = Some(map_.next_value()?);
}
GeneratedField::PositionAdjustmentEnabled => {
if position_adjustment_enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("positionAdjustmentEnabled"));
}
position_adjustment_enabled__ = Some(map_.next_value()?);
}
GeneratedField::PositionStrategy => {
if position_strategy__.is_some() {
return Err(serde::de::Error::duplicate_field("positionStrategy"));
}
position_strategy__ = Some(map_.next_value::<PositionAdjustmentStrategy>()? as i32);
}
GeneratedField::PositionThreshold => {
if position_threshold__.is_some() {
return Err(serde::de::Error::duplicate_field("positionThreshold"));
}
position_threshold__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::PositionAdjustmentStep => {
if position_adjustment_step__.is_some() {
return Err(serde::de::Error::duplicate_field("positionAdjustmentStep"));
}
position_adjustment_step__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmOffset {
bid_offset: bid_offset__.unwrap_or_default(),
ask_offset: ask_offset__.unwrap_or_default(),
min_offset: min_offset__.unwrap_or_default(),
max_offset: max_offset__.unwrap_or_default(),
time_adjustment_enabled: time_adjustment_enabled__.unwrap_or_default(),
adjustment_interval_secs: adjustment_interval_secs__.unwrap_or_default(),
adjustment_step: adjustment_step__.unwrap_or_default(),
reset_on_fill: reset_on_fill__.unwrap_or_default(),
position_adjustment_enabled: position_adjustment_enabled__.unwrap_or_default(),
position_strategy: position_strategy__.unwrap_or_default(),
position_threshold: position_threshold__.unwrap_or_default(),
position_adjustment_step: position_adjustment_step__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.MmOffset", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmQuantityLimit {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.MmQuantityLimit", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("max_bid_quantity", ToString::to_string(&self.max_bid_quantity).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("max_ask_quantity", ToString::to_string(&self.max_ask_quantity).as_str())?;
}
if let Some(v) = self.net_quantity.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("net_quantity", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.max_net_quantity.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("max_net_quantity", ToString::to_string(&v).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmQuantityLimit {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"max_bid_quantity",
"maxBidQuantity",
"max_ask_quantity",
"maxAskQuantity",
"net_quantity",
"netQuantity",
"max_net_quantity",
"maxNetQuantity",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
MaxBidQuantity,
MaxAskQuantity,
NetQuantity,
MaxNetQuantity,
__SkipField__,
}
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 {
"maxBidQuantity" | "max_bid_quantity" => Ok(GeneratedField::MaxBidQuantity),
"maxAskQuantity" | "max_ask_quantity" => Ok(GeneratedField::MaxAskQuantity),
"netQuantity" | "net_quantity" => Ok(GeneratedField::NetQuantity),
"maxNetQuantity" | "max_net_quantity" => Ok(GeneratedField::MaxNetQuantity),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmQuantityLimit;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.MmQuantityLimit")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmQuantityLimit, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut max_bid_quantity__ = None;
let mut max_ask_quantity__ = None;
let mut net_quantity__ = None;
let mut max_net_quantity__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::MaxBidQuantity => {
if max_bid_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("maxBidQuantity"));
}
max_bid_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MaxAskQuantity => {
if max_ask_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("maxAskQuantity"));
}
max_ask_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::NetQuantity => {
if net_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("netQuantity"));
}
net_quantity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MaxNetQuantity => {
if max_net_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("maxNetQuantity"));
}
max_net_quantity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmQuantityLimit {
max_bid_quantity: max_bid_quantity__.unwrap_or_default(),
max_ask_quantity: max_ask_quantity__.unwrap_or_default(),
net_quantity: net_quantity__,
max_net_quantity: max_net_quantity__,
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.MmQuantityLimit", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmState {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "MM_STATE_UNSPECIFIED",
Self::Idle => "MM_STATE_IDLE",
Self::Running => "MM_STATE_RUNNING",
Self::Stopping => "MM_STATE_STOPPING",
Self::Error => "MM_STATE_ERROR",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for MmState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"MM_STATE_UNSPECIFIED",
"MM_STATE_IDLE",
"MM_STATE_RUNNING",
"MM_STATE_STOPPING",
"MM_STATE_ERROR",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmState;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::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) -> std::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) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"MM_STATE_UNSPECIFIED" => Ok(MmState::Unspecified),
"MM_STATE_IDLE" => Ok(MmState::Idle),
"MM_STATE_RUNNING" => Ok(MmState::Running),
"MM_STATE_STOPPING" => Ok(MmState::Stopping),
"MM_STATE_ERROR" => Ok(MmState::Error),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for MmStatus {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.MmStatus", len)?;
if true {
struct_ser.serialize_field("etf_symbol", &self.etf_symbol)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
if let Some(v) = self.ask_basis.as_ref() {
struct_ser.serialize_field("ask_basis", v)?;
}
if let Some(v) = self.bid_basis.as_ref() {
struct_ser.serialize_field("bid_basis", v)?;
}
if true {
let v = MmState::try_from(self.state)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
struct_ser.serialize_field("state", &v)?;
}
if let Some(v) = self.pricing.as_ref() {
struct_ser.serialize_field("pricing", v)?;
}
if let Some(v) = self.fill_statistics.as_ref() {
struct_ser.serialize_field("fill_statistics", v)?;
}
if let Some(v) = self.offset.as_ref() {
struct_ser.serialize_field("offset", v)?;
}
if let Some(v) = self.hedge.as_ref() {
struct_ser.serialize_field("hedge", v)?;
}
if let Some(v) = self.bid_adjustment.as_ref() {
struct_ser.serialize_field("bid_adjustment", v)?;
}
if let Some(v) = self.ask_adjustment.as_ref() {
struct_ser.serialize_field("ask_adjustment", v)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("bid_quantity", ToString::to_string(&self.bid_quantity).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("ask_quantity", ToString::to_string(&self.ask_quantity).as_str())?;
}
if let Some(v) = self.momentum_enabled.as_ref() {
struct_ser.serialize_field("momentum_enabled", v)?;
}
if let Some(v) = self.momentum_window.as_ref() {
struct_ser.serialize_field("momentum_window", v)?;
}
if let Some(v) = self.momentum_sensitivity.as_ref() {
struct_ser.serialize_field("momentum_sensitivity", v)?;
}
if let Some(v) = self.momentum_bid_adjustment.as_ref() {
struct_ser.serialize_field("momentum_bid_adjustment", v)?;
}
if let Some(v) = self.momentum_ask_adjustment.as_ref() {
struct_ser.serialize_field("momentum_ask_adjustment", v)?;
}
if let Some(v) = self.quantity_limit.as_ref() {
struct_ser.serialize_field("quantity_limit", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmStatus {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf_symbol",
"etfSymbol",
"fund_code",
"fundCode",
"ask_basis",
"askBasis",
"bid_basis",
"bidBasis",
"state",
"pricing",
"fill_statistics",
"fillStatistics",
"offset",
"hedge",
"bid_adjustment",
"bidAdjustment",
"ask_adjustment",
"askAdjustment",
"bid_quantity",
"bidQuantity",
"ask_quantity",
"askQuantity",
"momentum_enabled",
"momentumEnabled",
"momentum_window",
"momentumWindow",
"momentum_sensitivity",
"momentumSensitivity",
"momentum_bid_adjustment",
"momentumBidAdjustment",
"momentum_ask_adjustment",
"momentumAskAdjustment",
"quantity_limit",
"quantityLimit",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
EtfSymbol,
FundCode,
AskBasis,
BidBasis,
State,
Pricing,
FillStatistics,
Offset,
Hedge,
BidAdjustment,
AskAdjustment,
BidQuantity,
AskQuantity,
MomentumEnabled,
MomentumWindow,
MomentumSensitivity,
MomentumBidAdjustment,
MomentumAskAdjustment,
QuantityLimit,
__SkipField__,
}
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 {
"etfSymbol" | "etf_symbol" => Ok(GeneratedField::EtfSymbol),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
"askBasis" | "ask_basis" => Ok(GeneratedField::AskBasis),
"bidBasis" | "bid_basis" => Ok(GeneratedField::BidBasis),
"state" => Ok(GeneratedField::State),
"pricing" => Ok(GeneratedField::Pricing),
"fillStatistics" | "fill_statistics" => Ok(GeneratedField::FillStatistics),
"offset" => Ok(GeneratedField::Offset),
"hedge" => Ok(GeneratedField::Hedge),
"bidAdjustment" | "bid_adjustment" => Ok(GeneratedField::BidAdjustment),
"askAdjustment" | "ask_adjustment" => Ok(GeneratedField::AskAdjustment),
"bidQuantity" | "bid_quantity" => Ok(GeneratedField::BidQuantity),
"askQuantity" | "ask_quantity" => Ok(GeneratedField::AskQuantity),
"momentumEnabled" | "momentum_enabled" => Ok(GeneratedField::MomentumEnabled),
"momentumWindow" | "momentum_window" => Ok(GeneratedField::MomentumWindow),
"momentumSensitivity" | "momentum_sensitivity" => Ok(GeneratedField::MomentumSensitivity),
"momentumBidAdjustment" | "momentum_bid_adjustment" => Ok(GeneratedField::MomentumBidAdjustment),
"momentumAskAdjustment" | "momentum_ask_adjustment" => Ok(GeneratedField::MomentumAskAdjustment),
"quantityLimit" | "quantity_limit" => Ok(GeneratedField::QuantityLimit),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmStatus;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.MmStatus")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmStatus, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf_symbol__ = None;
let mut fund_code__ = None;
let mut ask_basis__ = None;
let mut bid_basis__ = None;
let mut state__ = None;
let mut pricing__ = None;
let mut fill_statistics__ = None;
let mut offset__ = None;
let mut hedge__ = None;
let mut bid_adjustment__ = None;
let mut ask_adjustment__ = None;
let mut bid_quantity__ = None;
let mut ask_quantity__ = None;
let mut momentum_enabled__ = None;
let mut momentum_window__ = None;
let mut momentum_sensitivity__ = None;
let mut momentum_bid_adjustment__ = None;
let mut momentum_ask_adjustment__ = None;
let mut quantity_limit__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::EtfSymbol => {
if etf_symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("etfSymbol"));
}
etf_symbol__ = Some(map_.next_value()?);
}
GeneratedField::FundCode => {
if fund_code__.is_some() {
return Err(serde::de::Error::duplicate_field("fundCode"));
}
fund_code__ = Some(map_.next_value()?);
}
GeneratedField::AskBasis => {
if ask_basis__.is_some() {
return Err(serde::de::Error::duplicate_field("askBasis"));
}
ask_basis__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::BidBasis => {
if bid_basis__.is_some() {
return Err(serde::de::Error::duplicate_field("bidBasis"));
}
bid_basis__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::State => {
if state__.is_some() {
return Err(serde::de::Error::duplicate_field("state"));
}
state__ = Some(map_.next_value::<MmState>()? as i32);
}
GeneratedField::Pricing => {
if pricing__.is_some() {
return Err(serde::de::Error::duplicate_field("pricing"));
}
pricing__ = map_.next_value()?;
}
GeneratedField::FillStatistics => {
if fill_statistics__.is_some() {
return Err(serde::de::Error::duplicate_field("fillStatistics"));
}
fill_statistics__ = map_.next_value()?;
}
GeneratedField::Offset => {
if offset__.is_some() {
return Err(serde::de::Error::duplicate_field("offset"));
}
offset__ = map_.next_value()?;
}
GeneratedField::Hedge => {
if hedge__.is_some() {
return Err(serde::de::Error::duplicate_field("hedge"));
}
hedge__ = map_.next_value()?;
}
GeneratedField::BidAdjustment => {
if bid_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("bidAdjustment"));
}
bid_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::AskAdjustment => {
if ask_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("askAdjustment"));
}
ask_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::BidQuantity => {
if bid_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("bidQuantity"));
}
bid_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::AskQuantity => {
if ask_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("askQuantity"));
}
ask_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MomentumEnabled => {
if momentum_enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumEnabled"));
}
momentum_enabled__ = map_.next_value()?;
}
GeneratedField::MomentumWindow => {
if momentum_window__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumWindow"));
}
momentum_window__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumSensitivity => {
if momentum_sensitivity__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumSensitivity"));
}
momentum_sensitivity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumBidAdjustment => {
if momentum_bid_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumBidAdjustment"));
}
momentum_bid_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumAskAdjustment => {
if momentum_ask_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumAskAdjustment"));
}
momentum_ask_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::QuantityLimit => {
if quantity_limit__.is_some() {
return Err(serde::de::Error::duplicate_field("quantityLimit"));
}
quantity_limit__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmStatus {
etf_symbol: etf_symbol__.unwrap_or_default(),
fund_code: fund_code__.unwrap_or_default(),
ask_basis: ask_basis__,
bid_basis: bid_basis__,
state: state__.unwrap_or_default(),
pricing: pricing__,
fill_statistics: fill_statistics__,
offset: offset__,
hedge: hedge__,
bid_adjustment: bid_adjustment__,
ask_adjustment: ask_adjustment__,
bid_quantity: bid_quantity__.unwrap_or_default(),
ask_quantity: ask_quantity__.unwrap_or_default(),
momentum_enabled: momentum_enabled__,
momentum_window: momentum_window__,
momentum_sensitivity: momentum_sensitivity__,
momentum_bid_adjustment: momentum_bid_adjustment__,
momentum_ask_adjustment: momentum_ask_adjustment__,
quantity_limit: quantity_limit__,
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.MmStatus", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmStatusUpdate {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.MmStatusUpdate", len)?;
if true {
struct_ser.serialize_field("etf_symbol", &self.etf_symbol)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
if let Some(v) = self.ask_basis.as_ref() {
struct_ser.serialize_field("ask_basis", v)?;
}
if let Some(v) = self.bid_basis.as_ref() {
struct_ser.serialize_field("bid_basis", v)?;
}
if let Some(v) = self.state.as_ref() {
let v = MmState::try_from(*v)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
struct_ser.serialize_field("state", &v)?;
}
if let Some(v) = self.pricing.as_ref() {
struct_ser.serialize_field("pricing", v)?;
}
if let Some(v) = self.fill_statistics.as_ref() {
struct_ser.serialize_field("fill_statistics", v)?;
}
if let Some(v) = self.offset.as_ref() {
struct_ser.serialize_field("offset", v)?;
}
if let Some(v) = self.bid_adjustment.as_ref() {
struct_ser.serialize_field("bid_adjustment", v)?;
}
if let Some(v) = self.ask_adjustment.as_ref() {
struct_ser.serialize_field("ask_adjustment", v)?;
}
if let Some(v) = self.bid_quantity.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("bid_quantity", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.ask_quantity.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("ask_quantity", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.momentum_enabled.as_ref() {
struct_ser.serialize_field("momentum_enabled", v)?;
}
if let Some(v) = self.momentum_window.as_ref() {
struct_ser.serialize_field("momentum_window", v)?;
}
if let Some(v) = self.momentum_sensitivity.as_ref() {
struct_ser.serialize_field("momentum_sensitivity", v)?;
}
if let Some(v) = self.momentum_bid_adjustment.as_ref() {
struct_ser.serialize_field("momentum_bid_adjustment", v)?;
}
if let Some(v) = self.momentum_ask_adjustment.as_ref() {
struct_ser.serialize_field("momentum_ask_adjustment", v)?;
}
if let Some(v) = self.quantity_limit.as_ref() {
struct_ser.serialize_field("quantity_limit", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmStatusUpdate {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf_symbol",
"etfSymbol",
"fund_code",
"fundCode",
"ask_basis",
"askBasis",
"bid_basis",
"bidBasis",
"state",
"pricing",
"fill_statistics",
"fillStatistics",
"offset",
"bid_adjustment",
"bidAdjustment",
"ask_adjustment",
"askAdjustment",
"bid_quantity",
"bidQuantity",
"ask_quantity",
"askQuantity",
"momentum_enabled",
"momentumEnabled",
"momentum_window",
"momentumWindow",
"momentum_sensitivity",
"momentumSensitivity",
"momentum_bid_adjustment",
"momentumBidAdjustment",
"momentum_ask_adjustment",
"momentumAskAdjustment",
"quantity_limit",
"quantityLimit",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
EtfSymbol,
FundCode,
AskBasis,
BidBasis,
State,
Pricing,
FillStatistics,
Offset,
BidAdjustment,
AskAdjustment,
BidQuantity,
AskQuantity,
MomentumEnabled,
MomentumWindow,
MomentumSensitivity,
MomentumBidAdjustment,
MomentumAskAdjustment,
QuantityLimit,
__SkipField__,
}
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 {
"etfSymbol" | "etf_symbol" => Ok(GeneratedField::EtfSymbol),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
"askBasis" | "ask_basis" => Ok(GeneratedField::AskBasis),
"bidBasis" | "bid_basis" => Ok(GeneratedField::BidBasis),
"state" => Ok(GeneratedField::State),
"pricing" => Ok(GeneratedField::Pricing),
"fillStatistics" | "fill_statistics" => Ok(GeneratedField::FillStatistics),
"offset" => Ok(GeneratedField::Offset),
"bidAdjustment" | "bid_adjustment" => Ok(GeneratedField::BidAdjustment),
"askAdjustment" | "ask_adjustment" => Ok(GeneratedField::AskAdjustment),
"bidQuantity" | "bid_quantity" => Ok(GeneratedField::BidQuantity),
"askQuantity" | "ask_quantity" => Ok(GeneratedField::AskQuantity),
"momentumEnabled" | "momentum_enabled" => Ok(GeneratedField::MomentumEnabled),
"momentumWindow" | "momentum_window" => Ok(GeneratedField::MomentumWindow),
"momentumSensitivity" | "momentum_sensitivity" => Ok(GeneratedField::MomentumSensitivity),
"momentumBidAdjustment" | "momentum_bid_adjustment" => Ok(GeneratedField::MomentumBidAdjustment),
"momentumAskAdjustment" | "momentum_ask_adjustment" => Ok(GeneratedField::MomentumAskAdjustment),
"quantityLimit" | "quantity_limit" => Ok(GeneratedField::QuantityLimit),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmStatusUpdate;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.MmStatusUpdate")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmStatusUpdate, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf_symbol__ = None;
let mut fund_code__ = None;
let mut ask_basis__ = None;
let mut bid_basis__ = None;
let mut state__ = None;
let mut pricing__ = None;
let mut fill_statistics__ = None;
let mut offset__ = None;
let mut bid_adjustment__ = None;
let mut ask_adjustment__ = None;
let mut bid_quantity__ = None;
let mut ask_quantity__ = None;
let mut momentum_enabled__ = None;
let mut momentum_window__ = None;
let mut momentum_sensitivity__ = None;
let mut momentum_bid_adjustment__ = None;
let mut momentum_ask_adjustment__ = None;
let mut quantity_limit__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::EtfSymbol => {
if etf_symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("etfSymbol"));
}
etf_symbol__ = Some(map_.next_value()?);
}
GeneratedField::FundCode => {
if fund_code__.is_some() {
return Err(serde::de::Error::duplicate_field("fundCode"));
}
fund_code__ = Some(map_.next_value()?);
}
GeneratedField::AskBasis => {
if ask_basis__.is_some() {
return Err(serde::de::Error::duplicate_field("askBasis"));
}
ask_basis__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::BidBasis => {
if bid_basis__.is_some() {
return Err(serde::de::Error::duplicate_field("bidBasis"));
}
bid_basis__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::State => {
if state__.is_some() {
return Err(serde::de::Error::duplicate_field("state"));
}
state__ = map_.next_value::<::std::option::Option<MmState>>()?.map(|x| x as i32);
}
GeneratedField::Pricing => {
if pricing__.is_some() {
return Err(serde::de::Error::duplicate_field("pricing"));
}
pricing__ = map_.next_value()?;
}
GeneratedField::FillStatistics => {
if fill_statistics__.is_some() {
return Err(serde::de::Error::duplicate_field("fillStatistics"));
}
fill_statistics__ = map_.next_value()?;
}
GeneratedField::Offset => {
if offset__.is_some() {
return Err(serde::de::Error::duplicate_field("offset"));
}
offset__ = map_.next_value()?;
}
GeneratedField::BidAdjustment => {
if bid_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("bidAdjustment"));
}
bid_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::AskAdjustment => {
if ask_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("askAdjustment"));
}
ask_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::BidQuantity => {
if bid_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("bidQuantity"));
}
bid_quantity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::AskQuantity => {
if ask_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("askQuantity"));
}
ask_quantity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumEnabled => {
if momentum_enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumEnabled"));
}
momentum_enabled__ = map_.next_value()?;
}
GeneratedField::MomentumWindow => {
if momentum_window__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumWindow"));
}
momentum_window__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumSensitivity => {
if momentum_sensitivity__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumSensitivity"));
}
momentum_sensitivity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumBidAdjustment => {
if momentum_bid_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumBidAdjustment"));
}
momentum_bid_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumAskAdjustment => {
if momentum_ask_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumAskAdjustment"));
}
momentum_ask_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::QuantityLimit => {
if quantity_limit__.is_some() {
return Err(serde::de::Error::duplicate_field("quantityLimit"));
}
quantity_limit__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmStatusUpdate {
etf_symbol: etf_symbol__.unwrap_or_default(),
fund_code: fund_code__.unwrap_or_default(),
ask_basis: ask_basis__,
bid_basis: bid_basis__,
state: state__,
pricing: pricing__,
fill_statistics: fill_statistics__,
offset: offset__,
bid_adjustment: bid_adjustment__,
ask_adjustment: ask_adjustment__,
bid_quantity: bid_quantity__,
ask_quantity: ask_quantity__,
momentum_enabled: momentum_enabled__,
momentum_window: momentum_window__,
momentum_sensitivity: momentum_sensitivity__,
momentum_bid_adjustment: momentum_bid_adjustment__,
momentum_ask_adjustment: momentum_ask_adjustment__,
quantity_limit: quantity_limit__,
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.MmStatusUpdate", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for OrderStats {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.OrderStats", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("total_orders_sent", ToString::to_string(&self.total_orders_sent).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("orders_accepted", ToString::to_string(&self.orders_accepted).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("orders_rejected", ToString::to_string(&self.orders_rejected).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("orders_filled", ToString::to_string(&self.orders_filled).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("total_filled_quantity", ToString::to_string(&self.total_filled_quantity).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("daily_filled_quantity", ToString::to_string(&self.daily_filled_quantity).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for OrderStats {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"total_orders_sent",
"totalOrdersSent",
"orders_accepted",
"ordersAccepted",
"orders_rejected",
"ordersRejected",
"orders_filled",
"ordersFilled",
"total_filled_quantity",
"totalFilledQuantity",
"daily_filled_quantity",
"dailyFilledQuantity",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
TotalOrdersSent,
OrdersAccepted,
OrdersRejected,
OrdersFilled,
TotalFilledQuantity,
DailyFilledQuantity,
__SkipField__,
}
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 {
"totalOrdersSent" | "total_orders_sent" => Ok(GeneratedField::TotalOrdersSent),
"ordersAccepted" | "orders_accepted" => Ok(GeneratedField::OrdersAccepted),
"ordersRejected" | "orders_rejected" => Ok(GeneratedField::OrdersRejected),
"ordersFilled" | "orders_filled" => Ok(GeneratedField::OrdersFilled),
"totalFilledQuantity" | "total_filled_quantity" => Ok(GeneratedField::TotalFilledQuantity),
"dailyFilledQuantity" | "daily_filled_quantity" => Ok(GeneratedField::DailyFilledQuantity),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = OrderStats;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.OrderStats")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<OrderStats, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut total_orders_sent__ = None;
let mut orders_accepted__ = None;
let mut orders_rejected__ = None;
let mut orders_filled__ = None;
let mut total_filled_quantity__ = None;
let mut daily_filled_quantity__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::TotalOrdersSent => {
if total_orders_sent__.is_some() {
return Err(serde::de::Error::duplicate_field("totalOrdersSent"));
}
total_orders_sent__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::OrdersAccepted => {
if orders_accepted__.is_some() {
return Err(serde::de::Error::duplicate_field("ordersAccepted"));
}
orders_accepted__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::OrdersRejected => {
if orders_rejected__.is_some() {
return Err(serde::de::Error::duplicate_field("ordersRejected"));
}
orders_rejected__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::OrdersFilled => {
if orders_filled__.is_some() {
return Err(serde::de::Error::duplicate_field("ordersFilled"));
}
orders_filled__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::TotalFilledQuantity => {
if total_filled_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("totalFilledQuantity"));
}
total_filled_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::DailyFilledQuantity => {
if daily_filled_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("dailyFilledQuantity"));
}
daily_filled_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(OrderStats {
total_orders_sent: total_orders_sent__.unwrap_or_default(),
orders_accepted: orders_accepted__.unwrap_or_default(),
orders_rejected: orders_rejected__.unwrap_or_default(),
orders_filled: orders_filled__.unwrap_or_default(),
total_filled_quantity: total_filled_quantity__.unwrap_or_default(),
daily_filled_quantity: daily_filled_quantity__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.OrderStats", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for PdfNavHedgePricing {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("kdo.v1.lp.PdfNavHedgePricing", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for PdfNavHedgePricing {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
__SkipField__,
}
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,
{
Ok(GeneratedField::__SkipField__)
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = PdfNavHedgePricing;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.PdfNavHedgePricing")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<PdfNavHedgePricing, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(PdfNavHedgePricing {
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.PdfNavHedgePricing", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for PositionAdjustmentStrategy {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "POSITION_ADJUSTMENT_STRATEGY_UNSPECIFIED",
Self::Avoidance => "POSITION_ADJUSTMENT_STRATEGY_AVOIDANCE",
Self::Turnover => "POSITION_ADJUSTMENT_STRATEGY_TURNOVER",
Self::All => "POSITION_ADJUSTMENT_STRATEGY_ALL",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for PositionAdjustmentStrategy {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"POSITION_ADJUSTMENT_STRATEGY_UNSPECIFIED",
"POSITION_ADJUSTMENT_STRATEGY_AVOIDANCE",
"POSITION_ADJUSTMENT_STRATEGY_TURNOVER",
"POSITION_ADJUSTMENT_STRATEGY_ALL",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = PositionAdjustmentStrategy;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::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) -> std::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) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"POSITION_ADJUSTMENT_STRATEGY_UNSPECIFIED" => Ok(PositionAdjustmentStrategy::Unspecified),
"POSITION_ADJUSTMENT_STRATEGY_AVOIDANCE" => Ok(PositionAdjustmentStrategy::Avoidance),
"POSITION_ADJUSTMENT_STRATEGY_TURNOVER" => Ok(PositionAdjustmentStrategy::Turnover),
"POSITION_ADJUSTMENT_STRATEGY_ALL" => Ok(PositionAdjustmentStrategy::All),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for StartMmRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.StartMmRequest", len)?;
if true {
struct_ser.serialize_field("etf", &self.etf)?;
}
if true {
struct_ser.serialize_field("fund", &self.fund)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StartMmRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf",
"fund",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Etf,
Fund,
__SkipField__,
}
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 {
"etf" => Ok(GeneratedField::Etf),
"fund" => Ok(GeneratedField::Fund),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StartMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.StartMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf__ = None;
let mut fund__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Etf => {
if etf__.is_some() {
return Err(serde::de::Error::duplicate_field("etf"));
}
etf__ = Some(map_.next_value()?);
}
GeneratedField::Fund => {
if fund__.is_some() {
return Err(serde::de::Error::duplicate_field("fund"));
}
fund__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StartMmRequest {
etf: etf__.unwrap_or_default(),
fund: fund__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.StartMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StartMmResponse {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.StartMmResponse", len)?;
if let Some(v) = self.status.as_ref() {
struct_ser.serialize_field("status", v)?;
}
if true {
struct_ser.serialize_field("message", &self.message)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StartMmResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"status",
"message",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Status,
Message,
__SkipField__,
}
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 {
"status" => Ok(GeneratedField::Status),
"message" => Ok(GeneratedField::Message),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StartMmResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.StartMmResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartMmResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut status__ = None;
let mut message__ = 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__ = map_.next_value()?;
}
GeneratedField::Message => {
if message__.is_some() {
return Err(serde::de::Error::duplicate_field("message"));
}
message__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StartMmResponse {
status: status__,
message: message__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.StartMmResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StopMmRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.StopMmRequest", len)?;
if true {
struct_ser.serialize_field("etf", &self.etf)?;
}
if true {
struct_ser.serialize_field("fund", &self.fund)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StopMmRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf",
"fund",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Etf,
Fund,
__SkipField__,
}
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 {
"etf" => Ok(GeneratedField::Etf),
"fund" => Ok(GeneratedField::Fund),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StopMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.StopMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf__ = None;
let mut fund__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Etf => {
if etf__.is_some() {
return Err(serde::de::Error::duplicate_field("etf"));
}
etf__ = Some(map_.next_value()?);
}
GeneratedField::Fund => {
if fund__.is_some() {
return Err(serde::de::Error::duplicate_field("fund"));
}
fund__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StopMmRequest {
etf: etf__.unwrap_or_default(),
fund: fund__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.StopMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StopMmResponse {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.StopMmResponse", len)?;
if let Some(v) = self.status.as_ref() {
struct_ser.serialize_field("status", v)?;
}
if true {
struct_ser.serialize_field("message", &self.message)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StopMmResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"status",
"message",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Status,
Message,
__SkipField__,
}
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 {
"status" => Ok(GeneratedField::Status),
"message" => Ok(GeneratedField::Message),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StopMmResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.StopMmResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMmResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut status__ = None;
let mut message__ = 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__ = map_.next_value()?;
}
GeneratedField::Message => {
if message__.is_some() {
return Err(serde::de::Error::duplicate_field("message"));
}
message__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StopMmResponse {
status: status__,
message: message__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.StopMmResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StreamLpEventsRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.StreamLpEventsRequest", len)?;
if true {
struct_ser.serialize_field("etf", &self.etf)?;
}
if true {
struct_ser.serialize_field("fund", &self.fund)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StreamLpEventsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf",
"fund",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Etf,
Fund,
__SkipField__,
}
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 {
"etf" => Ok(GeneratedField::Etf),
"fund" => Ok(GeneratedField::Fund),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StreamLpEventsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.StreamLpEventsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamLpEventsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf__ = None;
let mut fund__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Etf => {
if etf__.is_some() {
return Err(serde::de::Error::duplicate_field("etf"));
}
etf__ = Some(map_.next_value()?);
}
GeneratedField::Fund => {
if fund__.is_some() {
return Err(serde::de::Error::duplicate_field("fund"));
}
fund__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StreamLpEventsRequest {
etf: etf__.unwrap_or_default(),
fund: fund__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.StreamLpEventsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StreamMmStatusUpdateRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.StreamMmStatusUpdateRequest", len)?;
if true {
struct_ser.serialize_field("etf", &self.etf)?;
}
if true {
struct_ser.serialize_field("fund", &self.fund)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StreamMmStatusUpdateRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"etf",
"fund",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Etf,
Fund,
__SkipField__,
}
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 {
"etf" => Ok(GeneratedField::Etf),
"fund" => Ok(GeneratedField::Fund),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StreamMmStatusUpdateRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.StreamMmStatusUpdateRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMmStatusUpdateRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut etf__ = None;
let mut fund__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Etf => {
if etf__.is_some() {
return Err(serde::de::Error::duplicate_field("etf"));
}
etf__ = Some(map_.next_value()?);
}
GeneratedField::Fund => {
if fund__.is_some() {
return Err(serde::de::Error::duplicate_field("fund"));
}
fund__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StreamMmStatusUpdateRequest {
etf: etf__.unwrap_or_default(),
fund: fund__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.StreamMmStatusUpdateRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for TimeFrameStatus {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.TimeFrameStatus", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("window_seconds", ToString::to_string(&self.window_seconds).as_str())?;
}
if true {
struct_ser.serialize_field("current_count", &self.current_count)?;
}
if true {
struct_ser.serialize_field("max_orders", &self.max_orders)?;
}
if true {
struct_ser.serialize_field("usage_percent", &self.usage_percent)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for TimeFrameStatus {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"window_seconds",
"windowSeconds",
"current_count",
"currentCount",
"max_orders",
"maxOrders",
"usage_percent",
"usagePercent",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
WindowSeconds,
CurrentCount,
MaxOrders,
UsagePercent,
__SkipField__,
}
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 {
"windowSeconds" | "window_seconds" => Ok(GeneratedField::WindowSeconds),
"currentCount" | "current_count" => Ok(GeneratedField::CurrentCount),
"maxOrders" | "max_orders" => Ok(GeneratedField::MaxOrders),
"usagePercent" | "usage_percent" => Ok(GeneratedField::UsagePercent),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = TimeFrameStatus;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.TimeFrameStatus")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<TimeFrameStatus, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut window_seconds__ = None;
let mut current_count__ = None;
let mut max_orders__ = None;
let mut usage_percent__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::WindowSeconds => {
if window_seconds__.is_some() {
return Err(serde::de::Error::duplicate_field("windowSeconds"));
}
window_seconds__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::CurrentCount => {
if current_count__.is_some() {
return Err(serde::de::Error::duplicate_field("currentCount"));
}
current_count__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MaxOrders => {
if max_orders__.is_some() {
return Err(serde::de::Error::duplicate_field("maxOrders"));
}
max_orders__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::UsagePercent => {
if usage_percent__.is_some() {
return Err(serde::de::Error::duplicate_field("usagePercent"));
}
usage_percent__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(TimeFrameStatus {
window_seconds: window_seconds__.unwrap_or_default(),
current_count: current_count__.unwrap_or_default(),
max_orders: max_orders__.unwrap_or_default(),
usage_percent: usage_percent__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.TimeFrameStatus", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdateMmRequest {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.UpdateMmRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
if let Some(v) = self.depth.as_ref() {
struct_ser.serialize_field("depth", v)?;
}
if let Some(v) = self.offset.as_ref() {
struct_ser.serialize_field("offset", v)?;
}
if let Some(v) = self.ask_basis.as_ref() {
struct_ser.serialize_field("ask_basis", v)?;
}
if let Some(v) = self.bid_basis.as_ref() {
struct_ser.serialize_field("bid_basis", v)?;
}
if let Some(v) = self.bid_quantity.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("bid_quantity", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.ask_quantity.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("ask_quantity", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.bid_adjustment.as_ref() {
struct_ser.serialize_field("bid_adjustment", v)?;
}
if let Some(v) = self.ask_adjustment.as_ref() {
struct_ser.serialize_field("ask_adjustment", v)?;
}
if let Some(v) = self.momentum_enabled.as_ref() {
struct_ser.serialize_field("momentum_enabled", v)?;
}
if let Some(v) = self.momentum_window.as_ref() {
struct_ser.serialize_field("momentum_window", v)?;
}
if let Some(v) = self.momentum_sensitivity.as_ref() {
struct_ser.serialize_field("momentum_sensitivity", v)?;
}
if let Some(v) = self.quantity_limit.as_ref() {
struct_ser.serialize_field("quantity_limit", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdateMmRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
"fund_code",
"fundCode",
"depth",
"offset",
"ask_basis",
"askBasis",
"bid_basis",
"bidBasis",
"bid_quantity",
"bidQuantity",
"ask_quantity",
"askQuantity",
"bid_adjustment",
"bidAdjustment",
"ask_adjustment",
"askAdjustment",
"momentum_enabled",
"momentumEnabled",
"momentum_window",
"momentumWindow",
"momentum_sensitivity",
"momentumSensitivity",
"quantity_limit",
"quantityLimit",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
FundCode,
Depth,
Offset,
AskBasis,
BidBasis,
BidQuantity,
AskQuantity,
BidAdjustment,
AskAdjustment,
MomentumEnabled,
MomentumWindow,
MomentumSensitivity,
QuantityLimit,
__SkipField__,
}
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 {
"symbol" => Ok(GeneratedField::Symbol),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
"depth" => Ok(GeneratedField::Depth),
"offset" => Ok(GeneratedField::Offset),
"askBasis" | "ask_basis" => Ok(GeneratedField::AskBasis),
"bidBasis" | "bid_basis" => Ok(GeneratedField::BidBasis),
"bidQuantity" | "bid_quantity" => Ok(GeneratedField::BidQuantity),
"askQuantity" | "ask_quantity" => Ok(GeneratedField::AskQuantity),
"bidAdjustment" | "bid_adjustment" => Ok(GeneratedField::BidAdjustment),
"askAdjustment" | "ask_adjustment" => Ok(GeneratedField::AskAdjustment),
"momentumEnabled" | "momentum_enabled" => Ok(GeneratedField::MomentumEnabled),
"momentumWindow" | "momentum_window" => Ok(GeneratedField::MomentumWindow),
"momentumSensitivity" | "momentum_sensitivity" => Ok(GeneratedField::MomentumSensitivity),
"quantityLimit" | "quantity_limit" => Ok(GeneratedField::QuantityLimit),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdateMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.UpdateMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut fund_code__ = None;
let mut depth__ = None;
let mut offset__ = None;
let mut ask_basis__ = None;
let mut bid_basis__ = None;
let mut bid_quantity__ = None;
let mut ask_quantity__ = None;
let mut bid_adjustment__ = None;
let mut ask_adjustment__ = None;
let mut momentum_enabled__ = None;
let mut momentum_window__ = None;
let mut momentum_sensitivity__ = None;
let mut quantity_limit__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::FundCode => {
if fund_code__.is_some() {
return Err(serde::de::Error::duplicate_field("fundCode"));
}
fund_code__ = Some(map_.next_value()?);
}
GeneratedField::Depth => {
if depth__.is_some() {
return Err(serde::de::Error::duplicate_field("depth"));
}
depth__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::Offset => {
if offset__.is_some() {
return Err(serde::de::Error::duplicate_field("offset"));
}
offset__ = map_.next_value()?;
}
GeneratedField::AskBasis => {
if ask_basis__.is_some() {
return Err(serde::de::Error::duplicate_field("askBasis"));
}
ask_basis__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::BidBasis => {
if bid_basis__.is_some() {
return Err(serde::de::Error::duplicate_field("bidBasis"));
}
bid_basis__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::BidQuantity => {
if bid_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("bidQuantity"));
}
bid_quantity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::AskQuantity => {
if ask_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("askQuantity"));
}
ask_quantity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::BidAdjustment => {
if bid_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("bidAdjustment"));
}
bid_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::AskAdjustment => {
if ask_adjustment__.is_some() {
return Err(serde::de::Error::duplicate_field("askAdjustment"));
}
ask_adjustment__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumEnabled => {
if momentum_enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumEnabled"));
}
momentum_enabled__ = map_.next_value()?;
}
GeneratedField::MomentumWindow => {
if momentum_window__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumWindow"));
}
momentum_window__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::MomentumSensitivity => {
if momentum_sensitivity__.is_some() {
return Err(serde::de::Error::duplicate_field("momentumSensitivity"));
}
momentum_sensitivity__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::QuantityLimit => {
if quantity_limit__.is_some() {
return Err(serde::de::Error::duplicate_field("quantityLimit"));
}
quantity_limit__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UpdateMmRequest {
symbol: symbol__.unwrap_or_default(),
fund_code: fund_code__.unwrap_or_default(),
depth: depth__,
offset: offset__,
ask_basis: ask_basis__,
bid_basis: bid_basis__,
bid_quantity: bid_quantity__,
ask_quantity: ask_quantity__,
bid_adjustment: bid_adjustment__,
ask_adjustment: ask_adjustment__,
momentum_enabled: momentum_enabled__,
momentum_window: momentum_window__,
momentum_sensitivity: momentum_sensitivity__,
quantity_limit: quantity_limit__,
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.UpdateMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UserOrderbookData {
#[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 true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.lp.UserOrderbookData", len)?;
if true {
struct_ser.serialize_field("bid_prices", &self.bid_prices)?;
}
if true {
struct_ser.serialize_field("ask_prices", &self.ask_prices)?;
}
if true {
struct_ser.serialize_field("bid_quantities", &self.bid_quantities.iter().map(ToString::to_string).collect::<Vec<_>>())?;
}
if true {
struct_ser.serialize_field("ask_quantities", &self.ask_quantities.iter().map(ToString::to_string).collect::<Vec<_>>())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UserOrderbookData {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"bid_prices",
"bidPrices",
"ask_prices",
"askPrices",
"bid_quantities",
"bidQuantities",
"ask_quantities",
"askQuantities",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
BidPrices,
AskPrices,
BidQuantities,
AskQuantities,
__SkipField__,
}
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 {
"bidPrices" | "bid_prices" => Ok(GeneratedField::BidPrices),
"askPrices" | "ask_prices" => Ok(GeneratedField::AskPrices),
"bidQuantities" | "bid_quantities" => Ok(GeneratedField::BidQuantities),
"askQuantities" | "ask_quantities" => Ok(GeneratedField::AskQuantities),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UserOrderbookData;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.lp.UserOrderbookData")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UserOrderbookData, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut bid_prices__ = None;
let mut ask_prices__ = None;
let mut bid_quantities__ = None;
let mut ask_quantities__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::BidPrices => {
if bid_prices__.is_some() {
return Err(serde::de::Error::duplicate_field("bidPrices"));
}
bid_prices__ = Some(map_.next_value()?);
}
GeneratedField::AskPrices => {
if ask_prices__.is_some() {
return Err(serde::de::Error::duplicate_field("askPrices"));
}
ask_prices__ = Some(map_.next_value()?);
}
GeneratedField::BidQuantities => {
if bid_quantities__.is_some() {
return Err(serde::de::Error::duplicate_field("bidQuantities"));
}
bid_quantities__ =
Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
.into_iter().map(|x| x.0).collect())
;
}
GeneratedField::AskQuantities => {
if ask_quantities__.is_some() {
return Err(serde::de::Error::duplicate_field("askQuantities"));
}
ask_quantities__ =
Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
.into_iter().map(|x| x.0).collect())
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UserOrderbookData {
bid_prices: bid_prices__.unwrap_or_default(),
ask_prices: ask_prices__.unwrap_or_default(),
bid_quantities: bid_quantities__.unwrap_or_default(),
ask_quantities: ask_quantities__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.lp.UserOrderbookData", FIELDS, GeneratedVisitor)
}
}