Struct Group 

pub struct Group { /* private fields */ }

Corresponds to Parquet groups of named fields.

Its fields can be accessed by name via get()/get_mut() and via name or ordinal with group[index].

Implementations

impl Group

pub fn get(&self, k: &str) -> Option<&Value>

Get a reference to the value belonging to a particular field name. Returns None if the field name doesn’t exist.

Trait Implementations

impl AmadeusOrd for Group

fn amadeus_cmp(&self, other: &Self) -> Ordering

impl Clone for Group

fn clone(&self) -> Group

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Data for Group

type Vec = Vec<Group>

type DynamicType = ()

fn new_vec(_type: Self::DynamicType) -> Self::Vec

impl Debug for Group

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Group

fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl DowncastFrom<Group> for ()

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A> DowncastFrom<Group> for (A,)

where A: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B> DowncastFrom<Group> for (A, B)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C> DowncastFrom<Group> for (A, B, C)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D> DowncastFrom<Group> for (A, B, C, D)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D, E> DowncastFrom<Group> for (A, B, C, D, E)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>, E: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D, E, F> DowncastFrom<Group> for (A, B, C, D, E, F)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>, E: DowncastFrom<Value>, F: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D, E, F, G> DowncastFrom<Group> for (A, B, C, D, E, F, G)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>, E: DowncastFrom<Value>, F: DowncastFrom<Value>, G: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D, E, F, G, H> DowncastFrom<Group> for (A, B, C, D, E, F, G, H)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>, E: DowncastFrom<Value>, F: DowncastFrom<Value>, G: DowncastFrom<Value>, H: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D, E, F, G, H, I> DowncastFrom<Group> for (A, B, C, D, E, F, G, H, I)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>, E: DowncastFrom<Value>, F: DowncastFrom<Value>, G: DowncastFrom<Value>, H: DowncastFrom<Value>, I: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D, E, F, G, H, I, J> DowncastFrom<Group> for (A, B, C, D, E, F, G, H, I, J)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>, E: DowncastFrom<Value>, F: DowncastFrom<Value>, G: DowncastFrom<Value>, H: DowncastFrom<Value>, I: DowncastFrom<Value>, J: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D, E, F, G, H, I, J, K> DowncastFrom<Group> for (A, B, C, D, E, F, G, H, I, J, K)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>, E: DowncastFrom<Value>, F: DowncastFrom<Value>, G: DowncastFrom<Value>, H: DowncastFrom<Value>, I: DowncastFrom<Value>, J: DowncastFrom<Value>, K: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl<A, B, C, D, E, F, G, H, I, J, K, L> DowncastFrom<Group> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: DowncastFrom<Value>, B: DowncastFrom<Value>, C: DowncastFrom<Value>, D: DowncastFrom<Value>, E: DowncastFrom<Value>, F: DowncastFrom<Value>, G: DowncastFrom<Value>, H: DowncastFrom<Value>, I: DowncastFrom<Value>, J: DowncastFrom<Value>, K: DowncastFrom<Value>, L: DowncastFrom<Value>,

fn downcast_from(self_: Group) -> Result<Self, DowncastError>

impl DowncastFrom<Value> for Group

fn downcast_from(self_: Value) -> Result<Self, DowncastError>

impl From<()> for Group

fn from(value: ()) -> Self

Converts to this type from the input type.

impl<A> From<(A,)> for Group

where A: Into<Value>,

fn from(value: (A,)) -> Self

Converts to this type from the input type.

impl<A, B> From<(A, B)> for Group

where A: Into<Value>, B: Into<Value>,

fn from(value: (A, B)) -> Self

Converts to this type from the input type.

impl<A, B, C> From<(A, B, C)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>,

fn from(value: (A, B, C)) -> Self

Converts to this type from the input type.

impl<A, B, C, D> From<(A, B, C, D)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>,

fn from(value: (A, B, C, D)) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E> From<(A, B, C, D, E)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>, E: Into<Value>,

fn from(value: (A, B, C, D, E)) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F> From<(A, B, C, D, E, F)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>, E: Into<Value>, F: Into<Value>,

fn from(value: (A, B, C, D, E, F)) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F, G> From<(A, B, C, D, E, F, G)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>, E: Into<Value>, F: Into<Value>, G: Into<Value>,

fn from(value: (A, B, C, D, E, F, G)) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F, G, H> From<(A, B, C, D, E, F, G, H)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>, E: Into<Value>, F: Into<Value>, G: Into<Value>, H: Into<Value>,

fn from(value: (A, B, C, D, E, F, G, H)) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F, G, H, I> From<(A, B, C, D, E, F, G, H, I)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>, E: Into<Value>, F: Into<Value>, G: Into<Value>, H: Into<Value>, I: Into<Value>,

fn from(value: (A, B, C, D, E, F, G, H, I)) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F, G, H, I, J> From<(A, B, C, D, E, F, G, H, I, J)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>, E: Into<Value>, F: Into<Value>, G: Into<Value>, H: Into<Value>, I: Into<Value>, J: Into<Value>,

fn from(value: (A, B, C, D, E, F, G, H, I, J)) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F, G, H, I, J, K> From<(A, B, C, D, E, F, G, H, I, J, K)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>, E: Into<Value>, F: Into<Value>, G: Into<Value>, H: Into<Value>, I: Into<Value>, J: Into<Value>, K: Into<Value>,

fn from(value: (A, B, C, D, E, F, G, H, I, J, K)) -> Self

Converts to this type from the input type.

impl<A, B, C, D, E, F, G, H, I, J, K, L> From<(A, B, C, D, E, F, G, H, I, J, K, L)> for Group

where A: Into<Value>, B: Into<Value>, C: Into<Value>, D: Into<Value>, E: Into<Value>, F: Into<Value>, G: Into<Value>, H: Into<Value>, I: Into<Value>, J: Into<Value>, K: Into<Value>, L: Into<Value>,

fn from(value: (A, B, C, D, E, F, G, H, I, J, K, L)) -> Self

Converts to this type from the input type.

impl From<Group> for Value

fn from(value: Group) -> Self

Converts to this type from the input type.

impl From<LinkedHashMap<String, Value, BuildHasherDefault<FxHasher>>> for Group

fn from(hashmap: LinkedHashMap<String, Value, FxBuildHasher>) -> Self

Converts to this type from the input type.

impl<I> Index<I> for Group

where I: SliceIndex<[Value]>,

type Output = <I as SliceIndex<[Value]>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl PartialEq<()> for Group

where Value:,

fn eq(&self, other: &()) -> 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<A> PartialEq<(A,)> for Group

where Value: PartialEq<A>,

fn eq(&self, other: &(A,)) -> 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<A, B> PartialEq<(A, B)> for Group

where Value: PartialEq<A> + PartialEq<B>,

fn eq(&self, other: &(A, B)) -> 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<A, B, C> PartialEq<(A, B, C)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C>,

fn eq(&self, other: &(A, B, C)) -> 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<A, B, C, D> PartialEq<(A, B, C, D)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D>,

fn eq(&self, other: &(A, B, C, D)) -> 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<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D> + PartialEq<E>,

fn eq(&self, other: &(A, B, C, D, E)) -> 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<A, B, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D> + PartialEq<E> + PartialEq<F>,

fn eq(&self, other: &(A, B, C, D, E, F)) -> 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<A, B, C, D, E, F, G> PartialEq<(A, B, C, D, E, F, G)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D> + PartialEq<E> + PartialEq<F> + PartialEq<G>,

fn eq(&self, other: &(A, B, C, D, E, F, G)) -> 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<A, B, C, D, E, F, G, H> PartialEq<(A, B, C, D, E, F, G, H)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D> + PartialEq<E> + PartialEq<F> + PartialEq<G> + PartialEq<H>,

fn eq(&self, other: &(A, B, C, D, E, F, G, H)) -> 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<A, B, C, D, E, F, G, H, I> PartialEq<(A, B, C, D, E, F, G, H, I)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D> + PartialEq<E> + PartialEq<F> + PartialEq<G> + PartialEq<H> + PartialEq<I>,

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I)) -> 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<A, B, C, D, E, F, G, H, I, J> PartialEq<(A, B, C, D, E, F, G, H, I, J)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D> + PartialEq<E> + PartialEq<F> + PartialEq<G> + PartialEq<H> + PartialEq<I> + PartialEq<J>,

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> 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<A, B, C, D, E, F, G, H, I, J, K> PartialEq<(A, B, C, D, E, F, G, H, I, J, K)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D> + PartialEq<E> + PartialEq<F> + PartialEq<G> + PartialEq<H> + PartialEq<I> + PartialEq<J> + PartialEq<K>,

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> 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<A, B, C, D, E, F, G, H, I, J, K, L> PartialEq<(A, B, C, D, E, F, G, H, I, J, K, L)> for Group

where Value: PartialEq<A> + PartialEq<B> + PartialEq<C> + PartialEq<D> + PartialEq<E> + PartialEq<F> + PartialEq<G> + PartialEq<H> + PartialEq<I> + PartialEq<J> + PartialEq<K> + PartialEq<L>,

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> 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 PartialEq<Group> for Value

fn eq(&self, other: &Group) -> 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 PartialEq for Group

fn eq(&self, other: &Group) -> 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 Group

fn partial_cmp(&self, other: &Self) -> 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 Group

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 Group