Struct Grid 

pub struct Grid {
    pub meta: Option<Dict>,
    pub columns: Vec<Column>,
    pub rows: Vec<Dict>,
    pub ver: String,
}

Haystack Grid

Example

Create Grid from list of Dicts

use libhaystack::dict;
use libhaystack::val::*;

 let rows = vec![
  dict! {
   "site" => Value::make_marker(),
   "dis" => Value::make_str("Site")
  },
  dict! {
   "equip" => Value::make_marker(),
   "navName" => Value::make_str("Equip")
  },
  ];
  let grid = Grid::make_from_dicts(rows);
  assert_eq!(grid.is_empty(), false);
  // Get the first row from `Grid`
  assert_eq!(grid[0], dict! {
   "site" => Value::make_marker(),
   "dis" => Value::make_str("Site")
  });

Fields

meta: Option<Dict>

Optional Grid meta-data dictionary

columns: Vec<Column>

List of the columns this Grid has

rows: Vec<Dict>

List of the row for this Grid

ver: String

The version of this grid

Implementations

impl Grid

pub fn make_empty() -> Self

Create an empty Grid

pub fn make_from_dicts(rows: Vec<Dict>) -> Self

Constructs a Grid from a list of Dicts

pub fn make_from_dicts_with_meta(rows: Vec<Dict>, meta: Dict) -> Self

Constructs a Grid from a list of Dicts with a meta Dict

Example

Create Grid from list of Dicts with metadata

use libhaystack::dict;
use libhaystack::val::*;

 let rows = vec![
  dict! {
   "site" => Value::make_marker(),
   "dis" => Value::make_str("Site")
  },
  dict! {
   "equip" => Value::make_marker(),
   "navName" => Value::make_str("Equip")
  },
  ];
  let grid = Grid::make_from_dicts_with_meta(rows, dict! {
   "dis" => Value::make_str("A Test Grid")
  });
  assert_eq!(grid.is_empty(), false);
  assert_eq!(grid.meta, Some(dict! {
   "dis" => Value::make_str("A Test Grid")
  }));

pub fn make_err(dis: &str) -> Self

Create an Err Grid

pub fn is_empty(&self) -> bool

True if Grid has no rows

pub fn len(&self) -> usize

Returns number of rows in this Grid

pub fn is_err(&self) -> bool

True if Grid is an error grid

Trait Implementations

impl Clone for Grid

fn clone(&self) -> Grid

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Grid

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

Formats the value using the given formatter.

impl Default for Grid

Implements the Default trait for the Grid

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Grid

Hayson Grid deserializer

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Grid, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'a> Filtered<'a, Option<&'a Dict>> for Grid

Implement the Filtered trait for Grid.

fn filter(&'a self, filter: &Filter) -> Option<&'a Dict>

This will find the first matching Dict in the grid, one None

Example

 use libhaystack::dict;
 use libhaystack::val::{Dict, Grid, Value};
 use libhaystack::filter::{Filter, Filtered};
 let rows = vec![
  dict! {
   "site" => Value::make_marker(),
   "dis" => Value::make_str("Site")
  },
  dict! {
   "equip" => Value::make_marker(),
   "navName" => Value::make_str("Equip")
  },
  ];
 let grid = Grid::make_from_dicts(rows);
 assert_eq!(grid.filter(&Filter::try_from("equip and navName").expect("Filter")), Some(&dict! {
   "equip" => Value::make_marker(),
   "navName" => Value::make_str("Equip")
  }));

impl From<Grid> for Value

Converts from Grid to a Grid Value

fn from(value: Grid) -> Self

Converts to this type from the input type.

impl FromBrio for Grid

fn from_brio<R: Read>(reader: &mut R) -> Result<Self>

Read the complete Brio encoding of Self (ctrl byte + payload) from reader.

impl Hash for Grid

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<usize> for Grid

Implements the Index trait for the Grid this allows usage such mygrid[1]

type Output = Dict

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Grid

Implement IntoIterator for Grid

type Item = &'a Dict

The type of the elements being iterated over.

type IntoIter = IterHelper<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> ListFiltered<'a, Dict> for Grid

fn filter_all(&'a self, filter: &Filter) -> Vec<&'a Dict>

Find all rows in the grid that match the given filter.

Example

 use libhaystack::dict;
 use libhaystack::val::{Dict, Grid, Value};
 use libhaystack::filter::{Filter, ListFiltered};
 let rows = vec![
  dict! { "a" => Value::make_marker()},
  dict! { "b" => Value::make_marker()}];
 let grid = Grid::make_from_dicts(rows);
 let res = grid.filter_all(&Filter::try_from("a or b").unwrap());
 assert_eq!(res.len(), 2);

impl Ord for Grid

fn cmp(&self, other: &Grid) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Grid

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Grid

fn partial_cmp(&self, other: &Grid) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Grid

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl ToBrio for Grid

fn to_brio<W: Write>(&self, writer: &mut W) -> Result<()>

Write the Brio encoding of self into writer.

fn to_brio_vec(&self) -> Result<Vec<u8>>

Convenience: encode to a Vec<u8>.

impl ToZinc for Grid

fn to_zinc<W: Write>(&self, writer: &mut W) -> Result<()>

fn to_zinc_string(&self) -> Result<String>

Encodes this Haystack type as a Zinc string

impl TryFrom<&Value> for Grid

Tries to convert from Value to a Grid

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: &Value) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for Grid

impl StructuralPartialEq for Grid