use serde::{Deserialize, Serialize};
use std::fmt;
pub const CREDITS_PER_USD: f64 = 10_000.0;
#[derive(Debug, Clone, Copy, Default, PartialEq, PartialOrd, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Credits(pub f64);
impl Credits {
pub const ZERO: Credits = Credits(0.0);
pub const fn new(credits: f64) -> Credits {
Credits(credits)
}
pub fn from_usd(usd: f64) -> Credits {
Credits(usd * CREDITS_PER_USD)
}
pub const fn get(self) -> f64 {
self.0
}
pub fn to_usd(self) -> f64 {
self.0 / CREDITS_PER_USD
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, PartialOrd, Serialize)]
#[serde(transparent)]
pub struct Usd(f64);
impl<'de> Deserialize<'de> for Usd {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Usd, D::Error> {
struct UsdVisitor;
impl<'de> serde::de::Visitor<'de> for UsdVisitor {
type Value = Usd;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("a cost in US dollars, as a number, a numeric string or null")
}
fn visit_f64<E: serde::de::Error>(self, value: f64) -> Result<Usd, E> {
Ok(Usd::charged(value))
}
fn visit_i64<E: serde::de::Error>(self, value: i64) -> Result<Usd, E> {
Ok(Usd::charged(value as f64))
}
fn visit_u64<E: serde::de::Error>(self, value: u64) -> Result<Usd, E> {
Ok(Usd::charged(value as f64))
}
fn visit_str<E: serde::de::Error>(self, value: &str) -> Result<Usd, E> {
value
.trim()
.parse::<f64>()
.map(Usd::charged)
.map_err(|_| E::invalid_value(serde::de::Unexpected::Str(value), &self))
}
fn visit_unit<E: serde::de::Error>(self) -> Result<Usd, E> {
Ok(Usd::ZERO)
}
fn visit_none<E: serde::de::Error>(self) -> Result<Usd, E> {
Ok(Usd::ZERO)
}
fn visit_some<D: serde::Deserializer<'de>>(
self,
deserializer: D,
) -> Result<Usd, D::Error> {
deserializer.deserialize_any(self)
}
}
deserializer.deserialize_any(UsdVisitor)
}
}
impl Usd {
fn charged(value: f64) -> Usd {
if value.is_nan() || value < 0.0 {
Usd::ZERO
} else {
Usd(value)
}
}
pub const ZERO: Usd = Usd(0.0);
pub const fn new(usd: f64) -> Usd {
Usd(usd)
}
pub const fn get(self) -> f64 {
self.0
}
}
impl From<Usd> for Credits {
fn from(usd: Usd) -> Credits {
Credits::from_usd(usd.get())
}
}
impl From<Credits> for Usd {
fn from(credits: Credits) -> Usd {
Usd(credits.to_usd())
}
}
impl std::ops::Add for Usd {
type Output = Usd;
fn add(self, other: Usd) -> Usd {
Usd(self.0 + other.0)
}
}
impl std::iter::Sum for Usd {
fn sum<I: Iterator<Item = Usd>>(iter: I) -> Usd {
iter.fold(Usd::ZERO, |total, next| total + next)
}
}
impl fmt::Display for Usd {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "${}", self.0)
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(transparent)]
pub struct WholeCredits(u64);
impl WholeCredits {
pub const fn new(credits: u64) -> WholeCredits {
WholeCredits(credits)
}
pub fn floor(credits: Credits) -> WholeCredits {
let whole = credits.get().max(0.0).floor();
if whole < 1.0 {
WholeCredits(1)
} else {
WholeCredits(whole.min(u64::MAX as f64) as u64)
}
}
pub const fn get(self) -> u64 {
self.0
}
pub fn credits(self) -> Credits {
Credits(self.0 as f64)
}
}
impl fmt::Display for WholeCredits {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{} credits", self.0)
}
}
impl std::ops::Add for Credits {
type Output = Credits;
fn add(self, other: Credits) -> Credits {
Credits(self.0 + other.0)
}
}
impl std::ops::AddAssign for Credits {
fn add_assign(&mut self, other: Credits) {
self.0 += other.0;
}
}
impl std::iter::Sum for Credits {
fn sum<I: Iterator<Item = Credits>>(iter: I) -> Credits {
iter.fold(Credits::ZERO, |total, next| total + next)
}
}
impl fmt::Display for Credits {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{} credits", self.0)
}
}
#[cfg(test)]
mod tests {
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::unreachable,
clippy::indexing_slicing,
clippy::string_slice
)]
use super::*;
#[test]
fn a_dollar_is_ten_thousand_credits() {
assert_eq!(Credits::from_usd(1.0), Credits(10_000.0));
assert_eq!(Credits(10_000.0).to_usd(), 1.0);
}
#[test]
fn credits_sum() {
let total: Credits = [Credits(1.5), Credits(2.5)].into_iter().sum();
assert_eq!(total, Credits(4.0));
}
#[test]
fn credits_serialize_as_a_bare_number() {
assert_eq!(serde_json::to_string(&Credits(2.5)).unwrap(), "2.5");
}
#[test]
fn dollars_reach_credits_only_through_the_rate() {
let reported = Usd::new(1.0870316666666668e-05);
let charged = Credits::from(reported);
assert!((charged.get() - 0.10870316666666668).abs() < 1e-15);
assert_eq!(Credits::from(Usd::new(1.0)), Credits(10_000.0));
assert_eq!(Usd::from(Credits(10_000.0)), Usd::new(1.0));
}
#[test]
fn dollars_serialize_as_the_bare_number_the_wire_sent() {
assert_eq!(serde_json::to_string(&Usd::new(0.25)).unwrap(), "0.25");
assert_eq!(
serde_json::from_str::<Usd>("1e-05").unwrap(),
Usd::new(0.00001)
);
}
#[test]
fn a_whole_cap_rounds_down_so_it_never_allows_more_than_was_asked() {
assert_eq!(WholeCredits::floor(Credits(30.9)).get(), 30);
assert_eq!(WholeCredits::floor(Credits(30.0)).get(), 30);
assert_eq!(WholeCredits::floor(Credits(0.5)).get(), 1);
assert_eq!(WholeCredits::floor(Credits::ZERO).get(), 1);
assert_eq!(WholeCredits::floor(Credits(-5.0)).get(), 1);
}
#[test]
fn a_whole_cap_serializes_as_an_integer_because_the_service_rejects_a_float() {
assert_eq!(
serde_json::to_string(&WholeCredits::floor(Credits(30.0))).unwrap(),
"30"
);
assert_eq!(WholeCredits::new(7).credits(), Credits(7.0));
}
}