ridstack-form 0.1.0

End-to-End Type-safe form handling for Dioxus applications
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use crate::prelude::*;
use std::{
    num::{ParseFloatError, ParseIntError},
    str::ParseBoolError,
};

macro_rules! impl_int {
    ($($ty:tt),*) => {
        $(impl PrimitiveFieldValue for $ty {}
        impl FieldValue for $ty {
            type PrimitiveValue = Self;
            type ConversionError = ParseIntError;
            fn from_str(value: &str) -> Result<Self, Self::ConversionError> {
                value.parse()
            }
            fn to_primitive_field_value(&self) -> Self::PrimitiveValue {
                *self
            }


        }

        impl SealedNum for $ty{}
        impl StringValue for $ty{
        fn to_string_value(&self)->String{
            self.to_string()
        }
        }
        )*
    };
}
macro_rules! impl_float {
    ($($ty:tt),*) => {
        $(impl PrimitiveFieldValue for $ty {}
        impl FieldValue for $ty {
            type PrimitiveValue = Self;
            type ConversionError = ParseFloatError;
            fn from_str(value: &str) -> Result<Self, Self::ConversionError> {
                value.parse()
            }
            fn to_primitive_field_value(&self) -> Self::PrimitiveValue {
                *self
            }
        }

        impl SealedNum for $ty{}
        impl StringValue for $ty{

            fn to_string_value(&self)->String{
                self.to_string()
            }
        }
        )*
    };
}

impl_int!(
    u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize
);

impl_float!(f32, f64);

#[derive(thiserror::Error, Debug, Clone, derive_more::Display, PartialEq, Eq, PartialOrd, Ord)]
pub struct Infallible;
impl FieldError for Infallible {}
impl PrimitiveFieldValue for String {}
impl FieldValue for String {
    type ConversionError = Infallible;
    type PrimitiveValue = String;
    fn from_str(value: &str) -> Result<Self, Self::ConversionError> {
        Ok(value.into())
    }
    fn to_primitive_field_value(&self) -> Self::PrimitiveValue {
        self.clone()
    }
}
impl StringValue for String {
    fn to_string_value(&self) -> String {
        self.to_string()
    }
}
impl<T: PrimitiveFieldValue> PrimitiveFieldValue for Option<T> {}

impl<T: FieldValue> FieldValue for Option<T>
where
    std::option::Option<T>:
        From<std::option::Option<<T as crate::prelude::FieldValue>::PrimitiveValue>>,
{
    type PrimitiveValue = Option<T::PrimitiveValue>;
    type ConversionError = Infallible;
    fn from_str(value: &str) -> dioxus::Result<Self, Self::ConversionError> {
        Ok(T::from_str(value).ok())
    }
    fn to_primitive_field_value(&self) -> Self::PrimitiveValue {
        if let Some(val) = self {
            return Some(val.to_primitive_field_value());
        }
        return None;
    }
}
impl<T: StringValue> StringValue for Option<T> {
    fn to_string_value(&self) -> String {
        self.as_ref()
            .map(|f| f.to_string_value())
            .unwrap_or_else(String::new)
    }
}

impl PrimitiveFieldValue for bool {}
impl FieldValue for bool {
    type ConversionError = ParseBoolError;
    type PrimitiveValue = Self;
    fn from_str(value: &str) -> dioxus::Result<Self, Self::ConversionError> {
        value.parse()
    }
    fn to_primitive_field_value(&self) -> Self::PrimitiveValue {
        *self
    }
}
impl StringValue for bool {
    fn to_string_value(&self) -> String {
        self.to_string()
    }
}