Enum wikidata::EntityError

#[non_exhaustive]
pub enum EntityError {
    FloatParse,
    ExpectedString,
    ExpectedObject,
    ExpectedArray,
    ExpectedNumberString,
    ExpectedUriString,
    ExpectedQidString,
    ExpectedStringDatatype,
    TimeEmpty,
    BadId,
    NoDateYear,
    NoDateMatched,
    DateAmbiguous,
    InvalidDatatype,
    UnknownDatatype,
    MissingHour,
    MissingMinute,
    MissingSecond,
    InvalidSnaktype,
    InvalidPrecision,
    NoRank,
    NumberOutOfBounds,
    NoId,
    NoEntities,
    MultipleEntities,
    NoEntityType,
    NoClaims,
    NoClaimId,
    UnknownRank,
    NoSnakOrder,
    NoHash,
    NoReferenceSnaks,
    SnaksOrderIncludesNonSnak,
    QualifiersOrderButNoObject,
    QualiferOrderNamesNonQualifier,
    ExpectedKeyvalTextString,
    ExpectedTextValue,
    ExpectedAliasArray,
    ExpectedClaimArray,
    ExpectedReferenceArray,
    ExpectedReferenceSubsnakArray,
    ExpectedHashString,
    ExpectedLangString,
    ExpectedAliasString,
    ExpectedPidString,
    MissingMainsnak,
}

An error related to entity parsing/creation.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

FloatParse

A float couldn’t be parsed

ExpectedString

A string was expected but not found

ExpectedObject

An object was expected but not found

ExpectedArray

An array was expected but now found

ExpectedNumberString

Expected string repersenting number

ExpectedUriString

Expected string repersenting URI

ExpectedQidString

A valid Qid URI was expected but not found

ExpectedStringDatatype

Expected a string because the datatype is string

TimeEmpty

A time string was empty

BadId

An ID was invalid

NoDateYear

A date didn’t have a year

NoDateMatched

No date matched the day/month/year

DateAmbiguous

An ambiguous date was specified

InvalidDatatype

The datatype was invalid

UnknownDatatype

The datatype was invalid or unknown

MissingHour

The time was missing an hour

MissingMinute

The time was missing an minute

MissingSecond

The time was missing an second

InvalidSnaktype

The snaktype was invalid

InvalidPrecision

The precision level was invalid

NoRank

No rank was specified

NumberOutOfBounds

A number was out of bounds

NoId

No ID was found

NoEntities

No entities are in the object

MultipleEntities

Multiple entities are in the object

NoEntityType

The entity had no type

NoClaims

There are no claims

NoClaimId

The claim ID is missing

UnknownRank

That rank is unknown

NoSnakOrder

A reference group is missing a snaks-order field

NoHash

A hash is missing on a reference group

NoReferenceSnaks

A reference group has no snaks

SnaksOrderIncludesNonSnak

snaks-order includes a non-snak

QualifiersOrderButNoObject

A qualifier order exists but qulaifiers do not

QualiferOrderNamesNonQualifier

qualifier-order names property that is not a qualifier

ExpectedKeyvalTextString

Expected a string in a key-val entity info object (name or description)

ExpectedTextValue

Expected a value in a language+value object

ExpectedAliasArray

An array of aliases was not found

ExpectedClaimArray

An array of claims was not found

ExpectedReferenceArray

An array of references was not found

ExpectedReferenceSubsnakArray

An array of reference subsnaks was not found

ExpectedHashString

A hash was expected but not found

ExpectedLangString

A string representing a language was expected but not found

ExpectedAliasString

A string repersenting an alias was expected but not found

ExpectedPidString

A string reperesnting a Pid was expected but not found

MissingMainsnak

A mainsnak is missing

Trait Implementations

impl Clone for EntityError

fn clone(&self) -> EntityError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for EntityError

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

Formats the value using the given formatter.

impl PartialEq<EntityError> for EntityError

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

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

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

This method tests for !=.

impl Eq for EntityError

impl StructuralEq for EntityError

impl StructuralPartialEq for EntityError