use std::fmt::{Debug, Display};
use std::hash::{Hash, Hasher};
use std::marker::PhantomData;
use super::*;
pub(crate) type Marker<T> = PhantomData<fn() -> T>;
pub struct ValidatedValue<P, I, VI, VP>(P, Marker<(I, VI, VP)>);
pub type Validated<P, VI, VP = True> =
ValidatedValue<P, <P as DefaultInputType>::InputType, VI, VP>;
impl<P, I, VI, VP> ValidatedValue<P, I, VI, VP> {
pub fn from_input(i: &I) -> Result<Self, Message>
where
I: Clone,
VI: Validator<I>,
VP: Validator<P>,
P: Parsable<I>,
{
Self::from_input_owned(i.clone())
}
pub fn from_input_owned(i: I) -> Result<Self, Message>
where
VI: Validator<I>,
VP: Validator<P>,
P: Parsable<I>,
{
VI::validate(i).and_then(|i| P::parse(i).and_then(|p| Self::from_raw(p)))
}
pub fn from_raw(p: P) -> Result<Self, Message>
where
VP: Validator<P>,
{
VP::validate(p).map(|p| ValidatedValue(p, PhantomData))
}
pub fn into_raw(self) -> P {
self.0
}
}
pub trait Parsable<I>: Sized {
fn parse(i: I) -> Result<Self, Message>;
}
impl Parsable<String> for String {
fn parse(i: String) -> Result<Self, Message> {
Ok(i)
}
}
impl<P: PartialEq, I, VI, VP> PartialEq for ValidatedValue<P, I, VI, VP> {
fn eq(&self, r: &Self) -> bool {
self.0.eq(&r.0)
}
}
impl<P: Eq, I, VI, VP> Eq for ValidatedValue<P, I, VI, VP> {}
impl<P: PartialOrd, I, VI, VP> PartialOrd for ValidatedValue<P, I, VI, VP> {
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
self.0.partial_cmp(&other.0)
}
}
impl<P: Ord, I, VI, VP> Ord for ValidatedValue<P, I, VI, VP> {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
P::cmp(&self.0, &other.0)
}
}
impl<P: Hash, I, VI, VP> Hash for ValidatedValue<P, I, VI, VP> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.0.hash(state);
}
}
impl<P: Clone, I, VI, VP> Clone for ValidatedValue<P, I, VI, VP> {
fn clone(&self) -> Self {
Self(self.0.clone(), PhantomData)
}
}
impl<P: Copy, I, VI, VP> Copy for ValidatedValue<P, I, VI, VP> {}
impl<P, I, VI, VP> AsRef<P> for ValidatedValue<P, I, VI, VP> {
fn as_ref(&self) -> &P {
&self.0
}
}
impl<P, I, VI, VP> std::ops::Deref for ValidatedValue<P, I, VI, VP> {
type Target = P;
fn deref(&self) -> &P {
&self.0
}
}
impl<P: Debug, I, VI, VP> Debug for ValidatedValue<P, I, VI, VP> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
<P as Debug>::fmt(&self.0, f)
}
}
impl<P: Display, I, VI, VP> Display for ValidatedValue<P, I, VI, VP> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
<P as Display>::fmt(&self.0, f)
}
}
#[cfg(feature = "serde")]
impl<P: serde::Serialize, I, VI, VP> serde::Serialize for ValidatedValue<P, I, VI, VP> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
self.0.serialize(serializer)
}
}
#[cfg(feature = "serde")]
impl<'de, P, I, VI, VP> serde::Deserialize<'de> for ValidatedValue<P, I, VI, VP>
where
P: serde::Deserialize<'de>,
{
fn deserialize<Z>(deserializer: Z) -> Result<Self, Z::Error>
where
Z: serde::Deserializer<'de>,
{
P::deserialize(deserializer).map(|v| ValidatedValue(v, PhantomData))
}
}