impl serde::Serialize for AmendAction {
#[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 => "AMEND_ACTION_UNSPECIFIED",
Self::ChangePrice => "AMEND_ACTION_CHANGE_PRICE",
Self::ChangeQuantity => "AMEND_ACTION_CHANGE_QUANTITY",
Self::ChangePriceAndQuantity => "AMEND_ACTION_CHANGE_PRICE_AND_QUANTITY",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for AmendAction {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"AMEND_ACTION_UNSPECIFIED",
"AMEND_ACTION_CHANGE_PRICE",
"AMEND_ACTION_CHANGE_QUANTITY",
"AMEND_ACTION_CHANGE_PRICE_AND_QUANTITY",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AmendAction;
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 {
"AMEND_ACTION_UNSPECIFIED" => Ok(AmendAction::Unspecified),
"AMEND_ACTION_CHANGE_PRICE" => Ok(AmendAction::ChangePrice),
"AMEND_ACTION_CHANGE_QUANTITY" => Ok(AmendAction::ChangeQuantity),
"AMEND_ACTION_CHANGE_PRICE_AND_QUANTITY" => Ok(AmendAction::ChangePriceAndQuantity),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for AmendConfig {
#[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.auto_amend.AmendConfig", len)?;
if let Some(v) = self.regular_session.as_ref() {
struct_ser.serialize_field("regular_session", v)?;
}
if let Some(v) = self.auction_session.as_ref() {
struct_ser.serialize_field("auction_session", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AmendConfig {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"regular_session",
"regularSession",
"auction_session",
"auctionSession",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
RegularSession,
AuctionSession,
__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 {
"regularSession" | "regular_session" => Ok(GeneratedField::RegularSession),
"auctionSession" | "auction_session" => Ok(GeneratedField::AuctionSession),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AmendConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.AmendConfig")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AmendConfig, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut regular_session__ = None;
let mut auction_session__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::RegularSession => {
if regular_session__.is_some() {
return Err(serde::de::Error::duplicate_field("regularSession"));
}
regular_session__ = map_.next_value()?;
}
GeneratedField::AuctionSession => {
if auction_session__.is_some() {
return Err(serde::de::Error::duplicate_field("auctionSession"));
}
auction_session__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(AmendConfig {
regular_session: regular_session__,
auction_session: auction_session__,
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.AmendConfig", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for AmendFailedEvent {
#[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.auto_amend.AmendFailedEvent", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("order_id", ToString::to_string(&self.order_id).as_str())?;
}
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
struct_ser.serialize_field("reason", &self.reason)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AmendFailedEvent {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"order_id",
"orderId",
"symbol",
"reason",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OrderId,
Symbol,
Reason,
__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 {
"orderId" | "order_id" => Ok(GeneratedField::OrderId),
"symbol" => Ok(GeneratedField::Symbol),
"reason" => Ok(GeneratedField::Reason),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AmendFailedEvent;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.AmendFailedEvent")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AmendFailedEvent, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut order_id__ = None;
let mut symbol__ = None;
let mut reason__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OrderId => {
if order_id__.is_some() {
return Err(serde::de::Error::duplicate_field("orderId"));
}
order_id__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::Reason => {
if reason__.is_some() {
return Err(serde::de::Error::duplicate_field("reason"));
}
reason__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(AmendFailedEvent {
order_id: order_id__.unwrap_or_default(),
symbol: symbol__.unwrap_or_default(),
reason: reason__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.AmendFailedEvent", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for AmendedEvent {
#[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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.auto_amend.AmendedEvent", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("order_id", ToString::to_string(&self.order_id).as_str())?;
}
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
let v = AmendAction::try_from(self.action)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.action)))?;
struct_ser.serialize_field("action", &v)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("old_price", ToString::to_string(&self.old_price).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("new_price", ToString::to_string(&self.new_price).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("old_quantity", ToString::to_string(&self.old_quantity).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("new_quantity", ToString::to_string(&self.new_quantity).as_str())?;
}
if true {
struct_ser.serialize_field("reason", &self.reason)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AmendedEvent {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"order_id",
"orderId",
"symbol",
"action",
"old_price",
"oldPrice",
"new_price",
"newPrice",
"old_quantity",
"oldQuantity",
"new_quantity",
"newQuantity",
"reason",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OrderId,
Symbol,
Action,
OldPrice,
NewPrice,
OldQuantity,
NewQuantity,
Reason,
__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 {
"orderId" | "order_id" => Ok(GeneratedField::OrderId),
"symbol" => Ok(GeneratedField::Symbol),
"action" => Ok(GeneratedField::Action),
"oldPrice" | "old_price" => Ok(GeneratedField::OldPrice),
"newPrice" | "new_price" => Ok(GeneratedField::NewPrice),
"oldQuantity" | "old_quantity" => Ok(GeneratedField::OldQuantity),
"newQuantity" | "new_quantity" => Ok(GeneratedField::NewQuantity),
"reason" => Ok(GeneratedField::Reason),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AmendedEvent;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.AmendedEvent")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AmendedEvent, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut order_id__ = None;
let mut symbol__ = None;
let mut action__ = None;
let mut old_price__ = None;
let mut new_price__ = None;
let mut old_quantity__ = None;
let mut new_quantity__ = None;
let mut reason__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OrderId => {
if order_id__.is_some() {
return Err(serde::de::Error::duplicate_field("orderId"));
}
order_id__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::Action => {
if action__.is_some() {
return Err(serde::de::Error::duplicate_field("action"));
}
action__ = Some(map_.next_value::<AmendAction>()? as i32);
}
GeneratedField::OldPrice => {
if old_price__.is_some() {
return Err(serde::de::Error::duplicate_field("oldPrice"));
}
old_price__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::NewPrice => {
if new_price__.is_some() {
return Err(serde::de::Error::duplicate_field("newPrice"));
}
new_price__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::OldQuantity => {
if old_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("oldQuantity"));
}
old_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::NewQuantity => {
if new_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("newQuantity"));
}
new_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Reason => {
if reason__.is_some() {
return Err(serde::de::Error::duplicate_field("reason"));
}
reason__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(AmendedEvent {
order_id: order_id__.unwrap_or_default(),
symbol: symbol__.unwrap_or_default(),
action: action__.unwrap_or_default(),
old_price: old_price__.unwrap_or_default(),
new_price: new_price__.unwrap_or_default(),
old_quantity: old_quantity__.unwrap_or_default(),
new_quantity: new_quantity__.unwrap_or_default(),
reason: reason__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.AmendedEvent", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for AuctionSessionConfig {
#[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.auto_amend.AuctionSessionConfig", len)?;
if true {
struct_ser.serialize_field("enabled", &self.enabled)?;
}
if true {
struct_ser.serialize_field("price_limit_pct", &self.price_limit_pct)?;
}
if true {
struct_ser.serialize_field("quantity_limit_pct", &self.quantity_limit_pct)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AuctionSessionConfig {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"enabled",
"price_limit_pct",
"priceLimitPct",
"quantity_limit_pct",
"quantityLimitPct",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Enabled,
PriceLimitPct,
QuantityLimitPct,
__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),
"priceLimitPct" | "price_limit_pct" => Ok(GeneratedField::PriceLimitPct),
"quantityLimitPct" | "quantity_limit_pct" => Ok(GeneratedField::QuantityLimitPct),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AuctionSessionConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.AuctionSessionConfig")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AuctionSessionConfig, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut enabled__ = None;
let mut price_limit_pct__ = None;
let mut quantity_limit_pct__ = 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::PriceLimitPct => {
if price_limit_pct__.is_some() {
return Err(serde::de::Error::duplicate_field("priceLimitPct"));
}
price_limit_pct__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::QuantityLimitPct => {
if quantity_limit_pct__.is_some() {
return Err(serde::de::Error::duplicate_field("quantityLimitPct"));
}
quantity_limit_pct__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(AuctionSessionConfig {
enabled: enabled__.unwrap_or_default(),
price_limit_pct: price_limit_pct__.unwrap_or_default(),
quantity_limit_pct: quantity_limit_pct__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.AuctionSessionConfig", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for AutoAmendEvent {
#[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.event.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.auto_amend.AutoAmendEvent", len)?;
if let Some(v) = self.event.as_ref() {
match v {
auto_amend_event::Event::Amended(v) => {
struct_ser.serialize_field("amended", v)?;
}
auto_amend_event::Event::AmendFailed(v) => {
struct_ser.serialize_field("amend_failed", v)?;
}
auto_amend_event::Event::SessionChanged(v) => {
struct_ser.serialize_field("session_changed", v)?;
}
auto_amend_event::Event::OrderRegistered(v) => {
struct_ser.serialize_field("order_registered", v)?;
}
auto_amend_event::Event::OrderUnregistered(v) => {
struct_ser.serialize_field("order_unregistered", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AutoAmendEvent {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"amended",
"amend_failed",
"amendFailed",
"session_changed",
"sessionChanged",
"order_registered",
"orderRegistered",
"order_unregistered",
"orderUnregistered",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Amended,
AmendFailed,
SessionChanged,
OrderRegistered,
OrderUnregistered,
__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 {
"amended" => Ok(GeneratedField::Amended),
"amendFailed" | "amend_failed" => Ok(GeneratedField::AmendFailed),
"sessionChanged" | "session_changed" => Ok(GeneratedField::SessionChanged),
"orderRegistered" | "order_registered" => Ok(GeneratedField::OrderRegistered),
"orderUnregistered" | "order_unregistered" => Ok(GeneratedField::OrderUnregistered),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AutoAmendEvent;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.AutoAmendEvent")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoAmendEvent, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut event__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Amended => {
if event__.is_some() {
return Err(serde::de::Error::duplicate_field("amended"));
}
event__ = map_.next_value::<::std::option::Option<_>>()?.map(auto_amend_event::Event::Amended)
;
}
GeneratedField::AmendFailed => {
if event__.is_some() {
return Err(serde::de::Error::duplicate_field("amendFailed"));
}
event__ = map_.next_value::<::std::option::Option<_>>()?.map(auto_amend_event::Event::AmendFailed)
;
}
GeneratedField::SessionChanged => {
if event__.is_some() {
return Err(serde::de::Error::duplicate_field("sessionChanged"));
}
event__ = map_.next_value::<::std::option::Option<_>>()?.map(auto_amend_event::Event::SessionChanged)
;
}
GeneratedField::OrderRegistered => {
if event__.is_some() {
return Err(serde::de::Error::duplicate_field("orderRegistered"));
}
event__ = map_.next_value::<::std::option::Option<_>>()?.map(auto_amend_event::Event::OrderRegistered)
;
}
GeneratedField::OrderUnregistered => {
if event__.is_some() {
return Err(serde::de::Error::duplicate_field("orderUnregistered"));
}
event__ = map_.next_value::<::std::option::Option<_>>()?.map(auto_amend_event::Event::OrderUnregistered)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(AutoAmendEvent {
event: event__,
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.AutoAmendEvent", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for AutoAmendOrder {
#[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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.auto_amend.AutoAmendOrder", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("order_id", ToString::to_string(&self.order_id).as_str())?;
}
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
let v = super::common::OrderSide::try_from(self.side)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.side)))?;
struct_ser.serialize_field("side", &v)?;
}
if true {
struct_ser.serialize_field("price", &self.price)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("quantity", ToString::to_string(&self.quantity).as_str())?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("remaining_quantity", ToString::to_string(&self.remaining_quantity).as_str())?;
}
if let Some(v) = self.config.as_ref() {
struct_ser.serialize_field("config", v)?;
}
if true {
struct_ser.serialize_field("amend_count", &self.amend_count)?;
}
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("last_amend_time_ms", ToString::to_string(&self.last_amend_time_ms).as_str())?;
}
if true {
struct_ser.serialize_field("is_active", &self.is_active)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for AutoAmendOrder {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"order_id",
"orderId",
"symbol",
"side",
"price",
"quantity",
"remaining_quantity",
"remainingQuantity",
"config",
"amend_count",
"amendCount",
"last_amend_time_ms",
"lastAmendTimeMs",
"is_active",
"isActive",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OrderId,
Symbol,
Side,
Price,
Quantity,
RemainingQuantity,
Config,
AmendCount,
LastAmendTimeMs,
IsActive,
__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 {
"orderId" | "order_id" => Ok(GeneratedField::OrderId),
"symbol" => Ok(GeneratedField::Symbol),
"side" => Ok(GeneratedField::Side),
"price" => Ok(GeneratedField::Price),
"quantity" => Ok(GeneratedField::Quantity),
"remainingQuantity" | "remaining_quantity" => Ok(GeneratedField::RemainingQuantity),
"config" => Ok(GeneratedField::Config),
"amendCount" | "amend_count" => Ok(GeneratedField::AmendCount),
"lastAmendTimeMs" | "last_amend_time_ms" => Ok(GeneratedField::LastAmendTimeMs),
"isActive" | "is_active" => Ok(GeneratedField::IsActive),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AutoAmendOrder;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.AutoAmendOrder")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<AutoAmendOrder, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut order_id__ = None;
let mut symbol__ = None;
let mut side__ = None;
let mut price__ = None;
let mut quantity__ = None;
let mut remaining_quantity__ = None;
let mut config__ = None;
let mut amend_count__ = None;
let mut last_amend_time_ms__ = None;
let mut is_active__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OrderId => {
if order_id__.is_some() {
return Err(serde::de::Error::duplicate_field("orderId"));
}
order_id__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::Side => {
if side__.is_some() {
return Err(serde::de::Error::duplicate_field("side"));
}
side__ = Some(map_.next_value::<super::common::OrderSide>()? as i32);
}
GeneratedField::Price => {
if price__.is_some() {
return Err(serde::de::Error::duplicate_field("price"));
}
price__ = Some(map_.next_value()?);
}
GeneratedField::Quantity => {
if quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("quantity"));
}
quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::RemainingQuantity => {
if remaining_quantity__.is_some() {
return Err(serde::de::Error::duplicate_field("remainingQuantity"));
}
remaining_quantity__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Config => {
if config__.is_some() {
return Err(serde::de::Error::duplicate_field("config"));
}
config__ = map_.next_value()?;
}
GeneratedField::AmendCount => {
if amend_count__.is_some() {
return Err(serde::de::Error::duplicate_field("amendCount"));
}
amend_count__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::LastAmendTimeMs => {
if last_amend_time_ms__.is_some() {
return Err(serde::de::Error::duplicate_field("lastAmendTimeMs"));
}
last_amend_time_ms__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::IsActive => {
if is_active__.is_some() {
return Err(serde::de::Error::duplicate_field("isActive"));
}
is_active__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(AutoAmendOrder {
order_id: order_id__.unwrap_or_default(),
symbol: symbol__.unwrap_or_default(),
side: side__.unwrap_or_default(),
price: price__.unwrap_or_default(),
quantity: quantity__.unwrap_or_default(),
remaining_quantity: remaining_quantity__.unwrap_or_default(),
config: config__,
amend_count: amend_count__.unwrap_or_default(),
last_amend_time_ms: last_amend_time_ms__.unwrap_or_default(),
is_active: is_active__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.AutoAmendOrder", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetAutoAmendOrderRequest {
#[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.auto_amend.GetAutoAmendOrderRequest", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("order_id", ToString::to_string(&self.order_id).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetAutoAmendOrderRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"order_id",
"orderId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OrderId,
__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 {
"orderId" | "order_id" => Ok(GeneratedField::OrderId),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetAutoAmendOrderRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.GetAutoAmendOrderRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetAutoAmendOrderRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut order_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OrderId => {
if order_id__.is_some() {
return Err(serde::de::Error::duplicate_field("orderId"));
}
order_id__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetAutoAmendOrderRequest {
order_id: order_id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.GetAutoAmendOrderRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListAutoAmendOrdersRequest {
#[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.auto_amend.ListAutoAmendOrdersRequest", len)?;
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
let v = super::common::OrderSide::try_from(self.side)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.side)))?;
struct_ser.serialize_field("side", &v)?;
}
if true {
struct_ser.serialize_field("active_only", &self.active_only)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListAutoAmendOrdersRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"symbol",
"side",
"active_only",
"activeOnly",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Symbol,
Side,
ActiveOnly,
__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),
"side" => Ok(GeneratedField::Side),
"activeOnly" | "active_only" => Ok(GeneratedField::ActiveOnly),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListAutoAmendOrdersRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.ListAutoAmendOrdersRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAutoAmendOrdersRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut symbol__ = None;
let mut side__ = None;
let mut active_only__ = 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::Side => {
if side__.is_some() {
return Err(serde::de::Error::duplicate_field("side"));
}
side__ = Some(map_.next_value::<super::common::OrderSide>()? as i32);
}
GeneratedField::ActiveOnly => {
if active_only__.is_some() {
return Err(serde::de::Error::duplicate_field("activeOnly"));
}
active_only__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListAutoAmendOrdersRequest {
symbol: symbol__.unwrap_or_default(),
side: side__.unwrap_or_default(),
active_only: active_only__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.ListAutoAmendOrdersRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListAutoAmendOrdersResponse {
#[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.auto_amend.ListAutoAmendOrdersResponse", len)?;
if true {
struct_ser.serialize_field("orders", &self.orders)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListAutoAmendOrdersResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"orders",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Orders,
__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 {
"orders" => Ok(GeneratedField::Orders),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListAutoAmendOrdersResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.ListAutoAmendOrdersResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAutoAmendOrdersResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut orders__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Orders => {
if orders__.is_some() {
return Err(serde::de::Error::duplicate_field("orders"));
}
orders__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListAutoAmendOrdersResponse {
orders: orders__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.ListAutoAmendOrdersResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for OrderRegisteredEvent {
#[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.auto_amend.OrderRegisteredEvent", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("order_id", ToString::to_string(&self.order_id).as_str())?;
}
if true {
struct_ser.serialize_field("symbol", &self.symbol)?;
}
if true {
let v = super::common::OrderSide::try_from(self.side)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.side)))?;
struct_ser.serialize_field("side", &v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for OrderRegisteredEvent {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"order_id",
"orderId",
"symbol",
"side",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OrderId,
Symbol,
Side,
__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 {
"orderId" | "order_id" => Ok(GeneratedField::OrderId),
"symbol" => Ok(GeneratedField::Symbol),
"side" => Ok(GeneratedField::Side),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = OrderRegisteredEvent;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.OrderRegisteredEvent")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<OrderRegisteredEvent, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut order_id__ = None;
let mut symbol__ = None;
let mut side__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OrderId => {
if order_id__.is_some() {
return Err(serde::de::Error::duplicate_field("orderId"));
}
order_id__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Symbol => {
if symbol__.is_some() {
return Err(serde::de::Error::duplicate_field("symbol"));
}
symbol__ = Some(map_.next_value()?);
}
GeneratedField::Side => {
if side__.is_some() {
return Err(serde::de::Error::duplicate_field("side"));
}
side__ = Some(map_.next_value::<super::common::OrderSide>()? as i32);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(OrderRegisteredEvent {
order_id: order_id__.unwrap_or_default(),
symbol: symbol__.unwrap_or_default(),
side: side__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.OrderRegisteredEvent", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for OrderUnregisteredEvent {
#[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.auto_amend.OrderUnregisteredEvent", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("order_id", ToString::to_string(&self.order_id).as_str())?;
}
if true {
struct_ser.serialize_field("reason", &self.reason)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for OrderUnregisteredEvent {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"order_id",
"orderId",
"reason",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OrderId,
Reason,
__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 {
"orderId" | "order_id" => Ok(GeneratedField::OrderId),
"reason" => Ok(GeneratedField::Reason),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = OrderUnregisteredEvent;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.OrderUnregisteredEvent")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<OrderUnregisteredEvent, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut order_id__ = None;
let mut reason__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OrderId => {
if order_id__.is_some() {
return Err(serde::de::Error::duplicate_field("orderId"));
}
order_id__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Reason => {
if reason__.is_some() {
return Err(serde::de::Error::duplicate_field("reason"));
}
reason__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(OrderUnregisteredEvent {
order_id: order_id__.unwrap_or_default(),
reason: reason__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.OrderUnregisteredEvent", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for RegularSessionConfig {
#[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.auto_amend.RegularSessionConfig", len)?;
if true {
struct_ser.serialize_field("enabled", &self.enabled)?;
}
if true {
struct_ser.serialize_field("opposite_qty_ratio_threshold", &self.opposite_qty_ratio_threshold)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for RegularSessionConfig {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"enabled",
"opposite_qty_ratio_threshold",
"oppositeQtyRatioThreshold",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Enabled,
OppositeQtyRatioThreshold,
__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),
"oppositeQtyRatioThreshold" | "opposite_qty_ratio_threshold" => Ok(GeneratedField::OppositeQtyRatioThreshold),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = RegularSessionConfig;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.RegularSessionConfig")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<RegularSessionConfig, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut enabled__ = None;
let mut opposite_qty_ratio_threshold__ = 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::OppositeQtyRatioThreshold => {
if opposite_qty_ratio_threshold__.is_some() {
return Err(serde::de::Error::duplicate_field("oppositeQtyRatioThreshold"));
}
opposite_qty_ratio_threshold__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(RegularSessionConfig {
enabled: enabled__.unwrap_or_default(),
opposite_qty_ratio_threshold: opposite_qty_ratio_threshold__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.RegularSessionConfig", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ServiceStatus {
#[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.auto_amend.ServiceStatus", len)?;
if true {
struct_ser.serialize_field("is_running", &self.is_running)?;
}
if true {
let v = super::common::TradingSession::try_from(self.current_session)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.current_session)))?;
struct_ser.serialize_field("current_session", &v)?;
}
if true {
struct_ser.serialize_field("active_order_count", &self.active_order_count)?;
}
if true {
struct_ser.serialize_field("total_order_count", &self.total_order_count)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ServiceStatus {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"is_running",
"isRunning",
"current_session",
"currentSession",
"active_order_count",
"activeOrderCount",
"total_order_count",
"totalOrderCount",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
IsRunning,
CurrentSession,
ActiveOrderCount,
TotalOrderCount,
__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 {
"isRunning" | "is_running" => Ok(GeneratedField::IsRunning),
"currentSession" | "current_session" => Ok(GeneratedField::CurrentSession),
"activeOrderCount" | "active_order_count" => Ok(GeneratedField::ActiveOrderCount),
"totalOrderCount" | "total_order_count" => Ok(GeneratedField::TotalOrderCount),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ServiceStatus;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.ServiceStatus")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ServiceStatus, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut is_running__ = None;
let mut current_session__ = None;
let mut active_order_count__ = None;
let mut total_order_count__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::IsRunning => {
if is_running__.is_some() {
return Err(serde::de::Error::duplicate_field("isRunning"));
}
is_running__ = Some(map_.next_value()?);
}
GeneratedField::CurrentSession => {
if current_session__.is_some() {
return Err(serde::de::Error::duplicate_field("currentSession"));
}
current_session__ = Some(map_.next_value::<super::common::TradingSession>()? as i32);
}
GeneratedField::ActiveOrderCount => {
if active_order_count__.is_some() {
return Err(serde::de::Error::duplicate_field("activeOrderCount"));
}
active_order_count__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::TotalOrderCount => {
if total_order_count__.is_some() {
return Err(serde::de::Error::duplicate_field("totalOrderCount"));
}
total_order_count__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ServiceStatus {
is_running: is_running__.unwrap_or_default(),
current_session: current_session__.unwrap_or_default(),
active_order_count: active_order_count__.unwrap_or_default(),
total_order_count: total_order_count__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.ServiceStatus", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for SessionChangedEvent {
#[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.auto_amend.SessionChangedEvent", len)?;
if true {
let v = super::common::TradingSession::try_from(self.old_session)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.old_session)))?;
struct_ser.serialize_field("old_session", &v)?;
}
if true {
let v = super::common::TradingSession::try_from(self.new_session)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.new_session)))?;
struct_ser.serialize_field("new_session", &v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for SessionChangedEvent {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"old_session",
"oldSession",
"new_session",
"newSession",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OldSession,
NewSession,
__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 {
"oldSession" | "old_session" => Ok(GeneratedField::OldSession),
"newSession" | "new_session" => Ok(GeneratedField::NewSession),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = SessionChangedEvent;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.SessionChangedEvent")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<SessionChangedEvent, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut old_session__ = None;
let mut new_session__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OldSession => {
if old_session__.is_some() {
return Err(serde::de::Error::duplicate_field("oldSession"));
}
old_session__ = Some(map_.next_value::<super::common::TradingSession>()? as i32);
}
GeneratedField::NewSession => {
if new_session__.is_some() {
return Err(serde::de::Error::duplicate_field("newSession"));
}
new_session__ = Some(map_.next_value::<super::common::TradingSession>()? as i32);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(SessionChangedEvent {
old_session: old_session__.unwrap_or_default(),
new_session: new_session__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.SessionChangedEvent", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StreamEventsRequest {
#[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.auto_amend.StreamEventsRequest", len)?;
if true {
struct_ser.serialize_field("order_ids", &self.order_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StreamEventsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"order_ids",
"orderIds",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OrderIds,
__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 {
"orderIds" | "order_ids" => Ok(GeneratedField::OrderIds),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StreamEventsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.StreamEventsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamEventsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut order_ids__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OrderIds => {
if order_ids__.is_some() {
return Err(serde::de::Error::duplicate_field("orderIds"));
}
order_ids__ =
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(StreamEventsRequest {
order_ids: order_ids__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.StreamEventsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdateConfigRequest {
#[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.auto_amend.UpdateConfigRequest", len)?;
if true {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("order_id", ToString::to_string(&self.order_id).as_str())?;
}
if let Some(v) = self.config.as_ref() {
struct_ser.serialize_field("config", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdateConfigRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"order_id",
"orderId",
"config",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
OrderId,
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 {
"orderId" | "order_id" => Ok(GeneratedField::OrderId),
"config" => Ok(GeneratedField::Config),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdateConfigRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.auto_amend.UpdateConfigRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateConfigRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut order_id__ = None;
let mut config__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::OrderId => {
if order_id__.is_some() {
return Err(serde::de::Error::duplicate_field("orderId"));
}
order_id__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
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(UpdateConfigRequest {
order_id: order_id__.unwrap_or_default(),
config: config__,
})
}
}
deserializer.deserialize_struct("kdo.v1.auto_amend.UpdateConfigRequest", FIELDS, GeneratedVisitor)
}
}