Enum tor_netdoc::NetdocErrorKind

#[non_exhaustive]
pub enum NetdocErrorKind {
    Internal,
    BadApiUsage,
    MissingKeyword,
    TruncatedLine,
    BadKeyword,
    BadObjectBeginTag,
    BadObjectEndTag,
    BadObjectMismatchedTag,
    BadObjectBase64,
    DuplicateToken,
    UnexpectedToken,
    MissingToken,
    MisplacedToken,
    TooManyArguments,
    TooFewArguments,
    UnexpectedObject,
    MissingObject,
    WrongObject,
    MissingArgument,
    BadArgument,
    BadObjectVal,
    BadSignature,
    BadTimeBound,
    BadTorVersion,
    BadPolicy,
    Undecodable,
    BadDocumentVersion,
    BadDocumentType,
    MissingEntry,
    WrongStartingToken,
    WrongEndingToken,
    WrongSortOrder,
    InvalidLifetime,
    EmptyLine,
}

A variety of parsing error.

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.

Internal

An internal error in the parser: these should never happen.

BadApiUsage

Invoked an API in an incorrect manner.

MissingKeyword

An entry was found with no keyword.

TruncatedLine

An entry was found with no newline at the end.

BadKeyword

A bad string was found in the keyword position.

BadObjectBeginTag

We found an ill-formed “BEGIN FOO” tag.

BadObjectEndTag

We found an ill-formed “END FOO” tag.

BadObjectMismatchedTag

We found a “BEGIN FOO” tag with an “END FOO” tag that didn’t match.

BadObjectBase64

We found a base64 object with an invalid base64 encoding.

DuplicateToken

The document is not supposed to contain more than one of some kind of entry, but we found one anyway.

UnexpectedToken

The document is not supposed to contain any of some particular kind of entry, but we found one anyway.

MissingToken

The document is supposed to contain any of some particular kind of entry, but we didn’t find one one anyway.

MisplacedToken

The document was supposed to have one of these, but not where we found it.

TooManyArguments

We found more arguments on an entry than it is allowed to have.

TooFewArguments

We didn’t fine enough arguments for some entry.

UnexpectedObject

We found an object attached to an entry that isn’t supposed to have one.

MissingObject

An entry was supposed to have an object, but it didn’t.

WrongObject

We found an object on an entry, but the type was wrong.

MissingArgument

We tried to find an argument that we were sure would be there, but it wasn’t!

This error should never occur in correct code; it should be caught earlier by TooFewArguments.

BadArgument

We found an argument that couldn’t be parsed.

BadObjectVal

We found an object that couldn’t be parsed after it was decoded.

BadSignature

There was some signature that we couldn’t validate.

BadTimeBound

The object is not valid at the required time.

BadTorVersion

There was a tor version we couldn’t parse.

BadPolicy

There was an ipv4 or ipv6 policy entry that we couldn’t parse.

Undecodable

An underlying byte sequence couldn’t be decoded.

BadDocumentVersion

Versioned document with an unrecognized version.

BadDocumentType

Unexpected document type

MissingEntry

We expected a kind of entry that we didn’t find

WrongStartingToken

Document or section started with wrong token

WrongEndingToken

Document or section ended with wrong token

WrongSortOrder

Items not sorted as expected

InvalidLifetime

A consensus lifetime was ill-formed.

EmptyLine

Found an empty line in the middle of a document

Trait Implementations

impl Clone for NetdocErrorKind

fn clone(&self) -> NetdocErrorKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NetdocErrorKind

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

Formats the value using the given formatter.

impl Display for NetdocErrorKind

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

Formats the value using the given formatter.

impl PartialEq for NetdocErrorKind

fn eq(&self, other: &NetdocErrorKind) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for NetdocErrorKind

impl Eq for NetdocErrorKind

impl StructuralPartialEq for NetdocErrorKind