Struct amadeus::data::Group

pub struct Group { /* fields omitted */ }

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: &Group) -> Ordering

impl Clone for Group

fn clone(&self) -> Group

Returns a copy 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: <Group as Data>::DynamicType) -> <Group as Data>::Vec

impl Data for Group

fn cast<D: Data>(self) -> Result<D, CastError>

fn eq<D: Data>(self, other: D) -> bool

fn partial_cmp<D: Data>(self, other: D) -> Option<Ordering>

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

impl Debug for Group

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

Formats the value using the given formatter.

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

fn deserialize<D>(
    _deserializer: D
) -> Result<Group, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

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<(A, B, C, D, E, F, G, H, I), 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<(A, B, C, D, E, F), DowncastError>

impl DowncastFrom<Group> for ()

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

impl<A> DowncastFrom<Group> for (A,) where
    A: DowncastFrom<Value>, 

fn downcast_from(self_: Group) -> Result<(A,), 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<(A, B, C, D, E, F, G, H), 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<(A, B, C, D, E, F, G, H, I, J), 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<(A, B, C, D, E, F, G), DowncastError>

impl<A, B> DowncastFrom<Group> for (A, B) where
    A: DowncastFrom<Value>,
    B: DowncastFrom<Value>, 

fn downcast_from(self_: Group) -> Result<(A, B), 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<(A, B, C), 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<(A, B, C, D, E, F, G, H, I, J, K, L), 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<(A, B, C, D), 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<(A, B, C, D, E), 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<(A, B, C, D, E, F, G, H, I, J, K), DowncastError>

impl DowncastFrom<Value> for Group

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

impl From<()> for Group

fn from(value: ()) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

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)) -> Group

Performs the conversion.

impl<A, B> From<(A, B)> for Group where
    A: Into<Value>,
    B: Into<Value>, 

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

Performs the conversion.

impl<A> From<(A,)> for Group where
    A: Into<Value>, 

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

Performs the conversion.

impl From<Group> for Value

fn from(value: Group) -> Value

Performs the conversion.

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

fn from(
    hashmap: LinkedHashMap<String, Value, BuildHasherDefault<FxHasher>>
) -> Group

Performs the conversion.

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) -> &<Group as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl ParquetData for Group

type Schema = GroupSchema

type Reader = GroupReader

type Predicate = GroupPredicate

fn parse(
    schema: &Type,
    predicate: Option<&<Group as ParquetData>::Predicate>,
    repetition: Option<Repetition>
) -> Result<(String, <Group as ParquetData>::Schema), ParquetError>

Parse a [Type] into Self::Schema, using repetition instead of Type::get_basic_info().repetition(). A repetition of None denotes a root schema.

fn reader(
    schema: &<Group as ParquetData>::Schema,
    path: &mut Vec<String>,
    def_level: i16,
    rep_level: i16,
    paths: &mut HashMap<ColumnPath, ColumnReader, RandomState>,
    batch_size: usize
) -> <Group as ParquetData>::Reader

Builds tree of [Reader]s for the specified [Schema] recursively.

impl PartialEq<()> for Group

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>,
    Value: PartialEq<E>,
    Value: PartialEq<F>,
    Value: PartialEq<G>,
    Value: PartialEq<H>,
    Value: PartialEq<I>,
    Value: PartialEq<J>,
    Value: PartialEq<K>,
    Value: PartialEq<L>, 

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K, L)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>,
    Value: PartialEq<E>,
    Value: PartialEq<F>,
    Value: PartialEq<G>,
    Value: PartialEq<H>,
    Value: PartialEq<I>,
    Value: PartialEq<J>,
    Value: PartialEq<K>, 

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J, K)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>,
    Value: PartialEq<E>,
    Value: PartialEq<F>,
    Value: PartialEq<G>,
    Value: PartialEq<H>,
    Value: PartialEq<I>,
    Value: PartialEq<J>, 

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I, J)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>,
    Value: PartialEq<E>,
    Value: PartialEq<F>,
    Value: PartialEq<G>,
    Value: PartialEq<H>,
    Value: PartialEq<I>, 

fn eq(&self, other: &(A, B, C, D, E, F, G, H, I)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B, C, D, E, F, G, H> PartialEq<(A, B, C, D, E, F, G, H)> for Group where
    Value: PartialEq<A>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>,
    Value: PartialEq<E>,
    Value: PartialEq<F>,
    Value: PartialEq<G>,
    Value: PartialEq<H>, 

fn eq(&self, other: &(A, B, C, D, E, F, G, H)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B, C, D, E, F, G> PartialEq<(A, B, C, D, E, F, G)> for Group where
    Value: PartialEq<A>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>,
    Value: PartialEq<E>,
    Value: PartialEq<F>,
    Value: PartialEq<G>, 

fn eq(&self, other: &(A, B, C, D, E, F, G)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B, C, D, E, F> PartialEq<(A, B, C, D, E, F)> for Group where
    Value: PartialEq<A>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>,
    Value: PartialEq<E>,
    Value: PartialEq<F>, 

fn eq(&self, other: &(A, B, C, D, E, F)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B, C, D, E> PartialEq<(A, B, C, D, E)> for Group where
    Value: PartialEq<A>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>,
    Value: PartialEq<E>, 

fn eq(&self, other: &(A, B, C, D, E)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B, C, D> PartialEq<(A, B, C, D)> for Group where
    Value: PartialEq<A>,
    Value: PartialEq<B>,
    Value: PartialEq<C>,
    Value: PartialEq<D>, 

fn eq(&self, other: &(A, B, C, D)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B, C> PartialEq<(A, B, C)> for Group where
    Value: PartialEq<A>,
    Value: PartialEq<B>,
    Value: PartialEq<C>, 

fn eq(&self, other: &(A, B, C)) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A, B> PartialEq<(A, B)> for Group where
    Value: PartialEq<A>,
    Value: PartialEq<B>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A> PartialEq<(A,)> for Group where
    Value: PartialEq<A>, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Group> for Value

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Group> for Group

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<Group> for Group

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

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

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

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

impl PostgresData for Group

fn query(_f: &mut Formatter, _name: Option<&Names>) -> Result<(), Error>

fn decode(
    _type_: &Type,
    _buf: Option<&[u8]>
) -> Result<Group, Box<dyn Error + 'static + Sync + Send>>

impl SerdeData for Group

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

fn deserialize<'de, D>(
    deserializer: D,
    _schema: Option<SchemaIncomplete>
) -> Result<Group, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

impl Serialize for Group

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Group