enum-tools 0.5.5

Automatically derive functions and trait implementations for enums
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

use std::fmt::{Display, Formatter};

#[allow(clippy::enum_variant_names)]
pub(crate) enum Error<'a> {
    DuplicateFeature,
    DuplicateParameter,
    DuplicateReprAttribute,
    DuplicateValue,
    ExpectedLiteral(&'a str),
    FieldsNotNameSorted,
    FieldsNotValueSorted,
    I64Overflow,
    MetaParseError(syn::Error),
    MissingReprAttribute,
    NoEnum,
    NoI64,
    NoVariantsFound,
    NotInteger,
    OnlyUnitField,
    UnexpectedLiteral,
    UnknownFeature,
    UnknownParameter,
    UnsupportedAttributeType,
    UnsupportedPath,
    UnsupportedVisibility,
}

impl Display for Error<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Error::DuplicateFeature => write!(f, "duplicate feature"),
            Error::DuplicateParameter => write!(f, "duplicate parameter"),
            Error::DuplicateReprAttribute => write!(f, "duplicate repr attribute"),
            Error::DuplicateValue => write!(f, "Duplicate value"),
            Error::ExpectedLiteral(p) => write!(f, "expected literal: {p}"),
            Error::FieldsNotNameSorted => write!(f, "variants are not sorted by name"),
            Error::FieldsNotValueSorted => write!(f, "variants are not sorted by value"),
            Error::I64Overflow => write!(f, "i64 overflow"),
            Error::MetaParseError(e) => write!(f, "meta parse error: {e}"),
            Error::MissingReprAttribute => write!(f, "missing repr attribute"),
            Error::NoEnum => write!(f, "only enums are supported"),
            Error::NoI64 => write!(f, "can't be parsed as i64"),
            Error::NoVariantsFound => write!(f, "no variants found"),
            Error::NotInteger => write!(f, "only integer literals are allowed"),
            Error::OnlyUnitField => write!(f, "only unit field items are allowed"),
            Error::UnexpectedLiteral => write!(f, "unexpected literal"),
            Error::UnknownFeature => write!(f, "unknown feature"),
            Error::UnknownParameter => write!(f, "unknown parameter"),
            Error::UnsupportedAttributeType => write!(f, "unsupported attribute type"),
            Error::UnsupportedPath => write!(f, "unsupported path"),
            Error::UnsupportedVisibility => write!(f, "unsupported visibility"),
        }
    }
}