pub use non_empty_string::NonEmptyString;
pub use nonempty::{nonempty, NonEmpty};
use super::*;
impl<P: ValidatableValue<String>> ValidatableValue<String> for Option<P> {
fn validate_from(input: &String) -> Result<Self, Message> {
if input.is_empty() {
return Ok(None);
}
match P::validate_from(input) {
Ok(v) => Ok(Some(v)),
Err(Message::Empty) => Ok(None),
Err(e) => Err(e),
}
}
fn default_input() -> String {
String::new()
}
fn into_input(self) -> String {
match self {
None => "".to_owned(),
Some(v) => P::into_input(v),
}
}
}
impl<P> DefaultInputType for Option<P>
where
P: ValidatableValue<String> + DefaultInputType<InputType = String>,
{
type InputType = String;
type FormType = Edit<String>;
}
impl<P: Validatable<I, E>, I, E> Validatable<Vec<I>, Vec<E>> for Vec<P> {
fn validate_from(form: &mut Vec<E>) -> Option<Self> {
let mut vs = Vec::new();
let mut fail = false;
for e in form {
match P::validate_from(e) {
Some(v) => vs.push(v),
None => fail = true,
}
}
if fail {
None
} else {
Some(vs)
}
}
fn default_input() -> Vec<I> {
Vec::new()
}
fn into_input(self) -> Vec<I> {
self.into_iter().map(|e| P::into_input(e)).collect()
}
fn form_into_input(form: Vec<E>) -> Vec<I> {
form.into_iter().map(|e| P::form_into_input(e)).collect()
}
fn input_into_form(input: Vec<I>) -> Vec<E> {
input.into_iter().map(|e| P::input_into_form(e)).collect()
}
}
impl<P: Validatable<I, E>, I, E> Validatable<Vec<I>, Edit<Vec<E>>> for Vec<P> {
fn validate_from(form: &mut Edit<Vec<E>>) -> Option<Self> {
match <Vec<P> as Validatable<Vec<I>, Vec<E>>>::validate_from(&mut form.value) {
Some(v) => {
form.message = None;
Some(v)
}
None => {
form.message = Some(Message::ContentProblem);
None
}
}
}
fn default_input() -> Vec<I> {
<Vec<P> as Validatable<Vec<I>, Vec<E>>>::default_input()
}
fn into_input(self) -> Vec<I> {
<Vec<P> as Validatable<Vec<I>, Vec<E>>>::into_input(self)
}
fn form_into_input(form: Edit<Vec<E>>) -> Vec<I> {
<Vec<P> as Validatable<Vec<I>, Vec<E>>>::form_into_input(form.value)
}
fn input_into_form(input: Vec<I>) -> Edit<Vec<E>> {
Edit::from_input(<Vec<P> as Validatable<Vec<I>, Vec<E>>>::input_into_form(
input,
))
}
}
impl<P: DefaultInputType> DefaultInputType for Vec<P> {
type InputType = Vec<P::InputType>;
type FormType = Edit<Vec<P::FormType>>;
}
impl<P: Validatable<I, E>, I, E> Validatable<NonEmpty<I>, NonEmpty<E>> for NonEmpty<P> {
fn validate_from(form: &mut NonEmpty<E>) -> Option<Self> {
let mut vs = Vec::new();
let mut fail = false;
for e in form.iter_mut() {
match P::validate_from(e) {
Some(v) => vs.push(v),
None => fail = true,
}
}
if fail {
None
} else {
NonEmpty::from_vec(vs)
}
}
fn default_input() -> NonEmpty<I> {
NonEmpty::new(<P as Validatable<I, E>>::default_input())
}
fn into_input(self) -> NonEmpty<I> {
self.map(P::into_input)
}
fn form_into_input(form: NonEmpty<E>) -> NonEmpty<I> {
form.map(P::form_into_input)
}
fn input_into_form(input: NonEmpty<I>) -> NonEmpty<E> {
input.map(P::input_into_form)
}
}
impl<P: Validatable<I, E>, I, E> Validatable<NonEmpty<I>, Edit<NonEmpty<E>>> for NonEmpty<P> {
fn validate_from(form: &mut Edit<NonEmpty<E>>) -> Option<Self> {
match <NonEmpty<P> as Validatable<NonEmpty<I>, NonEmpty<E>>>::validate_from(&mut form.value)
{
Some(v) => {
form.message = None;
Some(v)
}
None => {
form.message = Some(Message::ContentProblem);
None
}
}
}
fn default_input() -> NonEmpty<I> {
<NonEmpty<P> as Validatable<NonEmpty<I>, NonEmpty<E>>>::default_input()
}
fn into_input(self) -> NonEmpty<I> {
<NonEmpty<P> as Validatable<NonEmpty<I>, NonEmpty<E>>>::into_input(self)
}
fn form_into_input(form: Edit<NonEmpty<E>>) -> NonEmpty<I> {
<NonEmpty<P> as Validatable<NonEmpty<I>, NonEmpty<E>>>::form_into_input(form.value)
}
fn input_into_form(input: NonEmpty<I>) -> Edit<NonEmpty<E>> {
Edit::from_input(
<NonEmpty<P> as Validatable<NonEmpty<I>, NonEmpty<E>>>::input_into_form(input),
)
}
}
impl<P: DefaultInputType> DefaultInputType for NonEmpty<P> {
type InputType = NonEmpty<P::InputType>;
type FormType = Edit<NonEmpty<P::FormType>>;
}
impl<P: Validatable<I, E>, I, E, const MIN: usize, const MAX: usize>
Validatable<BoundedVec<I, MIN, MAX>, BoundedVec<E, MIN, MAX>> for BoundedVec<P, MIN, MAX>
{
fn validate_from(form: &mut BoundedVec<E, MIN, MAX>) -> Option<Self> {
let mut vs = Vec::new();
let mut fail = false;
for e in form.as_mut_slice().iter_mut() {
match P::validate_from(e) {
Some(v) => vs.push(v),
None => fail = true,
}
}
if fail {
None
} else {
BoundedVec::from_vec(vs)
}
}
fn default_input() -> BoundedVec<I, MIN, MAX> {
BoundedVec::from_vec_unchecked((0..MIN).map(|_| P::default_input()).collect())
}
fn into_input(self) -> BoundedVec<I, MIN, MAX> {
BoundedVec::from_vec_unchecked(self.into_vec().into_iter().map(P::into_input).collect())
}
fn form_into_input(form: BoundedVec<E, MIN, MAX>) -> BoundedVec<I, MIN, MAX> {
BoundedVec::from_vec_unchecked(
form.into_vec()
.into_iter()
.map(P::form_into_input)
.collect(),
)
}
fn input_into_form(input: BoundedVec<I, MIN, MAX>) -> BoundedVec<E, MIN, MAX> {
BoundedVec::from_vec_unchecked(
input
.into_vec()
.into_iter()
.map(P::input_into_form)
.collect(),
)
}
}
impl<P: Validatable<I, E>, I, E, const MIN: usize, const MAX: usize>
Validatable<Vec<I>, Edit<Vec<E>>> for BoundedVec<P, MIN, MAX>
{
fn validate_from(form: &mut Edit<Vec<E>>) -> Option<Self> {
let len_message = if form.value.len() < MIN {
Some(if form.value.is_empty() {
Message::Empty
} else {
Message::LengthExceedMin(MIN.to_string())
})
} else if form.value.len() > MAX {
Some(Message::LengthExceedMax(MAX.to_string()))
} else {
None
};
match <Vec<P> as Validatable<Vec<I>, Vec<E>>>::validate_from(&mut form.value) {
Some(v) => {
form.message = len_message;
if form.message.is_some() {
None
} else {
form.message = None;
BoundedVec::from_vec(v)
}
}
None => {
form.message = Some(len_message.unwrap_or(Message::ContentProblem));
None
}
}
}
fn default_input() -> Vec<I> {
<BoundedVec<P, MIN, MAX> as Validatable<BoundedVec<I, MIN, MAX>, BoundedVec<E, MIN, MAX>>>::default_input().into_vec()
}
fn into_input(self) -> Vec<I> {
<BoundedVec<P, MIN, MAX> as Validatable<BoundedVec<I, MIN, MAX>, BoundedVec<E, MIN, MAX>>>::into_input(self).into_vec()
}
fn form_into_input(form: Edit<Vec<E>>) -> Vec<I> {
<Vec<P> as Validatable<Vec<I>, Vec<E>>>::form_into_input(form.value)
}
fn input_into_form(input: Vec<I>) -> Edit<Vec<E>> {
Edit::from_input(<Vec<P> as Validatable<Vec<I>, Vec<E>>>::input_into_form(
input,
))
}
}
impl<P: DefaultInputType, const MIN: usize, const MAX: usize> DefaultInputType
for BoundedVec<P, MIN, MAX>
{
type InputType = Vec<P::InputType>;
type FormType = Edit<Vec<P::FormType>>;
}
impl ValidatableValue<bool> for bool {
fn validate_from(input: &bool) -> Result<Self, Message> {
Ok(*input)
}
fn default_input() -> bool {
false
}
fn into_input(self) -> bool {
self
}
}
impl ValidatableValue<Option<bool>> for Option<bool> {
fn validate_from(input: &Option<bool>) -> Result<Self, Message> {
Ok(*input)
}
fn default_input() -> Option<bool> {
None
}
fn into_input(self) -> Option<bool> {
self
}
}
impl ValidatableValue<String> for char {
fn validate_from(input: &String) -> Result<Self, Message> {
let mut chars = input.chars();
match (chars.next(), chars.next()) {
(None, _) => Err(Message::Empty),
(Some(c), None) => Ok(c),
(Some(_), Some(_)) => Err(Message::BadFormat(Format::Char)),
}
}
fn default_input() -> String {
"".to_owned()
}
fn into_input(self) -> String {
self.to_string()
}
}
impl ValidatableValue<String> for String {
fn validate_from(input: &String) -> Result<Self, Message> {
Ok(input.clone())
}
fn default_input() -> String {
"".to_owned()
}
fn into_input(self) -> String {
self
}
}
impl ValidatableValue<String> for NonEmptyString {
fn validate_from(input: &String) -> Result<Self, Message> {
NonEmptyString::new(input.clone()).map_err(|_| Message::Empty)
}
fn default_input() -> String {
"".to_owned()
}
fn into_input(self) -> String {
self.to_string()
}
}
impl Parsable<String> for NonEmptyString {
fn parse(i: String) -> Result<Self, Message> {
NonEmptyString::new(i).map_err(|_| Message::Empty)
}
}
macro_rules! impl_validatable_value_validated {
($i: ty) => {
impl<P, VI, VP> ValidatableValue<$i> for ValidatedValue<P, $i, VI, VP>
where
P: ValidatableValue<$i> + Parsable<$i>,
VI: Validator<$i>,
VP: Validator<P>,
{
fn validate_from(input: &$i) -> Result<Self, Message> {
ValidatedValue::from_input(input)
}
fn default_input() -> $i {
<P as ValidatableValue<$i>>::default_input()
}
fn into_input(self) -> $i {
<P as ValidatableValue<$i>>::into_input(self.into_raw())
}
}
};
}
impl_validatable_value_validated!(String);
impl<P, I, VI, VP> DefaultInputType for ValidatedValue<P, I, VI, VP> {
type InputType = I;
type FormType = Edit<I>;
}
macro_rules! impl_validatable_value_parsable {
($t: ty) => {
impl ValidatableValue<String> for $t {
fn validate_from(input: &String) -> Result<Self, Message> {
Parsable::parse(input.clone())
}
fn default_input() -> String {
"".to_owned()
}
fn into_input(self) -> String {
self.to_string()
}
}
};
}
macro_rules! impl_default_type {
($t: ty, $dt: ty) => {
impl DefaultInputType for $t {
type InputType = $dt;
type FormType = Edit<$dt>;
}
};
}
macro_rules! impl_parsable {
($t: ty, $f: expr) => {
impl Parsable<String> for $t {
fn parse(i: String) -> Result<Self, Message> {
let i = i.trim();
if i.is_empty() {
Err(Message::Empty)
} else {
i.parse().map_err(|_| Message::BadFormat($f))
}
}
}
};
}
macro_rules! impl_parsable_float {
($t: ty) => {
impl Parsable<String> for $t {
fn parse(i: String) -> Result<Self, Message> {
let i = i.trim();
if i.is_empty() {
Err(Message::Empty)
} else {
match i.parse::<$t>() {
Ok(v) if v.is_finite() => Ok(v),
Ok(v) if v.is_infinite() && v.is_sign_positive() => {
Err(Message::ValueExceedMax(<$t>::MAX.to_string()))
}
Ok(v) if v.is_infinite() => {
Err(Message::ValueExceedMin(<$t>::MIN.to_string()))
}
_ => Err(Message::BadFormat(Format::Float)),
}
}
}
}
};
}
fn is_negative_zero(i: &str) -> bool {
i.strip_prefix('-')
.map(|r| !r.is_empty() && r.bytes().all(|b| b == b'0'))
.unwrap_or(false)
}
fn is_negative_integer(i: &str) -> bool {
i.strip_prefix('-')
.map(|r| !r.is_empty() && r.bytes().all(|b| b.is_ascii_digit()))
.unwrap_or(false)
}
macro_rules! impl_parsable_integer {
($t: ty, $f: expr) => {
impl Parsable<String> for $t {
fn parse(i: String) -> Result<Self, Message> {
let i = i.trim();
if i.is_empty() {
return Err(Message::Empty);
}
match i.parse::<$t>() {
Ok(v) => Ok(v),
Err(e) => match e.kind() {
std::num::IntErrorKind::PosOverflow => {
Err(Message::ValueExceedMax(<$t>::MAX.to_string()))
}
std::num::IntErrorKind::NegOverflow => {
Err(Message::ValueExceedMin(<$t>::MIN.to_string()))
}
_ if is_negative_zero(i) => Ok(0),
_ if is_negative_integer(i) => {
Err(Message::ValueExceedMin(<$t>::MIN.to_string()))
}
_ => Err(Message::BadFormat($f)),
},
}
}
}
};
}
macro_rules! impl_validated_from {
($p: ty) => {
impl<I, VI, VP> From<ValidatedValue<$p, I, VI, VP>> for $p {
fn from(value: ValidatedValue<$p, I, VI, VP>) -> Self {
value.into_raw()
}
}
};
}
impl_default_type!(bool, bool);
impl_default_type!(i8, String);
impl_default_type!(i16, String);
impl_default_type!(i32, String);
impl_default_type!(i64, String);
impl_default_type!(u8, String);
impl_default_type!(u16, String);
impl_default_type!(u32, String);
impl_default_type!(u64, String);
impl_default_type!(f32, String);
impl_default_type!(f64, String);
impl_default_type!(char, String);
impl_default_type!(String, String);
impl_default_type!(NonEmptyString, String);
impl_default_type!(Option<bool>, Option<bool>);
impl_validatable_value_parsable!(bool);
impl_validatable_value_parsable!(i8);
impl_validatable_value_parsable!(i16);
impl_validatable_value_parsable!(i32);
impl_validatable_value_parsable!(i64);
impl_validatable_value_parsable!(u8);
impl_validatable_value_parsable!(u16);
impl_validatable_value_parsable!(u32);
impl_validatable_value_parsable!(u64);
impl_validatable_value_parsable!(f32);
impl_validatable_value_parsable!(f64);
impl_parsable!(bool, Format::Bool);
impl_parsable_integer!(i8, Format::SignedInteger);
impl_parsable_integer!(i16, Format::SignedInteger);
impl_parsable_integer!(i32, Format::SignedInteger);
impl_parsable_integer!(i64, Format::SignedInteger);
impl_parsable_integer!(u8, Format::UnsignedInteger);
impl_parsable_integer!(u16, Format::UnsignedInteger);
impl_parsable_integer!(u32, Format::UnsignedInteger);
impl_parsable_integer!(u64, Format::UnsignedInteger);
impl_parsable_float!(f32);
impl_parsable_float!(f64);
impl_validated_from!(bool);
impl_validated_from!(char);
impl_validated_from!(String);
impl_validated_from!(NonEmptyString);
impl_validated_from!(i8);
impl_validated_from!(i16);
impl_validated_from!(i32);
impl_validated_from!(i64);
impl_validated_from!(u8);
impl_validated_from!(u16);
impl_validated_from!(u32);
impl_validated_from!(u64);
impl_validated_from!(f32);
impl_validated_from!(f64);