diff options
Diffstat (limited to 'vendor/bitflags/src/traits.rs')
| -rw-r--r-- | vendor/bitflags/src/traits.rs | 430 |
1 files changed, 0 insertions, 430 deletions
diff --git a/vendor/bitflags/src/traits.rs b/vendor/bitflags/src/traits.rs deleted file mode 100644 index 2823514..0000000 --- a/vendor/bitflags/src/traits.rs +++ /dev/null @@ -1,430 +0,0 @@ -use core::{ - fmt, - ops::{BitAnd, BitOr, BitXor, Not}, -}; - -use crate::{ - iter, - parser::{ParseError, ParseHex, WriteHex}, -}; - -/** -A defined flags value that may be named or unnamed. -*/ -pub struct Flag<B> { - name: &'static str, - value: B, -} - -impl<B> Flag<B> { - /** - Define a flag. - - If `name` is non-empty then the flag is named, otherwise it's unnamed. - */ - pub const fn new(name: &'static str, value: B) -> Self { - Flag { name, value } - } - - /** - Get the name of this flag. - - If the flag is unnamed then the returned string will be empty. - */ - pub const fn name(&self) -> &'static str { - self.name - } - - /** - Get the flags value of this flag. - */ - pub const fn value(&self) -> &B { - &self.value - } - - /** - Whether the flag is named. - - If [`Flag::name`] returns a non-empty string then this method will return `true`. - */ - pub const fn is_named(&self) -> bool { - !self.name.is_empty() - } - - /** - Whether the flag is unnamed. - - If [`Flag::name`] returns a non-empty string then this method will return `false`. - */ - pub const fn is_unnamed(&self) -> bool { - self.name.is_empty() - } -} - -/** -A set of defined flags using a bits type as storage. - -## Implementing `Flags` - -This trait is implemented by the [`bitflags`](macro.bitflags.html) macro: - -``` -use bitflags::bitflags; - -bitflags! { - struct MyFlags: u8 { - const A = 1; - const B = 1 << 1; - } -} -``` - -It can also be implemented manually: - -``` -use bitflags::{Flag, Flags}; - -struct MyFlags(u8); - -impl Flags for MyFlags { - const FLAGS: &'static [Flag<Self>] = &[ - Flag::new("A", MyFlags(1)), - Flag::new("B", MyFlags(1 << 1)), - ]; - - type Bits = u8; - - fn from_bits_retain(bits: Self::Bits) -> Self { - MyFlags(bits) - } - - fn bits(&self) -> Self::Bits { - self.0 - } -} -``` - -## Using `Flags` - -The `Flags` trait can be used generically to work with any flags types. In this example, -we can count the number of defined named flags: - -``` -# use bitflags::{bitflags, Flags}; -fn defined_flags<F: Flags>() -> usize { - F::FLAGS.iter().filter(|f| f.is_named()).count() -} - -bitflags! { - struct MyFlags: u8 { - const A = 1; - const B = 1 << 1; - const C = 1 << 2; - - const _ = !0; - } -} - -assert_eq!(3, defined_flags::<MyFlags>()); -``` -*/ -pub trait Flags: Sized + 'static { - /// The set of defined flags. - const FLAGS: &'static [Flag<Self>]; - - /// The underlying bits type. - type Bits: Bits; - - /// Get a flags value with all bits unset. - fn empty() -> Self { - Self::from_bits_retain(Self::Bits::EMPTY) - } - - /// Get a flags value with all known bits set. - fn all() -> Self { - let mut truncated = Self::Bits::EMPTY; - - for flag in Self::FLAGS.iter() { - truncated = truncated | flag.value().bits(); - } - - Self::from_bits_retain(truncated) - } - - /// Get the underlying bits value. - /// - /// The returned value is exactly the bits set in this flags value. - fn bits(&self) -> Self::Bits; - - /// Convert from a bits value. - /// - /// This method will return `None` if any unknown bits are set. - fn from_bits(bits: Self::Bits) -> Option<Self> { - let truncated = Self::from_bits_truncate(bits); - - if truncated.bits() == bits { - Some(truncated) - } else { - None - } - } - - /// Convert from a bits value, unsetting any unknown bits. - fn from_bits_truncate(bits: Self::Bits) -> Self { - Self::from_bits_retain(bits & Self::all().bits()) - } - - /// Convert from a bits value exactly. - fn from_bits_retain(bits: Self::Bits) -> Self; - - /// Get a flags value with the bits of a flag with the given name set. - /// - /// This method will return `None` if `name` is empty or doesn't - /// correspond to any named flag. - fn from_name(name: &str) -> Option<Self> { - // Don't parse empty names as empty flags - if name.is_empty() { - return None; - } - - for flag in Self::FLAGS { - if flag.name() == name { - return Some(Self::from_bits_retain(flag.value().bits())); - } - } - - None - } - - /// Yield a set of contained flags values. - /// - /// Each yielded flags value will correspond to a defined named flag. Any unknown bits - /// will be yielded together as a final flags value. - fn iter(&self) -> iter::Iter<Self> { - iter::Iter::new(self) - } - - /// Yield a set of contained named flags values. - /// - /// This method is like [`Flags::iter`], except only yields bits in contained named flags. - /// Any unknown bits, or bits not corresponding to a contained flag will not be yielded. - fn iter_names(&self) -> iter::IterNames<Self> { - iter::IterNames::new(self) - } - - /// Whether all bits in this flags value are unset. - fn is_empty(&self) -> bool { - self.bits() == Self::Bits::EMPTY - } - - /// Whether all known bits in this flags value are set. - fn is_all(&self) -> bool { - // NOTE: We check against `Self::all` here, not `Self::Bits::ALL` - // because the set of all flags may not use all bits - Self::all().bits() | self.bits() == self.bits() - } - - /// Whether any set bits in a source flags value are also set in a target flags value. - fn intersects(&self, other: Self) -> bool - where - Self: Sized, - { - self.bits() & other.bits() != Self::Bits::EMPTY - } - - /// Whether all set bits in a source flags value are also set in a target flags value. - fn contains(&self, other: Self) -> bool - where - Self: Sized, - { - self.bits() & other.bits() == other.bits() - } - - /// The bitwise or (`|`) of the bits in two flags values. - fn insert(&mut self, other: Self) - where - Self: Sized, - { - *self = Self::from_bits_retain(self.bits()).union(other); - } - - /// The intersection of a source flags value with the complement of a target flags value (`&!`). - /// - /// This method is not equivalent to `self & !other` when `other` has unknown bits set. - /// `remove` won't truncate `other`, but the `!` operator will. - fn remove(&mut self, other: Self) - where - Self: Sized, - { - *self = Self::from_bits_retain(self.bits()).difference(other); - } - - /// The bitwise exclusive-or (`^`) of the bits in two flags values. - fn toggle(&mut self, other: Self) - where - Self: Sized, - { - *self = Self::from_bits_retain(self.bits()).symmetric_difference(other); - } - - /// Call [`Flags::insert`] when `value` is `true` or [`Flags::remove`] when `value` is `false`. - fn set(&mut self, other: Self, value: bool) - where - Self: Sized, - { - if value { - self.insert(other); - } else { - self.remove(other); - } - } - - /// The bitwise and (`&`) of the bits in two flags values. - #[must_use] - fn intersection(self, other: Self) -> Self { - Self::from_bits_retain(self.bits() & other.bits()) - } - - /// The bitwise or (`|`) of the bits in two flags values. - #[must_use] - fn union(self, other: Self) -> Self { - Self::from_bits_retain(self.bits() | other.bits()) - } - - /// The intersection of a source flags value with the complement of a target flags value (`&!`). - /// - /// This method is not equivalent to `self & !other` when `other` has unknown bits set. - /// `difference` won't truncate `other`, but the `!` operator will. - #[must_use] - fn difference(self, other: Self) -> Self { - Self::from_bits_retain(self.bits() & !other.bits()) - } - - /// The bitwise exclusive-or (`^`) of the bits in two flags values. - #[must_use] - fn symmetric_difference(self, other: Self) -> Self { - Self::from_bits_retain(self.bits() ^ other.bits()) - } - - /// The bitwise negation (`!`) of the bits in a flags value, truncating the result. - #[must_use] - fn complement(self) -> Self { - Self::from_bits_truncate(!self.bits()) - } -} - -/** -A bits type that can be used as storage for a flags type. -*/ -pub trait Bits: - Clone - + Copy - + PartialEq - + BitAnd<Output = Self> - + BitOr<Output = Self> - + BitXor<Output = Self> - + Not<Output = Self> - + Sized - + 'static -{ - /// A value with all bits unset. - const EMPTY: Self; - - /// A value with all bits set. - const ALL: Self; -} - -// Not re-exported: prevent custom `Bits` impls being used in the `bitflags!` macro, -// or they may fail to compile based on crate features -pub trait Primitive {} - -macro_rules! impl_bits { - ($($u:ty, $i:ty,)*) => { - $( - impl Bits for $u { - const EMPTY: $u = 0; - const ALL: $u = <$u>::MAX; - } - - impl Bits for $i { - const EMPTY: $i = 0; - const ALL: $i = <$u>::MAX as $i; - } - - impl ParseHex for $u { - fn parse_hex(input: &str) -> Result<Self, ParseError> { - <$u>::from_str_radix(input, 16).map_err(|_| ParseError::invalid_hex_flag(input)) - } - } - - impl ParseHex for $i { - fn parse_hex(input: &str) -> Result<Self, ParseError> { - <$i>::from_str_radix(input, 16).map_err(|_| ParseError::invalid_hex_flag(input)) - } - } - - impl WriteHex for $u { - fn write_hex<W: fmt::Write>(&self, mut writer: W) -> fmt::Result { - write!(writer, "{:x}", self) - } - } - - impl WriteHex for $i { - fn write_hex<W: fmt::Write>(&self, mut writer: W) -> fmt::Result { - write!(writer, "{:x}", self) - } - } - - impl Primitive for $i {} - impl Primitive for $u {} - )* - } -} - -impl_bits! { - u8, i8, - u16, i16, - u32, i32, - u64, i64, - u128, i128, - usize, isize, -} - -/// A trait for referencing the `bitflags`-owned internal type -/// without exposing it publicly. -pub trait PublicFlags { - /// The type of the underlying storage. - type Primitive: Primitive; - - /// The type of the internal field on the generated flags type. - type Internal; -} - -#[doc(hidden)] -#[deprecated(note = "use the `Flags` trait instead")] -pub trait BitFlags: ImplementedByBitFlagsMacro + Flags { - /// An iterator over enabled flags in an instance of the type. - type Iter: Iterator<Item = Self>; - - /// An iterator over the raw names and bits for enabled flags in an instance of the type. - type IterNames: Iterator<Item = (&'static str, Self)>; -} - -#[allow(deprecated)] -impl<B: Flags> BitFlags for B { - type Iter = iter::Iter<Self>; - type IterNames = iter::IterNames<Self>; -} - -impl<B: Flags> ImplementedByBitFlagsMacro for B {} - -/// A marker trait that signals that an implementation of `BitFlags` came from the `bitflags!` macro. -/// -/// There's nothing stopping an end-user from implementing this trait, but we don't guarantee their -/// manual implementations won't break between non-breaking releases. -#[doc(hidden)] -pub trait ImplementedByBitFlagsMacro {} - -pub(crate) mod __private { - pub use super::{ImplementedByBitFlagsMacro, PublicFlags}; -} |