impl TryFrom<T::Type> for BitFlags<T>

enumflags/Cargo.toml

@@ -12,3 +12,6 @@ documentation = "https://docs.rs/enumflags2"
 [dependencies]
 enumflags2_derive = { version = "0.6.0", path = "../enumflags_derive" }
 serde = { version = "^1.0.0", default-features = false, optional = true }
+
+[features]
+std = []

enumflags/src/fallible.rs

@@ -0,0 +1,27 @@
+use core::convert::TryFrom;
+use super::{BitFlags, FromBitsError};
+use super::_internal::RawBitFlags;
+
+macro_rules! impl_try_from {
+    () => { };
+    ($ty:ty, $($tt:tt)*) => {
+        impl_try_from! { $ty }
+        impl_try_from! { $($tt)* }
+    };
+    ($ty:ty) => {
+        impl<T> TryFrom<$ty> for BitFlags<T>
+        where
+            T: RawBitFlags<Type=$ty>,
+        {
+            type Error = FromBitsError<T>;
+
+            fn try_from(bits: T::Type) -> Result<Self, Self::Error> {
+                Self::try_from_bits(bits)
+            }
+        }
+    };
+}
+
+impl_try_from! {
+    u8, u16, u32, u64, usize
+}

enumflags/src/formatting.rs

@@ -1,5 +1,5 @@
 use core::fmt::{self, Debug, Binary};
-use crate::{BitFlags, _internal::RawBitFlags};
+use crate::{BitFlags, FromBitsError, _internal::RawBitFlags};
 
 impl<T> fmt::Debug for BitFlags<T>
 where

enumflags/src/lib.rs

@@ -44,10 +44,11 @@
 //! ## Optional Feature Flags
 //!
 //! - [`serde`](https://serde.rs/) implements `Serialize` and `Deserialize` for `BitFlags<T>`.
+//! - `std` implements `std::error::Error` for `FromBitsError`.
 #![warn(missing_docs)]
-#![cfg_attr(not(test), no_std)]
+#![cfg_attr(all(not(test), not(feature = "std")), no_std)]
 
-#[cfg(test)]
+#[cfg(all(test, not(feature = "std")))]
 extern crate core;
 use core::{cmp, ops};
 use core::iter::FromIterator;
@@ -119,6 +120,9 @@ pub mod _internal {
 // Internal debug formatting implementations
 mod formatting;
 
+// impl TryFrom<T::Type> for BitFlags<T>
+mod fallible;
+
 use _internal::RawBitFlags;
 
 /// Represents a set of flags of some type `T`.
@@ -151,7 +155,7 @@ where
 
 impl<T: RawBitFlags> From<T> for BitFlags<T> {
     fn from(t: T) -> BitFlags<T> {
-        BitFlags { val: t.bits() }
+        Self::from_flag(t)
     }
 }
 
@@ -204,6 +208,22 @@ where
         }
     }
 
+    pub fn from_flag(t: T) -> Self {
+        BitFlags { val: t.bits() }
+    }
+
+    pub fn try_from_bits(bits: T::Type) -> Result<Self, FromBitsError<T>> {
+        let flags = Self::from_bits_truncate(bits);
+        if flags.bits() == bits {
+            Ok(flags)
+        } else {
+            Err(FromBitsError {
+                flags,
+                invalid: bits & !flags.bits(),
+            })
+        }
+    }
+
     /// Truncates flags that are illegal
     pub fn from_bits_truncate(bits: T::Type) -> Self {
         unsafe { BitFlags::new(bits & T::all()) }
@@ -361,3 +381,26 @@ mod impl_serde {
         }
     }
 }
+
+#[derive(Debug, Copy, Clone)]
+pub struct FromBitsError<T: RawBitFlags> {
+    flags: BitFlags<T>,
+    invalid: T::Type,
+}
+
+impl<T: RawBitFlags> FromBitsError<T> {
+    pub fn truncate(self) -> BitFlags<T> {
+        self.flags
+    }
+
+    pub fn invalid_bits(self) -> T::Type {
+        self.invalid
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T: RawBitFlags> std::error::Error for FromBitsError<T> {
+    fn description(&self) -> &str {
+        "invalid bit representation"
+    }
+}