106 lines
2.8 KiB
Rust
106 lines
2.8 KiB
Rust
use std::sync::Arc;
|
|
|
|
use datatype::DataType;
|
|
use serde::ser::{SerializeMap, Serializer};
|
|
use serde::{Deserialize, Serialize};
|
|
use validation::Validation;
|
|
|
|
mod datatype;
|
|
mod validation;
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Parameter {
|
|
name: Arc<str>,
|
|
|
|
data_type: DataType,
|
|
|
|
#[allow(dead_code)]
|
|
is_array: bool,
|
|
|
|
aliases: Vec<Arc<str>>,
|
|
description: Option<Arc<str>>,
|
|
help_message: Option<Arc<str>>,
|
|
parameter_sets: Vec<ParameterSet>,
|
|
validations: Vec<Validation>,
|
|
}
|
|
|
|
impl Serialize for Parameter {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let mut state = serializer.serialize_map(None)?;
|
|
|
|
state.serialize_entry("name", &self.name)?;
|
|
|
|
let mut type_str = format!("{}", self.data_type);
|
|
if self.is_array {
|
|
type_str.push_str("[]");
|
|
}
|
|
state.serialize_entry("type", &type_str)?;
|
|
|
|
state.serialize_entry("aliases", &self.aliases)?;
|
|
|
|
if let Some(desc) = &self.description {
|
|
state.serialize_entry("description", desc)?;
|
|
}
|
|
|
|
if let Some(help) = &self.help_message {
|
|
state.serialize_entry("helpMessage", help)?;
|
|
}
|
|
|
|
state.serialize_entry("parameterSets", &self.parameter_sets)?;
|
|
state.serialize_entry("validations", &self.validations)?;
|
|
|
|
state.end()
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for Parameter {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
#[derive(Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct RawParameter {
|
|
name: Arc<str>,
|
|
#[serde(rename = "type")]
|
|
data_type: String,
|
|
aliases: Vec<Arc<str>>,
|
|
description: Option<Arc<str>>,
|
|
help_message: Option<Arc<str>>,
|
|
parameter_sets: Vec<ParameterSet>,
|
|
validations: Vec<Validation>,
|
|
}
|
|
|
|
let raw = RawParameter::deserialize(deserializer)?;
|
|
|
|
let is_array = raw.data_type.ends_with("[]");
|
|
let type_str = raw.data_type.trim_end_matches("[]");
|
|
|
|
let data_type: DataType =
|
|
serde_json::from_str(&format!("\"{}\"", type_str)).map_err(serde::de::Error::custom)?;
|
|
|
|
Ok(Parameter {
|
|
name: raw.name,
|
|
data_type,
|
|
is_array,
|
|
aliases: raw.aliases,
|
|
description: raw.description,
|
|
help_message: raw.help_message,
|
|
parameter_sets: raw.parameter_sets,
|
|
validations: raw.validations,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize, Serialize, Clone, PartialEq, Eq, Default, Debug)]
|
|
pub struct ParameterSet {
|
|
name: Arc<str>,
|
|
mandatory: bool,
|
|
position: Option<u8>,
|
|
value_from_pipeline: Option<bool>,
|
|
value_from_pipeline_by_property_name: Option<bool>,
|
|
}
|