impl serde::Serialize for FepClientInfo {
#[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;
}
let mut struct_ser = serializer.serialize_struct("kdo.v1.system.FepClientInfo", len)?;
if true {
struct_ser.serialize_field("market_type", &self.market_type)?;
}
if true {
struct_ser.serialize_field("exchange_type", &self.exchange_type)?;
}
if true {
struct_ser.serialize_field("client_type", &self.client_type)?;
}
if true {
struct_ser.serialize_field("task_code", &self.task_code)?;
}
if true {
struct_ser.serialize_field("transport_type", &self.transport_type)?;
}
if true {
struct_ser.serialize_field("host", &self.host)?;
}
if true {
struct_ser.serialize_field("port", &self.port)?;
}
if true {
struct_ser.serialize_field("path", &self.path)?;
}
if true {
struct_ser.serialize_field("hostname", &self.hostname)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for FepClientInfo {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"market_type",
"marketType",
"exchange_type",
"exchangeType",
"client_type",
"clientType",
"task_code",
"taskCode",
"transport_type",
"transportType",
"host",
"port",
"path",
"hostname",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
MarketType,
ExchangeType,
ClientType,
TaskCode,
TransportType,
Host,
Port,
Path,
Hostname,
__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 {
"marketType" | "market_type" => Ok(GeneratedField::MarketType),
"exchangeType" | "exchange_type" => Ok(GeneratedField::ExchangeType),
"clientType" | "client_type" => Ok(GeneratedField::ClientType),
"taskCode" | "task_code" => Ok(GeneratedField::TaskCode),
"transportType" | "transport_type" => Ok(GeneratedField::TransportType),
"host" => Ok(GeneratedField::Host),
"port" => Ok(GeneratedField::Port),
"path" => Ok(GeneratedField::Path),
"hostname" => Ok(GeneratedField::Hostname),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = FepClientInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.FepClientInfo")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<FepClientInfo, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut market_type__ = None;
let mut exchange_type__ = None;
let mut client_type__ = None;
let mut task_code__ = None;
let mut transport_type__ = None;
let mut host__ = None;
let mut port__ = None;
let mut path__ = None;
let mut hostname__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::MarketType => {
if market_type__.is_some() {
return Err(serde::de::Error::duplicate_field("marketType"));
}
market_type__ = Some(map_.next_value()?);
}
GeneratedField::ExchangeType => {
if exchange_type__.is_some() {
return Err(serde::de::Error::duplicate_field("exchangeType"));
}
exchange_type__ = Some(map_.next_value()?);
}
GeneratedField::ClientType => {
if client_type__.is_some() {
return Err(serde::de::Error::duplicate_field("clientType"));
}
client_type__ = Some(map_.next_value()?);
}
GeneratedField::TaskCode => {
if task_code__.is_some() {
return Err(serde::de::Error::duplicate_field("taskCode"));
}
task_code__ = Some(map_.next_value()?);
}
GeneratedField::TransportType => {
if transport_type__.is_some() {
return Err(serde::de::Error::duplicate_field("transportType"));
}
transport_type__ = Some(map_.next_value()?);
}
GeneratedField::Host => {
if host__.is_some() {
return Err(serde::de::Error::duplicate_field("host"));
}
host__ = Some(map_.next_value()?);
}
GeneratedField::Port => {
if port__.is_some() {
return Err(serde::de::Error::duplicate_field("port"));
}
port__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Path => {
if path__.is_some() {
return Err(serde::de::Error::duplicate_field("path"));
}
path__ = Some(map_.next_value()?);
}
GeneratedField::Hostname => {
if hostname__.is_some() {
return Err(serde::de::Error::duplicate_field("hostname"));
}
hostname__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(FepClientInfo {
market_type: market_type__.unwrap_or_default(),
exchange_type: exchange_type__.unwrap_or_default(),
client_type: client_type__.unwrap_or_default(),
task_code: task_code__.unwrap_or_default(),
transport_type: transport_type__.unwrap_or_default(),
host: host__.unwrap_or_default(),
port: port__.unwrap_or_default(),
path: path__.unwrap_or_default(),
hostname: hostname__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.system.FepClientInfo", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for FepInfo {
#[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.system.FepInfo", len)?;
if true {
struct_ser.serialize_field("implementation", &self.implementation)?;
}
if true {
struct_ser.serialize_field("clients", &self.clients)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for FepInfo {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"implementation",
"clients",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Implementation,
Clients,
__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 {
"implementation" => Ok(GeneratedField::Implementation),
"clients" => Ok(GeneratedField::Clients),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = FepInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.FepInfo")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<FepInfo, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut implementation__ = None;
let mut clients__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Implementation => {
if implementation__.is_some() {
return Err(serde::de::Error::duplicate_field("implementation"));
}
implementation__ = Some(map_.next_value()?);
}
GeneratedField::Clients => {
if clients__.is_some() {
return Err(serde::de::Error::duplicate_field("clients"));
}
clients__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(FepInfo {
implementation: implementation__.unwrap_or_default(),
clients: clients__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.system.FepInfo", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetConnectionInfoRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("kdo.v1.system.GetConnectionInfoRequest", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetConnectionInfoRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Ok(GeneratedField::__SkipField__)
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetConnectionInfoRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.GetConnectionInfoRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetConnectionInfoRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(GetConnectionInfoRequest {
})
}
}
deserializer.deserialize_struct("kdo.v1.system.GetConnectionInfoRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetConnectionInfoResponse {
#[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.system.GetConnectionInfoResponse", len)?;
if let Some(v) = self.krx_market_feed.as_ref() {
struct_ser.serialize_field("krx_market_feed", v)?;
}
if let Some(v) = self.nxt_market_feed.as_ref() {
struct_ser.serialize_field("nxt_market_feed", v)?;
}
if let Some(v) = self.fep.as_ref() {
struct_ser.serialize_field("fep", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetConnectionInfoResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"krx_market_feed",
"krxMarketFeed",
"nxt_market_feed",
"nxtMarketFeed",
"fep",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
KrxMarketFeed,
NxtMarketFeed,
Fep,
__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 {
"krxMarketFeed" | "krx_market_feed" => Ok(GeneratedField::KrxMarketFeed),
"nxtMarketFeed" | "nxt_market_feed" => Ok(GeneratedField::NxtMarketFeed),
"fep" => Ok(GeneratedField::Fep),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetConnectionInfoResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.GetConnectionInfoResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetConnectionInfoResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut krx_market_feed__ = None;
let mut nxt_market_feed__ = None;
let mut fep__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::KrxMarketFeed => {
if krx_market_feed__.is_some() {
return Err(serde::de::Error::duplicate_field("krxMarketFeed"));
}
krx_market_feed__ = map_.next_value()?;
}
GeneratedField::NxtMarketFeed => {
if nxt_market_feed__.is_some() {
return Err(serde::de::Error::duplicate_field("nxtMarketFeed"));
}
nxt_market_feed__ = map_.next_value()?;
}
GeneratedField::Fep => {
if fep__.is_some() {
return Err(serde::de::Error::duplicate_field("fep"));
}
fep__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetConnectionInfoResponse {
krx_market_feed: krx_market_feed__,
nxt_market_feed: nxt_market_feed__,
fep: fep__,
})
}
}
deserializer.deserialize_struct("kdo.v1.system.GetConnectionInfoResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetVersionInfoRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("kdo.v1.system.GetVersionInfoRequest", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetVersionInfoRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Ok(GeneratedField::__SkipField__)
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetVersionInfoRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.GetVersionInfoRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionInfoRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(GetVersionInfoRequest {
})
}
}
deserializer.deserialize_struct("kdo.v1.system.GetVersionInfoRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetVersionInfoResponse {
#[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.system.GetVersionInfoResponse", len)?;
if true {
struct_ser.serialize_field("git_commit_hash", &self.git_commit_hash)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetVersionInfoResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"git_commit_hash",
"gitCommitHash",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
GitCommitHash,
__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 {
"gitCommitHash" | "git_commit_hash" => Ok(GeneratedField::GitCommitHash),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetVersionInfoResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.GetVersionInfoResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetVersionInfoResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut git_commit_hash__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::GitCommitHash => {
if git_commit_hash__.is_some() {
return Err(serde::de::Error::duplicate_field("gitCommitHash"));
}
git_commit_hash__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetVersionInfoResponse {
git_commit_hash: git_commit_hash__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.system.GetVersionInfoResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MarketFeedInfo {
#[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.system.MarketFeedInfo", len)?;
if true {
struct_ser.serialize_field("implementation", &self.implementation)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MarketFeedInfo {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"implementation",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Implementation,
__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 {
"implementation" => Ok(GeneratedField::Implementation),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MarketFeedInfo;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.MarketFeedInfo")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<MarketFeedInfo, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut implementation__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Implementation => {
if implementation__.is_some() {
return Err(serde::de::Error::duplicate_field("implementation"));
}
implementation__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(MarketFeedInfo {
implementation: implementation__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("kdo.v1.system.MarketFeedInfo", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StopAllTradingRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("kdo.v1.system.StopAllTradingRequest", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StopAllTradingRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Ok(GeneratedField::__SkipField__)
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StopAllTradingRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.StopAllTradingRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopAllTradingRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(StopAllTradingRequest {
})
}
}
deserializer.deserialize_struct("kdo.v1.system.StopAllTradingRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StopAllTradingResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("kdo.v1.system.StopAllTradingResponse", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StopAllTradingResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
__SkipField__,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Ok(GeneratedField::__SkipField__)
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StopAllTradingResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct kdo.v1.system.StopAllTradingResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopAllTradingResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(StopAllTradingResponse {
})
}
}
deserializer.deserialize_struct("kdo.v1.system.StopAllTradingResponse", FIELDS, GeneratedVisitor)
}
}