Enum swagger::OneOf11

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

OneOf11 type.

This allows modelling of oneOf JSON schemas.

Variants

A(A)

A variant of OneOf11

B(B)

B variant of OneOf11

C(C)

C variant of OneOf11

D(D)

D variant of OneOf11

E(E)

E variant of OneOf11

F(F)

F variant of OneOf11

G(G)

G variant of OneOf11

H(H)

H variant of OneOf11

I(I)

I variant of OneOf11

J(J)

J variant of OneOf11

K(K)

K variant of OneOf11

Trait Implementations

impl<A: Clone, B: Clone, C: Clone, D: Clone, E: Clone, F: Clone, G: Clone, H: Clone, I: Clone, J: Clone, K: Clone> Clone for OneOf11<A, B, C, D, E, F, G, H, I, J, K> where
    A: PartialEq,
    B: PartialEq,
    C: PartialEq,
    D: PartialEq,
    E: PartialEq,
    F: PartialEq,
    G: PartialEq,
    H: PartialEq,
    I: PartialEq,
    J: PartialEq,
    K: PartialEq, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug, C: Debug, D: Debug, E: Debug, F: Debug, G: Debug, H: Debug, I: Debug, J: Debug, K: Debug> Debug for OneOf11<A, B, C, D, E, F, G, H, I, J, K> where
    A: PartialEq,
    B: PartialEq,
    C: PartialEq,
    D: PartialEq,
    E: PartialEq,
    F: PartialEq,
    G: PartialEq,
    H: PartialEq,
    I: PartialEq,
    J: PartialEq,
    K: PartialEq, 

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, J, K> Deserialize<'b> for OneOf11<A, B, C, D, E, F, G, H, I, J, K> 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>,
    J: PartialEq + for<'a> Deserialize<'a>,
    K: 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, J, K> FromStr for OneOf11<A, B, C, D, E, F, G, H, I, J, K> 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,
    J: PartialEq + FromStr,
    K: 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: PartialEq, B: PartialEq, C: PartialEq, D: PartialEq, E: PartialEq, F: PartialEq, G: PartialEq, H: PartialEq, I: PartialEq, J: PartialEq, K: PartialEq> PartialEq<OneOf11<A, B, C, D, E, F, G, H, I, J, K>> for OneOf11<A, B, C, D, E, F, G, H, I, J, K> where
    A: PartialEq,
    B: PartialEq,
    C: PartialEq,
    D: PartialEq,
    E: PartialEq,
    F: PartialEq,
    G: PartialEq,
    H: PartialEq,
    I: PartialEq,
    J: PartialEq,
    K: PartialEq, 

fn eq(&self, other: &OneOf11<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 ==.

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

This method tests for !=.

impl<A, B, C, D, E, F, G, H, I, J, K> Serialize for OneOf11<A, B, C, D, E, F, G, H, I, J, K> 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,
    J: PartialEq + Serialize,
    K: 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, J, K> ToString for OneOf11<A, B, C, D, E, F, G, H, I, J, K> 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,
    J: PartialEq + ToString,
    K: PartialEq + ToString, 

fn to_string(&self) -> String

Converts the given value to a String.

impl<A, B, C, D, E, F, G, H, I, J, K> StructuralPartialEq for OneOf11<A, B, C, D, E, F, G, H, I, J, K> where
    A: PartialEq,
    B: PartialEq,
    C: PartialEq,
    D: PartialEq,
    E: PartialEq,
    F: PartialEq,
    G: PartialEq,
    H: PartialEq,
    I: PartialEq,
    J: PartialEq,
    K: PartialEq,