use core::{fmt, str::FromStr};
use crate::{Error, ErrorKind};
#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Region([u8; 2]);
impl Region {
pub fn new(value: &str) -> crate::Result<Self> {
Self::try_from(value)
}
pub fn as_str(&self) -> &str {
core::str::from_utf8(&self.0).expect("region invariant")
}
}
impl TryFrom<&str> for Region {
type Error = Error;
fn try_from(value: &str) -> crate::Result<Self> {
let bytes = value.as_bytes();
if bytes.len() != 2 || !bytes.iter().all(u8::is_ascii_alphabetic) {
return Err(Error::new(ErrorKind::UnsupportedRegion));
}
let region = Self([bytes[0].to_ascii_uppercase(), bytes[1].to_ascii_uppercase()]);
if crate::plans::calling_code(region.as_str()).is_none() {
return Err(Error::new(ErrorKind::UnsupportedRegion));
}
Ok(region)
}
}
impl AsRef<str> for Region {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl FromStr for Region {
type Err = Error;
fn from_str(value: &str) -> crate::Result<Self> {
Self::try_from(value)
}
}
impl fmt::Display for Region {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
impl fmt::Debug for Region {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Region").field(&self.as_str()).finish()
}
}
#[cfg(feature = "serde")]
impl serde::Serialize for Region {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_str(self.as_str())
}
}
#[cfg(feature = "serde")]
impl<'de> serde::Deserialize<'de> for Region {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = <std::borrow::Cow<'de, str>>::deserialize(deserializer)?;
Self::new(&value).map_err(serde::de::Error::custom)
}
}