Enum EpochError 

pub enum EpochError {
    ConfigRead(Error),
    ConfigWrite(Error),
    ConfigCreation(String, Error),
    AlreadyInitialized {
        advice: Option<String>,
    },
    FolderNotEmpty {
        name: String,
        show_label: Option<(usize, usize)>,
    },
    EpochInfoParse(EpochId, PathBuf, Error),
    EpochInfoWrite {
        id: EpochId,
        path: PathBuf,
        help: Option<String>,
        src: Option<Error>,
    },
    EpochNotFound(String),
    AmbiguousTag(String),
    EpochFolderMissing(EpochId, PathBuf),
    FutureEpochExist,
    EpochAlreadyExists(EpochId),
    SwitchPastEpoch(EpochId),
    InvalidEpochId(EpochId),
    TagAlreadyExists(EpochId, String),
    ParentEpochMissing(EpochId, EpochId),
    Io {
        source: Error,
        help: Option<String>,
        error_line: u32,
    },
    Serde {
        source: Error,
        file_name: String,
        version: String,
    },
    TreeInvalid(EpochId, String),
    MainFolderInvalid(String),
    ParsingEpochId(ParseIntError),
    LoadingEpochId(EpochId),
    Unknown(String),
    UnknownStatAcronim(String),
    IllFormedStatQualifier(String),
    UserError(UserErrors),
    RNGPickError {
        cause: String,
        help: Option<String>,
    },
    EpochHashingImpossible(&'static str, u32),
    EntityNotFoundById(EntityIdentifier, Option<EntityType>),
    EntityNotFound(EntityType, Option<EntityIdentifier>),
    UniformRngCreation(Error),
    InvalidPositionFormat(String),
    ParsePositionError(String),
    TableStringConversionError {
        name: String,
        id: Uuid,
    },
    ParsingDuration(&'static str, String),
    ParsingBounds(&'static str, String),
    EmptyIdentifier,
    EntityAlreadyExist(Option<EntityIdentifier>),
    ParsingArgument {
        argument_parsed: String,
        while_parsing: &'static str,
    },
    IncorrectArgumentCombinaison {
        category: &'static str,
        e_type: EntityType,
        advice: Option<String>,
    },
}

All errors that can occur while working with epochs.

The enum is deliberately small - each variant is self-contained and carries the information you need to surface a friendly message to the user (and to the test-suite).

Variants

ConfigRead(Error)

Problems with the .epochconfig file.

ConfigWrite(Error)

Failed to write the epoch configuration.

ConfigCreation(String, Error)

Failed to create the epoch configuration.

AlreadyInitialized

This directory is already an epoch folder and thus cannot be initialized.

Fields

advice: Option<String>

User given advice

FolderNotEmpty

This directory isn’t empty and thus cannot be initialized.

Fields

name: String

Name of the file causing problem

show_label: Option<(usize, usize)>

Trick used to have a cute line showing the following error message

EpochInfoParse(EpochId, PathBuf, Error)

Problems while serialising / deserialising an EpochInfo.

EpochInfoWrite

Failed to write .epochinfo in epoch {id} ({path}).

Fields

id: EpochId

The id of the epoch

path: PathBuf

The path of the epoch

help: Option<String>

An optionnal help message

src: Option<Error>

The source error

EpochNotFound(String)

The user supplied an epoch id or tag that does not exist.

AmbiguousTag(String)

The user attempted to resolve an epoch that is ambiguous.

EpochFolderMissing(EpochId, PathBuf)

The epoch folder for the target id is missing.

FutureEpochExist

A future epoch exists, forbidding you to compute next and overriding them.

EpochAlreadyExists(EpochId)

A specific epoch exists, forbidding the further execution of the command.

SwitchPastEpoch(EpochId)

Attempt to switch to an epoch that has already been advanced past.

InvalidEpochId(EpochId)

The supplied epoch id is out of bounds (negative, zero or too large).

TagAlreadyExists(EpochId, String)

A tag that the user tried to assign already exists.

ParentEpochMissing(EpochId, EpochId)

The parent epoch referenced in an EpochInfo cannot be found.

Io

Generic I/O errors that bubble up from other sub-tasks.

Fields

source: Error

The source error

help: Option<String>

An optionnal help message

error_line: u32

Where the error originated from

Serde

Serialization / deserialization errors that are not caught above.

Fields

source: Error

The source error

file_name: String

The file that was being written

version: String

A version number vs file version number

TreeInvalid(EpochId, String)

The epoch tree is in an incorrect state.

MainFolderInvalid(String)

The main folder is not an epoch folder.

ParsingEpochId(ParseIntError)

Couldn’t parse an EpochId.

LoadingEpochId(EpochId)

Impossible to load the given epoch

Unknown(String)

Any other error that didn’t fit into the above categories.

UnknownStatAcronim(String)

The user tried to parse an acronim that doen’t match any stats known to the system.

IllFormedStatQualifier(String)

The user gave a stat:identifier pair that was incorrect

UserError(UserErrors)

User error, meant to be very explicit over what happened and what to do.

RNGPickError

An error happened when picking a rng event

Fields

cause: String

The root cause originating the error

help: Option<String>

Optionnal help

EpochHashingImpossible(&'static str, u32)

A non-recoverable error while hashing an epoch identifier.

This error should never happen in normal operation. It is surfaced only when the hashing routine fails to produce a unique identifier for a given epoch index.

EntityNotFoundById(EntityIdentifier, Option<EntityType>)

The entity with id {0} could not be found.

EntityNotFound(EntityType, Option<EntityIdentifier>)

The entity could not be found

UniformRngCreation(Error)

The requested uniform RNG could not be created because the supplied distribution parameters were invalid.

InvalidPositionFormat(String)

The string did not contain exactly two comma-separated values.

ParsePositionError(String)

One of the components failed to parse as an isize.

TableStringConversionError

Failed to render a table into its string representation.

Fields

name: String

The logical name of the table that failed to convert.

id: Uuid

The UUID that uniquely identifies the table instance.

ParsingDuration(&'static str, String)

Failed to parse a duration string.

ParsingBounds(&'static str, String)

Failed to parse a bounds string.

EmptyIdentifier

The value started with @ but the remainder was not a valid id or the name was empty.

EntityAlreadyExist(Option<EntityIdentifier>)

The entity already exists.

ParsingArgument

The argument could not be parsed.

Fields

argument_parsed: String

The argument that was being parsed

while_parsing: &'static str

The thing that was being parsed

IncorrectArgumentCombinaison

Indicates that the user supplied mutually‑exclusive arguments.

The command line parser accepts a number of optional arguments that belong to argument groups – e.g. --force, --dry-run, --verbose, etc.
Some of these groups are incompatible with each other. If the user specifies an argument from one group together with an argument from a conflicting group, this error is returned.

Fields

category: &'static str

The argument category that was involved in the conflict

e_type: EntityType

The entity type for which the conflict was detected.

advice: Option<String>

Optional, user‑friendly guidance on how to fix the issue.

Trait Implementations

impl Debug for EpochError

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

Formats the value using the given formatter.

impl Diagnostic for EpochError

fn code(&self) -> Option<Box<dyn Display + '_>>

Unique diagnostic code that can be used to look up more information about this Diagnostic. Ideally also globally unique, and documented in the toplevel crate’s documentation for easy searching. Rust path format (foo::bar::baz) is recommended, but more classic codes like E0123 or enums will work just fine.

fn help(&self) -> Option<Box<dyn Display + '_>>

Additional help text related to this Diagnostic. Do you have any advice for the poor soul who’s just run into this issue?

fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>>

Labels to apply to this Diagnostic’s Diagnostic::source_code

fn source_code(&self) -> Option<&dyn SourceCode>

Source code to apply this Diagnostic’s Diagnostic::labels to.

fn severity(&self) -> Option<Severity>

Diagnostic severity. This may be used by ReportHandlers to change the display format of this diagnostic.

fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

URL to visit for a more detailed explanation/help about this Diagnostic.

fn related<'a>( &'a self, ) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>>

Additional related Diagnostics.

fn diagnostic_source(&self) -> Option<&dyn Diagnostic>

The cause of the error.

impl Display for EpochError

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

Formats the value using the given formatter.

impl Error for EpochError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for EpochError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for EpochError

fn from(source: ParseIntError) -> Self

Converts to this type from the input type.