Enum OneOf9

pub enum OneOf9<A, B, C, D, E, F, G, H, I>
where
    A: PartialEq,
    B: PartialEq,
    C: PartialEq,
    D: PartialEq,
    E: PartialEq,
    F: PartialEq,
    G: PartialEq,
    H: PartialEq,
    I: PartialEq,
{
    A(A),
    B(B),
    C(C),
    D(D),
    E(E),
    F(F),
    G(G),
    H(H),
    I(I),
}

OneOf9 type.

This allows modelling of oneOf JSON schemas.

Variants

A(A)

A variant of OneOf9

B(B)

B variant of OneOf9

C(C)

C variant of OneOf9

D(D)

D variant of OneOf9

E(E)

E variant of OneOf9

F(F)

F variant of OneOf9

G(G)

G variant of OneOf9

H(H)

H variant of OneOf9

I(I)

I variant of OneOf9

Trait Implementations

impl<A, B, C, D, E, F, G, H, I> Clone for OneOf9<A, B, C, D, E, F, G, H, I>

where A: PartialEq + Clone, B: PartialEq + Clone, C: PartialEq + Clone, D: PartialEq + Clone, E: PartialEq + Clone, F: PartialEq + Clone, G: PartialEq + Clone, H: PartialEq + Clone, I: PartialEq + Clone,

fn clone(&self) -> OneOf9<A, B, C, D, E, F, G, H, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, B, C, D, E, F, G, H, I> Debug for OneOf9<A, B, C, D, E, F, G, H, I>

where A: PartialEq + Debug, B: PartialEq + Debug, C: PartialEq + Debug, D: PartialEq + Debug, E: PartialEq + Debug, F: PartialEq + Debug, G: PartialEq + Debug, H: PartialEq + Debug, I: PartialEq + Debug,

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

Formats the value using the given formatter.

impl<'b, A, B, C, D, E, F, G, H, I> Deserialize<'b> for OneOf9<A, B, C, D, E, F, G, H, I>

where A: PartialEq + for<'a> Deserialize<'a>, B: PartialEq + for<'a> Deserialize<'a>, C: PartialEq + for<'a> Deserialize<'a>, D: PartialEq + for<'a> Deserialize<'a>, E: PartialEq + for<'a> Deserialize<'a>, F: PartialEq + for<'a> Deserialize<'a>, G: PartialEq + for<'a> Deserialize<'a>, H: PartialEq + for<'a> Deserialize<'a>, I: PartialEq + for<'a> Deserialize<'a>,

fn deserialize<De: Deserializer<'b>>( deserializer: De, ) -> Result<Self, De::Error>

Deserialize this value from the given Serde deserializer.

impl<A, B, C, D, E, F, G, H, I> FromStr for OneOf9<A, B, C, D, E, F, G, H, I>

where A: PartialEq + FromStr, B: PartialEq + FromStr, C: PartialEq + FromStr, D: PartialEq + FromStr, E: PartialEq + FromStr, F: PartialEq + FromStr, G: PartialEq + FromStr, H: PartialEq + FromStr, I: PartialEq + FromStr,

type Err = &'static str

The associated error which can be returned from parsing.

fn from_str(x: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<A, B, C, D, E, F, G, H, I> LabelledGeneric for OneOf9<A, B, C, D, E, F, G, H, I>

where A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq,

type Repr = HEither<Variant<A, HCons<Field<(__, _0), A>, HNil>>, HEither<Variant<B, HCons<Field<(__, _0), B>, HNil>>, HEither<Variant<C, HCons<Field<(__, _0), C>, HNil>>, HEither<Variant<D, HCons<Field<(__, _0), D>, HNil>>, HEither<Variant<E, HCons<Field<(__, _0), E>, HNil>>, HEither<Variant<F, HCons<Field<(__, _0), F>, HNil>>, HEither<Variant<G, HCons<Field<(__, _0), G>, HNil>>, HEither<Variant<H, HCons<Field<(__, _0), H>, HNil>>, HEither<Variant<I, HCons<Field<(__, _0), I>, HNil>>, Void>>>>>>>>>

The labelled generic representation type.

fn into(self) -> Self::Repr

Convert a value to its representation type Repr.

fn from(repr: Self::Repr) -> Self

Convert a value’s labelled representation type Repr to the values’s type.

fn convert_from<Src>(src: Src) -> Self

where Src: LabelledGeneric<Repr = Self::Repr>, Self: Sized,

Convert from one type to another using a type with the same labelled generic representation

fn sculpted_convert_from<A, Indices>(a: A) -> Self

where A: LabelledGeneric, Self: Sized, <A as LabelledGeneric>::Repr: Sculptor<Self::Repr, Indices>,

👎Deprecated: obsolete, transform_from instead

Converts from another type A into Self assuming that A and Self have labelled generic representations that can be sculpted into each other.

fn transform_from<Src, Indices>(src: Src) -> Self

where Src: LabelledGeneric, Self: Sized, <Src as LabelledGeneric>::Repr: Sculptor<Self::Repr, Indices>,

Converts from another type Src into Self assuming that Src and Self have labelled generic representations that can be sculpted into each other.

impl<A, B, C, D, E, F, G, H, I> PartialEq for OneOf9<A, B, C, D, E, F, G, H, I>

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

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

where A: PartialEq + Serialize, B: PartialEq + Serialize, C: PartialEq + Serialize, D: PartialEq + Serialize, E: PartialEq + Serialize, F: PartialEq + Serialize, G: PartialEq + Serialize, H: PartialEq + Serialize, I: PartialEq + Serialize,

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

Serialize this value into the given Serde serializer.

impl<A, B, C, D, E, F, G, H, I> ToString for OneOf9<A, B, C, D, E, F, G, H, I>

where A: PartialEq + ToString, B: PartialEq + ToString, C: PartialEq + ToString, D: PartialEq + ToString, E: PartialEq + ToString, F: PartialEq + ToString, G: PartialEq + ToString, H: PartialEq + ToString, I: PartialEq + ToString,

fn to_string(&self) -> String

Converts the given value to a String.

impl<A, B, C, D, E, F, G, H, I> Validate for OneOf9<A, B, C, D, E, F, G, H, I>

where A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq,

fn validate(&self) -> Result<(), Errors>

impl<A, B, C, D, E, F, G, H, I> StructuralPartialEq for OneOf9<A, B, C, D, E, F, G, H, I>

where A: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq,