Struct ArrayField 

#[non_exhaustive]
pub struct ArrayField {
    pub label: String,
    pub name: String,
    pub minimum_length: u32,
    pub maximum_length: Option<u32>,
    pub element_schema: QuerySchema,
}

Defines an array of composite fields.

This is commonly used for arbitrarily long list of (key, value) pairs, or lists of (key, operator, value) filters.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

label: String

Suggested label to display along the form field.

name: String

Name of the field as it will be included in the encoded query or config object.

minimum_length: u32

The minimum number of entries the array must have to be valid.

Leaving the minimum_length to 0 makes the whole field optional.

maximum_length: Option<u32>

The maximum number of entries the array can have and still be valid.

It is None when there is no maximum number

element_schema: QuerySchema

The schema of the elements inside a row of the array.

Accessing row fields

The name of each QueryField inside the element_schema can be used as an indexing key for a field. That means that if element_schema contains a TextField with the name parameter_name, then you will be able to access the value of that field using ArrayField::get(i)::get("parameter_name") for the i-th element.

Serialization

For example if an array field has this element_schema:

ArrayField::new()
  .with_name("table")
  .with_label("example".to_string())
  .with_element_schema(vec![
    TextField::new().with_name("key").into(),
    SelectField::new().with_name("operator").with_options([
      "<".into(),
      ">".into(),
      "<=".into(),
      ">=".into(),
      "==".into()
    ]).into(),
    IntegerField::new().with_name("value").into(),
  ]);

Then the URL-encoded serialization for the fields is expected to use the bracketed-notation. This means you can encode all the keys in the array in any order you want. It can look like this (line breaks are only kept for legibility):

 "table[0][key]=less+than&
 table[2][operator]=%3E&
 table[0][operator]=%3C&
 table[2][key]=greater+than&
 table[2][value]=10&
 table[0][value]=12"

or you can do the “logic” ordering too:

 "table[0][key]=less+than&
 table[0][operator]=%3C&
 table[0][value]=12&
 table[1][key]=greater+than&
 table[1][operator]=%3E&
 table[1][value]=10"

Note that we are allowed to skip indices. Any of those 2 examples above will be read as:

assert_eq!(table, vec![
  Row {
    key: "less than".to_string(),
    operator: "<".to_string(),
    value: 12,
  },
  Row {
    key: "greater than".to_string(),
    operator: ">".to_string(),
    value: 10,
  },
]);

Required row fields

Any field that is marked as required inside element_schema makes it mandatory to create a valid row to the Array Field.

Implementations

impl ArrayField

pub fn new() -> Self

Creates a new array field with all default values.

pub fn with_label(self, label: impl Into<String>) -> Self

pub fn with_element_schema(self, schema: QuerySchema) -> Self

pub fn with_name(self, name: impl Into<String>) -> Self

pub fn with_minimum_length(self, minimum_length: u32) -> Self

pub fn with_maximum_length(self, maximum_length: u32) -> Self

Trait Implementations

impl Clone for ArrayField

fn clone(&self) -> ArrayField

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ArrayField

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ArrayField

fn default() -> ArrayField

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ArrayField

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ArrayField> for QueryField

fn from(field: ArrayField) -> Self

Converts to this type from the input type.

impl PartialEq for ArrayField

fn eq(&self, other: &ArrayField) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for ArrayField

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ArrayField