use crate::{
build::FieldBuilder,
form::{
Form,
MetaForm,
PortableForm,
},
prelude::vec::Vec,
IntoPortable,
MetaType,
Registry,
};
use scale::Encode;
#[cfg(feature = "serde")]
use serde::{
de::DeserializeOwned,
Deserialize,
Serialize,
};
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(
feature = "serde",
serde(bound(
serialize = "T::Type: Serialize, T::String: Serialize",
deserialize = "T::Type: DeserializeOwned, T::String: DeserializeOwned",
))
)]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
#[cfg_attr(any(feature = "std", feature = "decode"), derive(scale::Decode))]
#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug, Encode)]
pub struct Field<T: Form = MetaForm> {
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
name: Option<T::String>,
#[cfg_attr(feature = "serde", serde(rename = "type"))]
ty: T::Type,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Option::is_none", default)
)]
type_name: Option<T::String>,
#[cfg_attr(
feature = "serde",
serde(skip_serializing_if = "Vec::is_empty", default)
)]
docs: Vec<T::String>,
}
impl IntoPortable for Field {
type Output = Field<PortableForm>;
fn into_portable(self, registry: &mut Registry) -> Self::Output {
Field {
name: self.name.map(|name| name.into_portable(registry)),
ty: registry.register_type(&self.ty),
type_name: self.type_name.map(|tn| tn.into_portable(registry)),
docs: registry.map_into_portable(self.docs),
}
}
}
impl Field {
pub fn builder() -> FieldBuilder {
FieldBuilder::new()
}
pub fn new(
name: Option<&'static str>,
ty: MetaType,
type_name: Option<&'static str>,
docs: &[&'static str],
) -> Self {
Self {
name,
ty,
type_name,
docs: docs.to_vec(),
}
}
}
impl<T> Field<T>
where
T: Form,
{
pub fn name(&self) -> Option<&T::String> {
self.name.as_ref()
}
pub fn ty(&self) -> &T::Type {
&self.ty
}
pub fn type_name(&self) -> Option<&T::String> {
self.type_name.as_ref()
}
pub fn docs(&self) -> &[T::String] {
&self.docs
}
}