use std::{fmt, marker::PhantomData};
use serde::{
Deserialize, Deserializer, Serialize,
de::{self, DeserializeSeed, SeqAccess, Visitor},
};
use super::{Source, Timestamp, market::Identifier};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
#[serde(rename_all = "snake_case")]
pub enum BindingError {
InvalidCapacity,
CapacityExceeded,
DuplicateMapping,
ConflictingMapping,
}
impl fmt::Display for BindingError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(match self {
Self::InvalidCapacity => "invalid asset binding capacity",
Self::CapacityExceeded => "asset binding capacity exceeded",
Self::DuplicateMapping => "duplicate asset market mapping",
Self::ConflictingMapping => "conflicting asset market mapping",
})
}
}
impl std::error::Error for BindingError {}
#[derive(Clone, Eq, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MarketListing {
provider: Identifier,
listing_id: Identifier,
}
impl MarketListing {
#[must_use]
pub const fn new(provider: Identifier, listing_id: Identifier) -> Self {
Self {
provider,
listing_id,
}
}
#[must_use]
pub const fn provider(&self) -> &Identifier {
&self.provider
}
#[must_use]
pub const fn listing_id(&self) -> &Identifier {
&self.listing_id
}
}
impl fmt::Debug for MarketListing {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("MarketListing")
.finish_non_exhaustive()
}
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AssetMarketBinding<A> {
asset_key: A,
listing: MarketListing,
source: Source,
recorded_at: Timestamp,
}
impl<A> AssetMarketBinding<A> {
#[must_use]
pub const fn new(
asset_key: A,
listing: MarketListing,
source: Source,
recorded_at: Timestamp,
) -> Self {
Self {
asset_key,
listing,
source,
recorded_at,
}
}
#[must_use]
pub const fn asset_key(&self) -> &A {
&self.asset_key
}
#[must_use]
pub const fn listing(&self) -> &MarketListing {
&self.listing
}
#[must_use]
pub const fn source(&self) -> &Source {
&self.source
}
#[must_use]
pub const fn recorded_at(&self) -> Timestamp {
self.recorded_at
}
}
impl<A> fmt::Debug for AssetMarketBinding<A> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("AssetMarketBinding")
.finish_non_exhaustive()
}
}
#[derive(Clone, Eq, PartialEq, Serialize)]
pub struct AssetMarketRegistry<A> {
capacity: u16,
bindings: Vec<AssetMarketBinding<A>>,
}
impl<A> AssetMarketRegistry<A> {
pub const MAX_BINDINGS: u16 = 1024;
#[must_use]
pub const fn capacity(&self) -> u16 {
self.capacity
}
#[must_use]
pub fn bindings(&self) -> &[AssetMarketBinding<A>] {
&self.bindings
}
}
impl<A: Eq> AssetMarketRegistry<A> {
pub fn new(capacity: u16, bindings: Vec<AssetMarketBinding<A>>) -> Result<Self, BindingError> {
if capacity == 0 || capacity > Self::MAX_BINDINGS {
return Err(BindingError::InvalidCapacity);
}
if bindings.len() > usize::from(capacity) {
return Err(BindingError::CapacityExceeded);
}
for (position, binding) in bindings.iter().enumerate() {
if let Some(previous) = bindings[..position].iter().find(|previous| {
previous.asset_key == binding.asset_key
&& previous.listing.provider == binding.listing.provider
}) {
return Err(
if previous.listing.listing_id == binding.listing.listing_id {
BindingError::DuplicateMapping
} else {
BindingError::ConflictingMapping
},
);
}
}
Ok(Self { capacity, bindings })
}
#[must_use]
pub fn lookup(&self, asset_key: &A, provider: &Identifier) -> Option<&AssetMarketBinding<A>> {
self.bindings.iter().find(|binding| {
&binding.asset_key == asset_key && binding.listing.provider() == provider
})
}
}
impl<A> fmt::Debug for AssetMarketRegistry<A> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("AssetMarketRegistry")
.field("capacity", &self.capacity)
.field("binding_count", &self.bindings.len())
.finish_non_exhaustive()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RegistryFields<A> {
capacity: u16,
#[serde(
deserialize_with = "deserialize_bindings",
bound(deserialize = "A: Deserialize<'de>")
)]
bindings: Vec<AssetMarketBinding<A>>,
}
impl<'de, A: Deserialize<'de> + Eq> Deserialize<'de> for AssetMarketRegistry<A> {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let fields = RegistryFields::<A>::deserialize(deserializer)?;
Self::new(fields.capacity, fields.bindings).map_err(de::Error::custom)
}
}
fn deserialize_bindings<'de, D, A>(deserializer: D) -> Result<Vec<AssetMarketBinding<A>>, D::Error>
where
D: Deserializer<'de>,
A: Deserialize<'de>,
{
struct BindingsVisitor<A>(PhantomData<fn() -> A>);
impl<'de, A: Deserialize<'de>> Visitor<'de> for BindingsVisitor<A> {
type Value = Vec<AssetMarketBinding<A>>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a bounded asset binding sequence")
}
fn visit_seq<S: SeqAccess<'de>>(self, mut sequence: S) -> Result<Self::Value, S::Error> {
let maximum = usize::from(AssetMarketRegistry::<A>::MAX_BINDINGS);
if sequence.size_hint().is_some_and(|size| size > maximum) {
return Err(de::Error::custom(BindingError::CapacityExceeded));
}
let mut bindings = Vec::new();
for _ in 0..maximum {
match sequence.next_element()? {
Some(binding) => bindings.push(binding),
None => return Ok(bindings),
}
}
if sequence
.next_element_seed(RejectAdditionalBinding)?
.is_some()
{
return Err(de::Error::custom(BindingError::CapacityExceeded));
}
Ok(bindings)
}
}
deserializer.deserialize_seq(BindingsVisitor(PhantomData))
}
struct RejectAdditionalBinding;
impl<'de> DeserializeSeed<'de> for RejectAdditionalBinding {
type Value = ();
fn deserialize<D: Deserializer<'de>>(self, _deserializer: D) -> Result<(), D::Error> {
Err(de::Error::custom(BindingError::CapacityExceeded))
}
}