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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

// Wrap this in two cfg_attrs so that it continues to parse pre-1.54.0.
// See https://github.com/rust-lang/rust/issues/82768
#![cfg_attr(feature = "external_doc", cfg_attr(all(), doc = include_str!("../README.md")))]
#![cfg_attr(
    not(feature = "external_doc"),
    doc = "See <https://docs.rs/num_enum> for more info about this crate."
)]
#![cfg_attr(not(feature = "std"), no_std)]

pub use ::num_enum_derive::{
    Default, FromPrimitive, IntoPrimitive, TryFromPrimitive, UnsafeFromPrimitive,
};

use ::core::fmt;

pub trait FromPrimitive: Sized {
    type Primitive: Copy + Eq;

    fn from_primitive(number: Self::Primitive) -> Self;
}

pub trait TryFromPrimitive: Sized {
    type Primitive: Copy + Eq + fmt::Debug;

    const NAME: &'static str;

    fn try_from_primitive(number: Self::Primitive) -> Result<Self, TryFromPrimitiveError<Self>>;
}

pub trait UnsafeFromPrimitive: Sized {
    type Primitive: Copy + Eq;

    /// Transmutes into an enum from its primitive.
    ///
    /// # Safety
    ///
    /// - `number` must represent a valid discriminant of `Self`.
    #[deprecated(
        since = "0.6.0",
        note = "Prefer to use `unchecked_transmute_from`, `from_unchecked` will be removed in a future release."
    )]
    unsafe fn from_unchecked(number: Self::Primitive) -> Self {
        Self::unchecked_transmute_from(number)
    }

    /// Transmutes into an enum from its primitive.
    ///
    /// # Safety
    ///
    /// - `number` must represent a valid discriminant of `Self`.
    unsafe fn unchecked_transmute_from(number: Self::Primitive) -> Self;
}

pub struct TryFromPrimitiveError<Enum: TryFromPrimitive> {
    pub number: Enum::Primitive,
}

impl<Enum: TryFromPrimitive> Copy for TryFromPrimitiveError<Enum> {}
impl<Enum: TryFromPrimitive> Clone for TryFromPrimitiveError<Enum> {
    fn clone(&self) -> Self {
        TryFromPrimitiveError {
            number: self.number,
        }
    }
}
impl<Enum: TryFromPrimitive> Eq for TryFromPrimitiveError<Enum> {}
impl<Enum: TryFromPrimitive> PartialEq for TryFromPrimitiveError<Enum> {
    fn eq(&self, other: &Self) -> bool {
        self.number == other.number
    }
}
impl<Enum: TryFromPrimitive> fmt::Debug for TryFromPrimitiveError<Enum> {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.debug_struct("TryFromPrimitiveError")
            .field("number", &self.number)
            .finish()
    }
}
impl<Enum: TryFromPrimitive> fmt::Display for TryFromPrimitiveError<Enum> {
    fn fmt(&self, stream: &'_ mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            stream,
            "No discriminant in enum `{name}` matches the value `{input:?}`",
            name = Enum::NAME,
            input = self.number,
        )
    }
}

#[cfg(feature = "std")]
impl<Enum: TryFromPrimitive> ::std::error::Error for TryFromPrimitiveError<Enum> {}

// This trait exists to try to give a more clear error message when someone attempts to derive both FromPrimitive and TryFromPrimitive.
// This isn't allowed because both end up creating a `TryFrom<primitive>` implementation.
// TryFromPrimitive explicitly implements TryFrom<primitive> with Error=TryFromPrimitiveError, which conflicts with:
// FromPrimitive explicitly implements From<primitive> which has a blanket implementation of TryFrom<primitive> with Error=Infallible.
//
// This is a private implementation detail of the num_enum crate which should not be depended on externally.
// It is subject to change in any release regardless of semver.
#[doc(hidden)]
pub trait CannotDeriveBothFromPrimitiveAndTryFromPrimitive {}