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;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.mm.CreateMmRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if let Some(v) = self.config.as_ref() {
struct_ser.serialize_field("config", 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] = &[
"symbol",
"config",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
Config,
__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),
"config" => Ok(GeneratedField::Config),
_ => 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.mm.CreateMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut config__ = 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::Config => {
if config__.is_some() {
return Err(serde::de::Error::duplicate_field("config"));
}
config__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(CreateMmRequest {
symbol: symbol__.unwrap_or_default(),
config: config__,
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.CreateMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetMmOrderbookRequest {
#[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.mm.GetMmOrderbookRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetMmOrderbookRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
__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),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetMmOrderbookRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.GetMmOrderbookRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMmOrderbookRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetMmOrderbookRequest {
symbol: symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.GetMmOrderbookRequest", 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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.mm.GetMmStatusRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
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] = &[
"symbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
__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),
_ => 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.mm.GetMmStatusRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMmStatusRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetMmStatusRequest {
symbol: symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.GetMmStatusRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListMmRequest {
#[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.mm.ListMmRequest", 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)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListMmRequest {
#[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",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PageSize,
PageToken,
__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),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.ListMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut page_size__ = None;
let mut page_token__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListMmRequest {
page_size: page_size__,
page_token: page_token__,
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.ListMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListMmResponse {
#[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.mm.ListMmResponse", len)?;
if true {
struct_ser.serialize_field("entries", &self.entries)?;
}
if true {
struct_ser.serialize_field("next_page_token", &self.next_page_token)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListMmResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"entries",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Entries,
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 {
"entries" => Ok(GeneratedField::Entries),
"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 = ListMmResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.ListMmResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListMmResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut entries__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Entries => {
if entries__.is_some() {
return Err(serde::de::Error::duplicate_field("entries"));
}
entries__ = 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(ListMmResponse {
entries: entries__.unwrap_or_default(),
next_page_token: next_page_token__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.ListMmResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmConfiguration {
#[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.mm.MmConfiguration", len)?;
if true {
struct_ser.serialize_field("pricing", &self.pricing)?;
}
if let Some(v) = self.skew.as_ref() {
struct_ser.serialize_field("skew", v)?;
}
if let Some(v) = self.trade_analyzer.as_ref() {
struct_ser.serialize_field("trade_analyzer", v)?;
}
if let Some(v) = self.screening.as_ref() {
struct_ser.serialize_field("screening", v)?;
}
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 true {
struct_ser.serialize_field("enabled", &self.enabled)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmConfiguration {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"pricing",
"skew",
"trade_analyzer",
"tradeAnalyzer",
"screening",
"tick_size",
"tickSize",
"enabled",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Pricing,
Skew,
TradeAnalyzer,
Screening,
TickSize,
Enabled,
__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 {
"pricing" => Ok(GeneratedField::Pricing),
"skew" => Ok(GeneratedField::Skew),
"tradeAnalyzer" | "trade_analyzer" => Ok(GeneratedField::TradeAnalyzer),
"screening" => Ok(GeneratedField::Screening),
"tickSize" | "tick_size" => Ok(GeneratedField::TickSize),
"enabled" => Ok(GeneratedField::Enabled),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmConfiguration;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.MmConfiguration")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmConfiguration, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut pricing__ = None;
let mut skew__ = None;
let mut trade_analyzer__ = None;
let mut screening__ = None;
let mut tick_size__ = None;
let mut enabled__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Pricing => {
if pricing__.is_some() {
return Err(serde::de::Error::duplicate_field("pricing"));
}
pricing__ = Some(map_.next_value()?);
}
GeneratedField::Skew => {
if skew__.is_some() {
return Err(serde::de::Error::duplicate_field("skew"));
}
skew__ = map_.next_value()?;
}
GeneratedField::TradeAnalyzer => {
if trade_analyzer__.is_some() {
return Err(serde::de::Error::duplicate_field("tradeAnalyzer"));
}
trade_analyzer__ = map_.next_value()?;
}
GeneratedField::Screening => {
if screening__.is_some() {
return Err(serde::de::Error::duplicate_field("screening"));
}
screening__ = map_.next_value()?;
}
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::Enabled => {
if enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("enabled"));
}
enabled__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmConfiguration {
pricing: pricing__.unwrap_or_default(),
skew: skew__,
trade_analyzer: trade_analyzer__,
screening: screening__,
tick_size: tick_size__.unwrap_or_default(),
enabled: enabled__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.MmConfiguration", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmEntry {
#[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.mm.MmEntry", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
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.config.as_ref() {
struct_ser.serialize_field("config", v)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmEntry {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
"state",
"config",
"fund_code",
"fundCode",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
State,
Config,
FundCode,
__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),
"state" => Ok(GeneratedField::State),
"config" => Ok(GeneratedField::Config),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmEntry;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.MmEntry")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmEntry, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut state__ = None;
let mut config__ = None;
let mut fund_code__ = 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::State => {
if state__.is_some() {
return Err(serde::de::Error::duplicate_field("state"));
}
state__ = Some(map_.next_value::<MmState>()? as i32);
}
GeneratedField::Config => {
if config__.is_some() {
return Err(serde::de::Error::duplicate_field("config"));
}
config__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmEntry {
symbol: symbol__.unwrap_or_default(),
state: state__.unwrap_or_default(),
config: config__,
fund_code: fund_code__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.MmEntry", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmOrderbookData {
#[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.mm.MmOrderbookData", 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 MmOrderbookData {
#[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 = MmOrderbookData;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.MmOrderbookData")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmOrderbookData, 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(MmOrderbookData {
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.mm.MmOrderbookData", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmScreeningConfig {
#[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.mm.MmScreeningConfig", len)?;
if true {
struct_ser.serialize_field("max_spread_width_ticks", &self.max_spread_width_ticks)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("min_price", ToString::to_string(&self.min_price).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("max_price", ToString::to_string(&self.max_price).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmScreeningConfig {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"max_spread_width_ticks",
"maxSpreadWidthTicks",
"min_price",
"minPrice",
"max_price",
"maxPrice",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
MaxSpreadWidthTicks,
MinPrice,
MaxPrice,
__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 {
"maxSpreadWidthTicks" | "max_spread_width_ticks" => Ok(GeneratedField::MaxSpreadWidthTicks),
"minPrice" | "min_price" => Ok(GeneratedField::MinPrice),
"maxPrice" | "max_price" => Ok(GeneratedField::MaxPrice),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmScreeningConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.MmScreeningConfig")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmScreeningConfig, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut max_spread_width_ticks__ = None;
let mut min_price__ = None;
let mut max_price__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::MaxSpreadWidthTicks => {
if max_spread_width_ticks__.is_some() {
return Err(serde::de::Error::duplicate_field("maxSpreadWidthTicks"));
}
max_spread_width_ticks__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MinPrice => {
if min_price__.is_some() {
return Err(serde::de::Error::duplicate_field("minPrice"));
}
min_price__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MaxPrice => {
if max_price__.is_some() {
return Err(serde::de::Error::duplicate_field("maxPrice"));
}
max_price__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmScreeningConfig {
max_spread_width_ticks: max_spread_width_ticks__.unwrap_or_default(),
min_price: min_price__.unwrap_or_default(),
max_price: max_price__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.MmScreeningConfig", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmSkewConfig {
#[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.mm.MmSkewConfig", len)?;
if true {
struct_ser.serialize_field("mode", &self.mode)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("trigger_amt", ToString::to_string(&self.trigger_amt).as_str())?;
}
if true {
struct_ser.serialize_field("skew_unit", &self.skew_unit)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmSkewConfig {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"mode",
"trigger_amt",
"triggerAmt",
"skew_unit",
"skewUnit",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Mode,
TriggerAmt,
SkewUnit,
__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 {
"mode" => Ok(GeneratedField::Mode),
"triggerAmt" | "trigger_amt" => Ok(GeneratedField::TriggerAmt),
"skewUnit" | "skew_unit" => Ok(GeneratedField::SkewUnit),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmSkewConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.MmSkewConfig")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmSkewConfig, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut mode__ = None;
let mut trigger_amt__ = None;
let mut skew_unit__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Mode => {
if mode__.is_some() {
return Err(serde::de::Error::duplicate_field("mode"));
}
mode__ = Some(map_.next_value()?);
}
GeneratedField::TriggerAmt => {
if trigger_amt__.is_some() {
return Err(serde::de::Error::duplicate_field("triggerAmt"));
}
trigger_amt__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::SkewUnit => {
if skew_unit__.is_some() {
return Err(serde::de::Error::duplicate_field("skewUnit"));
}
skew_unit__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmSkewConfig {
mode: mode__.unwrap_or_default(),
trigger_amt: trigger_amt__.unwrap_or_default(),
skew_unit: skew_unit__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.MmSkewConfig", 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::Paused => "MM_STATE_PAUSED",
};
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_PAUSED",
];
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_PAUSED" => Ok(MmState::Paused),
_ => 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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.mm.MmStatus", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
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.config.as_ref() {
struct_ser.serialize_field("config", v)?;
}
if true {
struct_ser.serialize_field("registered", &self.registered)?;
}
if true {
struct_ser.serialize_field("active", &self.active)?;
}
if true {
struct_ser.serialize_field("fund_code", &self.fund_code)?;
}
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] = &[
"symbol",
"state",
"config",
"registered",
"active",
"fund_code",
"fundCode",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
State,
Config,
Registered,
Active,
FundCode,
__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),
"state" => Ok(GeneratedField::State),
"config" => Ok(GeneratedField::Config),
"registered" => Ok(GeneratedField::Registered),
"active" => Ok(GeneratedField::Active),
"fundCode" | "fund_code" => Ok(GeneratedField::FundCode),
_ => 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.mm.MmStatus")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmStatus, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut state__ = None;
let mut config__ = None;
let mut registered__ = None;
let mut active__ = None;
let mut fund_code__ = 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::State => {
if state__.is_some() {
return Err(serde::de::Error::duplicate_field("state"));
}
state__ = Some(map_.next_value::<MmState>()? as i32);
}
GeneratedField::Config => {
if config__.is_some() {
return Err(serde::de::Error::duplicate_field("config"));
}
config__ = map_.next_value()?;
}
GeneratedField::Registered => {
if registered__.is_some() {
return Err(serde::de::Error::duplicate_field("registered"));
}
registered__ = Some(map_.next_value()?);
}
GeneratedField::Active => {
if active__.is_some() {
return Err(serde::de::Error::duplicate_field("active"));
}
active__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmStatus {
symbol: symbol__.unwrap_or_default(),
state: state__.unwrap_or_default(),
config: config__,
registered: registered__.unwrap_or_default(),
active: active__.unwrap_or_default(),
fund_code: fund_code__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.MmStatus", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MmTradeAnalyzerConfig {
#[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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.mm.MmTradeAnalyzerConfig", len)?;
if true {
struct_ser.serialize_field("enabled", &self.enabled)?;
}
if true {
struct_ser.serialize_field("window", &self.window)?;
}
if true {
struct_ser.serialize_field("ratio_threshold", &self.ratio_threshold)?;
}
if true {
struct_ser.serialize_field("strength_threshold", &self.strength_threshold)?;
}
if true {
struct_ser.serialize_field("max_deco_tick", &self.max_deco_tick)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MmTradeAnalyzerConfig {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"enabled",
"window",
"ratio_threshold",
"ratioThreshold",
"strength_threshold",
"strengthThreshold",
"max_deco_tick",
"maxDecoTick",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Enabled,
Window,
RatioThreshold,
StrengthThreshold,
MaxDecoTick,
__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 {
"enabled" => Ok(GeneratedField::Enabled),
"window" => Ok(GeneratedField::Window),
"ratioThreshold" | "ratio_threshold" => Ok(GeneratedField::RatioThreshold),
"strengthThreshold" | "strength_threshold" => Ok(GeneratedField::StrengthThreshold),
"maxDecoTick" | "max_deco_tick" => Ok(GeneratedField::MaxDecoTick),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MmTradeAnalyzerConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.MmTradeAnalyzerConfig")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MmTradeAnalyzerConfig, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut enabled__ = None;
let mut window__ = None;
let mut ratio_threshold__ = None;
let mut strength_threshold__ = None;
let mut max_deco_tick__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Enabled => {
if enabled__.is_some() {
return Err(serde::de::Error::duplicate_field("enabled"));
}
enabled__ = Some(map_.next_value()?);
}
GeneratedField::Window => {
if window__.is_some() {
return Err(serde::de::Error::duplicate_field("window"));
}
window__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::RatioThreshold => {
if ratio_threshold__.is_some() {
return Err(serde::de::Error::duplicate_field("ratioThreshold"));
}
ratio_threshold__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::StrengthThreshold => {
if strength_threshold__.is_some() {
return Err(serde::de::Error::duplicate_field("strengthThreshold"));
}
strength_threshold__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::MaxDecoTick => {
if max_deco_tick__.is_some() {
return Err(serde::de::Error::duplicate_field("maxDecoTick"));
}
max_deco_tick__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MmTradeAnalyzerConfig {
enabled: enabled__.unwrap_or_default(),
window: window__.unwrap_or_default(),
ratio_threshold: ratio_threshold__.unwrap_or_default(),
strength_threshold: strength_threshold__.unwrap_or_default(),
max_deco_tick: max_deco_tick__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.MmTradeAnalyzerConfig", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for PauseMmRequest {
#[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.mm.PauseMmRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for PauseMmRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
__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),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = PauseMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.PauseMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(PauseMmRequest {
symbol: symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.PauseMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for PauseMmResponse {
#[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.mm.PauseMmResponse", len)?;
if true {
struct_ser.serialize_field("message", &self.message)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for PauseMmResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"message",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
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 {
"message" => Ok(GeneratedField::Message),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = PauseMmResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.PauseMmResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMmResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut message__ = None;
while let Some(k) = map_.next_key()? {
match k {
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(PauseMmResponse {
message: message__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.PauseMmResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ResetMmRequest {
#[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.mm.ResetMmRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ResetMmRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
__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),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ResetMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.ResetMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ResetMmRequest {
symbol: symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.ResetMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ResetMmResponse {
#[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.mm.ResetMmResponse", len)?;
if true {
struct_ser.serialize_field("reset_count", &self.reset_count)?;
}
if true {
struct_ser.serialize_field("message", &self.message)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ResetMmResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"reset_count",
"resetCount",
"message",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ResetCount,
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 {
"resetCount" | "reset_count" => Ok(GeneratedField::ResetCount),
"message" => Ok(GeneratedField::Message),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ResetMmResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.ResetMmResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResetMmResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut reset_count__ = None;
let mut message__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ResetCount => {
if reset_count__.is_some() {
return Err(serde::de::Error::duplicate_field("resetCount"));
}
reset_count__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
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(ResetMmResponse {
reset_count: reset_count__.unwrap_or_default(),
message: message__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.ResetMmResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ResumeMmRequest {
#[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.mm.ResumeMmRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ResumeMmRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
__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),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ResumeMmRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.ResumeMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ResumeMmRequest {
symbol: symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.ResumeMmRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ResumeMmResponse {
#[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.mm.ResumeMmResponse", len)?;
if true {
struct_ser.serialize_field("message", &self.message)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ResumeMmResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"message",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
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 {
"message" => Ok(GeneratedField::Message),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ResumeMmResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.ResumeMmResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMmResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut message__ = None;
while let Some(k) = map_.next_key()? {
match k {
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(ResumeMmResponse {
message: message__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.ResumeMmResponse", FIELDS, 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.mm.StartMmRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if let Some(v) = self.config.as_ref() {
struct_ser.serialize_field("config", v)?;
}
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] = &[
"symbol",
"config",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
Config,
__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),
"config" => Ok(GeneratedField::Config),
_ => 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.mm.StartMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut config__ = 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::Config => {
if config__.is_some() {
return Err(serde::de::Error::duplicate_field("config"));
}
config__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StartMmRequest {
symbol: symbol__.unwrap_or_default(),
config: config__,
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.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.mm.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.mm.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.mm.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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.mm.StopMmRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
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] = &[
"symbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
__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),
_ => 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.mm.StopMmRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMmRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StopMmRequest {
symbol: symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.mm.StopMmResponse", len)?;
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] = &[
"message",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
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 {
"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.mm.StopMmResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMmResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut message__ = None;
while let Some(k) = map_.next_key()? {
match k {
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 {
message: message__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.StopMmResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StreamMmStatusRequest {
#[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.mm.StreamMmStatusRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StreamMmStatusRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
__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),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StreamMmStatusRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.StreamMmStatusRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMmStatusRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(StreamMmStatusRequest {
symbol: symbol__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.StreamMmStatusRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdateMmConfigRequest {
#[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.mm.UpdateMmConfigRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if let Some(v) = self.config.as_ref() {
struct_ser.serialize_field("config", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdateMmConfigRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
"config",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
Config,
__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),
"config" => Ok(GeneratedField::Config),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdateMmConfigRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.mm.UpdateMmConfigRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMmConfigRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut config__ = 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::Config => {
if config__.is_some() {
return Err(serde::de::Error::duplicate_field("config"));
}
config__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UpdateMmConfigRequest {
symbol: symbol__.unwrap_or_default(),
config: config__,
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.UpdateMmConfigRequest", 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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.mm.UpdateMmRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if let Some(v) = self.config.as_ref() {
struct_ser.serialize_field("config", 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",
"config",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
Config,
__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),
"config" => Ok(GeneratedField::Config),
_ => 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.mm.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 config__ = 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::Config => {
if config__.is_some() {
return Err(serde::de::Error::duplicate_field("config"));
}
config__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UpdateMmRequest {
symbol: symbol__.unwrap_or_default(),
config: config__,
})
}
}
deserializer.deserialize_struct("kdo.v1.mm.UpdateMmRequest", FIELDS, GeneratedVisitor)
}
}