impl serde::Serialize for AmendMethodType {
#[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_METHOD_TYPE_UNSPECIFIED",
Self::Aggressive => "AMEND_METHOD_TYPE_AGGRESSIVE",
Self::Evasive => "AMEND_METHOD_TYPE_EVASIVE",
Self::BestPrice => "AMEND_METHOD_TYPE_BEST_PRICE",
Self::StopLoss => "AMEND_METHOD_TYPE_STOP_LOSS",
Self::TimedMarket => "AMEND_METHOD_TYPE_TIMED_MARKET",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for AmendMethodType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"AMEND_METHOD_TYPE_UNSPECIFIED",
"AMEND_METHOD_TYPE_AGGRESSIVE",
"AMEND_METHOD_TYPE_EVASIVE",
"AMEND_METHOD_TYPE_BEST_PRICE",
"AMEND_METHOD_TYPE_STOP_LOSS",
"AMEND_METHOD_TYPE_TIMED_MARKET",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = AmendMethodType;
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_METHOD_TYPE_UNSPECIFIED" => Ok(AmendMethodType::Unspecified),
"AMEND_METHOD_TYPE_AGGRESSIVE" => Ok(AmendMethodType::Aggressive),
"AMEND_METHOD_TYPE_EVASIVE" => Ok(AmendMethodType::Evasive),
"AMEND_METHOD_TYPE_BEST_PRICE" => Ok(AmendMethodType::BestPrice),
"AMEND_METHOD_TYPE_STOP_LOSS" => Ok(AmendMethodType::StopLoss),
"AMEND_METHOD_TYPE_TIMED_MARKET" => Ok(AmendMethodType::TimedMarket),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for MarketType {
#[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 => "MARKET_TYPE_UNSPECIFIED",
Self::Kospi => "MARKET_TYPE_KOSPI",
Self::Kosdaq => "MARKET_TYPE_KOSDAQ",
Self::Derivative => "MARKET_TYPE_DERIVATIVE",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for MarketType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"MARKET_TYPE_UNSPECIFIED",
"MARKET_TYPE_KOSPI",
"MARKET_TYPE_KOSDAQ",
"MARKET_TYPE_DERIVATIVE",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MarketType;
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 {
"MARKET_TYPE_UNSPECIFIED" => Ok(MarketType::Unspecified),
"MARKET_TYPE_KOSPI" => Ok(MarketType::Kospi),
"MARKET_TYPE_KOSDAQ" => Ok(MarketType::Kosdaq),
"MARKET_TYPE_DERIVATIVE" => Ok(MarketType::Derivative),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for OrderSide {
#[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 => "ORDER_SIDE_UNSPECIFIED",
Self::Bid => "ORDER_SIDE_BID",
Self::Ask => "ORDER_SIDE_ASK",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for OrderSide {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"ORDER_SIDE_UNSPECIFIED",
"ORDER_SIDE_BID",
"ORDER_SIDE_ASK",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = OrderSide;
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 {
"ORDER_SIDE_UNSPECIFIED" => Ok(OrderSide::Unspecified),
"ORDER_SIDE_BID" => Ok(OrderSide::Bid),
"ORDER_SIDE_ASK" => Ok(OrderSide::Ask),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for ProductType {
#[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 => "PRODUCT_TYPE_UNSPECIFIED",
Self::Stock => "PRODUCT_TYPE_STOCK",
Self::Futures => "PRODUCT_TYPE_FUTURES",
Self::Etf => "PRODUCT_TYPE_ETF",
Self::Cash => "PRODUCT_TYPE_CASH",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for ProductType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"PRODUCT_TYPE_UNSPECIFIED",
"PRODUCT_TYPE_STOCK",
"PRODUCT_TYPE_FUTURES",
"PRODUCT_TYPE_ETF",
"PRODUCT_TYPE_CASH",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ProductType;
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 {
"PRODUCT_TYPE_UNSPECIFIED" => Ok(ProductType::Unspecified),
"PRODUCT_TYPE_STOCK" => Ok(ProductType::Stock),
"PRODUCT_TYPE_FUTURES" => Ok(ProductType::Futures),
"PRODUCT_TYPE_ETF" => Ok(ProductType::Etf),
"PRODUCT_TYPE_CASH" => Ok(ProductType::Cash),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for TradingSession {
#[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 => "TRADING_SESSION_UNSPECIFIED",
Self::PreMarket => "TRADING_SESSION_PRE_MARKET",
Self::OpeningAuction => "TRADING_SESSION_OPENING_AUCTION",
Self::Regular => "TRADING_SESSION_REGULAR",
Self::ClosingAuction => "TRADING_SESSION_CLOSING_AUCTION",
Self::Closed => "TRADING_SESSION_CLOSED",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for TradingSession {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"TRADING_SESSION_UNSPECIFIED",
"TRADING_SESSION_PRE_MARKET",
"TRADING_SESSION_OPENING_AUCTION",
"TRADING_SESSION_REGULAR",
"TRADING_SESSION_CLOSING_AUCTION",
"TRADING_SESSION_CLOSED",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = TradingSession;
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 {
"TRADING_SESSION_UNSPECIFIED" => Ok(TradingSession::Unspecified),
"TRADING_SESSION_PRE_MARKET" => Ok(TradingSession::PreMarket),
"TRADING_SESSION_OPENING_AUCTION" => Ok(TradingSession::OpeningAuction),
"TRADING_SESSION_REGULAR" => Ok(TradingSession::Regular),
"TRADING_SESSION_CLOSING_AUCTION" => Ok(TradingSession::ClosingAuction),
"TRADING_SESSION_CLOSED" => Ok(TradingSession::Closed),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}