Update bitflags
crate to version 2.4.2.
This CL was generated semi-automatically: * Manually updated `bitflags = "1"` to `bitflags = "2"` in `//third_party/rust/chromium_crates_io/Cargo.toml` * Run `tools/crates/run_gnrt.py vendor` * Run `tools/crates/run_gnrt.py gen` * Run `git rm -r third_party/rust/bitflags/v1` * Run `git add third_party/rust/bitflags/v2` * Run `git add third_party/rust/chromium_crates_io` * Manually updated `//mojo/public/rust/BUILD.gn` * Manually recorded the security audit notes in `//third_party/rust/chromium_crates_io/supply-chain/audits.toml` I've tested the CL by checking that I can successfully build the `mojo/public/rust:mojo_system` target (note that I have set `enable_all_rust_features = true`). This is the only target that depends on the updated crate. Bug: 1521111 Change-Id: Ib281e1a6e1a56933e1c2dbde3ea44a0e05aa6d50 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5238056 Commit-Queue: Łukasz Anforowicz <lukasza@chromium.org> Reviewed-by: danakj <danakj@chromium.org> Cr-Commit-Position: refs/heads/main@{#1252888}
This commit is contained in:

committed by
Chromium LUCI CQ

parent
2b5d0f8852
commit
a1a3dbde30
mojo/public/rust
third_party/rust
bitflags
chromium_crates_io
Cargo.lockCargo.toml
supply-chain
vendor
bitflags-1.3.2
.cargo_vcs_info.jsonCHANGELOG.mdCargo.tomlCargo.toml.origREADME.md
.github
workflows
src
tests
basic.rscompile.rs
compile-fail
compile-pass
impls
redefinition
repr
visibility
bitflags-2.4.2
.cargo-checksum.json.cargo_vcs_info.json.gitignoreCHANGELOG.mdCODE_OF_CONDUCT.mdCONTRIBUTING.mdCargo.tomlCargo.toml.origLICENSE-APACHELICENSE-MITREADME.mdSECURITY.md
benches
examples
spec.mdsrc
example_generated.rsexternal.rs
external
internal.rsiter.rslib.rsparser.rspublic.rstests.rstests
all.rsbits.rscomplement.rscontains.rsdifference.rsempty.rseq.rsextend.rsflags.rsfmt.rsfrom_bits.rsfrom_bits_retain.rsfrom_bits_truncate.rsfrom_name.rsinsert.rsintersection.rsintersects.rsis_all.rsis_empty.rsiter.rsparser.rsremove.rssymmetric_difference.rsunion.rs
traits.rs@@ -68,7 +68,7 @@ rust_static_library("mojo_system") {
|
||||
":mojo_c_system_binding",
|
||||
":mojo_c_system_wrapper",
|
||||
"//mojo/public/c/system",
|
||||
"//third_party/rust/bitflags/v1:lib",
|
||||
"//third_party/rust/bitflags/v2:lib",
|
||||
]
|
||||
|
||||
bindgen_output = get_target_outputs(":mojo_c_system_binding")
|
||||
|
36
third_party/rust/bitflags/v1/BUILD.gn
vendored
36
third_party/rust/bitflags/v1/BUILD.gn
vendored
@@ -1,36 +0,0 @@
|
||||
# Copyright 2023 The Chromium Authors
|
||||
# Use of this source code is governed by a BSD-style license that can be
|
||||
# found in the LICENSE file.
|
||||
|
||||
# @generated from third_party/rust/chromium_crates_io/BUILD.gn.hbs by
|
||||
# tools/crates/gnrt.
|
||||
# Do not edit!
|
||||
|
||||
import("//build/rust/cargo_crate.gni")
|
||||
|
||||
cargo_crate("lib") {
|
||||
crate_name = "bitflags"
|
||||
epoch = "1"
|
||||
crate_type = "rlib"
|
||||
crate_root =
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/src/lib.rs"
|
||||
sources = [
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/src/example_generated.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/src/lib.rs",
|
||||
]
|
||||
inputs = []
|
||||
|
||||
build_native_rust_unit_tests = false
|
||||
edition = "2018"
|
||||
cargo_pkg_version = "1.3.2"
|
||||
cargo_pkg_authors = "The Rust Project Developers"
|
||||
cargo_pkg_name = "bitflags"
|
||||
cargo_pkg_description =
|
||||
"A macro to generate structures which behave like bitflags."
|
||||
library_configs -= [ "//build/config/compiler:chromium_code" ]
|
||||
library_configs += [ "//build/config/compiler:no_chromium_code" ]
|
||||
executable_configs -= [ "//build/config/compiler:chromium_code" ]
|
||||
executable_configs += [ "//build/config/compiler:no_chromium_code" ]
|
||||
proc_macro_configs -= [ "//build/config/compiler:chromium_code" ]
|
||||
proc_macro_configs += [ "//build/config/compiler:no_chromium_code" ]
|
||||
}
|
70
third_party/rust/bitflags/v2/BUILD.gn
vendored
Normal file
70
third_party/rust/bitflags/v2/BUILD.gn
vendored
Normal file
@@ -0,0 +1,70 @@
|
||||
# Copyright 2023 The Chromium Authors
|
||||
# Use of this source code is governed by a BSD-style license that can be
|
||||
# found in the LICENSE file.
|
||||
|
||||
# @generated from third_party/rust/chromium_crates_io/BUILD.gn.hbs by
|
||||
# tools/crates/gnrt.
|
||||
# Do not edit!
|
||||
|
||||
import("//build/rust/cargo_crate.gni")
|
||||
|
||||
cargo_crate("lib") {
|
||||
crate_name = "bitflags"
|
||||
epoch = "2"
|
||||
crate_type = "rlib"
|
||||
crate_root =
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/lib.rs"
|
||||
sources = [
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/example_generated.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/arbitrary.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/bytemuck.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/serde.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/internal.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/iter.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/lib.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/parser.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/public.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/all.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/bits.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/complement.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/contains.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/difference.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/empty.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/eq.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/extend.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/flags.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/fmt.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits_retain.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits_truncate.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_name.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/insert.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/intersection.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/intersects.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/is_all.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/is_empty.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/iter.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/parser.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/remove.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/symmetric_difference.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/union.rs",
|
||||
"//third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/traits.rs",
|
||||
]
|
||||
inputs = []
|
||||
|
||||
build_native_rust_unit_tests = false
|
||||
edition = "2021"
|
||||
cargo_pkg_version = "2.4.2"
|
||||
cargo_pkg_authors = "The Rust Project Developers"
|
||||
cargo_pkg_name = "bitflags"
|
||||
cargo_pkg_description =
|
||||
"A macro to generate structures which behave like bitflags."
|
||||
library_configs -= [ "//build/config/compiler:chromium_code" ]
|
||||
library_configs += [ "//build/config/compiler:no_chromium_code" ]
|
||||
executable_configs -= [ "//build/config/compiler:chromium_code" ]
|
||||
executable_configs += [ "//build/config/compiler:no_chromium_code" ]
|
||||
proc_macro_configs -= [ "//build/config/compiler:chromium_code" ]
|
||||
proc_macro_configs += [ "//build/config/compiler:no_chromium_code" ]
|
||||
}
|
6
third_party/rust/bitflags/v1/README.chromium → third_party/rust/bitflags/v2/README.chromium
vendored
6
third_party/rust/bitflags/v1/README.chromium → third_party/rust/bitflags/v2/README.chromium
vendored
@@ -2,9 +2,9 @@ Name: bitflags
|
||||
URL: https://crates.io/crates/bitflags
|
||||
Description: A macro to generate structures which behave like bitflags.
|
||||
|
||||
Version: 1.3.2
|
||||
Version: 2.4.2
|
||||
Security Critical: yes
|
||||
Shipped: yes
|
||||
License: Apache 2.0
|
||||
License File: //third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/LICENSE-APACHE
|
||||
Revision: ed185cfb1c447c1b4bd6ac021c9ec3bb02c9e2f2
|
||||
License File: //third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/LICENSE-APACHE
|
||||
Revision: a5f9ce20e9d18444aa9b20c8fea9c00155cbafa3
|
2
third_party/rust/chromium_crates_io/Cargo.lock
generated
vendored
2
third_party/rust/chromium_crates_io/Cargo.lock
generated
vendored
@@ -32,7 +32,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.3.2"
|
||||
version = "2.4.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
|
||||
[[package]]
|
||||
|
@@ -17,7 +17,7 @@ edition = "2021"
|
||||
|
||||
[dependencies]
|
||||
anyhow = "1"
|
||||
bitflags = "1"
|
||||
bitflags = "2"
|
||||
bytes = "1"
|
||||
cfg-if = "1"
|
||||
cxx = "1"
|
||||
|
@@ -59,6 +59,22 @@ Reviewed in https://crrev.com/c/5171063
|
||||
Previously reviewed during security review and the audit is grandparented in.
|
||||
"""
|
||||
|
||||
[[audits.bitflags]]
|
||||
who = "Lukasz Anforowicz <lukasza@chromium.org>"
|
||||
criteria = ["safe-to-deploy", "does-not-implement-crypto", "ub-risk-1"]
|
||||
version = "2.4.2"
|
||||
notes = """
|
||||
Audit notes:
|
||||
|
||||
* I've checked for any discussion in Google-internal cl/546819168 (where audit
|
||||
of version 2.3.3 happened)
|
||||
* `src/lib.rs` contains `#![cfg_attr(not(test), forbid(unsafe_code))]`
|
||||
* There are 2 cases of `unsafe` in `src/external.rs` but they seem to be
|
||||
correct in a straightforward way - they just propagate the marker trait's
|
||||
impl (e.g. `impl bytemuck::Pod`) from the inner to the outer type
|
||||
* Additional discussion and/or notes may be found in https://crrev.com/c/5238056
|
||||
"""
|
||||
|
||||
[[audits.bytes]]
|
||||
who = "agl@chromium.org"
|
||||
criteria = ["safe-to-run", "does-not-implement-crypto"]
|
||||
|
@@ -76,7 +76,7 @@ criteria = ["does-not-implement-crypto", "safe-to-deploy", "ub-risk-2"]
|
||||
[policy."base64:0.13.1"]
|
||||
criteria = ["does-not-implement-crypto", "safe-to-run"]
|
||||
|
||||
[policy."bitflags:1.3.2"]
|
||||
[policy."bitflags:2.4.2"]
|
||||
criteria = ["does-not-implement-crypto", "safe-to-deploy", "ub-risk-2"]
|
||||
|
||||
[policy."bytes:1.5.0"]
|
||||
|
@@ -1,5 +0,0 @@
|
||||
{
|
||||
"git": {
|
||||
"sha1": "ed185cfb1c447c1b4bd6ac021c9ec3bb02c9e2f2"
|
||||
}
|
||||
}
|
@@ -1,56 +0,0 @@
|
||||
name: Rust
|
||||
|
||||
on: [push, pull_request]
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
|
||||
jobs:
|
||||
check:
|
||||
name: Test
|
||||
runs-on: ubuntu-latest
|
||||
strategy:
|
||||
fail-fast: true
|
||||
matrix:
|
||||
rust:
|
||||
- stable
|
||||
- beta
|
||||
- nightly
|
||||
- 1.46.0
|
||||
steps:
|
||||
- name: Checkout sources
|
||||
uses: actions/checkout@v2
|
||||
|
||||
- name: Install Rust toolchain
|
||||
uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: ${{ matrix.rust }}
|
||||
override: true
|
||||
|
||||
- name: Default features
|
||||
uses: actions-rs/cargo@v1
|
||||
with:
|
||||
command: test
|
||||
args: --features example_generated
|
||||
|
||||
embedded:
|
||||
name: Build (embedded)
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout sources
|
||||
uses: actions/checkout@v2
|
||||
|
||||
- name: Install Rust toolchain
|
||||
uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: nightly
|
||||
target: thumbv6m-none-eabi
|
||||
override: true
|
||||
|
||||
- name: Default features
|
||||
uses: actions-rs/cargo@v1
|
||||
with:
|
||||
command: build
|
||||
args: -Z avoid-dev-deps --features example_generated --target thumbv6m-none-eabi
|
@@ -1,206 +0,0 @@
|
||||
# 1.3.2
|
||||
|
||||
- Allow `non_snake_case` in generated flags types ([#256])
|
||||
|
||||
[#252]: https://github.com/bitflags/bitflags/pull/256
|
||||
|
||||
# 1.3.1
|
||||
|
||||
- Revert unconditional `#[repr(transparent)]` ([#252])
|
||||
|
||||
[#252]: https://github.com/bitflags/bitflags/pull/252
|
||||
|
||||
# 1.3.0 (yanked)
|
||||
|
||||
- Add `#[repr(transparent)]` ([#187])
|
||||
|
||||
- End `empty` doc comment with full stop ([#202])
|
||||
|
||||
- Fix typo in crate root docs ([#206])
|
||||
|
||||
- Document from_bits_unchecked unsafety ([#207])
|
||||
|
||||
- Let `is_all` ignore extra bits ([#211])
|
||||
|
||||
- Allows empty flag definition ([#225])
|
||||
|
||||
- Making crate accessible from std ([#227])
|
||||
|
||||
- Make `from_bits` a const fn ([#229])
|
||||
|
||||
- Allow multiple bitflags structs in one macro invocation ([#235])
|
||||
|
||||
- Add named functions to perform set operations ([#244])
|
||||
|
||||
- Fix typos in method docs ([#245])
|
||||
|
||||
- Modernization of the `bitflags` macro to take advantage of newer features and 2018 idioms ([#246])
|
||||
|
||||
- Fix regression (in an unreleased feature) and simplify tests ([#247])
|
||||
|
||||
- Use `Self` and fix bug when overriding `stringify!` ([#249])
|
||||
|
||||
[#187]: https://github.com/bitflags/bitflags/pull/187
|
||||
[#202]: https://github.com/bitflags/bitflags/pull/202
|
||||
[#206]: https://github.com/bitflags/bitflags/pull/206
|
||||
[#207]: https://github.com/bitflags/bitflags/pull/207
|
||||
[#211]: https://github.com/bitflags/bitflags/pull/211
|
||||
[#225]: https://github.com/bitflags/bitflags/pull/225
|
||||
[#227]: https://github.com/bitflags/bitflags/pull/227
|
||||
[#229]: https://github.com/bitflags/bitflags/pull/229
|
||||
[#235]: https://github.com/bitflags/bitflags/pull/235
|
||||
[#244]: https://github.com/bitflags/bitflags/pull/244
|
||||
[#245]: https://github.com/bitflags/bitflags/pull/245
|
||||
[#246]: https://github.com/bitflags/bitflags/pull/246
|
||||
[#247]: https://github.com/bitflags/bitflags/pull/247
|
||||
[#249]: https://github.com/bitflags/bitflags/pull/249
|
||||
|
||||
# 1.2.1
|
||||
|
||||
- Remove extraneous `#[inline]` attributes ([#194])
|
||||
|
||||
[#194]: https://github.com/bitflags/bitflags/pull/194
|
||||
|
||||
# 1.2.0
|
||||
|
||||
- Fix typo: {Lower, Upper}Exp - {Lower, Upper}Hex ([#183])
|
||||
|
||||
- Add support for "unknown" bits ([#188])
|
||||
|
||||
[#183]: https://github.com/rust-lang-nursery/bitflags/pull/183
|
||||
[#188]: https://github.com/rust-lang-nursery/bitflags/pull/188
|
||||
|
||||
# 1.1.0
|
||||
|
||||
This is a re-release of `1.0.5`, which was yanked due to a bug in the RLS.
|
||||
|
||||
# 1.0.5
|
||||
|
||||
- Use compiletest_rs flags supported by stable toolchain ([#171])
|
||||
|
||||
- Put the user provided attributes first ([#173])
|
||||
|
||||
- Make bitflags methods `const` on newer compilers ([#175])
|
||||
|
||||
[#171]: https://github.com/rust-lang-nursery/bitflags/pull/171
|
||||
[#173]: https://github.com/rust-lang-nursery/bitflags/pull/173
|
||||
[#175]: https://github.com/rust-lang-nursery/bitflags/pull/175
|
||||
|
||||
# 1.0.4
|
||||
|
||||
- Support Rust 2018 style macro imports ([#165])
|
||||
|
||||
```rust
|
||||
use bitflags::bitflags;
|
||||
```
|
||||
|
||||
[#165]: https://github.com/rust-lang-nursery/bitflags/pull/165
|
||||
|
||||
# 1.0.3
|
||||
|
||||
- Improve zero value flag handling and documentation ([#157])
|
||||
|
||||
[#157]: https://github.com/rust-lang-nursery/bitflags/pull/157
|
||||
|
||||
# 1.0.2
|
||||
|
||||
- 30% improvement in compile time of bitflags crate ([#156])
|
||||
|
||||
- Documentation improvements ([#153])
|
||||
|
||||
- Implementation cleanup ([#149])
|
||||
|
||||
[#156]: https://github.com/rust-lang-nursery/bitflags/pull/156
|
||||
[#153]: https://github.com/rust-lang-nursery/bitflags/pull/153
|
||||
[#149]: https://github.com/rust-lang-nursery/bitflags/pull/149
|
||||
|
||||
# 1.0.1
|
||||
- Add support for `pub(restricted)` specifier on the bitflags struct ([#135])
|
||||
- Optimize performance of `all()` when called from a separate crate ([#136])
|
||||
|
||||
[#135]: https://github.com/rust-lang-nursery/bitflags/pull/135
|
||||
[#136]: https://github.com/rust-lang-nursery/bitflags/pull/136
|
||||
|
||||
# 1.0.0
|
||||
- **[breaking change]** Macro now generates [associated constants](https://doc.rust-lang.org/reference/items.html#associated-constants) ([#24])
|
||||
|
||||
- **[breaking change]** Minimum supported version is Rust **1.20**, due to usage of associated constants
|
||||
|
||||
- After being broken in 0.9, the `#[deprecated]` attribute is now supported again ([#112])
|
||||
|
||||
- Other improvements to unit tests and documentation ([#106] and [#115])
|
||||
|
||||
[#24]: https://github.com/rust-lang-nursery/bitflags/pull/24
|
||||
[#106]: https://github.com/rust-lang-nursery/bitflags/pull/106
|
||||
[#112]: https://github.com/rust-lang-nursery/bitflags/pull/112
|
||||
[#115]: https://github.com/rust-lang-nursery/bitflags/pull/115
|
||||
|
||||
## How to update your code to use associated constants
|
||||
Assuming the following structure definition:
|
||||
```rust
|
||||
bitflags! {
|
||||
struct Something: u8 {
|
||||
const FOO = 0b01,
|
||||
const BAR = 0b10
|
||||
}
|
||||
}
|
||||
```
|
||||
In 0.9 and older you could do:
|
||||
```rust
|
||||
let x = FOO.bits | BAR.bits;
|
||||
```
|
||||
Now you must use:
|
||||
```rust
|
||||
let x = Something::FOO.bits | Something::BAR.bits;
|
||||
```
|
||||
|
||||
# 0.9.1
|
||||
- Fix the implementation of `Formatting` traits when other formatting traits were present in scope ([#105])
|
||||
|
||||
[#105]: https://github.com/rust-lang-nursery/bitflags/pull/105
|
||||
|
||||
# 0.9.0
|
||||
- **[breaking change]** Use struct keyword instead of flags to define bitflag types ([#84])
|
||||
|
||||
- **[breaking change]** Terminate const items with semicolons instead of commas ([#87])
|
||||
|
||||
- Implement the `Hex`, `Octal`, and `Binary` formatting traits ([#86])
|
||||
|
||||
- Printing an empty flag value with the `Debug` trait now prints "(empty)" instead of nothing ([#85])
|
||||
|
||||
- The `bitflags!` macro can now be used inside of a fn body, to define a type local to that function ([#74])
|
||||
|
||||
[#74]: https://github.com/rust-lang-nursery/bitflags/pull/74
|
||||
[#84]: https://github.com/rust-lang-nursery/bitflags/pull/84
|
||||
[#85]: https://github.com/rust-lang-nursery/bitflags/pull/85
|
||||
[#86]: https://github.com/rust-lang-nursery/bitflags/pull/86
|
||||
[#87]: https://github.com/rust-lang-nursery/bitflags/pull/87
|
||||
|
||||
# 0.8.2
|
||||
- Update feature flag used when building bitflags as a dependency of the Rust toolchain
|
||||
|
||||
# 0.8.1
|
||||
- Allow bitflags to be used as a dependency of the Rust toolchain
|
||||
|
||||
# 0.8.0
|
||||
- Add support for the experimental `i128` and `u128` integer types ([#57])
|
||||
- Add set method: `flags.set(SOME_FLAG, true)` or `flags.set(SOME_FLAG, false)` ([#55])
|
||||
This may break code that defines its own set method
|
||||
|
||||
[#55]: https://github.com/rust-lang-nursery/bitflags/pull/55
|
||||
[#57]: https://github.com/rust-lang-nursery/bitflags/pull/57
|
||||
|
||||
# 0.7.1
|
||||
*(yanked)*
|
||||
|
||||
# 0.7.0
|
||||
- Implement the Extend trait ([#49])
|
||||
- Allow definitions inside the `bitflags!` macro to refer to items imported from other modules ([#51])
|
||||
|
||||
[#49]: https://github.com/rust-lang-nursery/bitflags/pull/49
|
||||
[#51]: https://github.com/rust-lang-nursery/bitflags/pull/51
|
||||
|
||||
# 0.6.0
|
||||
- The `no_std` feature was removed as it is now the default
|
||||
- The `assignment_operators` feature was remove as it is now enabled by default
|
||||
- Some clippy suggestions have been applied
|
@@ -1,58 +0,0 @@
|
||||
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||
#
|
||||
# When uploading crates to the registry Cargo will automatically
|
||||
# "normalize" Cargo.toml files for maximal compatibility
|
||||
# with all versions of Cargo and also rewrite `path` dependencies
|
||||
# to registry (e.g., crates.io) dependencies
|
||||
#
|
||||
# If you believe there's an error in this file please file an
|
||||
# issue against the rust-lang/cargo repository. If you're
|
||||
# editing this file be aware that the upstream Cargo.toml
|
||||
# will likely look very different (and much more reasonable)
|
||||
|
||||
[package]
|
||||
edition = "2018"
|
||||
name = "bitflags"
|
||||
version = "1.3.2"
|
||||
authors = ["The Rust Project Developers"]
|
||||
exclude = ["bors.toml"]
|
||||
description = "A macro to generate structures which behave like bitflags.\n"
|
||||
homepage = "https://github.com/bitflags/bitflags"
|
||||
documentation = "https://docs.rs/bitflags"
|
||||
readme = "README.md"
|
||||
keywords = ["bit", "bitmask", "bitflags", "flags"]
|
||||
categories = ["no-std"]
|
||||
license = "MIT/Apache-2.0"
|
||||
repository = "https://github.com/bitflags/bitflags"
|
||||
[package.metadata.docs.rs]
|
||||
features = ["example_generated"]
|
||||
[dependencies.compiler_builtins]
|
||||
version = "0.1.2"
|
||||
optional = true
|
||||
|
||||
[dependencies.core]
|
||||
version = "1.0.0"
|
||||
optional = true
|
||||
package = "rustc-std-workspace-core"
|
||||
[dev-dependencies.rustversion]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.serde]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.serde_derive]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.serde_json]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.trybuild]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.walkdir]
|
||||
version = "2.3"
|
||||
|
||||
[features]
|
||||
default = []
|
||||
example_generated = []
|
||||
rustc-dep-of-std = ["core", "compiler_builtins"]
|
39
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/Cargo.toml.orig
generated
vendored
39
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/Cargo.toml.orig
generated
vendored
@@ -1,39 +0,0 @@
|
||||
[package]
|
||||
name = "bitflags"
|
||||
# NB: When modifying, also modify:
|
||||
# 1. html_root_url in lib.rs
|
||||
# 2. number in readme (for breaking changes)
|
||||
version = "1.3.2"
|
||||
edition = "2018"
|
||||
authors = ["The Rust Project Developers"]
|
||||
license = "MIT/Apache-2.0"
|
||||
keywords = ["bit", "bitmask", "bitflags", "flags"]
|
||||
readme = "README.md"
|
||||
repository = "https://github.com/bitflags/bitflags"
|
||||
homepage = "https://github.com/bitflags/bitflags"
|
||||
documentation = "https://docs.rs/bitflags"
|
||||
categories = ["no-std"]
|
||||
description = """
|
||||
A macro to generate structures which behave like bitflags.
|
||||
"""
|
||||
exclude = ["bors.toml"]
|
||||
|
||||
[dependencies]
|
||||
core = { version = '1.0.0', optional = true, package = 'rustc-std-workspace-core' }
|
||||
compiler_builtins = { version = '0.1.2', optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
trybuild = "1.0"
|
||||
rustversion = "1.0"
|
||||
walkdir = "2.3"
|
||||
serde = "1.0"
|
||||
serde_derive = "1.0"
|
||||
serde_json = "1.0"
|
||||
|
||||
[features]
|
||||
default = []
|
||||
example_generated = []
|
||||
rustc-dep-of-std = ["core", "compiler_builtins"]
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
features = ["example_generated"]
|
@@ -1,32 +0,0 @@
|
||||
bitflags
|
||||
========
|
||||
|
||||
[](https://github.com/bitflags/bitflags/actions)
|
||||
[](https://gitter.im/bitflags/Lobby?utm_source=badge&utm_medium=badge&utm_content=badge)
|
||||
[](https://crates.io/crates/bitflags)
|
||||
[](https://docs.rs/bitflags)
|
||||

|
||||
|
||||
A Rust macro to generate structures which behave like a set of bitflags
|
||||
|
||||
- [Documentation](https://docs.rs/bitflags)
|
||||
- [Release notes](https://github.com/bitflags/bitflags/releases)
|
||||
|
||||
## Usage
|
||||
|
||||
Add this to your `Cargo.toml`:
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
bitflags = "1.3"
|
||||
```
|
||||
|
||||
and this to your source code:
|
||||
|
||||
```rust
|
||||
use bitflags::bitflags;
|
||||
```
|
||||
|
||||
## Rust Version Support
|
||||
|
||||
The minimum supported Rust version is 1.46 due to use of associated constants and const functions.
|
@@ -1,14 +0,0 @@
|
||||
//! This module shows an example of code generated by the macro. **IT MUST NOT BE USED OUTSIDE THIS
|
||||
//! CRATE**.
|
||||
|
||||
bitflags! {
|
||||
/// This is the same `Flags` struct defined in the [crate level example](../index.html#example).
|
||||
/// Note that this struct is just for documentation purposes only, it must not be used outside
|
||||
/// this crate.
|
||||
pub struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
const B = 0b00000010;
|
||||
const C = 0b00000100;
|
||||
const ABC = Self::A.bits | Self::B.bits | Self::C.bits;
|
||||
}
|
||||
}
|
File diff suppressed because it is too large
Load Diff
@@ -1,20 +0,0 @@
|
||||
#![no_std]
|
||||
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
/// baz
|
||||
struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
#[doc = "bar"]
|
||||
const B = 0b00000010;
|
||||
const C = 0b00000100;
|
||||
#[doc = "foo"]
|
||||
const ABC = Flags::A.bits | Flags::B.bits | Flags::C.bits;
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn basic() {
|
||||
assert_eq!(Flags::ABC, Flags::A | Flags::B | Flags::C);
|
||||
}
|
@@ -1 +0,0 @@
|
||||
*.stderr
|
10
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.rs
vendored
10
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.rs
vendored
@@ -1,10 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
#[derive(Clone, Copy)]
|
||||
struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
27
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.stderr.beta
vendored
27
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/impls/copy.stderr.beta
vendored
@@ -1,27 +0,0 @@
|
||||
error[E0119]: conflicting implementations of trait `std::clone::Clone` for type `Flags`
|
||||
--> $DIR/copy.rs:3:1
|
||||
|
|
||||
3 | / bitflags! {
|
||||
4 | | #[derive(Clone, Copy)]
|
||||
| | ----- first implementation here
|
||||
5 | | struct Flags: u32 {
|
||||
6 | | const A = 0b00000001;
|
||||
7 | | }
|
||||
8 | | }
|
||||
| |_^ conflicting implementation for `Flags`
|
||||
|
|
||||
= note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
|
||||
error[E0119]: conflicting implementations of trait `std::marker::Copy` for type `Flags`
|
||||
--> $DIR/copy.rs:3:1
|
||||
|
|
||||
3 | / bitflags! {
|
||||
4 | | #[derive(Clone, Copy)]
|
||||
| | ---- first implementation here
|
||||
5 | | struct Flags: u32 {
|
||||
6 | | const A = 0b00000001;
|
||||
7 | | }
|
||||
8 | | }
|
||||
| |_^ conflicting implementation for `Flags`
|
||||
|
|
||||
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
|
10
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.rs
vendored
10
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.rs
vendored
@@ -1,10 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
#[derive(PartialEq, Eq)]
|
||||
struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
55
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.stderr.beta
vendored
55
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/impls/eq.stderr.beta
vendored
@@ -1,55 +0,0 @@
|
||||
error[E0119]: conflicting implementations of trait `std::cmp::PartialEq` for type `Flags`
|
||||
--> $DIR/eq.rs:3:1
|
||||
|
|
||||
3 | / bitflags! {
|
||||
4 | | #[derive(PartialEq, Eq)]
|
||||
| | --------- first implementation here
|
||||
5 | | struct Flags: u32 {
|
||||
6 | | const A = 0b00000001;
|
||||
7 | | }
|
||||
8 | | }
|
||||
| |_^ conflicting implementation for `Flags`
|
||||
|
|
||||
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
|
||||
error[E0119]: conflicting implementations of trait `std::cmp::Eq` for type `Flags`
|
||||
--> $DIR/eq.rs:3:1
|
||||
|
|
||||
3 | / bitflags! {
|
||||
4 | | #[derive(PartialEq, Eq)]
|
||||
| | -- first implementation here
|
||||
5 | | struct Flags: u32 {
|
||||
6 | | const A = 0b00000001;
|
||||
7 | | }
|
||||
8 | | }
|
||||
| |_^ conflicting implementation for `Flags`
|
||||
|
|
||||
= note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
|
||||
error[E0119]: conflicting implementations of trait `std::marker::StructuralPartialEq` for type `Flags`
|
||||
--> $DIR/eq.rs:3:1
|
||||
|
|
||||
3 | / bitflags! {
|
||||
4 | | #[derive(PartialEq, Eq)]
|
||||
| | --------- first implementation here
|
||||
5 | | struct Flags: u32 {
|
||||
6 | | const A = 0b00000001;
|
||||
7 | | }
|
||||
8 | | }
|
||||
| |_^ conflicting implementation for `Flags`
|
||||
|
|
||||
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
|
||||
error[E0119]: conflicting implementations of trait `std::marker::StructuralEq` for type `Flags`
|
||||
--> $DIR/eq.rs:3:1
|
||||
|
|
||||
3 | / bitflags! {
|
||||
4 | | #[derive(PartialEq, Eq)]
|
||||
| | -- first implementation here
|
||||
5 | | struct Flags: u32 {
|
||||
6 | | const A = 0b00000001;
|
||||
7 | | }
|
||||
8 | | }
|
||||
| |_^ conflicting implementation for `Flags`
|
||||
|
|
||||
= note: this error originates in the derive macro `Eq` (in Nightly builds, run with -Z macro-backtrace for more info)
|
123
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.rs
vendored
123
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_defined.rs
vendored
@@ -1,123 +0,0 @@
|
||||
use std::{
|
||||
fmt::{
|
||||
self,
|
||||
Debug,
|
||||
Display,
|
||||
LowerHex,
|
||||
UpperHex,
|
||||
Octal,
|
||||
Binary,
|
||||
},
|
||||
ops::{
|
||||
BitAnd,
|
||||
BitOr,
|
||||
BitXor,
|
||||
BitAndAssign,
|
||||
BitOrAssign,
|
||||
BitXorAssign,
|
||||
Not,
|
||||
},
|
||||
};
|
||||
|
||||
use bitflags::bitflags;
|
||||
|
||||
// Ideally we'd actually want this to work, but currently need something like `num`'s `Zero`
|
||||
// With some design work it could be made possible
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
struct MyInt(u8);
|
||||
|
||||
impl BitAnd for MyInt {
|
||||
type Output = Self;
|
||||
|
||||
fn bitand(self, other: Self) -> Self {
|
||||
MyInt(self.0 & other.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl BitOr for MyInt {
|
||||
type Output = Self;
|
||||
|
||||
fn bitor(self, other: Self) -> Self {
|
||||
MyInt(self.0 | other.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl BitXor for MyInt {
|
||||
type Output = Self;
|
||||
|
||||
fn bitxor(self, other: Self) -> Self {
|
||||
MyInt(self.0 ^ other.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl BitAndAssign for MyInt {
|
||||
fn bitand_assign(&mut self, other: Self) {
|
||||
self.0 &= other.0
|
||||
}
|
||||
}
|
||||
|
||||
impl BitOrAssign for MyInt {
|
||||
fn bitor_assign(&mut self, other: Self) {
|
||||
self.0 |= other.0
|
||||
}
|
||||
}
|
||||
|
||||
impl BitXorAssign for MyInt {
|
||||
fn bitxor_assign(&mut self, other: Self) {
|
||||
self.0 ^= other.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Debug for MyInt {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
Debug::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for MyInt {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
Display::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl LowerHex for MyInt {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
LowerHex::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl UpperHex for MyInt {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
UpperHex::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Octal for MyInt {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
Octal::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Binary for MyInt {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
Binary::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl Not for MyInt {
|
||||
type Output = MyInt;
|
||||
|
||||
fn not(self) -> Self {
|
||||
MyInt(!self.0)
|
||||
}
|
||||
}
|
||||
|
||||
bitflags! {
|
||||
struct Flags128: MyInt {
|
||||
const A = MyInt(0b0000_0001u8);
|
||||
const B = MyInt(0b0000_0010u8);
|
||||
const C = MyInt(0b0000_0100u8);
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
@@ -1,27 +0,0 @@
|
||||
error[E0308]: mismatched types
|
||||
--> $DIR/all_defined.rs:115:1
|
||||
|
|
||||
115 | / bitflags! {
|
||||
116 | | struct Flags128: MyInt {
|
||||
117 | | const A = MyInt(0b0000_0001u8);
|
||||
118 | | const B = MyInt(0b0000_0010u8);
|
||||
119 | | const C = MyInt(0b0000_0100u8);
|
||||
120 | | }
|
||||
121 | | }
|
||||
| |_^ expected struct `MyInt`, found integer
|
||||
|
|
||||
= note: this error originates in the macro `__impl_all_bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
|
||||
error[E0308]: mismatched types
|
||||
--> $DIR/all_defined.rs:115:1
|
||||
|
|
||||
115 | / bitflags! {
|
||||
116 | | struct Flags128: MyInt {
|
||||
117 | | const A = MyInt(0b0000_0001u8);
|
||||
118 | | const B = MyInt(0b0000_0010u8);
|
||||
119 | | const C = MyInt(0b0000_0100u8);
|
||||
120 | | }
|
||||
121 | | }
|
||||
| |_^ expected struct `MyInt`, found integer
|
||||
|
|
||||
= note: this error originates in the macro `__impl_bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
|
13
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.rs
vendored
13
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/non_integer_base/all_missing.rs
vendored
@@ -1,13 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
struct MyInt(u8);
|
||||
|
||||
bitflags! {
|
||||
struct Flags128: MyInt {
|
||||
const A = MyInt(0b0000_0001);
|
||||
const B = MyInt(0b0000_0010);
|
||||
const C = MyInt(0b0000_0100);
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
@@ -1,13 +0,0 @@
|
||||
error[E0204]: the trait `Copy` may not be implemented for this type
|
||||
--> $DIR/all_missing.rs:5:1
|
||||
|
|
||||
5 | / bitflags! {
|
||||
6 | | struct Flags128: MyInt {
|
||||
7 | | const A = MyInt(0b0000_0001);
|
||||
8 | | const B = MyInt(0b0000_0010);
|
||||
9 | | const C = MyInt(0b0000_0100);
|
||||
10 | | }
|
||||
11 | | }
|
||||
| |_^ this field does not implement `Copy`
|
||||
|
|
||||
= note: this error originates in the derive macro `Copy` (in Nightly builds, run with -Z macro-backtrace for more info)
|
13
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.rs
vendored
13
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_field.rs
vendored
@@ -1,13 +0,0 @@
|
||||
mod example {
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
pub struct Flags1: u32 {
|
||||
const FLAG_A = 0b00000001;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let flag1 = example::Flags1::FLAG_A.bits;
|
||||
}
|
@@ -1,10 +0,0 @@
|
||||
error[E0616]: field `bits` of struct `Flags1` is private
|
||||
--> $DIR/private_field.rs:12:41
|
||||
|
|
||||
12 | let flag1 = example::Flags1::FLAG_A.bits;
|
||||
| ^^^^ private field
|
||||
|
|
||||
help: a method `bits` also exists, call it with parentheses
|
||||
|
|
||||
12 | let flag1 = example::Flags1::FLAG_A.bits();
|
||||
| ^^
|
18
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.rs
vendored
18
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/visibility/private_flags.rs
vendored
@@ -1,18 +0,0 @@
|
||||
mod example {
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
pub struct Flags1: u32 {
|
||||
const FLAG_A = 0b00000001;
|
||||
}
|
||||
|
||||
struct Flags2: u32 {
|
||||
const FLAG_B = 0b00000010;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let flag1 = example::Flags1::FLAG_A;
|
||||
let flag2 = example::Flags2::FLAG_B;
|
||||
}
|
@@ -1,18 +0,0 @@
|
||||
error[E0603]: struct `Flags2` is private
|
||||
--> $DIR/private_flags.rs:17:26
|
||||
|
|
||||
17 | let flag2 = example::Flags2::FLAG_B;
|
||||
| ^^^^^^ private struct
|
||||
|
|
||||
note: the struct `Flags2` is defined here
|
||||
--> $DIR/private_flags.rs:4:5
|
||||
|
|
||||
4 | / bitflags! {
|
||||
5 | | pub struct Flags1: u32 {
|
||||
6 | | const FLAG_A = 0b00000001;
|
||||
7 | | }
|
||||
... |
|
||||
11 | | }
|
||||
12 | | }
|
||||
| |_____^
|
||||
= note: this error originates in the macro `bitflags` (in Nightly builds, run with -Z macro-backtrace for more info)
|
9
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.rs
vendored
9
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-fail/visibility/pub_const.rs
vendored
@@ -1,9 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
pub struct Flags1: u32 {
|
||||
pub const FLAG_A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
@@ -1,5 +0,0 @@
|
||||
error: no rules expected the token `pub`
|
||||
--> $DIR/pub_const.rs:5:9
|
||||
|
|
||||
5 | pub const FLAG_A = 0b00000001;
|
||||
| ^^^ no rules expected this token in macro call
|
17
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/impls/convert.rs
vendored
17
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/impls/convert.rs
vendored
@@ -1,17 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
impl From<u32> for Flags {
|
||||
fn from(v: u32) -> Flags {
|
||||
Flags::from_bits_truncate(v)
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
|
||||
}
|
10
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/impls/default.rs
vendored
10
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/impls/default.rs
vendored
@@ -1,10 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
#[derive(Default)]
|
||||
struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
15
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/impls/inherent_methods.rs
vendored
15
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/impls/inherent_methods.rs
vendored
@@ -1,15 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
impl Flags {
|
||||
pub fn new() -> Flags {
|
||||
Flags::A
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
14
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/core.rs
vendored
14
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/core.rs
vendored
@@ -1,14 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
// Checks for possible errors caused by overriding names used by `bitflags!` internally.
|
||||
|
||||
mod core {}
|
||||
mod _core {}
|
||||
|
||||
bitflags! {
|
||||
struct Test: u8 {
|
||||
const A = 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
19
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/stringify.rs
vendored
19
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/redefinition/stringify.rs
vendored
@@ -1,19 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
// Checks for possible errors caused by overriding names used by `bitflags!` internally.
|
||||
|
||||
#[allow(unused_macros)]
|
||||
macro_rules! stringify {
|
||||
($($t:tt)*) => { "..." };
|
||||
}
|
||||
|
||||
bitflags! {
|
||||
struct Test: u8 {
|
||||
const A = 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
// Just make sure we don't call the redefined `stringify` macro
|
||||
assert_eq!(format!("{:?}", Test::A), "A");
|
||||
}
|
@@ -1,10 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
#[repr(C)]
|
||||
struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
10
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/repr/transparent.rs
vendored
10
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/repr/transparent.rs
vendored
@@ -1,10 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
#[repr(transparent)]
|
||||
struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
11
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/visibility/bits_field.rs
vendored
11
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/visibility/bits_field.rs
vendored
@@ -1,11 +0,0 @@
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
pub struct Flags1: u32 {
|
||||
const FLAG_A = 0b00000001;
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
assert_eq!(0b00000001, Flags1::FLAG_A.bits);
|
||||
}
|
19
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/visibility/pub_in.rs
vendored
19
third_party/rust/chromium_crates_io/vendor/bitflags-1.3.2/tests/compile-pass/visibility/pub_in.rs
vendored
@@ -1,19 +0,0 @@
|
||||
mod a {
|
||||
mod b {
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
pub(in crate::a) struct Flags: u32 {
|
||||
const FLAG_A = 0b00000001;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn flags() -> u32 {
|
||||
b::Flags::FLAG_A.bits()
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
assert_eq!(0b00000001, a::flags());
|
||||
}
|
@@ -1,63 +0,0 @@
|
||||
use std::{
|
||||
fs,
|
||||
ffi::OsStr,
|
||||
io,
|
||||
path::Path,
|
||||
};
|
||||
|
||||
use walkdir::WalkDir;
|
||||
|
||||
#[test]
|
||||
fn fail() {
|
||||
prepare_stderr_files("tests/compile-fail").unwrap();
|
||||
|
||||
let t = trybuild::TestCases::new();
|
||||
t.compile_fail("tests/compile-fail/**/*.rs");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pass() {
|
||||
let t = trybuild::TestCases::new();
|
||||
t.pass("tests/compile-pass/**/*.rs");
|
||||
}
|
||||
|
||||
// Compiler messages may change between versions
|
||||
// We don't want to have to track these too closely for `bitflags`, but
|
||||
// having some message to check makes sure user-facing errors are sensical.
|
||||
//
|
||||
// The approach we use is to run the test on all compilers, but only check stderr
|
||||
// output on beta (which is the next stable release). We do this by default ignoring
|
||||
// any `.stderr` files in the `compile-fail` directory, and copying `.stderr.beta` files
|
||||
// when we happen to be running on a beta compiler.
|
||||
fn prepare_stderr_files(path: impl AsRef<Path>) -> io::Result<()> {
|
||||
for entry in WalkDir::new(path) {
|
||||
let entry = entry?;
|
||||
|
||||
if entry.path().extension().and_then(OsStr::to_str) == Some("beta") {
|
||||
let renamed = entry.path().with_extension("");
|
||||
|
||||
// Unconditionally remove a corresponding `.stderr` file for a `.stderr.beta`
|
||||
// file if it exists. On `beta` compilers, we'll recreate it. On other compilers,
|
||||
// we don't want to end up checking it anyways.
|
||||
if renamed.exists() {
|
||||
fs::remove_file(&renamed)?;
|
||||
}
|
||||
|
||||
rename_beta_stderr(entry.path(), renamed)?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[rustversion::beta]
|
||||
fn rename_beta_stderr(from: impl AsRef<Path>, to: impl AsRef<Path>) -> io::Result<()> {
|
||||
fs::copy(from, to)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[rustversion::not(beta)]
|
||||
fn rename_beta_stderr(_: impl AsRef<Path>, _: impl AsRef<Path>) -> io::Result<()> {
|
||||
Ok(())
|
||||
}
|
6
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/.cargo_vcs_info.json
vendored
Normal file
6
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/.cargo_vcs_info.json
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"git": {
|
||||
"sha1": "a5f9ce20e9d18444aa9b20c8fea9c00155cbafa3"
|
||||
},
|
||||
"path_in_vcs": ""
|
||||
}
|
457
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/CHANGELOG.md
vendored
Normal file
457
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/CHANGELOG.md
vendored
Normal file
@@ -0,0 +1,457 @@
|
||||
# 2.4.2
|
||||
|
||||
## What's Changed
|
||||
* Cargo.toml: Anchor excludes to root of the package by @jamessan in https://github.com/bitflags/bitflags/pull/387
|
||||
* Update error messages by @KodrAus in https://github.com/bitflags/bitflags/pull/390
|
||||
* Add support for impl mode structs to be repr(packed) by @GnomedDev in https://github.com/bitflags/bitflags/pull/388
|
||||
* Remove old `unused_tuple_struct_fields` lint by @dtolnay in https://github.com/bitflags/bitflags/pull/393
|
||||
* Delete use of `local_inner_macros` by @dtolnay in https://github.com/bitflags/bitflags/pull/392
|
||||
|
||||
## New Contributors
|
||||
* @jamessan made their first contribution in https://github.com/bitflags/bitflags/pull/387
|
||||
* @GnomedDev made their first contribution in https://github.com/bitflags/bitflags/pull/388
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.4.1...2.4.2
|
||||
|
||||
# 2.4.1
|
||||
|
||||
## What's Changed
|
||||
* Allow some new pedantic clippy lints by @KodrAus in https://github.com/bitflags/bitflags/pull/380
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.4.0...2.4.1
|
||||
|
||||
# 2.4.0
|
||||
|
||||
## What's Changed
|
||||
* Remove html_root_url by @eldruin in https://github.com/bitflags/bitflags/pull/368
|
||||
* Support unnamed flags by @KodrAus in https://github.com/bitflags/bitflags/pull/371
|
||||
* Update smoke test to verify all Clippy and rustc lints by @MitMaro in https://github.com/bitflags/bitflags/pull/374
|
||||
* Specify the behavior of bitflags by @KodrAus in https://github.com/bitflags/bitflags/pull/369
|
||||
|
||||
## New Contributors
|
||||
* @eldruin made their first contribution in https://github.com/bitflags/bitflags/pull/368
|
||||
* @MitMaro made their first contribution in https://github.com/bitflags/bitflags/pull/374
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.3.3...2.4.0
|
||||
|
||||
# 2.3.3
|
||||
|
||||
## Changes to `-=`
|
||||
|
||||
The `-=` operator was incorrectly changed to truncate bits that didn't correspond to valid flags in `2.3.0`. This has
|
||||
been fixed up so it once again behaves the same as `-` and `difference`.
|
||||
|
||||
## Changes to `!`
|
||||
|
||||
The `!` operator previously called `Self::from_bits_truncate`, which would truncate any bits that only partially
|
||||
overlapped with a valid flag. It will now use `bits & Self::all().bits()`, so any bits that overlap any bits
|
||||
specified by any flag will be respected. This is unlikely to have any practical implications, but enables defining
|
||||
a flag like `const ALL = !0` as a way to signal that any bit pattern is a known set of flags.
|
||||
|
||||
## Changes to formatting
|
||||
|
||||
Zero-valued flags will never be printed. You'll either get `0x0` for empty flags using debug formatting, or the
|
||||
set of flags with zero-valued flags omitted for others.
|
||||
|
||||
Composite flags will no longer be redundantly printed if there are extra bits to print at the end that don't correspond
|
||||
to a valid flag.
|
||||
|
||||
## What's Changed
|
||||
* Fix up incorrect sub assign behavior and other cleanups by @KodrAus in https://github.com/bitflags/bitflags/pull/366
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.3.2...2.3.3
|
||||
|
||||
# 2.3.2
|
||||
|
||||
## What's Changed
|
||||
* [doc] [src/lib.rs] delete redundant path prefix by @OccupyMars2025 in https://github.com/bitflags/bitflags/pull/361
|
||||
|
||||
## New Contributors
|
||||
* @OccupyMars2025 made their first contribution in https://github.com/bitflags/bitflags/pull/361
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.3.1...2.3.2
|
||||
|
||||
# 2.3.1
|
||||
|
||||
## What's Changed
|
||||
* Fix Self in flags value expressions by @KodrAus in https://github.com/bitflags/bitflags/pull/355
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.3.0...2.3.1
|
||||
|
||||
# 2.3.0
|
||||
|
||||
## What's Changed
|
||||
* Support ejecting flags types from the bitflags macro by @KodrAus in https://github.com/bitflags/bitflags/pull/351
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.2.1...2.3.0
|
||||
|
||||
# 2.2.1
|
||||
|
||||
## What's Changed
|
||||
* Refactor attribute filtering to apply per-flag by @KodrAus in https://github.com/bitflags/bitflags/pull/345
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.2.0...2.2.1
|
||||
|
||||
# 2.2.0
|
||||
|
||||
## What's Changed
|
||||
* Create SECURITY.md by @KodrAus in https://github.com/bitflags/bitflags/pull/338
|
||||
* add docs to describe the behavior of multi-bit flags by @nicholasbishop in https://github.com/bitflags/bitflags/pull/340
|
||||
* Add support for bytemuck by @KodrAus in https://github.com/bitflags/bitflags/pull/336
|
||||
* Add a top-level macro for filtering attributes by @KodrAus in https://github.com/bitflags/bitflags/pull/341
|
||||
|
||||
## New Contributors
|
||||
* @nicholasbishop made their first contribution in https://github.com/bitflags/bitflags/pull/340
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.1.0...2.2.0
|
||||
|
||||
# 2.1.0
|
||||
|
||||
## What's Changed
|
||||
* Add docs for the internal Field0 and examples of formatting/parsing by @KodrAus in https://github.com/bitflags/bitflags/pull/328
|
||||
* Add support for arbitrary by @KodrAus in https://github.com/bitflags/bitflags/pull/324
|
||||
* Fix up missing docs for consts within consts by @KodrAus in https://github.com/bitflags/bitflags/pull/330
|
||||
* Ignore clippy lint in generated code by @Jake-Shadle in https://github.com/bitflags/bitflags/pull/331
|
||||
|
||||
## New Contributors
|
||||
* @Jake-Shadle made their first contribution in https://github.com/bitflags/bitflags/pull/331
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.0.2...2.1.0
|
||||
|
||||
# 2.0.2
|
||||
|
||||
## What's Changed
|
||||
* Fix up missing isize and usize Bits impls by @KodrAus in https://github.com/bitflags/bitflags/pull/321
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.0.1...2.0.2
|
||||
|
||||
# 2.0.1
|
||||
|
||||
## What's Changed
|
||||
* Fix up some docs issues by @KodrAus in https://github.com/bitflags/bitflags/pull/309
|
||||
* Make empty_flag() const. by @tormeh in https://github.com/bitflags/bitflags/pull/313
|
||||
* Fix formatting of multi-bit flags with partial overlap by @KodrAus in https://github.com/bitflags/bitflags/pull/316
|
||||
|
||||
## New Contributors
|
||||
* @tormeh made their first contribution in https://github.com/bitflags/bitflags/pull/313
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.0.0...2.0.1
|
||||
|
||||
# 2.0.0
|
||||
|
||||
## What's Changed
|
||||
* Fix a typo and call out MSRV bump by @KodrAus in https://github.com/bitflags/bitflags/pull/259
|
||||
* BitFlags trait by @arturoc in https://github.com/bitflags/bitflags/pull/220
|
||||
* Add a hidden trait to discourage manual impls of BitFlags by @KodrAus in https://github.com/bitflags/bitflags/pull/261
|
||||
* Sanitize `Ok` by @konsumlamm in https://github.com/bitflags/bitflags/pull/266
|
||||
* Fix bug in `Debug` implementation by @konsumlamm in https://github.com/bitflags/bitflags/pull/268
|
||||
* Fix a typo in the generated documentation by @wackbyte in https://github.com/bitflags/bitflags/pull/271
|
||||
* Use SPDX license format by @atouchet in https://github.com/bitflags/bitflags/pull/272
|
||||
* serde tests fail in CI by @arturoc in https://github.com/bitflags/bitflags/pull/277
|
||||
* Fix beta test output by @KodrAus in https://github.com/bitflags/bitflags/pull/279
|
||||
* Add example to the README.md file by @tiaanl in https://github.com/bitflags/bitflags/pull/270
|
||||
* Iterator over all the enabled options by @arturoc in https://github.com/bitflags/bitflags/pull/278
|
||||
* from_bits_(truncate) fail with composite flags by @arturoc in https://github.com/bitflags/bitflags/pull/276
|
||||
* Add more platform coverage to CI by @KodrAus in https://github.com/bitflags/bitflags/pull/280
|
||||
* rework the way cfgs are handled by @KodrAus in https://github.com/bitflags/bitflags/pull/281
|
||||
* Split generated code into two types by @KodrAus in https://github.com/bitflags/bitflags/pull/282
|
||||
* expose bitflags iters using nameable types by @KodrAus in https://github.com/bitflags/bitflags/pull/286
|
||||
* Support creating flags from their names by @KodrAus in https://github.com/bitflags/bitflags/pull/287
|
||||
* Update README.md by @KodrAus in https://github.com/bitflags/bitflags/pull/288
|
||||
* Prepare for 2.0.0-rc.1 release by @KodrAus in https://github.com/bitflags/bitflags/pull/289
|
||||
* Add missing "if" to contains doc-comment in traits.rs by @rusty-snake in https://github.com/bitflags/bitflags/pull/291
|
||||
* Forbid unsafe_code by @fintelia in https://github.com/bitflags/bitflags/pull/294
|
||||
* serde: enable no-std support by @nim65s in https://github.com/bitflags/bitflags/pull/296
|
||||
* Add a parser for flags formatted as bar-separated-values by @KodrAus in https://github.com/bitflags/bitflags/pull/297
|
||||
* Prepare for 2.0.0-rc.2 release by @KodrAus in https://github.com/bitflags/bitflags/pull/299
|
||||
* Use strip_prefix instead of starts_with + slice by @QuinnPainter in https://github.com/bitflags/bitflags/pull/301
|
||||
* Fix up some clippy lints by @KodrAus in https://github.com/bitflags/bitflags/pull/302
|
||||
* Prepare for 2.0.0-rc.3 release by @KodrAus in https://github.com/bitflags/bitflags/pull/303
|
||||
* feat: Add minimum permissions to rust.yml workflow by @gabibguti in https://github.com/bitflags/bitflags/pull/305
|
||||
|
||||
## New Contributors
|
||||
* @wackbyte made their first contribution in https://github.com/bitflags/bitflags/pull/271
|
||||
* @atouchet made their first contribution in https://github.com/bitflags/bitflags/pull/272
|
||||
* @tiaanl made their first contribution in https://github.com/bitflags/bitflags/pull/270
|
||||
* @rusty-snake made their first contribution in https://github.com/bitflags/bitflags/pull/291
|
||||
* @fintelia made their first contribution in https://github.com/bitflags/bitflags/pull/294
|
||||
* @nim65s made their first contribution in https://github.com/bitflags/bitflags/pull/296
|
||||
* @QuinnPainter made their first contribution in https://github.com/bitflags/bitflags/pull/301
|
||||
* @gabibguti made their first contribution in https://github.com/bitflags/bitflags/pull/305
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/1.3.2...2.0.0
|
||||
|
||||
# 2.0.0-rc.3
|
||||
|
||||
## What's Changed
|
||||
* Use strip_prefix instead of starts_with + slice by @QuinnPainter in https://github.com/bitflags/bitflags/pull/301
|
||||
* Fix up some clippy lints by @KodrAus in https://github.com/bitflags/bitflags/pull/302
|
||||
|
||||
## New Contributors
|
||||
* @QuinnPainter made their first contribution in https://github.com/bitflags/bitflags/pull/301
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.0.0-rc.2...2.0.0-rc.3
|
||||
|
||||
# 2.0.0-rc.2
|
||||
|
||||
## Changes to `serde` serialization
|
||||
|
||||
**⚠️ NOTE ⚠️** This release changes the default serialization you'll get if you `#[derive(Serialize, Deserialize)]`
|
||||
on your generated flags types. It will now use a formatted string for human-readable formats and the underlying bits
|
||||
type for compact formats.
|
||||
|
||||
To keep the old behavior, see the [`bitflags-serde-legacy`](https://github.com/KodrAus/bitflags-serde-legacy) library.
|
||||
|
||||
## What's Changed
|
||||
|
||||
* Add missing "if" to contains doc-comment in traits.rs by @rusty-snake in https://github.com/bitflags/bitflags/pull/291
|
||||
* Forbid unsafe_code by @fintelia in https://github.com/bitflags/bitflags/pull/294
|
||||
* serde: enable no-std support by @nim65s in https://github.com/bitflags/bitflags/pull/296
|
||||
* Add a parser for flags formatted as bar-separated-values by @KodrAus in https://github.com/bitflags/bitflags/pull/297
|
||||
|
||||
## New Contributors
|
||||
* @rusty-snake made their first contribution in https://github.com/bitflags/bitflags/pull/291
|
||||
* @fintelia made their first contribution in https://github.com/bitflags/bitflags/pull/294
|
||||
* @nim65s made their first contribution in https://github.com/bitflags/bitflags/pull/296
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/2.0.0-rc.1...2.0.0-rc.2
|
||||
|
||||
# 2.0.0-rc.1
|
||||
|
||||
This is a big release including a few years worth of work on a new `BitFlags` trait, iteration, and better macro organization for future extensibility.
|
||||
|
||||
## What's Changed
|
||||
* Fix a typo and call out MSRV bump by @KodrAus in https://github.com/bitflags/bitflags/pull/259
|
||||
* BitFlags trait by @arturoc in https://github.com/bitflags/bitflags/pull/220
|
||||
* Add a hidden trait to discourage manual impls of BitFlags by @KodrAus in https://github.com/bitflags/bitflags/pull/261
|
||||
* Sanitize `Ok` by @konsumlamm in https://github.com/bitflags/bitflags/pull/266
|
||||
* Fix bug in `Debug` implementation by @konsumlamm in https://github.com/bitflags/bitflags/pull/268
|
||||
* Fix a typo in the generated documentation by @wackbyte in https://github.com/bitflags/bitflags/pull/271
|
||||
* Use SPDX license format by @atouchet in https://github.com/bitflags/bitflags/pull/272
|
||||
* serde tests fail in CI by @arturoc in https://github.com/bitflags/bitflags/pull/277
|
||||
* Fix beta test output by @KodrAus in https://github.com/bitflags/bitflags/pull/279
|
||||
* Add example to the README.md file by @tiaanl in https://github.com/bitflags/bitflags/pull/270
|
||||
* Iterator over all the enabled options by @arturoc in https://github.com/bitflags/bitflags/pull/278
|
||||
* from_bits_(truncate) fail with composite flags by @arturoc in https://github.com/bitflags/bitflags/pull/276
|
||||
* Add more platform coverage to CI by @KodrAus in https://github.com/bitflags/bitflags/pull/280
|
||||
* rework the way cfgs are handled by @KodrAus in https://github.com/bitflags/bitflags/pull/281
|
||||
* Split generated code into two types by @KodrAus in https://github.com/bitflags/bitflags/pull/282
|
||||
* expose bitflags iters using nameable types by @KodrAus in https://github.com/bitflags/bitflags/pull/286
|
||||
* Support creating flags from their names by @KodrAus in https://github.com/bitflags/bitflags/pull/287
|
||||
* Update README.md by @KodrAus in https://github.com/bitflags/bitflags/pull/288
|
||||
|
||||
## New Contributors
|
||||
* @wackbyte made their first contribution in https://github.com/bitflags/bitflags/pull/271
|
||||
* @atouchet made their first contribution in https://github.com/bitflags/bitflags/pull/272
|
||||
* @tiaanl made their first contribution in https://github.com/bitflags/bitflags/pull/270
|
||||
|
||||
**Full Changelog**: https://github.com/bitflags/bitflags/compare/1.3.2...2.0.0-rc.1
|
||||
|
||||
# 1.3.2
|
||||
|
||||
- Allow `non_snake_case` in generated flags types ([#256])
|
||||
|
||||
[#256]: https://github.com/bitflags/bitflags/pull/256
|
||||
|
||||
# 1.3.1
|
||||
|
||||
- Revert unconditional `#[repr(transparent)]` ([#252])
|
||||
|
||||
[#252]: https://github.com/bitflags/bitflags/pull/252
|
||||
|
||||
# 1.3.0 (yanked)
|
||||
|
||||
**This release bumps the Minimum Supported Rust Version to `1.46.0`**
|
||||
|
||||
- Add `#[repr(transparent)]` ([#187])
|
||||
|
||||
- End `empty` doc comment with full stop ([#202])
|
||||
|
||||
- Fix typo in crate root docs ([#206])
|
||||
|
||||
- Document from_bits_unchecked unsafety ([#207])
|
||||
|
||||
- Let `is_all` ignore extra bits ([#211])
|
||||
|
||||
- Allows empty flag definition ([#225])
|
||||
|
||||
- Making crate accessible from std ([#227])
|
||||
|
||||
- Make `from_bits` a const fn ([#229])
|
||||
|
||||
- Allow multiple bitflags structs in one macro invocation ([#235])
|
||||
|
||||
- Add named functions to perform set operations ([#244])
|
||||
|
||||
- Fix typos in method docs ([#245])
|
||||
|
||||
- Modernization of the `bitflags` macro to take advantage of newer features and 2018 idioms ([#246])
|
||||
|
||||
- Fix regression (in an unreleased feature) and simplify tests ([#247])
|
||||
|
||||
- Use `Self` and fix bug when overriding `stringify!` ([#249])
|
||||
|
||||
[#187]: https://github.com/bitflags/bitflags/pull/187
|
||||
[#202]: https://github.com/bitflags/bitflags/pull/202
|
||||
[#206]: https://github.com/bitflags/bitflags/pull/206
|
||||
[#207]: https://github.com/bitflags/bitflags/pull/207
|
||||
[#211]: https://github.com/bitflags/bitflags/pull/211
|
||||
[#225]: https://github.com/bitflags/bitflags/pull/225
|
||||
[#227]: https://github.com/bitflags/bitflags/pull/227
|
||||
[#229]: https://github.com/bitflags/bitflags/pull/229
|
||||
[#235]: https://github.com/bitflags/bitflags/pull/235
|
||||
[#244]: https://github.com/bitflags/bitflags/pull/244
|
||||
[#245]: https://github.com/bitflags/bitflags/pull/245
|
||||
[#246]: https://github.com/bitflags/bitflags/pull/246
|
||||
[#247]: https://github.com/bitflags/bitflags/pull/247
|
||||
[#249]: https://github.com/bitflags/bitflags/pull/249
|
||||
|
||||
# 1.2.1
|
||||
|
||||
- Remove extraneous `#[inline]` attributes ([#194])
|
||||
|
||||
[#194]: https://github.com/bitflags/bitflags/pull/194
|
||||
|
||||
# 1.2.0
|
||||
|
||||
- Fix typo: {Lower, Upper}Exp - {Lower, Upper}Hex ([#183])
|
||||
|
||||
- Add support for "unknown" bits ([#188])
|
||||
|
||||
[#183]: https://github.com/rust-lang-nursery/bitflags/pull/183
|
||||
[#188]: https://github.com/rust-lang-nursery/bitflags/pull/188
|
||||
|
||||
# 1.1.0
|
||||
|
||||
This is a re-release of `1.0.5`, which was yanked due to a bug in the RLS.
|
||||
|
||||
# 1.0.5
|
||||
|
||||
- Use compiletest_rs flags supported by stable toolchain ([#171])
|
||||
|
||||
- Put the user provided attributes first ([#173])
|
||||
|
||||
- Make bitflags methods `const` on newer compilers ([#175])
|
||||
|
||||
[#171]: https://github.com/rust-lang-nursery/bitflags/pull/171
|
||||
[#173]: https://github.com/rust-lang-nursery/bitflags/pull/173
|
||||
[#175]: https://github.com/rust-lang-nursery/bitflags/pull/175
|
||||
|
||||
# 1.0.4
|
||||
|
||||
- Support Rust 2018 style macro imports ([#165])
|
||||
|
||||
```rust
|
||||
use bitflags::bitflags;
|
||||
```
|
||||
|
||||
[#165]: https://github.com/rust-lang-nursery/bitflags/pull/165
|
||||
|
||||
# 1.0.3
|
||||
|
||||
- Improve zero value flag handling and documentation ([#157])
|
||||
|
||||
[#157]: https://github.com/rust-lang-nursery/bitflags/pull/157
|
||||
|
||||
# 1.0.2
|
||||
|
||||
- 30% improvement in compile time of bitflags crate ([#156])
|
||||
|
||||
- Documentation improvements ([#153])
|
||||
|
||||
- Implementation cleanup ([#149])
|
||||
|
||||
[#156]: https://github.com/rust-lang-nursery/bitflags/pull/156
|
||||
[#153]: https://github.com/rust-lang-nursery/bitflags/pull/153
|
||||
[#149]: https://github.com/rust-lang-nursery/bitflags/pull/149
|
||||
|
||||
# 1.0.1
|
||||
- Add support for `pub(restricted)` specifier on the bitflags struct ([#135])
|
||||
- Optimize performance of `all()` when called from a separate crate ([#136])
|
||||
|
||||
[#135]: https://github.com/rust-lang-nursery/bitflags/pull/135
|
||||
[#136]: https://github.com/rust-lang-nursery/bitflags/pull/136
|
||||
|
||||
# 1.0.0
|
||||
- **[breaking change]** Macro now generates [associated constants](https://doc.rust-lang.org/reference/items.html#associated-constants) ([#24])
|
||||
|
||||
- **[breaking change]** Minimum supported version is Rust **1.20**, due to usage of associated constants
|
||||
|
||||
- After being broken in 0.9, the `#[deprecated]` attribute is now supported again ([#112])
|
||||
|
||||
- Other improvements to unit tests and documentation ([#106] and [#115])
|
||||
|
||||
[#24]: https://github.com/rust-lang-nursery/bitflags/pull/24
|
||||
[#106]: https://github.com/rust-lang-nursery/bitflags/pull/106
|
||||
[#112]: https://github.com/rust-lang-nursery/bitflags/pull/112
|
||||
[#115]: https://github.com/rust-lang-nursery/bitflags/pull/115
|
||||
|
||||
## How to update your code to use associated constants
|
||||
Assuming the following structure definition:
|
||||
```rust
|
||||
bitflags! {
|
||||
struct Something: u8 {
|
||||
const FOO = 0b01,
|
||||
const BAR = 0b10
|
||||
}
|
||||
}
|
||||
```
|
||||
In 0.9 and older you could do:
|
||||
```rust
|
||||
let x = FOO.bits | BAR.bits;
|
||||
```
|
||||
Now you must use:
|
||||
```rust
|
||||
let x = Something::FOO.bits | Something::BAR.bits;
|
||||
```
|
||||
|
||||
# 0.9.1
|
||||
- Fix the implementation of `Formatting` traits when other formatting traits were present in scope ([#105])
|
||||
|
||||
[#105]: https://github.com/rust-lang-nursery/bitflags/pull/105
|
||||
|
||||
# 0.9.0
|
||||
- **[breaking change]** Use struct keyword instead of flags to define bitflag types ([#84])
|
||||
|
||||
- **[breaking change]** Terminate const items with semicolons instead of commas ([#87])
|
||||
|
||||
- Implement the `Hex`, `Octal`, and `Binary` formatting traits ([#86])
|
||||
|
||||
- Printing an empty flag value with the `Debug` trait now prints "(empty)" instead of nothing ([#85])
|
||||
|
||||
- The `bitflags!` macro can now be used inside of a fn body, to define a type local to that function ([#74])
|
||||
|
||||
[#74]: https://github.com/rust-lang-nursery/bitflags/pull/74
|
||||
[#84]: https://github.com/rust-lang-nursery/bitflags/pull/84
|
||||
[#85]: https://github.com/rust-lang-nursery/bitflags/pull/85
|
||||
[#86]: https://github.com/rust-lang-nursery/bitflags/pull/86
|
||||
[#87]: https://github.com/rust-lang-nursery/bitflags/pull/87
|
||||
|
||||
# 0.8.2
|
||||
- Update feature flag used when building bitflags as a dependency of the Rust toolchain
|
||||
|
||||
# 0.8.1
|
||||
- Allow bitflags to be used as a dependency of the Rust toolchain
|
||||
|
||||
# 0.8.0
|
||||
- Add support for the experimental `i128` and `u128` integer types ([#57])
|
||||
- Add set method: `flags.set(SOME_FLAG, true)` or `flags.set(SOME_FLAG, false)` ([#55])
|
||||
This may break code that defines its own set method
|
||||
|
||||
[#55]: https://github.com/rust-lang-nursery/bitflags/pull/55
|
||||
[#57]: https://github.com/rust-lang-nursery/bitflags/pull/57
|
||||
|
||||
# 0.7.1
|
||||
*(yanked)*
|
||||
|
||||
# 0.7.0
|
||||
- Implement the Extend trait ([#49])
|
||||
- Allow definitions inside the `bitflags!` macro to refer to items imported from other modules ([#51])
|
||||
|
||||
[#49]: https://github.com/rust-lang-nursery/bitflags/pull/49
|
||||
[#51]: https://github.com/rust-lang-nursery/bitflags/pull/51
|
||||
|
||||
# 0.6.0
|
||||
- The `no_std` feature was removed as it is now the default
|
||||
- The `assignment_operators` feature was remove as it is now enabled by default
|
||||
- Some clippy suggestions have been applied
|
9
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/CONTRIBUTING.md
vendored
Normal file
9
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/CONTRIBUTING.md
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
# Updating compile-fail test outputs
|
||||
|
||||
`bitflags` uses the `trybuild` crate to integration test its macros. Since Rust error messages change frequently enough that `nightly` builds produce spurious failures, we only check the compiler output in `beta` builds. If you run:
|
||||
|
||||
```
|
||||
TRYBUILD=overwrite cargo +beta test --all
|
||||
```
|
||||
|
||||
it will run the tests and update the `trybuild` output files.
|
95
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/Cargo.toml
vendored
Normal file
95
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/Cargo.toml
vendored
Normal file
@@ -0,0 +1,95 @@
|
||||
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||
#
|
||||
# When uploading crates to the registry Cargo will automatically
|
||||
# "normalize" Cargo.toml files for maximal compatibility
|
||||
# with all versions of Cargo and also rewrite `path` dependencies
|
||||
# to registry (e.g., crates.io) dependencies.
|
||||
#
|
||||
# If you are reading this file be aware that the original Cargo.toml
|
||||
# will likely look very different (and much more reasonable).
|
||||
# See Cargo.toml.orig for the original contents.
|
||||
|
||||
[package]
|
||||
edition = "2021"
|
||||
rust-version = "1.56.0"
|
||||
name = "bitflags"
|
||||
version = "2.4.2"
|
||||
authors = ["The Rust Project Developers"]
|
||||
exclude = [
|
||||
"/tests",
|
||||
"/.github",
|
||||
]
|
||||
description = """
|
||||
A macro to generate structures which behave like bitflags.
|
||||
"""
|
||||
homepage = "https://github.com/bitflags/bitflags"
|
||||
documentation = "https://docs.rs/bitflags"
|
||||
readme = "README.md"
|
||||
keywords = [
|
||||
"bit",
|
||||
"bitmask",
|
||||
"bitflags",
|
||||
"flags",
|
||||
]
|
||||
categories = ["no-std"]
|
||||
license = "MIT OR Apache-2.0"
|
||||
repository = "https://github.com/bitflags/bitflags"
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
features = ["example_generated"]
|
||||
|
||||
[dependencies.arbitrary]
|
||||
version = "1.0"
|
||||
optional = true
|
||||
|
||||
[dependencies.bytemuck]
|
||||
version = "1.0"
|
||||
optional = true
|
||||
|
||||
[dependencies.compiler_builtins]
|
||||
version = "0.1.2"
|
||||
optional = true
|
||||
|
||||
[dependencies.core]
|
||||
version = "1.0.0"
|
||||
optional = true
|
||||
package = "rustc-std-workspace-core"
|
||||
|
||||
[dependencies.serde]
|
||||
version = "1.0"
|
||||
optional = true
|
||||
default-features = false
|
||||
|
||||
[dev-dependencies.arbitrary]
|
||||
version = "1.0"
|
||||
features = ["derive"]
|
||||
|
||||
[dev-dependencies.bytemuck]
|
||||
version = "1.0"
|
||||
features = ["derive"]
|
||||
|
||||
[dev-dependencies.rustversion]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.serde_derive]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.serde_json]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.serde_test]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.trybuild]
|
||||
version = "1.0"
|
||||
|
||||
[dev-dependencies.zerocopy]
|
||||
version = "0.6"
|
||||
|
||||
[features]
|
||||
example_generated = []
|
||||
rustc-dep-of-std = [
|
||||
"core",
|
||||
"compiler_builtins",
|
||||
]
|
||||
std = []
|
43
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/Cargo.toml.orig
generated
vendored
Normal file
43
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/Cargo.toml.orig
generated
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
[package]
|
||||
name = "bitflags"
|
||||
# NB: When modifying, also modify the number in readme (for breaking changes)
|
||||
version = "2.4.2"
|
||||
edition = "2021"
|
||||
rust-version = "1.56.0"
|
||||
authors = ["The Rust Project Developers"]
|
||||
license = "MIT OR Apache-2.0"
|
||||
keywords = ["bit", "bitmask", "bitflags", "flags"]
|
||||
readme = "README.md"
|
||||
repository = "https://github.com/bitflags/bitflags"
|
||||
homepage = "https://github.com/bitflags/bitflags"
|
||||
documentation = "https://docs.rs/bitflags"
|
||||
categories = ["no-std"]
|
||||
description = """
|
||||
A macro to generate structures which behave like bitflags.
|
||||
"""
|
||||
exclude = ["/tests", "/.github"]
|
||||
|
||||
[dependencies]
|
||||
serde = { version = "1.0", optional = true, default-features = false }
|
||||
arbitrary = { version = "1.0", optional = true }
|
||||
bytemuck = { version = "1.0", optional = true }
|
||||
core = { version = "1.0.0", optional = true, package = "rustc-std-workspace-core" }
|
||||
compiler_builtins = { version = "0.1.2", optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
trybuild = "1.0"
|
||||
rustversion = "1.0"
|
||||
serde_derive = "1.0"
|
||||
serde_json = "1.0"
|
||||
serde_test = "1.0"
|
||||
zerocopy = "0.6"
|
||||
arbitrary = { version = "1.0", features = ["derive"] }
|
||||
bytemuck = { version = "1.0", features = ["derive"] }
|
||||
|
||||
[features]
|
||||
std = []
|
||||
example_generated = []
|
||||
rustc-dep-of-std = ["core", "compiler_builtins"]
|
||||
|
||||
[package.metadata.docs.rs]
|
||||
features = ["example_generated"]
|
77
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/README.md
vendored
Normal file
77
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/README.md
vendored
Normal file
@@ -0,0 +1,77 @@
|
||||
bitflags
|
||||
========
|
||||
|
||||
[](https://github.com/bitflags/bitflags/actions)
|
||||
[](https://crates.io/crates/bitflags)
|
||||
[](https://docs.rs/bitflags)
|
||||

|
||||
|
||||
`bitflags` generates flags enums with well-defined semantics and ergonomic end-user APIs.
|
||||
|
||||
You can use `bitflags` to:
|
||||
|
||||
- provide more user-friendly bindings to C APIs where flags may or may not be fully known in advance.
|
||||
- generate efficient options types with string parsing and formatting support.
|
||||
|
||||
You can't use `bitflags` to:
|
||||
|
||||
- guarantee only bits corresponding to defined flags will ever be set. `bitflags` allows access to the underlying bits type so arbitrary bits may be set.
|
||||
- define bitfields. `bitflags` only generates types where set bits denote the presence of some combination of flags.
|
||||
|
||||
- [Documentation](https://docs.rs/bitflags)
|
||||
- [Specification](https://github.com/bitflags/bitflags/blob/main/spec.md)
|
||||
- [Release notes](https://github.com/bitflags/bitflags/releases)
|
||||
|
||||
## Usage
|
||||
|
||||
Add this to your `Cargo.toml`:
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
bitflags = "2.4.2"
|
||||
```
|
||||
|
||||
and this to your source code:
|
||||
|
||||
```rust
|
||||
use bitflags::bitflags;
|
||||
```
|
||||
|
||||
## Example
|
||||
|
||||
Generate a flags structure:
|
||||
|
||||
```rust
|
||||
use bitflags::bitflags;
|
||||
|
||||
// The `bitflags!` macro generates `struct`s that manage a set of flags.
|
||||
bitflags! {
|
||||
/// Represents a set of flags.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
struct Flags: u32 {
|
||||
/// The value `A`, at bit position `0`.
|
||||
const A = 0b00000001;
|
||||
/// The value `B`, at bit position `1`.
|
||||
const B = 0b00000010;
|
||||
/// The value `C`, at bit position `2`.
|
||||
const C = 0b00000100;
|
||||
|
||||
/// The combination of `A`, `B`, and `C`.
|
||||
const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
let e1 = Flags::A | Flags::C;
|
||||
let e2 = Flags::B | Flags::C;
|
||||
assert_eq!((e1 | e2), Flags::ABC); // union
|
||||
assert_eq!((e1 & e2), Flags::C); // intersection
|
||||
assert_eq!((e1 - e2), Flags::A); // set difference
|
||||
assert_eq!(!e2, Flags::A); // set complement
|
||||
}
|
||||
```
|
||||
|
||||
## Rust Version Support
|
||||
|
||||
The minimum supported Rust version is documented in the `Cargo.toml` file.
|
||||
This may be bumped in minor releases as necessary.
|
13
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/SECURITY.md
vendored
Normal file
13
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/SECURITY.md
vendored
Normal file
@@ -0,0 +1,13 @@
|
||||
# Security Policy
|
||||
|
||||
## Supported Versions
|
||||
|
||||
Security updates are applied only to the latest release.
|
||||
|
||||
## Reporting a Vulnerability
|
||||
|
||||
If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.
|
||||
|
||||
Please disclose it at [security advisory](https://github.com/bitflags/bitflags/security/advisories/new).
|
||||
|
||||
This project is maintained by a team of volunteers on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure.
|
96
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/benches/parse.rs
vendored
Normal file
96
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/benches/parse.rs
vendored
Normal file
@@ -0,0 +1,96 @@
|
||||
#![feature(test)]
|
||||
|
||||
extern crate test;
|
||||
|
||||
use std::{
|
||||
fmt::{self, Display},
|
||||
str::FromStr,
|
||||
};
|
||||
|
||||
bitflags::bitflags! {
|
||||
struct Flags10: u32 {
|
||||
const A = 0b0000_0000_0000_0001;
|
||||
const B = 0b0000_0000_0000_0010;
|
||||
const C = 0b0000_0000_0000_0100;
|
||||
const D = 0b0000_0000_0000_1000;
|
||||
const E = 0b0000_0000_0001_0000;
|
||||
const F = 0b0000_0000_0010_0000;
|
||||
const G = 0b0000_0000_0100_0000;
|
||||
const H = 0b0000_0000_1000_0000;
|
||||
const I = 0b0000_0001_0000_0000;
|
||||
const J = 0b0000_0010_0000_0000;
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for Flags10 {
|
||||
type Err = bitflags::parser::ParseError;
|
||||
|
||||
fn from_str(flags: &str) -> Result<Self, Self::Err> {
|
||||
Ok(Flags10(flags.parse()?))
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for Flags10 {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
Display::fmt(&self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn format_flags_1_present(b: &mut test::Bencher) {
|
||||
b.iter(|| Flags10::J.to_string())
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn format_flags_5_present(b: &mut test::Bencher) {
|
||||
b.iter(|| (Flags10::F | Flags10::G | Flags10::H | Flags10::I | Flags10::J).to_string())
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn format_flags_10_present(b: &mut test::Bencher) {
|
||||
b.iter(|| {
|
||||
(Flags10::A
|
||||
| Flags10::B
|
||||
| Flags10::C
|
||||
| Flags10::D
|
||||
| Flags10::E
|
||||
| Flags10::F
|
||||
| Flags10::G
|
||||
| Flags10::H
|
||||
| Flags10::I
|
||||
| Flags10::J)
|
||||
.to_string()
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn parse_flags_1_10(b: &mut test::Bencher) {
|
||||
b.iter(|| {
|
||||
let flags: Flags10 = "J".parse().unwrap();
|
||||
flags
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn parse_flags_5_10(b: &mut test::Bencher) {
|
||||
b.iter(|| {
|
||||
let flags: Flags10 = "F | G | H | I | J".parse().unwrap();
|
||||
flags
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn parse_flags_10_10(b: &mut test::Bencher) {
|
||||
b.iter(|| {
|
||||
let flags: Flags10 = "A | B | C | D | E | F | G | H | I | J".parse().unwrap();
|
||||
flags
|
||||
})
|
||||
}
|
||||
|
||||
#[bench]
|
||||
fn parse_flags_1_10_hex(b: &mut test::Bencher) {
|
||||
b.iter(|| {
|
||||
let flags: Flags10 = "0xFF".parse().unwrap();
|
||||
flags
|
||||
})
|
||||
}
|
97
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/custom_bits_type.rs
vendored
Normal file
97
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/custom_bits_type.rs
vendored
Normal file
@@ -0,0 +1,97 @@
|
||||
use std::ops::{BitAnd, BitOr, BitXor, Not};
|
||||
|
||||
use bitflags::{Bits, Flag, Flags};
|
||||
|
||||
// Define a custom container that can be used in flags types
|
||||
// Note custom bits types can't be used in `bitflags!`
|
||||
// without making the trait impls `const`. This is currently
|
||||
// unstable
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct CustomBits([bool; 3]);
|
||||
|
||||
impl Bits for CustomBits {
|
||||
const EMPTY: Self = CustomBits([false; 3]);
|
||||
|
||||
const ALL: Self = CustomBits([true; 3]);
|
||||
}
|
||||
|
||||
impl PartialEq for CustomBits {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
self.0 == other.0
|
||||
}
|
||||
}
|
||||
|
||||
impl BitAnd for CustomBits {
|
||||
type Output = Self;
|
||||
|
||||
fn bitand(self, other: Self) -> Self {
|
||||
CustomBits([
|
||||
self.0[0] & other.0[0],
|
||||
self.0[1] & other.0[1],
|
||||
self.0[2] & other.0[2],
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
impl BitOr for CustomBits {
|
||||
type Output = Self;
|
||||
|
||||
fn bitor(self, other: Self) -> Self {
|
||||
CustomBits([
|
||||
self.0[0] | other.0[0],
|
||||
self.0[1] | other.0[1],
|
||||
self.0[2] | other.0[2],
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
impl BitXor for CustomBits {
|
||||
type Output = Self;
|
||||
|
||||
fn bitxor(self, other: Self) -> Self {
|
||||
CustomBits([
|
||||
self.0[0] & other.0[0],
|
||||
self.0[1] & other.0[1],
|
||||
self.0[2] & other.0[2],
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
impl Not for CustomBits {
|
||||
type Output = Self;
|
||||
|
||||
fn not(self) -> Self {
|
||||
CustomBits([!self.0[0], !self.0[1], !self.0[2]])
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub struct CustomFlags(CustomBits);
|
||||
|
||||
impl CustomFlags {
|
||||
pub const A: Self = CustomFlags(CustomBits([true, false, false]));
|
||||
pub const B: Self = CustomFlags(CustomBits([false, true, false]));
|
||||
pub const C: Self = CustomFlags(CustomBits([false, false, true]));
|
||||
}
|
||||
|
||||
impl Flags for CustomFlags {
|
||||
const FLAGS: &'static [Flag<Self>] = &[
|
||||
Flag::new("A", Self::A),
|
||||
Flag::new("B", Self::B),
|
||||
Flag::new("C", Self::C),
|
||||
];
|
||||
|
||||
type Bits = CustomBits;
|
||||
|
||||
fn bits(&self) -> Self::Bits {
|
||||
self.0
|
||||
}
|
||||
|
||||
fn from_bits_retain(bits: Self::Bits) -> Self {
|
||||
CustomFlags(bits)
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
println!("{:?}", CustomFlags::A.union(CustomFlags::C));
|
||||
}
|
23
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/custom_derive.rs
vendored
Normal file
23
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/custom_derive.rs
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
//! An example of implementing the `BitFlags` trait manually for a flags type.
|
||||
|
||||
use std::str;
|
||||
|
||||
use bitflags::bitflags;
|
||||
|
||||
// Define a flags type outside of the `bitflags` macro as a newtype
|
||||
// It can accept custom derives for libaries `bitflags` doesn't support natively
|
||||
#[derive(zerocopy::AsBytes, zerocopy::FromBytes)]
|
||||
#[repr(transparent)]
|
||||
pub struct ManualFlags(u32);
|
||||
|
||||
// Next: use `impl Flags` instead of `struct Flags`
|
||||
bitflags! {
|
||||
impl ManualFlags: u32 {
|
||||
const A = 0b00000001;
|
||||
const B = 0b00000010;
|
||||
const C = 0b00000100;
|
||||
const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {}
|
49
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/fmt.rs
vendored
Normal file
49
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/fmt.rs
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
//! An example of implementing Rust's standard formatting and parsing traits for flags types.
|
||||
|
||||
use core::{fmt, str};
|
||||
|
||||
bitflags::bitflags! {
|
||||
// You can `#[derive]` the `Debug` trait, but implementing it manually
|
||||
// can produce output like `A | B` instead of `Flags(A | B)`.
|
||||
// #[derive(Debug)]
|
||||
#[derive(PartialEq, Eq)]
|
||||
pub struct Flags: u32 {
|
||||
const A = 1;
|
||||
const B = 2;
|
||||
const C = 4;
|
||||
const D = 8;
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Flags {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
bitflags::parser::to_writer(self, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for Flags {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
bitflags::parser::to_writer(self, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl str::FromStr for Flags {
|
||||
type Err = bitflags::parser::ParseError;
|
||||
|
||||
fn from_str(flags: &str) -> Result<Self, Self::Err> {
|
||||
bitflags::parser::from_str(flags)
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> Result<(), bitflags::parser::ParseError> {
|
||||
let flags = Flags::A | Flags::B;
|
||||
|
||||
println!("{}", flags);
|
||||
|
||||
let formatted = flags.to_string();
|
||||
let parsed: Flags = formatted.parse()?;
|
||||
|
||||
assert_eq!(flags, parsed);
|
||||
|
||||
Ok(())
|
||||
}
|
61
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/macro_free.rs
vendored
Normal file
61
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/macro_free.rs
vendored
Normal file
@@ -0,0 +1,61 @@
|
||||
//! An example of implementing the `BitFlags` trait manually for a flags type.
|
||||
//!
|
||||
//! This example doesn't use any macros.
|
||||
|
||||
use std::{fmt, str};
|
||||
|
||||
use bitflags::{Flag, Flags};
|
||||
|
||||
// First: Define your flags type. It just needs to be `Sized + 'static`.
|
||||
pub struct ManualFlags(u32);
|
||||
|
||||
// Not required: Define some constants for valid flags
|
||||
impl ManualFlags {
|
||||
pub const A: ManualFlags = ManualFlags(0b00000001);
|
||||
pub const B: ManualFlags = ManualFlags(0b00000010);
|
||||
pub const C: ManualFlags = ManualFlags(0b00000100);
|
||||
pub const ABC: ManualFlags = ManualFlags(0b00000111);
|
||||
}
|
||||
|
||||
// Next: Implement the `BitFlags` trait, specifying your set of valid flags
|
||||
// and iterators
|
||||
impl Flags for ManualFlags {
|
||||
const FLAGS: &'static [Flag<Self>] = &[
|
||||
Flag::new("A", Self::A),
|
||||
Flag::new("B", Self::B),
|
||||
Flag::new("C", Self::C),
|
||||
];
|
||||
|
||||
type Bits = u32;
|
||||
|
||||
fn bits(&self) -> u32 {
|
||||
self.0
|
||||
}
|
||||
|
||||
fn from_bits_retain(bits: u32) -> Self {
|
||||
Self(bits)
|
||||
}
|
||||
}
|
||||
|
||||
// Not required: Add parsing support
|
||||
impl str::FromStr for ManualFlags {
|
||||
type Err = bitflags::parser::ParseError;
|
||||
|
||||
fn from_str(input: &str) -> Result<Self, Self::Err> {
|
||||
bitflags::parser::from_str(input)
|
||||
}
|
||||
}
|
||||
|
||||
// Not required: Add formatting support
|
||||
impl fmt::Display for ManualFlags {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
bitflags::parser::to_writer(self, f)
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
println!(
|
||||
"{}",
|
||||
ManualFlags::A.union(ManualFlags::B).union(ManualFlags::C)
|
||||
);
|
||||
}
|
36
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/serde.rs
vendored
Normal file
36
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/examples/serde.rs
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
//! An example of implementing `serde::Serialize` and `serde::Deserialize`.
|
||||
//! The `#[serde(transparent)]` attribute is recommended to serialize directly
|
||||
//! to the underlying bits type without wrapping it in a `serde` newtype.
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
fn main() {
|
||||
use serde_derive::*;
|
||||
|
||||
bitflags::bitflags! {
|
||||
#[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
|
||||
#[serde(transparent)]
|
||||
pub struct Flags: u32 {
|
||||
const A = 1;
|
||||
const B = 2;
|
||||
const C = 4;
|
||||
const D = 8;
|
||||
}
|
||||
}
|
||||
|
||||
let flags = Flags::A | Flags::B;
|
||||
|
||||
let serialized = serde_json::to_string(&flags).unwrap();
|
||||
|
||||
println!("{:?} -> {}", flags, serialized);
|
||||
|
||||
assert_eq!(serialized, r#""A | B""#);
|
||||
|
||||
let deserialized: Flags = serde_json::from_str(&serialized).unwrap();
|
||||
|
||||
println!("{} -> {:?}", serialized, flags);
|
||||
|
||||
assert_eq!(deserialized, flags);
|
||||
}
|
||||
|
||||
#[cfg(not(feature = "serde"))]
|
||||
fn main() {}
|
552
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/spec.md
vendored
Normal file
552
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/spec.md
vendored
Normal file
@@ -0,0 +1,552 @@
|
||||
# Bitflags
|
||||
|
||||
`bitflags` generates flags enums with well-defined semantics and ergonomic end-user APIs.
|
||||
|
||||
You can use `bitflags` to:
|
||||
|
||||
- provide more user-friendly bindings to C APIs where flags may or may not be fully known in advance.
|
||||
- generate efficient options types with string parsing and formatting support.
|
||||
|
||||
You can't use `bitflags` to:
|
||||
|
||||
- guarantee only bits corresponding to defined flags will ever be set. `bitflags` allows access to the underlying bits type so arbitrary bits may be set.
|
||||
- define bitfields. `bitflags` only generates types where set bits denote the presence of some combination of flags.
|
||||
|
||||
## Definitions
|
||||
|
||||
This section formally defines the terminology and semantics of `bitflags`. It's organized so more fundamental concepts are introduced before those that build on them. It may be helpful to start from the bottom of the section and refer back up to concepts defined earlier.
|
||||
|
||||
Examples use `bitflags` syntax with `u8` as the bits type.
|
||||
|
||||
### Bits type
|
||||
|
||||
A type that defines a fixed number of bits at specific locations.
|
||||
|
||||
----
|
||||
|
||||
Bits types are typically fixed-width unsigned integers. For example, `u8` is a bits type that defines 8 bits; bit-0 through bit-7.
|
||||
|
||||
### Bits value
|
||||
|
||||
An instance of a bits type where each bit may be set (`1`) or unset (`0`).
|
||||
|
||||
----
|
||||
|
||||
Some examples of bits values for the bits type `u8` are:
|
||||
|
||||
```rust
|
||||
0b0000_0000
|
||||
0b1111_1111
|
||||
0b1010_0101
|
||||
```
|
||||
|
||||
#### Equality
|
||||
|
||||
Two bits values are equal if their bits are in the same configuration; set bits in one are set in the other, and unset bits in one are unset in the other.
|
||||
|
||||
#### Operations
|
||||
|
||||
Bits values define the bitwise operators and (`&`), or (`|`), exclusive-or (`^`), and negation (`!`) that apply to each of their bits.
|
||||
|
||||
### Flag
|
||||
|
||||
A set of bits in a bits type that may have a unique name.
|
||||
|
||||
----
|
||||
|
||||
Bits are not required to be exclusive to a flag. Bits are not required to be contiguous.
|
||||
|
||||
The following is a flag for `u8` with the name `A` that includes bit-0:
|
||||
|
||||
```rust
|
||||
const A = 0b0000_0001;
|
||||
```
|
||||
|
||||
The following is a flag for `u8` with the name `B` that includes bit-0, and bit-5:
|
||||
|
||||
```rust
|
||||
const B = 0b0010_0001;
|
||||
```
|
||||
|
||||
#### Named flag
|
||||
|
||||
A flag with a name.
|
||||
|
||||
----
|
||||
|
||||
The following is a named flag, where the name is `A`:
|
||||
|
||||
```rust
|
||||
const A = 0b0000_0001;
|
||||
```
|
||||
|
||||
#### Unnamed flag
|
||||
|
||||
A flag without a name.
|
||||
|
||||
----
|
||||
|
||||
The following is an unnamed flag:
|
||||
|
||||
```rust
|
||||
const _ = 0b0000_0001;
|
||||
```
|
||||
|
||||
#### Zero-bit flag
|
||||
|
||||
A flag with a set of zero bits.
|
||||
|
||||
----
|
||||
|
||||
The following is a zero-bit flag:
|
||||
|
||||
```rust
|
||||
const ZERO = 0b0000_0000;
|
||||
```
|
||||
|
||||
#### Single-bit flag
|
||||
|
||||
A flag with a set of one bit.
|
||||
|
||||
----
|
||||
|
||||
The following are single-bit flags:
|
||||
|
||||
```rust
|
||||
const A = 0b0000_0001;
|
||||
const B = 0b0000_0010;
|
||||
```
|
||||
|
||||
#### Multi-bit flag
|
||||
|
||||
A flag with a set of more than one bit.
|
||||
|
||||
----
|
||||
|
||||
The following are multi-bit flags:
|
||||
|
||||
```rust
|
||||
const A = 0b0000_0011;
|
||||
const B = 0b1111_1111;
|
||||
```
|
||||
|
||||
### Flags type
|
||||
|
||||
A set of defined flags over a specific bits type.
|
||||
|
||||
#### Known bit
|
||||
|
||||
A bit in any defined flag.
|
||||
|
||||
----
|
||||
|
||||
In the following flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0001;
|
||||
const B = 0b0000_0010;
|
||||
const C = 0b0000_0100;
|
||||
}
|
||||
```
|
||||
|
||||
the known bits are:
|
||||
|
||||
```rust
|
||||
0b0000_0111
|
||||
```
|
||||
|
||||
#### Unknown bit
|
||||
|
||||
A bit not in any defined flag.
|
||||
|
||||
----
|
||||
|
||||
In the following flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0001;
|
||||
const B = 0b0000_0010;
|
||||
const C = 0b0000_0100;
|
||||
}
|
||||
```
|
||||
|
||||
the unknown bits are:
|
||||
|
||||
```rust
|
||||
0b1111_1000
|
||||
```
|
||||
|
||||
### Flags value
|
||||
|
||||
An instance of a flags type using its specific bits value for storage.
|
||||
|
||||
The flags value of a flag is one where each of its bits is set, and all others are unset.
|
||||
|
||||
#### Contains
|
||||
|
||||
Whether all set bits in a source flags value are also set in a target flags value.
|
||||
|
||||
----
|
||||
|
||||
Given the flags value:
|
||||
|
||||
```rust
|
||||
0b0000_0011
|
||||
```
|
||||
|
||||
the following flags values are contained:
|
||||
|
||||
```rust
|
||||
0b0000_0000
|
||||
0b0000_0010
|
||||
0b0000_0001
|
||||
0b0000_0011
|
||||
```
|
||||
|
||||
but the following flags values are not contained:
|
||||
|
||||
```rust
|
||||
0b0000_1000
|
||||
0b0000_0110
|
||||
```
|
||||
|
||||
#### Intersects
|
||||
|
||||
Whether any set bits in a source flags value are also set in a target flags value.
|
||||
|
||||
----
|
||||
|
||||
Given the flags value:
|
||||
|
||||
```rust
|
||||
0b0000_0011
|
||||
```
|
||||
|
||||
the following flags intersect:
|
||||
|
||||
```rust
|
||||
0b0000_0010
|
||||
0b0000_0001
|
||||
0b1111_1111
|
||||
```
|
||||
|
||||
but the following flags values do not intersect:
|
||||
|
||||
```rust
|
||||
0b0000_0000
|
||||
0b1111_0000
|
||||
```
|
||||
|
||||
#### Empty
|
||||
|
||||
Whether all bits in a flags value are unset.
|
||||
|
||||
----
|
||||
|
||||
The following flags value is empty:
|
||||
|
||||
```rust
|
||||
0b0000_0000
|
||||
```
|
||||
|
||||
The following flags values are not empty:
|
||||
|
||||
```rust
|
||||
0b0000_0001
|
||||
0b0110_0000
|
||||
```
|
||||
|
||||
#### All
|
||||
|
||||
Whether all defined flags are contained in a flags value.
|
||||
|
||||
----
|
||||
|
||||
Given a flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0001;
|
||||
const B = 0b0000_0010;
|
||||
}
|
||||
```
|
||||
|
||||
the following flags values all satisfy all:
|
||||
|
||||
```rust
|
||||
0b0000_0011
|
||||
0b1000_0011
|
||||
0b1111_1111
|
||||
```
|
||||
|
||||
### Operations
|
||||
|
||||
Examples in this section all use the given flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0001;
|
||||
const B = 0b0000_0010;
|
||||
const C = 0b0000_1100;
|
||||
}
|
||||
```
|
||||
|
||||
#### Truncate
|
||||
|
||||
Unset all unknown bits in a flags value.
|
||||
|
||||
----
|
||||
|
||||
Given the flags value:
|
||||
|
||||
```rust
|
||||
0b1111_1111
|
||||
```
|
||||
|
||||
the result of truncation will be:
|
||||
|
||||
```rust
|
||||
0b0000_1111
|
||||
```
|
||||
|
||||
----
|
||||
|
||||
Truncating doesn't guarantee that a non-empty result will contain any defined flags. Given the following flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0101;
|
||||
}
|
||||
```
|
||||
|
||||
and the following flags value:
|
||||
|
||||
```rust
|
||||
0b0000_1110;
|
||||
```
|
||||
|
||||
The result of truncation will be:
|
||||
|
||||
```rust
|
||||
0b0000_0100;
|
||||
```
|
||||
|
||||
which intersects the flag `A`, but doesn't contain it.
|
||||
|
||||
This behavior is possible even when only operating with flags values containing defined flags. Given the following flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0101;
|
||||
const B = 0b0000_0001;
|
||||
}
|
||||
```
|
||||
|
||||
The result of `A ^ B` is `0b0000_0100`, which also doesn't contain any defined flag.
|
||||
|
||||
----
|
||||
|
||||
If all known bits are in the set of at least one defined single-bit flag, then all operations that produce non-empty results will always contain defined flags.
|
||||
|
||||
#### Union
|
||||
|
||||
The bitwise or (`|`) of the bits in two flags values.
|
||||
|
||||
----
|
||||
|
||||
The following are examples of the result of unioning flags values:
|
||||
|
||||
```rust
|
||||
0b0000_0001 | 0b0000_0010 = 0b0000_0011
|
||||
0b0000_0000 | 0b1111_1111 = 0b1111_1111
|
||||
```
|
||||
|
||||
#### Intersection
|
||||
|
||||
The bitwise and (`&`) of the bits in two flags values.
|
||||
|
||||
----
|
||||
|
||||
The following are examples of the result of intersecting flags values:
|
||||
|
||||
```rust
|
||||
0b0000_0001 & 0b0000_0010 = 0b0000_0000
|
||||
0b1111_1100 & 0b1111_0111 = 0b1111_0100
|
||||
0b1111_1111 & 0b1111_1111 = 0b1111_1111
|
||||
```
|
||||
|
||||
#### Symmetric difference
|
||||
|
||||
The bitwise exclusive-or (`^`) of the bits in two flags values.
|
||||
|
||||
----
|
||||
|
||||
The following are examples of the symmetric difference between two flags values:
|
||||
|
||||
```rust
|
||||
0b0000_0001 ^ 0b0000_0010 = 0b0000_0011
|
||||
0b0000_1111 ^ 0b0000_0011 = 0b0000_1100
|
||||
0b1100_0000 ^ 0b0011_0000 = 0b1111_0000
|
||||
```
|
||||
|
||||
#### Complement
|
||||
|
||||
The bitwise negation (`!`) of the bits in a flags value, truncating the result.
|
||||
|
||||
----
|
||||
|
||||
The following are examples of the complement of a flags value:
|
||||
|
||||
```rust
|
||||
!0b0000_0000 = 0b0000_1111
|
||||
!0b0000_1111 = 0b0000_0000
|
||||
!0b1111_1000 = 0b0000_0111
|
||||
```
|
||||
|
||||
#### Difference
|
||||
|
||||
The bitwise union (`|`) of the bits in one flags value and the bitwise negation (`!`) of the bits in another.
|
||||
|
||||
----
|
||||
|
||||
This operation is not equivalent to the intersection of one flags value with the complement of another (`&!`).
|
||||
The former will truncate the result, where difference will not.
|
||||
|
||||
----
|
||||
|
||||
The following are examples of the difference between two flags values:
|
||||
|
||||
```rust
|
||||
0b0000_0001 & !0b0000_0010 = 0b0000_0001
|
||||
0b0000_1101 & !0b0000_0011 = 0b0000_1100
|
||||
0b1111_1111 & !0b0000_0001 = 0b1111_1110
|
||||
```
|
||||
|
||||
### Iteration
|
||||
|
||||
Yield the bits of a source flags value in a set of contained flags values.
|
||||
|
||||
----
|
||||
|
||||
To be most useful, each yielded flags value should set exactly the bits of a defined flag contained in the source. Any known bits that aren't in the set of any contained flag should be yielded together as a final flags value.
|
||||
|
||||
----
|
||||
|
||||
Given the following flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0001;
|
||||
const B = 0b0000_0010;
|
||||
const AB = 0b0000_0011;
|
||||
}
|
||||
```
|
||||
|
||||
and the following flags value:
|
||||
|
||||
```rust
|
||||
0b0000_1111
|
||||
```
|
||||
|
||||
When iterated it may yield a flags value for `A` and `B`, then a final flag with the unknown bits:
|
||||
|
||||
```rust
|
||||
0b0000_0001
|
||||
0b0000_0010
|
||||
0b0000_1100
|
||||
```
|
||||
|
||||
It may also yield a flags value for `AB`, then a final flag with the unknown bits:
|
||||
|
||||
```rust
|
||||
0b0000_0011
|
||||
0b0000_1100
|
||||
```
|
||||
|
||||
----
|
||||
|
||||
Given the following flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0011;
|
||||
}
|
||||
```
|
||||
|
||||
and the following flags value:
|
||||
|
||||
```rust
|
||||
0b0000_0001
|
||||
```
|
||||
|
||||
When iterated it will still yield a flags value for the known bit `0b0000_0001` even though it doesn't contain a flag.
|
||||
|
||||
### Formatting
|
||||
|
||||
Format and parse a flags value as text using the following grammar:
|
||||
|
||||
- _Flags:_ (_Whitespace_ _Flag_ _Whitespace_)`|`*
|
||||
- _Flag:_ _Name_ | _Hex Number_
|
||||
- _Name:_ The name of any defined flag
|
||||
- _Hex Number_: `0x`([0-9a-fA-F])*
|
||||
- _Whitespace_: (\s)*
|
||||
|
||||
Flags values can be formatted as _Flags_ by iterating over them, formatting each yielded flags value as a _Flag_. Any yielded flags value that sets exactly the bits of a defined flag with a name should be formatted as a _Name_. Otherwise it must be formatted as a _Hex Number_.
|
||||
|
||||
Formatting and parsing supports three modes:
|
||||
|
||||
- **Retain**: Formatting and parsing roundtrips exactly the bits of the source flags value. This is the default behavior.
|
||||
- **Truncate**: Flags values are truncated before formatting, and truncated after parsing.
|
||||
- **Strict**: A _Flag_ may only be formatted and parsed as a _Name_. _Hex numbers_ are not allowed. A consequence of this is that unknown bits and any bits that aren't in a contained named flag will be ignored. This is recommended for flags values serialized across API boundaries, like web services.
|
||||
|
||||
Text that is empty or whitespace is an empty flags value.
|
||||
|
||||
----
|
||||
|
||||
Given the following flags type:
|
||||
|
||||
```rust
|
||||
struct Flags {
|
||||
const A = 0b0000_0001;
|
||||
const B = 0b0000_0010;
|
||||
const AB = 0b0000_0011;
|
||||
const C = 0b0000_1100;
|
||||
}
|
||||
```
|
||||
|
||||
The following are examples of how flags values can be formatted using any mode:
|
||||
|
||||
```rust
|
||||
0b0000_0000 = ""
|
||||
0b0000_0001 = "A"
|
||||
0b0000_0010 = "B"
|
||||
0b0000_0011 = "A | B"
|
||||
0b0000_0011 = "AB"
|
||||
0b0000_1111 = "A | B | C"
|
||||
```
|
||||
|
||||
Truncate mode will unset any unknown bits:
|
||||
|
||||
```rust
|
||||
0b1000_0000 = ""
|
||||
0b1111_1111 = "A | B | C"
|
||||
0b0000_1000 = "0x8"
|
||||
```
|
||||
|
||||
Retain mode will include any unknown bits as a final _Flag_:
|
||||
|
||||
```rust
|
||||
0b1000_0000 = "0x80"
|
||||
0b1111_1111 = "A | B | C | 0xf0"
|
||||
0b0000_1000 = "0x8"
|
||||
```
|
||||
|
||||
Strict mode will unset any unknown bits, as well as bits not contained in any defined named flags:
|
||||
|
||||
```rust
|
||||
0b1000_0000 = ""
|
||||
0b1111_1111 = "A | B | C"
|
||||
0b0000_1000 = ""
|
||||
```
|
65
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/example_generated.rs
vendored
Normal file
65
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/example_generated.rs
vendored
Normal file
@@ -0,0 +1,65 @@
|
||||
//! This module shows an example of code generated by the macro. **IT MUST NOT BE USED OUTSIDE THIS
|
||||
//! CRATE**.
|
||||
//!
|
||||
//! Usually, when you call the `bitflags!` macro, only the `Flags` type would be visible. In this
|
||||
//! example, the `Field0`, `Iter`, and `IterRaw` types are also exposed so that you can explore
|
||||
//! their APIs. The `Field0` type can be accessed as `self.0` on an instance of `Flags`.
|
||||
|
||||
__declare_public_bitflags! {
|
||||
/// This is the same `Flags` struct defined in the [crate level example](../index.html#example).
|
||||
/// Note that this struct is just for documentation purposes only, it must not be used outside
|
||||
/// this crate.
|
||||
pub struct Flags
|
||||
}
|
||||
|
||||
__declare_internal_bitflags! {
|
||||
pub struct Field0: u32
|
||||
}
|
||||
|
||||
__impl_internal_bitflags! {
|
||||
Field0: u32, Flags {
|
||||
// Field `A`.
|
||||
///
|
||||
/// This flag has the value `0b00000001`.
|
||||
const A = 0b00000001;
|
||||
/// Field `B`.
|
||||
///
|
||||
/// This flag has the value `0b00000010`.
|
||||
const B = 0b00000010;
|
||||
/// Field `C`.
|
||||
///
|
||||
/// This flag has the value `0b00000100`.
|
||||
const C = 0b00000100;
|
||||
const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
|
||||
}
|
||||
}
|
||||
|
||||
__impl_public_bitflags_forward! {
|
||||
Flags: u32, Field0
|
||||
}
|
||||
|
||||
__impl_public_bitflags_ops! {
|
||||
Flags
|
||||
}
|
||||
|
||||
__impl_public_bitflags_iter! {
|
||||
Flags: u32, Flags
|
||||
}
|
||||
|
||||
__impl_public_bitflags_consts! {
|
||||
Flags: u32 {
|
||||
/// Field `A`.
|
||||
///
|
||||
/// This flag has the value `0b00000001`.
|
||||
const A = 0b00000001;
|
||||
/// Field `B`.
|
||||
///
|
||||
/// This flag has the value `0b00000010`.
|
||||
const B = 0b00000010;
|
||||
/// Field `C`.
|
||||
///
|
||||
/// This flag has the value `0b00000100`.
|
||||
const C = 0b00000100;
|
||||
const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
|
||||
}
|
||||
}
|
262
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external.rs
vendored
Normal file
262
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external.rs
vendored
Normal file
@@ -0,0 +1,262 @@
|
||||
//! Conditional trait implementations for external libraries.
|
||||
|
||||
/*
|
||||
How do I support a new external library?
|
||||
|
||||
Let's say we want to add support for `my_library`.
|
||||
|
||||
First, we create a module under `external`, like `serde` with any specialized code.
|
||||
Ideally, any utilities in here should just work off the `Flags` trait and maybe a
|
||||
few other assumed bounds.
|
||||
|
||||
Next, re-export the library from the `__private` module here.
|
||||
|
||||
Next, define a macro like so:
|
||||
|
||||
```rust
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
#[cfg(feature = "serde")]
|
||||
macro_rules! __impl_external_bitflags_my_library {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {
|
||||
// Implementation goes here
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
#[cfg(not(feature = "my_library"))]
|
||||
macro_rules! __impl_external_bitflags_my_library {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {};
|
||||
}
|
||||
```
|
||||
|
||||
Note that the macro is actually defined twice; once for when the `my_library` feature
|
||||
is available, and once for when it's not. This is because the `__impl_external_bitflags_my_library`
|
||||
macro is called in an end-user's library, not in `bitflags`. In an end-user's library we don't
|
||||
know whether or not a particular feature of `bitflags` is enabled, so we unconditionally call
|
||||
the macro, where the body of that macro depends on the feature flag.
|
||||
|
||||
Now, we add our macro call to the `__impl_external_bitflags` macro body:
|
||||
|
||||
```rust
|
||||
__impl_external_bitflags_my_library! {
|
||||
$InternalBitFlags: $T, $PublicBitFlags {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag;
|
||||
)*
|
||||
}
|
||||
}
|
||||
```
|
||||
*/
|
||||
|
||||
pub(crate) mod __private {
|
||||
#[cfg(feature = "serde")]
|
||||
pub use serde;
|
||||
|
||||
#[cfg(feature = "arbitrary")]
|
||||
pub use arbitrary;
|
||||
|
||||
#[cfg(feature = "bytemuck")]
|
||||
pub use bytemuck;
|
||||
}
|
||||
|
||||
/// Implements traits from external libraries for the internal bitflags type.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __impl_external_bitflags {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {
|
||||
// Any new library traits impls should be added here
|
||||
// Use `serde` as an example: generate code when the feature is available,
|
||||
// and a no-op when it isn't
|
||||
|
||||
$crate::__impl_external_bitflags_serde! {
|
||||
$InternalBitFlags: $T, $PublicBitFlags {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag;
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
$crate::__impl_external_bitflags_arbitrary! {
|
||||
$InternalBitFlags: $T, $PublicBitFlags {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag;
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
$crate::__impl_external_bitflags_bytemuck! {
|
||||
$InternalBitFlags: $T, $PublicBitFlags {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag;
|
||||
)*
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[cfg(feature = "serde")]
|
||||
pub mod serde;
|
||||
|
||||
/// Implement `Serialize` and `Deserialize` for the internal bitflags type.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
#[cfg(feature = "serde")]
|
||||
macro_rules! __impl_external_bitflags_serde {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {
|
||||
impl $crate::__private::serde::Serialize for $InternalBitFlags {
|
||||
fn serialize<S: $crate::__private::serde::Serializer>(
|
||||
&self,
|
||||
serializer: S,
|
||||
) -> $crate::__private::core::result::Result<S::Ok, S::Error> {
|
||||
$crate::serde::serialize(
|
||||
&$PublicBitFlags::from_bits_retain(self.bits()),
|
||||
serializer,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'de> $crate::__private::serde::Deserialize<'de> for $InternalBitFlags {
|
||||
fn deserialize<D: $crate::__private::serde::Deserializer<'de>>(
|
||||
deserializer: D,
|
||||
) -> $crate::__private::core::result::Result<Self, D::Error> {
|
||||
let flags: $PublicBitFlags = $crate::serde::deserialize(deserializer)?;
|
||||
|
||||
Ok(flags.0)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
#[cfg(not(feature = "serde"))]
|
||||
macro_rules! __impl_external_bitflags_serde {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {};
|
||||
}
|
||||
|
||||
#[cfg(feature = "arbitrary")]
|
||||
pub mod arbitrary;
|
||||
|
||||
#[cfg(feature = "bytemuck")]
|
||||
mod bytemuck;
|
||||
|
||||
/// Implement `Arbitrary` for the internal bitflags type.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
#[cfg(feature = "arbitrary")]
|
||||
macro_rules! __impl_external_bitflags_arbitrary {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {
|
||||
impl<'a> $crate::__private::arbitrary::Arbitrary<'a> for $InternalBitFlags {
|
||||
fn arbitrary(
|
||||
u: &mut $crate::__private::arbitrary::Unstructured<'a>,
|
||||
) -> $crate::__private::arbitrary::Result<Self> {
|
||||
$crate::arbitrary::arbitrary::<$PublicBitFlags>(u).map(|flags| flags.0)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
#[cfg(not(feature = "arbitrary"))]
|
||||
macro_rules! __impl_external_bitflags_arbitrary {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {};
|
||||
}
|
||||
|
||||
/// Implement `Pod` and `Zeroable` for the internal bitflags type.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
#[cfg(feature = "bytemuck")]
|
||||
macro_rules! __impl_external_bitflags_bytemuck {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {
|
||||
// SAFETY: $InternalBitFlags is guaranteed to have the same ABI as $T,
|
||||
// and $T implements Pod
|
||||
unsafe impl $crate::__private::bytemuck::Pod for $InternalBitFlags where
|
||||
$T: $crate::__private::bytemuck::Pod
|
||||
{
|
||||
}
|
||||
|
||||
// SAFETY: $InternalBitFlags is guaranteed to have the same ABI as $T,
|
||||
// and $T implements Zeroable
|
||||
unsafe impl $crate::__private::bytemuck::Zeroable for $InternalBitFlags where
|
||||
$T: $crate::__private::bytemuck::Zeroable
|
||||
{
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
#[cfg(not(feature = "bytemuck"))]
|
||||
macro_rules! __impl_external_bitflags_bytemuck {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt;
|
||||
)*
|
||||
}
|
||||
) => {};
|
||||
}
|
33
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/arbitrary.rs
vendored
Normal file
33
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/arbitrary.rs
vendored
Normal file
@@ -0,0 +1,33 @@
|
||||
//! Specialized fuzzing for flags types using `arbitrary`.
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
/**
|
||||
Generate some arbitrary flags value with only known bits set.
|
||||
*/
|
||||
pub fn arbitrary<'a, B: Flags>(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<B>
|
||||
where
|
||||
B::Bits: arbitrary::Arbitrary<'a>,
|
||||
{
|
||||
B::from_bits(u.arbitrary()?).ok_or_else(|| arbitrary::Error::IncorrectFormat)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use arbitrary::Arbitrary;
|
||||
|
||||
bitflags! {
|
||||
#[derive(Arbitrary)]
|
||||
struct Color: u32 {
|
||||
const RED = 0x1;
|
||||
const GREEN = 0x2;
|
||||
const BLUE = 0x4;
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_arbitrary() {
|
||||
let mut unstructured = arbitrary::Unstructured::new(&[0_u8; 256]);
|
||||
let _color = Color::arbitrary(&mut unstructured);
|
||||
}
|
||||
}
|
19
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/bytemuck.rs
vendored
Normal file
19
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/bytemuck.rs
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use bytemuck::{Pod, Zeroable};
|
||||
|
||||
bitflags! {
|
||||
#[derive(Pod, Zeroable, Clone, Copy)]
|
||||
#[repr(transparent)]
|
||||
struct Color: u32 {
|
||||
const RED = 0x1;
|
||||
const GREEN = 0x2;
|
||||
const BLUE = 0x4;
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytemuck() {
|
||||
assert_eq!(0x1, bytemuck::cast::<Color, u32>(Color::RED));
|
||||
}
|
||||
}
|
93
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/serde.rs
vendored
Normal file
93
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/external/serde.rs
vendored
Normal file
@@ -0,0 +1,93 @@
|
||||
//! Specialized serialization for flags types using `serde`.
|
||||
|
||||
use crate::{
|
||||
parser::{self, ParseHex, WriteHex},
|
||||
Flags,
|
||||
};
|
||||
use core::{fmt, str};
|
||||
use serde::{
|
||||
de::{Error, Visitor},
|
||||
Deserialize, Deserializer, Serialize, Serializer,
|
||||
};
|
||||
|
||||
/**
|
||||
Serialize a set of flags as a human-readable string or their underlying bits.
|
||||
|
||||
Any unknown bits will be retained.
|
||||
*/
|
||||
pub fn serialize<B: Flags, S: Serializer>(flags: &B, serializer: S) -> Result<S::Ok, S::Error>
|
||||
where
|
||||
B::Bits: WriteHex + Serialize,
|
||||
{
|
||||
// Serialize human-readable flags as a string like `"A | B"`
|
||||
if serializer.is_human_readable() {
|
||||
serializer.collect_str(&parser::AsDisplay(flags))
|
||||
}
|
||||
// Serialize non-human-readable flags directly as the underlying bits
|
||||
else {
|
||||
flags.bits().serialize(serializer)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Deserialize a set of flags from a human-readable string or their underlying bits.
|
||||
|
||||
Any unknown bits will be retained.
|
||||
*/
|
||||
pub fn deserialize<'de, B: Flags, D: Deserializer<'de>>(deserializer: D) -> Result<B, D::Error>
|
||||
where
|
||||
B::Bits: ParseHex + Deserialize<'de>,
|
||||
{
|
||||
if deserializer.is_human_readable() {
|
||||
// Deserialize human-readable flags by parsing them from strings like `"A | B"`
|
||||
struct FlagsVisitor<B>(core::marker::PhantomData<B>);
|
||||
|
||||
impl<'de, B: Flags> Visitor<'de> for FlagsVisitor<B>
|
||||
where
|
||||
B::Bits: ParseHex,
|
||||
{
|
||||
type Value = B;
|
||||
|
||||
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
formatter.write_str("a string value of `|` separated flags")
|
||||
}
|
||||
|
||||
fn visit_str<E: Error>(self, flags: &str) -> Result<Self::Value, E> {
|
||||
parser::from_str(flags).map_err(|e| E::custom(e))
|
||||
}
|
||||
}
|
||||
|
||||
deserializer.deserialize_str(FlagsVisitor(Default::default()))
|
||||
} else {
|
||||
// Deserialize non-human-readable flags directly from the underlying bits
|
||||
let bits = B::Bits::deserialize(deserializer)?;
|
||||
|
||||
Ok(B::from_bits_retain(bits))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use serde_test::{assert_tokens, Configure, Token::*};
|
||||
bitflags! {
|
||||
#[derive(serde_derive::Serialize, serde_derive::Deserialize, Debug, PartialEq, Eq)]
|
||||
#[serde(transparent)]
|
||||
struct SerdeFlags: u32 {
|
||||
const A = 1;
|
||||
const B = 2;
|
||||
const C = 4;
|
||||
const D = 8;
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_serde_bitflags_default() {
|
||||
assert_tokens(&SerdeFlags::empty().readable(), &[Str("")]);
|
||||
|
||||
assert_tokens(&SerdeFlags::empty().compact(), &[U32(0)]);
|
||||
|
||||
assert_tokens(&(SerdeFlags::A | SerdeFlags::B).readable(), &[Str("A | B")]);
|
||||
|
||||
assert_tokens(&(SerdeFlags::A | SerdeFlags::B).compact(), &[U32(1 | 2)]);
|
||||
}
|
||||
}
|
125
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/internal.rs
vendored
Normal file
125
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/internal.rs
vendored
Normal file
@@ -0,0 +1,125 @@
|
||||
//! Generate the internal `bitflags`-facing flags type.
|
||||
//!
|
||||
//! The code generated here is owned by `bitflags`, but still part of its public API.
|
||||
//! Changes to the types generated here need to be considered like any other public API change.
|
||||
|
||||
/// Declare the `bitflags`-facing bitflags struct.
|
||||
///
|
||||
/// This type is part of the `bitflags` crate's public API, but not part of the user's.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __declare_internal_bitflags {
|
||||
(
|
||||
$vis:vis struct $InternalBitFlags:ident: $T:ty
|
||||
) => {
|
||||
// NOTE: The ABI of this type is _guaranteed_ to be the same as `T`
|
||||
// This is relied on by some external libraries like `bytemuck` to make
|
||||
// its `unsafe` trait impls sound.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[repr(transparent)]
|
||||
$vis struct $InternalBitFlags($T);
|
||||
};
|
||||
}
|
||||
|
||||
/// Implement functions on the private (bitflags-facing) bitflags type.
|
||||
///
|
||||
/// Methods and trait implementations can be freely added here without breaking end-users.
|
||||
/// If we want to expose new functionality to `#[derive]`, this is the place to do it.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __impl_internal_bitflags {
|
||||
(
|
||||
$InternalBitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt = $value:expr;
|
||||
)*
|
||||
}
|
||||
) => {
|
||||
// NOTE: This impl is also used to prevent using bits types from non-primitive types
|
||||
// in the `bitflags` macro. If this approach is changed, this guard will need to be
|
||||
// retained somehow
|
||||
impl $crate::__private::PublicFlags for $PublicBitFlags {
|
||||
type Primitive = $T;
|
||||
type Internal = $InternalBitFlags;
|
||||
}
|
||||
|
||||
impl $crate::__private::core::default::Default for $InternalBitFlags {
|
||||
#[inline]
|
||||
fn default() -> Self {
|
||||
$InternalBitFlags::empty()
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::fmt::Debug for $InternalBitFlags {
|
||||
fn fmt(&self, f: &mut $crate::__private::core::fmt::Formatter<'_>) -> $crate::__private::core::fmt::Result {
|
||||
if self.is_empty() {
|
||||
// If no flags are set then write an empty hex flag to avoid
|
||||
// writing an empty string. In some contexts, like serialization,
|
||||
// an empty string is preferable, but it may be unexpected in
|
||||
// others for a format not to produce any output.
|
||||
//
|
||||
// We can remove this `0x0` and remain compatible with `FromStr`,
|
||||
// because an empty string will still parse to an empty set of flags,
|
||||
// just like `0x0` does.
|
||||
$crate::__private::core::write!(f, "{:#x}", <$T as $crate::Bits>::EMPTY)
|
||||
} else {
|
||||
$crate::__private::core::fmt::Display::fmt(self, f)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::fmt::Display for $InternalBitFlags {
|
||||
fn fmt(&self, f: &mut $crate::__private::core::fmt::Formatter<'_>) -> $crate::__private::core::fmt::Result {
|
||||
$crate::parser::to_writer(&$PublicBitFlags(*self), f)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::str::FromStr for $InternalBitFlags {
|
||||
type Err = $crate::parser::ParseError;
|
||||
|
||||
fn from_str(s: &str) -> $crate::__private::core::result::Result<Self, Self::Err> {
|
||||
$crate::parser::from_str::<$PublicBitFlags>(s).map(|flags| flags.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::convert::AsRef<$T> for $InternalBitFlags {
|
||||
fn as_ref(&self) -> &$T {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::convert::From<$T> for $InternalBitFlags {
|
||||
fn from(bits: $T) -> Self {
|
||||
Self::from_bits_retain(bits)
|
||||
}
|
||||
}
|
||||
|
||||
// The internal flags type offers a similar API to the public one
|
||||
|
||||
$crate::__impl_public_bitflags! {
|
||||
$InternalBitFlags: $T, $PublicBitFlags {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag = $value;
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
$crate::__impl_public_bitflags_ops! {
|
||||
$InternalBitFlags
|
||||
}
|
||||
|
||||
$crate::__impl_public_bitflags_iter! {
|
||||
$InternalBitFlags: $T, $PublicBitFlags
|
||||
}
|
||||
|
||||
impl $InternalBitFlags {
|
||||
/// Returns a mutable reference to the raw value of the flags currently stored.
|
||||
#[inline]
|
||||
pub fn bits_mut(&mut self) -> &mut $T {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
145
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/iter.rs
vendored
Normal file
145
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/iter.rs
vendored
Normal file
@@ -0,0 +1,145 @@
|
||||
/*!
|
||||
Yield the bits of a source flags value in a set of contained flags values.
|
||||
*/
|
||||
|
||||
use crate::{Flag, Flags};
|
||||
|
||||
/**
|
||||
An iterator over flags values.
|
||||
|
||||
This iterator will yield flags values for contained, defined flags first, with any remaining bits yielded
|
||||
as a final flags value.
|
||||
*/
|
||||
pub struct Iter<B: 'static> {
|
||||
inner: IterNames<B>,
|
||||
done: bool,
|
||||
}
|
||||
|
||||
impl<B: Flags> Iter<B> {
|
||||
pub(crate) fn new(flags: &B) -> Self {
|
||||
Iter {
|
||||
inner: IterNames::new(flags),
|
||||
done: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<B: 'static> Iter<B> {
|
||||
// Used by the `bitflags` macro
|
||||
#[doc(hidden)]
|
||||
pub const fn __private_const_new(flags: &'static [Flag<B>], source: B, remaining: B) -> Self {
|
||||
Iter {
|
||||
inner: IterNames::__private_const_new(flags, source, remaining),
|
||||
done: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<B: Flags> Iterator for Iter<B> {
|
||||
type Item = B;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match self.inner.next() {
|
||||
Some((_, flag)) => Some(flag),
|
||||
None if !self.done => {
|
||||
self.done = true;
|
||||
|
||||
// After iterating through valid names, if there are any bits left over
|
||||
// then return one final value that includes them. This makes `into_iter`
|
||||
// and `from_iter` roundtrip
|
||||
if !self.inner.remaining().is_empty() {
|
||||
Some(B::from_bits_retain(self.inner.remaining.bits()))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
An iterator over flags values.
|
||||
|
||||
This iterator only yields flags values for contained, defined, named flags. Any remaining bits
|
||||
won't be yielded, but can be found with the [`IterNames::remaining`] method.
|
||||
*/
|
||||
pub struct IterNames<B: 'static> {
|
||||
flags: &'static [Flag<B>],
|
||||
idx: usize,
|
||||
source: B,
|
||||
remaining: B,
|
||||
}
|
||||
|
||||
impl<B: Flags> IterNames<B> {
|
||||
pub(crate) fn new(flags: &B) -> Self {
|
||||
IterNames {
|
||||
flags: B::FLAGS,
|
||||
idx: 0,
|
||||
remaining: B::from_bits_retain(flags.bits()),
|
||||
source: B::from_bits_retain(flags.bits()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<B: 'static> IterNames<B> {
|
||||
// Used by the bitflags macro
|
||||
#[doc(hidden)]
|
||||
pub const fn __private_const_new(flags: &'static [Flag<B>], source: B, remaining: B) -> Self {
|
||||
IterNames {
|
||||
flags,
|
||||
idx: 0,
|
||||
remaining,
|
||||
source,
|
||||
}
|
||||
}
|
||||
|
||||
/// Get a flags value of any remaining bits that haven't been yielded yet.
|
||||
///
|
||||
/// Once the iterator has finished, this method can be used to
|
||||
/// check whether or not there are any bits that didn't correspond
|
||||
/// to a contained, defined, named flag remaining.
|
||||
pub fn remaining(&self) -> &B {
|
||||
&self.remaining
|
||||
}
|
||||
}
|
||||
|
||||
impl<B: Flags> Iterator for IterNames<B> {
|
||||
type Item = (&'static str, B);
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
while let Some(flag) = self.flags.get(self.idx) {
|
||||
// Short-circuit if our state is empty
|
||||
if self.remaining.is_empty() {
|
||||
return None;
|
||||
}
|
||||
|
||||
self.idx += 1;
|
||||
|
||||
// Skip unnamed flags
|
||||
if flag.name().is_empty() {
|
||||
continue;
|
||||
}
|
||||
|
||||
let bits = flag.value().bits();
|
||||
|
||||
// If the flag is set in the original source _and_ it has bits that haven't
|
||||
// been covered by a previous flag yet then yield it. These conditions cover
|
||||
// two cases for multi-bit flags:
|
||||
//
|
||||
// 1. When flags partially overlap, such as `0b00000001` and `0b00000101`, we'll
|
||||
// yield both flags.
|
||||
// 2. When flags fully overlap, such as in convenience flags that are a shorthand for others,
|
||||
// we won't yield both flags.
|
||||
if self.source.contains(B::from_bits_retain(bits))
|
||||
&& self.remaining.intersects(B::from_bits_retain(bits))
|
||||
{
|
||||
self.remaining.remove(B::from_bits_retain(bits));
|
||||
|
||||
return Some((flag.name(), B::from_bits_retain(bits)));
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
}
|
922
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/lib.rs
vendored
Normal file
922
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/lib.rs
vendored
Normal file
@@ -0,0 +1,922 @@
|
||||
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
/*!
|
||||
Generate types for C-style flags with ergonomic APIs.
|
||||
|
||||
# Getting started
|
||||
|
||||
Add `bitflags` to your `Cargo.toml`:
|
||||
|
||||
```toml
|
||||
[dependencies.bitflags]
|
||||
version = "2.4.2"
|
||||
```
|
||||
|
||||
## Generating flags types
|
||||
|
||||
Use the [`bitflags`] macro to generate flags types:
|
||||
|
||||
```rust
|
||||
use bitflags::bitflags;
|
||||
|
||||
bitflags! {
|
||||
pub struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
const B = 0b00000010;
|
||||
const C = 0b00000100;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
See the docs for the `bitflags` macro for the full syntax.
|
||||
|
||||
Also see the [`example_generated`] module for an example of what the `bitflags` macro generates for a flags type.
|
||||
|
||||
### Externally defined flags
|
||||
|
||||
If you're generating flags types for an external source, such as a C API, you can define
|
||||
an extra unnamed flag as a mask of all bits the external source may ever set. Usually this would be all bits (`!0`):
|
||||
|
||||
```rust
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
pub struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
const B = 0b00000010;
|
||||
const C = 0b00000100;
|
||||
|
||||
// The source may set any bits
|
||||
const _ = !0;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Why should you do this? Generated methods like `all` and truncating operators like `!` only consider
|
||||
bits in defined flags. Adding an unnamed flag makes those methods consider additional bits,
|
||||
without generating additional constants for them. It helps compatibility when the external source
|
||||
may start setting additional bits at any time. The [known and unknown bits](#known-and-unknown-bits)
|
||||
section has more details on this behavior.
|
||||
|
||||
### Custom derives
|
||||
|
||||
You can derive some traits on generated flags types if you enable Cargo features. The following
|
||||
libraries are currently supported:
|
||||
|
||||
- `serde`: Support `#[derive(Serialize, Deserialize)]`, using text for human-readable formats,
|
||||
and a raw number for binary formats.
|
||||
- `arbitrary`: Support `#[derive(Arbitrary)]`, only generating flags values with known bits.
|
||||
- `bytemuck`: Support `#[derive(Pod, Zeroable)]`, for casting between flags values and their
|
||||
underlying bits values.
|
||||
|
||||
You can also define your own flags type outside of the [`bitflags`] macro and then use it to generate methods.
|
||||
This can be useful if you need a custom `#[derive]` attribute for a library that `bitflags` doesn't
|
||||
natively support:
|
||||
|
||||
```rust
|
||||
# use std::fmt::Debug as SomeTrait;
|
||||
# use bitflags::bitflags;
|
||||
#[derive(SomeTrait)]
|
||||
pub struct Flags(u32);
|
||||
|
||||
bitflags! {
|
||||
impl Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
const B = 0b00000010;
|
||||
const C = 0b00000100;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Adding custom methods
|
||||
|
||||
The [`bitflags`] macro supports attributes on generated flags types within the macro itself, while
|
||||
`impl` blocks can be added outside of it:
|
||||
|
||||
```rust
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
// Attributes can be applied to flags types
|
||||
#[repr(transparent)]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub struct Flags: u32 {
|
||||
const A = 0b00000001;
|
||||
const B = 0b00000010;
|
||||
const C = 0b00000100;
|
||||
}
|
||||
}
|
||||
|
||||
// Impl blocks can be added to flags types
|
||||
impl Flags {
|
||||
pub fn as_u64(&self) -> u64 {
|
||||
self.bits() as u64
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Working with flags values
|
||||
|
||||
Use generated constants and standard bitwise operators to interact with flags values:
|
||||
|
||||
```rust
|
||||
# use bitflags::bitflags;
|
||||
# bitflags! {
|
||||
# #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
# pub struct Flags: u32 {
|
||||
# const A = 0b00000001;
|
||||
# const B = 0b00000010;
|
||||
# const C = 0b00000100;
|
||||
# }
|
||||
# }
|
||||
// union
|
||||
let ab = Flags::A | Flags::B;
|
||||
|
||||
// intersection
|
||||
let a = ab & Flags::A;
|
||||
|
||||
// difference
|
||||
let b = ab - Flags::A;
|
||||
|
||||
// complement
|
||||
let c = !ab;
|
||||
```
|
||||
|
||||
See the docs for the [`Flags`] trait for more details on operators and how they behave.
|
||||
|
||||
# Formatting and parsing
|
||||
|
||||
`bitflags` defines a text format that can be used to convert any flags value to and from strings.
|
||||
|
||||
See the [`parser`] module for more details.
|
||||
|
||||
# Specification
|
||||
|
||||
The terminology and behavior of generated flags types is
|
||||
[specified in the source repository](https://github.com/bitflags/bitflags/blob/main/spec.md).
|
||||
Details are repeated in these docs where appropriate, but is exhaustively listed in the spec. Some
|
||||
things are worth calling out explicitly here.
|
||||
|
||||
## Flags types, flags values, flags
|
||||
|
||||
The spec and these docs use consistent terminology to refer to things in the bitflags domain:
|
||||
|
||||
- **Bits type**: A type that defines a fixed number of bits at specific locations.
|
||||
- **Flag**: A set of bits in a bits type that may have a unique name.
|
||||
- **Flags type**: A set of defined flags over a specific bits type.
|
||||
- **Flags value**: An instance of a flags type using its specific bits value for storage.
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
struct FlagsType: u8 {
|
||||
// -- Bits type
|
||||
// --------- Flags type
|
||||
const A = 1;
|
||||
// ----- Flag
|
||||
}
|
||||
}
|
||||
|
||||
let flag = FlagsType::A;
|
||||
// ---- Flags value
|
||||
```
|
||||
|
||||
## Known and unknown bits
|
||||
|
||||
Any bits in a flag you define are called _known bits_. Any other bits are _unknown bits_.
|
||||
In the following flags type:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
struct Flags: u8 {
|
||||
const A = 1;
|
||||
const B = 1 << 1;
|
||||
const C = 1 << 2;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
The known bits are `0b0000_0111` and the unknown bits are `0b1111_1000`.
|
||||
|
||||
`bitflags` doesn't guarantee that a flags value will only ever have known bits set, but some operators
|
||||
will unset any unknown bits they encounter. In a future version of `bitflags`, all operators will
|
||||
unset unknown bits.
|
||||
|
||||
If you're using `bitflags` for flags types defined externally, such as from C, you probably want all
|
||||
bits to be considered known, in case that external source changes. You can do this using an unnamed
|
||||
flag, as described in [externally defined flags](#externally-defined-flags).
|
||||
|
||||
## Zero-bit flags
|
||||
|
||||
Flags with no bits set should be avoided because they interact strangely with [`Flags::contains`]
|
||||
and [`Flags::intersects`]. A zero-bit flag is always contained, but is never intersected. The
|
||||
names of zero-bit flags can be parsed, but are never formatted.
|
||||
|
||||
## Multi-bit flags
|
||||
|
||||
Flags that set multiple bits should be avoided unless each bit is also in a single-bit flag.
|
||||
Take the following flags type as an example:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
struct Flags: u8 {
|
||||
const A = 1;
|
||||
const B = 1 | 1 << 1;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
The result of `Flags::A ^ Flags::B` is `0b0000_0010`, which doesn't correspond to either
|
||||
`Flags::A` or `Flags::B` even though it's still a known bit.
|
||||
*/
|
||||
|
||||
#![cfg_attr(not(any(feature = "std", test)), no_std)]
|
||||
#![cfg_attr(not(test), forbid(unsafe_code))]
|
||||
#![cfg_attr(test, allow(mixed_script_confusables))]
|
||||
|
||||
#[doc(inline)]
|
||||
pub use traits::{Bits, Flag, Flags};
|
||||
|
||||
pub mod iter;
|
||||
pub mod parser;
|
||||
|
||||
mod traits;
|
||||
|
||||
#[doc(hidden)]
|
||||
pub mod __private {
|
||||
#[allow(unused_imports)] // Easier than conditionally checking any optional external dependencies
|
||||
pub use crate::{external::__private::*, traits::__private::*};
|
||||
|
||||
pub use core;
|
||||
}
|
||||
|
||||
#[allow(unused_imports)]
|
||||
pub use external::*;
|
||||
|
||||
#[allow(deprecated)]
|
||||
pub use traits::BitFlags;
|
||||
|
||||
/*
|
||||
How does the bitflags crate work?
|
||||
|
||||
This library generates a `struct` in the end-user's crate with a bunch of constants on it that represent flags.
|
||||
The difference between `bitflags` and a lot of other libraries is that we don't actually control the generated `struct` in the end.
|
||||
It's part of the end-user's crate, so it belongs to them. That makes it difficult to extend `bitflags` with new functionality
|
||||
because we could end up breaking valid code that was already written.
|
||||
|
||||
Our solution is to split the type we generate into two: the public struct owned by the end-user, and an internal struct owned by `bitflags` (us).
|
||||
To give you an example, let's say we had a crate that called `bitflags!`:
|
||||
|
||||
```rust
|
||||
bitflags! {
|
||||
pub struct MyFlags: u32 {
|
||||
const A = 1;
|
||||
const B = 2;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
What they'd end up with looks something like this:
|
||||
|
||||
```rust
|
||||
pub struct MyFlags(<MyFlags as PublicFlags>::InternalBitFlags);
|
||||
|
||||
const _: () = {
|
||||
#[repr(transparent)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub struct MyInternalBitFlags {
|
||||
bits: u32,
|
||||
}
|
||||
|
||||
impl PublicFlags for MyFlags {
|
||||
type Internal = InternalBitFlags;
|
||||
}
|
||||
};
|
||||
```
|
||||
|
||||
If we want to expose something like a new trait impl for generated flags types, we add it to our generated `MyInternalBitFlags`,
|
||||
and let `#[derive]` on `MyFlags` pick up that implementation, if an end-user chooses to add one.
|
||||
|
||||
The public API is generated in the `__impl_public_flags!` macro, and the internal API is generated in
|
||||
the `__impl_internal_flags!` macro.
|
||||
|
||||
The macros are split into 3 modules:
|
||||
|
||||
- `public`: where the user-facing flags types are generated.
|
||||
- `internal`: where the `bitflags`-facing flags types are generated.
|
||||
- `external`: where external library traits are implemented conditionally.
|
||||
*/
|
||||
|
||||
/**
|
||||
Generate a flags type.
|
||||
|
||||
# `struct` mode
|
||||
|
||||
A declaration that begins with `$vis struct` will generate a `struct` for a flags type, along with
|
||||
methods and trait implementations for it. The body of the declaration defines flags as constants,
|
||||
where each constant is a flags value of the generated flags type.
|
||||
|
||||
## Examples
|
||||
|
||||
Generate a flags type using `u8` as the bits type:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
struct Flags: u8 {
|
||||
const A = 1;
|
||||
const B = 1 << 1;
|
||||
const C = 0b0000_0100;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Flags types are private by default and accept standard visibility modifiers. Flags themselves
|
||||
are always public:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
pub struct Flags: u8 {
|
||||
// Constants are always `pub`
|
||||
const A = 1;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Flags may refer to other flags using their [`Flags::bits`] value:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
struct Flags: u8 {
|
||||
const A = 1;
|
||||
const B = 1 << 1;
|
||||
const AB = Flags::A.bits() | Flags::B.bits();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
A single `bitflags` invocation may include zero or more flags type declarations:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {}
|
||||
|
||||
bitflags! {
|
||||
struct Flags1: u8 {
|
||||
const A = 1;
|
||||
}
|
||||
|
||||
struct Flags2: u8 {
|
||||
const A = 1;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
# `impl` mode
|
||||
|
||||
A declaration that begins with `impl` will only generate methods and trait implementations for the
|
||||
`struct` defined outside of the `bitflags` macro.
|
||||
|
||||
The struct itself must be a newtype using the bits type as its field.
|
||||
|
||||
The syntax for `impl` mode is identical to `struct` mode besides the starting token.
|
||||
|
||||
## Examples
|
||||
|
||||
Implement flags methods and traits for a custom flags type using `u8` as its underlying bits type:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
struct Flags(u8);
|
||||
|
||||
bitflags! {
|
||||
impl Flags: u8 {
|
||||
const A = 1;
|
||||
const B = 1 << 1;
|
||||
const C = 0b0000_0100;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
# Named and unnamed flags
|
||||
|
||||
Constants in the body of a declaration are flags. The identifier of the constant is the name of
|
||||
the flag. If the identifier is `_`, then the flag is unnamed. Unnamed flags don't appear in the
|
||||
generated API, but affect how bits are truncated.
|
||||
|
||||
## Examples
|
||||
|
||||
Adding an unnamed flag that makes all bits known:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
struct Flags: u8 {
|
||||
const A = 1;
|
||||
const B = 1 << 1;
|
||||
|
||||
const _ = !0;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Flags types may define multiple unnamed flags:
|
||||
|
||||
```
|
||||
# use bitflags::bitflags;
|
||||
bitflags! {
|
||||
struct Flags: u8 {
|
||||
const _ = 1;
|
||||
const _ = 1 << 1;
|
||||
}
|
||||
}
|
||||
```
|
||||
*/
|
||||
#[macro_export]
|
||||
macro_rules! bitflags {
|
||||
(
|
||||
$(#[$outer:meta])*
|
||||
$vis:vis struct $BitFlags:ident: $T:ty {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt = $value:expr;
|
||||
)*
|
||||
}
|
||||
|
||||
$($t:tt)*
|
||||
) => {
|
||||
// Declared in the scope of the `bitflags!` call
|
||||
// This type appears in the end-user's API
|
||||
$crate::__declare_public_bitflags! {
|
||||
$(#[$outer])*
|
||||
$vis struct $BitFlags
|
||||
}
|
||||
|
||||
// Workaround for: https://github.com/bitflags/bitflags/issues/320
|
||||
$crate::__impl_public_bitflags_consts! {
|
||||
$BitFlags: $T {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag = $value;
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(
|
||||
dead_code,
|
||||
deprecated,
|
||||
unused_doc_comments,
|
||||
unused_attributes,
|
||||
unused_mut,
|
||||
unused_imports,
|
||||
non_upper_case_globals,
|
||||
clippy::assign_op_pattern,
|
||||
clippy::indexing_slicing,
|
||||
clippy::same_name_method,
|
||||
clippy::iter_without_into_iter,
|
||||
)]
|
||||
const _: () = {
|
||||
// Declared in a "hidden" scope that can't be reached directly
|
||||
// These types don't appear in the end-user's API
|
||||
$crate::__declare_internal_bitflags! {
|
||||
$vis struct InternalBitFlags: $T
|
||||
}
|
||||
|
||||
$crate::__impl_internal_bitflags! {
|
||||
InternalBitFlags: $T, $BitFlags {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag = $value;
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
// This is where new library trait implementations can be added
|
||||
$crate::__impl_external_bitflags! {
|
||||
InternalBitFlags: $T, $BitFlags {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag;
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
$crate::__impl_public_bitflags_forward! {
|
||||
$BitFlags: $T, InternalBitFlags
|
||||
}
|
||||
|
||||
$crate::__impl_public_bitflags_ops! {
|
||||
$BitFlags
|
||||
}
|
||||
|
||||
$crate::__impl_public_bitflags_iter! {
|
||||
$BitFlags: $T, $BitFlags
|
||||
}
|
||||
};
|
||||
|
||||
$crate::bitflags! {
|
||||
$($t)*
|
||||
}
|
||||
};
|
||||
(
|
||||
impl $BitFlags:ident: $T:ty {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt = $value:expr;
|
||||
)*
|
||||
}
|
||||
|
||||
$($t:tt)*
|
||||
) => {
|
||||
$crate::__impl_public_bitflags_consts! {
|
||||
$BitFlags: $T {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag = $value;
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(
|
||||
dead_code,
|
||||
deprecated,
|
||||
unused_doc_comments,
|
||||
unused_attributes,
|
||||
unused_mut,
|
||||
unused_imports,
|
||||
non_upper_case_globals,
|
||||
clippy::assign_op_pattern,
|
||||
clippy::iter_without_into_iter,
|
||||
)]
|
||||
const _: () = {
|
||||
$crate::__impl_public_bitflags! {
|
||||
$BitFlags: $T, $BitFlags {
|
||||
$(
|
||||
$(#[$inner $($args)*])*
|
||||
const $Flag = $value;
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
$crate::__impl_public_bitflags_ops! {
|
||||
$BitFlags
|
||||
}
|
||||
|
||||
$crate::__impl_public_bitflags_iter! {
|
||||
$BitFlags: $T, $BitFlags
|
||||
}
|
||||
};
|
||||
|
||||
$crate::bitflags! {
|
||||
$($t)*
|
||||
}
|
||||
};
|
||||
() => {};
|
||||
}
|
||||
|
||||
/// Implement functions on bitflags types.
|
||||
///
|
||||
/// We need to be careful about adding new methods and trait implementations here because they
|
||||
/// could conflict with items added by the end-user.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __impl_bitflags {
|
||||
(
|
||||
$PublicBitFlags:ident: $T:ty {
|
||||
fn empty() $empty:block
|
||||
fn all() $all:block
|
||||
fn bits($bits0:ident) $bits:block
|
||||
fn from_bits($from_bits0:ident) $from_bits:block
|
||||
fn from_bits_truncate($from_bits_truncate0:ident) $from_bits_truncate:block
|
||||
fn from_bits_retain($from_bits_retain0:ident) $from_bits_retain:block
|
||||
fn from_name($from_name0:ident) $from_name:block
|
||||
fn is_empty($is_empty0:ident) $is_empty:block
|
||||
fn is_all($is_all0:ident) $is_all:block
|
||||
fn intersects($intersects0:ident, $intersects1:ident) $intersects:block
|
||||
fn contains($contains0:ident, $contains1:ident) $contains:block
|
||||
fn insert($insert0:ident, $insert1:ident) $insert:block
|
||||
fn remove($remove0:ident, $remove1:ident) $remove:block
|
||||
fn toggle($toggle0:ident, $toggle1:ident) $toggle:block
|
||||
fn set($set0:ident, $set1:ident, $set2:ident) $set:block
|
||||
fn intersection($intersection0:ident, $intersection1:ident) $intersection:block
|
||||
fn union($union0:ident, $union1:ident) $union:block
|
||||
fn difference($difference0:ident, $difference1:ident) $difference:block
|
||||
fn symmetric_difference($symmetric_difference0:ident, $symmetric_difference1:ident) $symmetric_difference:block
|
||||
fn complement($complement0:ident) $complement:block
|
||||
}
|
||||
) => {
|
||||
#[allow(dead_code, deprecated, unused_attributes)]
|
||||
impl $PublicBitFlags {
|
||||
/// Get a flags value with all bits unset.
|
||||
#[inline]
|
||||
pub const fn empty() -> Self {
|
||||
$empty
|
||||
}
|
||||
|
||||
/// Get a flags value with all known bits set.
|
||||
#[inline]
|
||||
pub const fn all() -> Self {
|
||||
$all
|
||||
}
|
||||
|
||||
/// Get the underlying bits value.
|
||||
///
|
||||
/// The returned value is exactly the bits set in this flags value.
|
||||
#[inline]
|
||||
pub const fn bits(&self) -> $T {
|
||||
let $bits0 = self;
|
||||
$bits
|
||||
}
|
||||
|
||||
/// Convert from a bits value.
|
||||
///
|
||||
/// This method will return `None` if any unknown bits are set.
|
||||
#[inline]
|
||||
pub const fn from_bits(bits: $T) -> $crate::__private::core::option::Option<Self> {
|
||||
let $from_bits0 = bits;
|
||||
$from_bits
|
||||
}
|
||||
|
||||
/// Convert from a bits value, unsetting any unknown bits.
|
||||
#[inline]
|
||||
pub const fn from_bits_truncate(bits: $T) -> Self {
|
||||
let $from_bits_truncate0 = bits;
|
||||
$from_bits_truncate
|
||||
}
|
||||
|
||||
/// Convert from a bits value exactly.
|
||||
#[inline]
|
||||
pub const fn from_bits_retain(bits: $T) -> Self {
|
||||
let $from_bits_retain0 = bits;
|
||||
$from_bits_retain
|
||||
}
|
||||
|
||||
/// 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.
|
||||
#[inline]
|
||||
pub fn from_name(name: &str) -> $crate::__private::core::option::Option<Self> {
|
||||
let $from_name0 = name;
|
||||
$from_name
|
||||
}
|
||||
|
||||
/// Whether all bits in this flags value are unset.
|
||||
#[inline]
|
||||
pub const fn is_empty(&self) -> bool {
|
||||
let $is_empty0 = self;
|
||||
$is_empty
|
||||
}
|
||||
|
||||
/// Whether all known bits in this flags value are set.
|
||||
#[inline]
|
||||
pub const fn is_all(&self) -> bool {
|
||||
let $is_all0 = self;
|
||||
$is_all
|
||||
}
|
||||
|
||||
/// Whether any set bits in a source flags value are also set in a target flags value.
|
||||
#[inline]
|
||||
pub const fn intersects(&self, other: Self) -> bool {
|
||||
let $intersects0 = self;
|
||||
let $intersects1 = other;
|
||||
$intersects
|
||||
}
|
||||
|
||||
/// Whether all set bits in a source flags value are also set in a target flags value.
|
||||
#[inline]
|
||||
pub const fn contains(&self, other: Self) -> bool {
|
||||
let $contains0 = self;
|
||||
let $contains1 = other;
|
||||
$contains
|
||||
}
|
||||
|
||||
/// The bitwise or (`|`) of the bits in two flags values.
|
||||
#[inline]
|
||||
pub fn insert(&mut self, other: Self) {
|
||||
let $insert0 = self;
|
||||
let $insert1 = other;
|
||||
$insert
|
||||
}
|
||||
|
||||
/// 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.
|
||||
#[inline]
|
||||
pub fn remove(&mut self, other: Self) {
|
||||
let $remove0 = self;
|
||||
let $remove1 = other;
|
||||
$remove
|
||||
}
|
||||
|
||||
/// The bitwise exclusive-or (`^`) of the bits in two flags values.
|
||||
#[inline]
|
||||
pub fn toggle(&mut self, other: Self) {
|
||||
let $toggle0 = self;
|
||||
let $toggle1 = other;
|
||||
$toggle
|
||||
}
|
||||
|
||||
/// Call `insert` when `value` is `true` or `remove` when `value` is `false`.
|
||||
#[inline]
|
||||
pub fn set(&mut self, other: Self, value: bool) {
|
||||
let $set0 = self;
|
||||
let $set1 = other;
|
||||
let $set2 = value;
|
||||
$set
|
||||
}
|
||||
|
||||
/// The bitwise and (`&`) of the bits in two flags values.
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub const fn intersection(self, other: Self) -> Self {
|
||||
let $intersection0 = self;
|
||||
let $intersection1 = other;
|
||||
$intersection
|
||||
}
|
||||
|
||||
/// The bitwise or (`|`) of the bits in two flags values.
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub const fn union(self, other: Self) -> Self {
|
||||
let $union0 = self;
|
||||
let $union1 = other;
|
||||
$union
|
||||
}
|
||||
|
||||
/// 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.
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub const fn difference(self, other: Self) -> Self {
|
||||
let $difference0 = self;
|
||||
let $difference1 = other;
|
||||
$difference
|
||||
}
|
||||
|
||||
/// The bitwise exclusive-or (`^`) of the bits in two flags values.
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub const fn symmetric_difference(self, other: Self) -> Self {
|
||||
let $symmetric_difference0 = self;
|
||||
let $symmetric_difference1 = other;
|
||||
$symmetric_difference
|
||||
}
|
||||
|
||||
/// The bitwise negation (`!`) of the bits in a flags value, truncating the result.
|
||||
#[inline]
|
||||
#[must_use]
|
||||
pub const fn complement(self) -> Self {
|
||||
let $complement0 = self;
|
||||
$complement
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// A macro that processed the input to `bitflags!` and shuffles attributes around
|
||||
/// based on whether or not they're "expression-safe".
|
||||
///
|
||||
/// This macro is a token-tree muncher that works on 2 levels:
|
||||
///
|
||||
/// For each attribute, we explicitly match on its identifier, like `cfg` to determine
|
||||
/// whether or not it should be considered expression-safe.
|
||||
///
|
||||
/// If you find yourself with an attribute that should be considered expression-safe
|
||||
/// and isn't, it can be added here.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __bitflags_expr_safe_attrs {
|
||||
// Entrypoint: Move all flags and all attributes into `unprocessed` lists
|
||||
// where they'll be munched one-at-a-time
|
||||
(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
{ $e:expr }
|
||||
) => {
|
||||
$crate::__bitflags_expr_safe_attrs! {
|
||||
expr: { $e },
|
||||
attrs: {
|
||||
// All attributes start here
|
||||
unprocessed: [$(#[$inner $($args)*])*],
|
||||
// Attributes that are safe on expressions go here
|
||||
processed: [],
|
||||
},
|
||||
}
|
||||
};
|
||||
// Process the next attribute on the current flag
|
||||
// `cfg`: The next flag should be propagated to expressions
|
||||
// NOTE: You can copy this rules block and replace `cfg` with
|
||||
// your attribute name that should be considered expression-safe
|
||||
(
|
||||
expr: { $e:expr },
|
||||
attrs: {
|
||||
unprocessed: [
|
||||
// cfg matched here
|
||||
#[cfg $($args:tt)*]
|
||||
$($attrs_rest:tt)*
|
||||
],
|
||||
processed: [$($expr:tt)*],
|
||||
},
|
||||
) => {
|
||||
$crate::__bitflags_expr_safe_attrs! {
|
||||
expr: { $e },
|
||||
attrs: {
|
||||
unprocessed: [
|
||||
$($attrs_rest)*
|
||||
],
|
||||
processed: [
|
||||
$($expr)*
|
||||
// cfg added here
|
||||
#[cfg $($args)*]
|
||||
],
|
||||
},
|
||||
}
|
||||
};
|
||||
// Process the next attribute on the current flag
|
||||
// `$other`: The next flag should not be propagated to expressions
|
||||
(
|
||||
expr: { $e:expr },
|
||||
attrs: {
|
||||
unprocessed: [
|
||||
// $other matched here
|
||||
#[$other:ident $($args:tt)*]
|
||||
$($attrs_rest:tt)*
|
||||
],
|
||||
processed: [$($expr:tt)*],
|
||||
},
|
||||
) => {
|
||||
$crate::__bitflags_expr_safe_attrs! {
|
||||
expr: { $e },
|
||||
attrs: {
|
||||
unprocessed: [
|
||||
$($attrs_rest)*
|
||||
],
|
||||
processed: [
|
||||
// $other not added here
|
||||
$($expr)*
|
||||
],
|
||||
},
|
||||
}
|
||||
};
|
||||
// Once all attributes on all flags are processed, generate the actual code
|
||||
(
|
||||
expr: { $e:expr },
|
||||
attrs: {
|
||||
unprocessed: [],
|
||||
processed: [$(#[$expr:ident $($exprargs:tt)*])*],
|
||||
},
|
||||
) => {
|
||||
$(#[$expr $($exprargs)*])*
|
||||
{ $e }
|
||||
}
|
||||
}
|
||||
|
||||
/// Implement a flag, which may be a wildcard `_`.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __bitflags_flag {
|
||||
(
|
||||
{
|
||||
name: _,
|
||||
named: { $($named:tt)* },
|
||||
unnamed: { $($unnamed:tt)* },
|
||||
}
|
||||
) => {
|
||||
$($unnamed)*
|
||||
};
|
||||
(
|
||||
{
|
||||
name: $Flag:ident,
|
||||
named: { $($named:tt)* },
|
||||
unnamed: { $($unnamed:tt)* },
|
||||
}
|
||||
) => {
|
||||
$($named)*
|
||||
};
|
||||
}
|
||||
|
||||
#[macro_use]
|
||||
mod public;
|
||||
#[macro_use]
|
||||
mod internal;
|
||||
#[macro_use]
|
||||
mod external;
|
||||
|
||||
#[cfg(feature = "example_generated")]
|
||||
pub mod example_generated;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
247
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/parser.rs
vendored
Normal file
247
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/parser.rs
vendored
Normal file
@@ -0,0 +1,247 @@
|
||||
/*!
|
||||
Parsing flags from text.
|
||||
|
||||
Format and parse a flags value as text using the following grammar:
|
||||
|
||||
- _Flags:_ (_Whitespace_ _Flag_ _Whitespace_)`|`*
|
||||
- _Flag:_ _Name_ | _Hex Number_
|
||||
- _Name:_ The name of any defined flag
|
||||
- _Hex Number_: `0x`([0-9a-fA-F])*
|
||||
- _Whitespace_: (\s)*
|
||||
|
||||
As an example, this is how `Flags::A | Flags::B | 0x0c` can be represented as text:
|
||||
|
||||
```text
|
||||
A | B | 0x0c
|
||||
```
|
||||
|
||||
Alternatively, it could be represented without whitespace:
|
||||
|
||||
```text
|
||||
A|B|0x0C
|
||||
```
|
||||
|
||||
Note that identifiers are *case-sensitive*, so the following is *not equivalent*:
|
||||
|
||||
```text
|
||||
a|b|0x0C
|
||||
```
|
||||
*/
|
||||
|
||||
#![allow(clippy::let_unit_value)]
|
||||
|
||||
use core::fmt::{self, Write};
|
||||
|
||||
use crate::{Bits, Flags};
|
||||
|
||||
/**
|
||||
Write a flags value as text.
|
||||
|
||||
Any bits that aren't part of a contained flag will be formatted as a hex number.
|
||||
*/
|
||||
pub fn to_writer<B: Flags>(flags: &B, mut writer: impl Write) -> Result<(), fmt::Error>
|
||||
where
|
||||
B::Bits: WriteHex,
|
||||
{
|
||||
// A formatter for bitflags that produces text output like:
|
||||
//
|
||||
// A | B | 0xf6
|
||||
//
|
||||
// The names of set flags are written in a bar-separated-format,
|
||||
// followed by a hex number of any remaining bits that are set
|
||||
// but don't correspond to any flags.
|
||||
|
||||
// Iterate over known flag values
|
||||
let mut first = true;
|
||||
let mut iter = flags.iter_names();
|
||||
for (name, _) in &mut iter {
|
||||
if !first {
|
||||
writer.write_str(" | ")?;
|
||||
}
|
||||
|
||||
first = false;
|
||||
writer.write_str(name)?;
|
||||
}
|
||||
|
||||
// Append any extra bits that correspond to flags to the end of the format
|
||||
let remaining = iter.remaining().bits();
|
||||
if remaining != B::Bits::EMPTY {
|
||||
if !first {
|
||||
writer.write_str(" | ")?;
|
||||
}
|
||||
|
||||
writer.write_str("0x")?;
|
||||
remaining.write_hex(writer)?;
|
||||
}
|
||||
|
||||
fmt::Result::Ok(())
|
||||
}
|
||||
|
||||
pub(crate) struct AsDisplay<'a, B>(pub(crate) &'a B);
|
||||
|
||||
impl<'a, B: Flags> fmt::Display for AsDisplay<'a, B>
|
||||
where
|
||||
B::Bits: WriteHex,
|
||||
{
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
to_writer(self.0, f)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Parse a flags value from text.
|
||||
|
||||
This function will fail on any names that don't correspond to defined flags.
|
||||
Unknown bits will be retained.
|
||||
*/
|
||||
pub fn from_str<B: Flags>(input: &str) -> Result<B, ParseError>
|
||||
where
|
||||
B::Bits: ParseHex,
|
||||
{
|
||||
let mut parsed_flags = B::empty();
|
||||
|
||||
// If the input is empty then return an empty set of flags
|
||||
if input.trim().is_empty() {
|
||||
return Ok(parsed_flags);
|
||||
}
|
||||
|
||||
for flag in input.split('|') {
|
||||
let flag = flag.trim();
|
||||
|
||||
// If the flag is empty then we've got missing input
|
||||
if flag.is_empty() {
|
||||
return Err(ParseError::empty_flag());
|
||||
}
|
||||
|
||||
// If the flag starts with `0x` then it's a hex number
|
||||
// Parse it directly to the underlying bits type
|
||||
let parsed_flag = if let Some(flag) = flag.strip_prefix("0x") {
|
||||
let bits =
|
||||
<B::Bits>::parse_hex(flag).map_err(|_| ParseError::invalid_hex_flag(flag))?;
|
||||
|
||||
B::from_bits_retain(bits)
|
||||
}
|
||||
// Otherwise the flag is a name
|
||||
// The generated flags type will determine whether
|
||||
// or not it's a valid identifier
|
||||
else {
|
||||
B::from_name(flag).ok_or_else(|| ParseError::invalid_named_flag(flag))?
|
||||
};
|
||||
|
||||
parsed_flags.insert(parsed_flag);
|
||||
}
|
||||
|
||||
Ok(parsed_flags)
|
||||
}
|
||||
|
||||
/**
|
||||
Encode a value as a hex string.
|
||||
|
||||
Implementors of this trait should not write the `0x` prefix.
|
||||
*/
|
||||
pub trait WriteHex {
|
||||
/// Write the value as hex.
|
||||
fn write_hex<W: fmt::Write>(&self, writer: W) -> fmt::Result;
|
||||
}
|
||||
|
||||
/**
|
||||
Parse a value from a hex string.
|
||||
*/
|
||||
pub trait ParseHex {
|
||||
/// Parse the value from hex.
|
||||
fn parse_hex(input: &str) -> Result<Self, ParseError>
|
||||
where
|
||||
Self: Sized;
|
||||
}
|
||||
|
||||
/// An error encountered while parsing flags from text.
|
||||
#[derive(Debug)]
|
||||
pub struct ParseError(ParseErrorKind);
|
||||
|
||||
#[derive(Debug)]
|
||||
#[allow(clippy::enum_variant_names)]
|
||||
enum ParseErrorKind {
|
||||
EmptyFlag,
|
||||
InvalidNamedFlag {
|
||||
#[cfg(not(feature = "std"))]
|
||||
got: (),
|
||||
#[cfg(feature = "std")]
|
||||
got: String,
|
||||
},
|
||||
InvalidHexFlag {
|
||||
#[cfg(not(feature = "std"))]
|
||||
got: (),
|
||||
#[cfg(feature = "std")]
|
||||
got: String,
|
||||
},
|
||||
}
|
||||
|
||||
impl ParseError {
|
||||
/// An invalid hex flag was encountered.
|
||||
pub fn invalid_hex_flag(flag: impl fmt::Display) -> Self {
|
||||
let _flag = flag;
|
||||
|
||||
let got = {
|
||||
#[cfg(feature = "std")]
|
||||
{
|
||||
_flag.to_string()
|
||||
}
|
||||
};
|
||||
|
||||
ParseError(ParseErrorKind::InvalidHexFlag { got })
|
||||
}
|
||||
|
||||
/// A named flag that doesn't correspond to any on the flags type was encountered.
|
||||
pub fn invalid_named_flag(flag: impl fmt::Display) -> Self {
|
||||
let _flag = flag;
|
||||
|
||||
let got = {
|
||||
#[cfg(feature = "std")]
|
||||
{
|
||||
_flag.to_string()
|
||||
}
|
||||
};
|
||||
|
||||
ParseError(ParseErrorKind::InvalidNamedFlag { got })
|
||||
}
|
||||
|
||||
/// A hex or named flag wasn't found between separators.
|
||||
pub const fn empty_flag() -> Self {
|
||||
ParseError(ParseErrorKind::EmptyFlag)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for ParseError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match &self.0 {
|
||||
ParseErrorKind::InvalidNamedFlag { got } => {
|
||||
let _got = got;
|
||||
|
||||
write!(f, "unrecognized named flag")?;
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
{
|
||||
write!(f, " `{}`", _got)?;
|
||||
}
|
||||
}
|
||||
ParseErrorKind::InvalidHexFlag { got } => {
|
||||
let _got = got;
|
||||
|
||||
write!(f, "invalid hex flag")?;
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
{
|
||||
write!(f, " `{}`", _got)?;
|
||||
}
|
||||
}
|
||||
ParseErrorKind::EmptyFlag => {
|
||||
write!(f, "encountered empty flag")?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "std")]
|
||||
impl std::error::Error for ParseError {}
|
547
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/public.rs
vendored
Normal file
547
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/public.rs
vendored
Normal file
@@ -0,0 +1,547 @@
|
||||
//! Generate the user-facing flags type.
|
||||
//!
|
||||
//! The code here belongs to the end-user, so new trait implementations and methods can't be
|
||||
//! added without potentially breaking users.
|
||||
|
||||
/// Declare the user-facing bitflags struct.
|
||||
///
|
||||
/// This type is guaranteed to be a newtype with a `bitflags`-facing type as its single field.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __declare_public_bitflags {
|
||||
(
|
||||
$(#[$outer:meta])*
|
||||
$vis:vis struct $PublicBitFlags:ident
|
||||
) => {
|
||||
$(#[$outer])*
|
||||
$vis struct $PublicBitFlags(<$PublicBitFlags as $crate::__private::PublicFlags>::Internal);
|
||||
};
|
||||
}
|
||||
|
||||
/// Implement functions on the public (user-facing) bitflags type.
|
||||
///
|
||||
/// We need to be careful about adding new methods and trait implementations here because they
|
||||
/// could conflict with items added by the end-user.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __impl_public_bitflags_forward {
|
||||
(
|
||||
$PublicBitFlags:ident: $T:ty, $InternalBitFlags:ident
|
||||
) => {
|
||||
$crate::__impl_bitflags! {
|
||||
$PublicBitFlags: $T {
|
||||
fn empty() {
|
||||
Self($InternalBitFlags::empty())
|
||||
}
|
||||
|
||||
fn all() {
|
||||
Self($InternalBitFlags::all())
|
||||
}
|
||||
|
||||
fn bits(f) {
|
||||
f.0.bits()
|
||||
}
|
||||
|
||||
fn from_bits(bits) {
|
||||
match $InternalBitFlags::from_bits(bits) {
|
||||
$crate::__private::core::option::Option::Some(bits) => $crate::__private::core::option::Option::Some(Self(bits)),
|
||||
$crate::__private::core::option::Option::None => $crate::__private::core::option::Option::None,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_bits_truncate(bits) {
|
||||
Self($InternalBitFlags::from_bits_truncate(bits))
|
||||
}
|
||||
|
||||
fn from_bits_retain(bits) {
|
||||
Self($InternalBitFlags::from_bits_retain(bits))
|
||||
}
|
||||
|
||||
fn from_name(name) {
|
||||
match $InternalBitFlags::from_name(name) {
|
||||
$crate::__private::core::option::Option::Some(bits) => $crate::__private::core::option::Option::Some(Self(bits)),
|
||||
$crate::__private::core::option::Option::None => $crate::__private::core::option::Option::None,
|
||||
}
|
||||
}
|
||||
|
||||
fn is_empty(f) {
|
||||
f.0.is_empty()
|
||||
}
|
||||
|
||||
fn is_all(f) {
|
||||
f.0.is_all()
|
||||
}
|
||||
|
||||
fn intersects(f, other) {
|
||||
f.0.intersects(other.0)
|
||||
}
|
||||
|
||||
fn contains(f, other) {
|
||||
f.0.contains(other.0)
|
||||
}
|
||||
|
||||
fn insert(f, other) {
|
||||
f.0.insert(other.0)
|
||||
}
|
||||
|
||||
fn remove(f, other) {
|
||||
f.0.remove(other.0)
|
||||
}
|
||||
|
||||
fn toggle(f, other) {
|
||||
f.0.toggle(other.0)
|
||||
}
|
||||
|
||||
fn set(f, other, value) {
|
||||
f.0.set(other.0, value)
|
||||
}
|
||||
|
||||
fn intersection(f, other) {
|
||||
Self(f.0.intersection(other.0))
|
||||
}
|
||||
|
||||
fn union(f, other) {
|
||||
Self(f.0.union(other.0))
|
||||
}
|
||||
|
||||
fn difference(f, other) {
|
||||
Self(f.0.difference(other.0))
|
||||
}
|
||||
|
||||
fn symmetric_difference(f, other) {
|
||||
Self(f.0.symmetric_difference(other.0))
|
||||
}
|
||||
|
||||
fn complement(f) {
|
||||
Self(f.0.complement())
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Implement functions on the public (user-facing) bitflags type.
|
||||
///
|
||||
/// We need to be careful about adding new methods and trait implementations here because they
|
||||
/// could conflict with items added by the end-user.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __impl_public_bitflags {
|
||||
(
|
||||
$BitFlags:ident: $T:ty, $PublicBitFlags:ident {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt = $value:expr;
|
||||
)*
|
||||
}
|
||||
) => {
|
||||
$crate::__impl_bitflags! {
|
||||
$BitFlags: $T {
|
||||
fn empty() {
|
||||
Self(<$T as $crate::Bits>::EMPTY)
|
||||
}
|
||||
|
||||
fn all() {
|
||||
let mut truncated = <$T as $crate::Bits>::EMPTY;
|
||||
let mut i = 0;
|
||||
|
||||
$(
|
||||
$crate::__bitflags_expr_safe_attrs!(
|
||||
$(#[$inner $($args)*])*
|
||||
{{
|
||||
let flag = <$PublicBitFlags as $crate::Flags>::FLAGS[i].value().bits();
|
||||
|
||||
truncated = truncated | flag;
|
||||
i += 1;
|
||||
}}
|
||||
);
|
||||
)*
|
||||
|
||||
let _ = i;
|
||||
Self::from_bits_retain(truncated)
|
||||
}
|
||||
|
||||
fn bits(f) {
|
||||
f.0
|
||||
}
|
||||
|
||||
fn from_bits(bits) {
|
||||
let truncated = Self::from_bits_truncate(bits).0;
|
||||
|
||||
if truncated == bits {
|
||||
$crate::__private::core::option::Option::Some(Self(bits))
|
||||
} else {
|
||||
$crate::__private::core::option::Option::None
|
||||
}
|
||||
}
|
||||
|
||||
fn from_bits_truncate(bits) {
|
||||
Self(bits & Self::all().bits())
|
||||
}
|
||||
|
||||
fn from_bits_retain(bits) {
|
||||
Self(bits)
|
||||
}
|
||||
|
||||
fn from_name(name) {
|
||||
$(
|
||||
$crate::__bitflags_flag!({
|
||||
name: $Flag,
|
||||
named: {
|
||||
$crate::__bitflags_expr_safe_attrs!(
|
||||
$(#[$inner $($args)*])*
|
||||
{
|
||||
if name == $crate::__private::core::stringify!($Flag) {
|
||||
return $crate::__private::core::option::Option::Some(Self($PublicBitFlags::$Flag.bits()));
|
||||
}
|
||||
}
|
||||
);
|
||||
},
|
||||
unnamed: {},
|
||||
});
|
||||
)*
|
||||
|
||||
let _ = name;
|
||||
$crate::__private::core::option::Option::None
|
||||
}
|
||||
|
||||
fn is_empty(f) {
|
||||
f.bits() == <$T as $crate::Bits>::EMPTY
|
||||
}
|
||||
|
||||
fn is_all(f) {
|
||||
// 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() | f.bits() == f.bits()
|
||||
}
|
||||
|
||||
fn intersects(f, other) {
|
||||
f.bits() & other.bits() != <$T as $crate::Bits>::EMPTY
|
||||
}
|
||||
|
||||
fn contains(f, other) {
|
||||
f.bits() & other.bits() == other.bits()
|
||||
}
|
||||
|
||||
fn insert(f, other) {
|
||||
*f = Self::from_bits_retain(f.bits()).union(other);
|
||||
}
|
||||
|
||||
fn remove(f, other) {
|
||||
*f = Self::from_bits_retain(f.bits()).difference(other);
|
||||
}
|
||||
|
||||
fn toggle(f, other) {
|
||||
*f = Self::from_bits_retain(f.bits()).symmetric_difference(other);
|
||||
}
|
||||
|
||||
fn set(f, other, value) {
|
||||
if value {
|
||||
f.insert(other);
|
||||
} else {
|
||||
f.remove(other);
|
||||
}
|
||||
}
|
||||
|
||||
fn intersection(f, other) {
|
||||
Self::from_bits_retain(f.bits() & other.bits())
|
||||
}
|
||||
|
||||
fn union(f, other) {
|
||||
Self::from_bits_retain(f.bits() | other.bits())
|
||||
}
|
||||
|
||||
fn difference(f, other) {
|
||||
Self::from_bits_retain(f.bits() & !other.bits())
|
||||
}
|
||||
|
||||
fn symmetric_difference(f, other) {
|
||||
Self::from_bits_retain(f.bits() ^ other.bits())
|
||||
}
|
||||
|
||||
fn complement(f) {
|
||||
Self::from_bits_truncate(!f.bits())
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Implement iterators on the public (user-facing) bitflags type.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __impl_public_bitflags_iter {
|
||||
($BitFlags:ident: $T:ty, $PublicBitFlags:ident) => {
|
||||
impl $BitFlags {
|
||||
/// 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.
|
||||
#[inline]
|
||||
pub const fn iter(&self) -> $crate::iter::Iter<$PublicBitFlags> {
|
||||
$crate::iter::Iter::__private_const_new(
|
||||
<$PublicBitFlags as $crate::Flags>::FLAGS,
|
||||
$PublicBitFlags::from_bits_retain(self.bits()),
|
||||
$PublicBitFlags::from_bits_retain(self.bits()),
|
||||
)
|
||||
}
|
||||
|
||||
/// Yield a set of contained named flags values.
|
||||
///
|
||||
/// This method is like [`iter`](#method.iter), except only yields bits in contained named flags.
|
||||
/// Any unknown bits, or bits not corresponding to a contained flag will not be yielded.
|
||||
#[inline]
|
||||
pub const fn iter_names(&self) -> $crate::iter::IterNames<$PublicBitFlags> {
|
||||
$crate::iter::IterNames::__private_const_new(
|
||||
<$PublicBitFlags as $crate::Flags>::FLAGS,
|
||||
$PublicBitFlags::from_bits_retain(self.bits()),
|
||||
$PublicBitFlags::from_bits_retain(self.bits()),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::iter::IntoIterator for $BitFlags {
|
||||
type Item = $PublicBitFlags;
|
||||
type IntoIter = $crate::iter::Iter<$PublicBitFlags>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
self.iter()
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Implement traits on the public (user-facing) bitflags type.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __impl_public_bitflags_ops {
|
||||
($PublicBitFlags:ident) => {
|
||||
impl $crate::__private::core::fmt::Binary for $PublicBitFlags {
|
||||
fn fmt(
|
||||
&self,
|
||||
f: &mut $crate::__private::core::fmt::Formatter,
|
||||
) -> $crate::__private::core::fmt::Result {
|
||||
let inner = self.0;
|
||||
$crate::__private::core::fmt::Binary::fmt(&inner, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::fmt::Octal for $PublicBitFlags {
|
||||
fn fmt(
|
||||
&self,
|
||||
f: &mut $crate::__private::core::fmt::Formatter,
|
||||
) -> $crate::__private::core::fmt::Result {
|
||||
let inner = self.0;
|
||||
$crate::__private::core::fmt::Octal::fmt(&inner, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::fmt::LowerHex for $PublicBitFlags {
|
||||
fn fmt(
|
||||
&self,
|
||||
f: &mut $crate::__private::core::fmt::Formatter,
|
||||
) -> $crate::__private::core::fmt::Result {
|
||||
let inner = self.0;
|
||||
$crate::__private::core::fmt::LowerHex::fmt(&inner, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::fmt::UpperHex for $PublicBitFlags {
|
||||
fn fmt(
|
||||
&self,
|
||||
f: &mut $crate::__private::core::fmt::Formatter,
|
||||
) -> $crate::__private::core::fmt::Result {
|
||||
let inner = self.0;
|
||||
$crate::__private::core::fmt::UpperHex::fmt(&inner, f)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::BitOr for $PublicBitFlags {
|
||||
type Output = Self;
|
||||
|
||||
/// The bitwise or (`|`) of the bits in two flags values.
|
||||
#[inline]
|
||||
fn bitor(self, other: $PublicBitFlags) -> Self {
|
||||
self.union(other)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::BitOrAssign for $PublicBitFlags {
|
||||
/// The bitwise or (`|`) of the bits in two flags values.
|
||||
#[inline]
|
||||
fn bitor_assign(&mut self, other: Self) {
|
||||
self.insert(other);
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::BitXor for $PublicBitFlags {
|
||||
type Output = Self;
|
||||
|
||||
/// The bitwise exclusive-or (`^`) of the bits in two flags values.
|
||||
#[inline]
|
||||
fn bitxor(self, other: Self) -> Self {
|
||||
self.symmetric_difference(other)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::BitXorAssign for $PublicBitFlags {
|
||||
/// The bitwise exclusive-or (`^`) of the bits in two flags values.
|
||||
#[inline]
|
||||
fn bitxor_assign(&mut self, other: Self) {
|
||||
self.toggle(other);
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::BitAnd for $PublicBitFlags {
|
||||
type Output = Self;
|
||||
|
||||
/// The bitwise and (`&`) of the bits in two flags values.
|
||||
#[inline]
|
||||
fn bitand(self, other: Self) -> Self {
|
||||
self.intersection(other)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::BitAndAssign for $PublicBitFlags {
|
||||
/// The bitwise and (`&`) of the bits in two flags values.
|
||||
#[inline]
|
||||
fn bitand_assign(&mut self, other: Self) {
|
||||
*self = Self::from_bits_retain(self.bits()).intersection(other);
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::Sub for $PublicBitFlags {
|
||||
type Output = Self;
|
||||
|
||||
/// 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.
|
||||
#[inline]
|
||||
fn sub(self, other: Self) -> Self {
|
||||
self.difference(other)
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::SubAssign for $PublicBitFlags {
|
||||
/// 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.
|
||||
#[inline]
|
||||
fn sub_assign(&mut self, other: Self) {
|
||||
self.remove(other);
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::ops::Not for $PublicBitFlags {
|
||||
type Output = Self;
|
||||
|
||||
/// The bitwise negation (`!`) of the bits in a flags value, truncating the result.
|
||||
#[inline]
|
||||
fn not(self) -> Self {
|
||||
self.complement()
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::iter::Extend<$PublicBitFlags> for $PublicBitFlags {
|
||||
/// The bitwise or (`|`) of the bits in each flags value.
|
||||
fn extend<T: $crate::__private::core::iter::IntoIterator<Item = Self>>(
|
||||
&mut self,
|
||||
iterator: T,
|
||||
) {
|
||||
for item in iterator {
|
||||
self.insert(item)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl $crate::__private::core::iter::FromIterator<$PublicBitFlags> for $PublicBitFlags {
|
||||
/// The bitwise or (`|`) of the bits in each flags value.
|
||||
fn from_iter<T: $crate::__private::core::iter::IntoIterator<Item = Self>>(
|
||||
iterator: T,
|
||||
) -> Self {
|
||||
use $crate::__private::core::iter::Extend;
|
||||
|
||||
let mut result = Self::empty();
|
||||
result.extend(iterator);
|
||||
result
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Implement constants on the public (user-facing) bitflags type.
|
||||
#[macro_export]
|
||||
#[doc(hidden)]
|
||||
macro_rules! __impl_public_bitflags_consts {
|
||||
(
|
||||
$PublicBitFlags:ident: $T:ty {
|
||||
$(
|
||||
$(#[$inner:ident $($args:tt)*])*
|
||||
const $Flag:tt = $value:expr;
|
||||
)*
|
||||
}
|
||||
) => {
|
||||
impl $PublicBitFlags {
|
||||
$(
|
||||
$crate::__bitflags_flag!({
|
||||
name: $Flag,
|
||||
named: {
|
||||
$(#[$inner $($args)*])*
|
||||
#[allow(
|
||||
deprecated,
|
||||
non_upper_case_globals,
|
||||
)]
|
||||
pub const $Flag: Self = Self::from_bits_retain($value);
|
||||
},
|
||||
unnamed: {},
|
||||
});
|
||||
)*
|
||||
}
|
||||
|
||||
impl $crate::Flags for $PublicBitFlags {
|
||||
const FLAGS: &'static [$crate::Flag<$PublicBitFlags>] = &[
|
||||
$(
|
||||
$crate::__bitflags_flag!({
|
||||
name: $Flag,
|
||||
named: {
|
||||
$crate::__bitflags_expr_safe_attrs!(
|
||||
$(#[$inner $($args)*])*
|
||||
{
|
||||
#[allow(
|
||||
deprecated,
|
||||
non_upper_case_globals,
|
||||
)]
|
||||
$crate::Flag::new($crate::__private::core::stringify!($Flag), $PublicBitFlags::$Flag)
|
||||
}
|
||||
)
|
||||
},
|
||||
unnamed: {
|
||||
$crate::__bitflags_expr_safe_attrs!(
|
||||
$(#[$inner $($args)*])*
|
||||
{
|
||||
#[allow(
|
||||
deprecated,
|
||||
non_upper_case_globals,
|
||||
)]
|
||||
$crate::Flag::new("", $PublicBitFlags::from_bits_retain($value))
|
||||
}
|
||||
)
|
||||
},
|
||||
}),
|
||||
)*
|
||||
];
|
||||
|
||||
type Bits = $T;
|
||||
|
||||
fn bits(&self) -> $T {
|
||||
$PublicBitFlags::bits(self)
|
||||
}
|
||||
|
||||
fn from_bits_retain(bits: $T) -> $PublicBitFlags {
|
||||
$PublicBitFlags::from_bits_retain(bits)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
131
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests.rs
vendored
Normal file
131
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests.rs
vendored
Normal file
@@ -0,0 +1,131 @@
|
||||
mod all;
|
||||
mod bits;
|
||||
mod complement;
|
||||
mod contains;
|
||||
mod difference;
|
||||
mod empty;
|
||||
mod eq;
|
||||
mod extend;
|
||||
mod flags;
|
||||
mod fmt;
|
||||
mod from_bits;
|
||||
mod from_bits_retain;
|
||||
mod from_bits_truncate;
|
||||
mod from_name;
|
||||
mod insert;
|
||||
mod intersection;
|
||||
mod intersects;
|
||||
mod is_all;
|
||||
mod is_empty;
|
||||
mod iter;
|
||||
mod parser;
|
||||
mod remove;
|
||||
mod symmetric_difference;
|
||||
mod union;
|
||||
|
||||
bitflags! {
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestFlags: u8 {
|
||||
/// 1
|
||||
const A = 1;
|
||||
|
||||
/// 1 << 1
|
||||
const B = 1 << 1;
|
||||
|
||||
/// 1 << 2
|
||||
const C = 1 << 2;
|
||||
|
||||
/// 1 | (1 << 1) | (1 << 2)
|
||||
const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestFlagsInvert: u8 {
|
||||
/// 1 | (1 << 1) | (1 << 2)
|
||||
const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
|
||||
|
||||
/// 1
|
||||
const A = 1;
|
||||
|
||||
/// 1 << 1
|
||||
const B = 1 << 1;
|
||||
|
||||
/// 1 << 2
|
||||
const C = 1 << 2;
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestZero: u8 {
|
||||
/// 0
|
||||
const ZERO = 0;
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestZeroOne: u8 {
|
||||
/// 0
|
||||
const ZERO = 0;
|
||||
|
||||
/// 1
|
||||
const ONE = 1;
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestUnicode: u8 {
|
||||
/// 1
|
||||
const 一 = 1;
|
||||
|
||||
/// 2
|
||||
const 二 = 1 << 1;
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestEmpty: u8 {}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestOverlapping: u8 {
|
||||
/// 1 | (1 << 1)
|
||||
const AB = 1 | (1 << 1);
|
||||
|
||||
/// (1 << 1) | (1 << 2)
|
||||
const BC = (1 << 1) | (1 << 2);
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestOverlappingFull: u8 {
|
||||
/// 1
|
||||
const A = 1;
|
||||
|
||||
/// 1
|
||||
const B = 1;
|
||||
|
||||
/// 1
|
||||
const C = 1;
|
||||
|
||||
/// 2
|
||||
const D = 1 << 1;
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestExternal: u8 {
|
||||
/// 1
|
||||
const A = 1;
|
||||
|
||||
/// 1 << 1
|
||||
const B = 1 << 1;
|
||||
|
||||
/// 1 << 2
|
||||
const C = 1 << 2;
|
||||
|
||||
/// 1 | (1 << 1) | (1 << 2)
|
||||
const ABC = Self::A.bits() | Self::B.bits() | Self::C.bits();
|
||||
|
||||
/// External
|
||||
const _ = !0;
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
|
||||
pub struct TestExternalFull: u8 {
|
||||
/// External
|
||||
const _ = !0;
|
||||
}
|
||||
}
|
23
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/all.rs
vendored
Normal file
23
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/all.rs
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(1 | 1 << 1 | 1 << 2, TestFlags::all);
|
||||
|
||||
case(0, TestZero::all);
|
||||
|
||||
case(0, TestEmpty::all);
|
||||
|
||||
case(!0, TestExternal::all);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags>(expected: T::Bits, inherent: impl FnOnce() -> T)
|
||||
where
|
||||
<T as Flags>::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(expected, inherent().bits(), "T::all()");
|
||||
assert_eq!(expected, T::all().bits(), "Flags::all()");
|
||||
}
|
36
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/bits.rs
vendored
Normal file
36
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/bits.rs
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(0, TestFlags::empty(), TestFlags::bits);
|
||||
|
||||
case(1, TestFlags::A, TestFlags::bits);
|
||||
case(1 | 1 << 1 | 1 << 2, TestFlags::ABC, TestFlags::bits);
|
||||
|
||||
case(!0, TestFlags::from_bits_retain(u8::MAX), TestFlags::bits);
|
||||
case(1 << 3, TestFlags::from_bits_retain(1 << 3), TestFlags::bits);
|
||||
|
||||
case(1 << 3, TestZero::from_bits_retain(1 << 3), TestZero::bits);
|
||||
|
||||
case(1 << 3, TestEmpty::from_bits_retain(1 << 3), TestEmpty::bits);
|
||||
|
||||
case(
|
||||
1 << 4 | 1 << 6,
|
||||
TestExternal::from_bits_retain(1 << 4 | 1 << 6),
|
||||
TestExternal::bits,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug>(
|
||||
expected: T::Bits,
|
||||
value: T,
|
||||
inherent: impl FnOnce(&T) -> T::Bits,
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(expected, inherent(&value), "{:?}.bits()", value);
|
||||
assert_eq!(expected, Flags::bits(&value), "Flags::bits({:?})", value);
|
||||
}
|
53
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/complement.rs
vendored
Normal file
53
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/complement.rs
vendored
Normal file
@@ -0,0 +1,53 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(0, TestFlags::all(), TestFlags::complement);
|
||||
case(0, TestFlags::from_bits_retain(!0), TestFlags::complement);
|
||||
|
||||
case(1 | 1 << 1, TestFlags::C, TestFlags::complement);
|
||||
case(
|
||||
1 | 1 << 1,
|
||||
TestFlags::C | TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::complement,
|
||||
);
|
||||
|
||||
case(
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
TestFlags::empty(),
|
||||
TestFlags::complement,
|
||||
);
|
||||
case(
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::complement,
|
||||
);
|
||||
|
||||
case(0, TestZero::empty(), TestZero::complement);
|
||||
|
||||
case(0, TestEmpty::empty(), TestEmpty::complement);
|
||||
|
||||
case(1 << 2, TestOverlapping::AB, TestOverlapping::complement);
|
||||
|
||||
case(!0, TestExternal::empty(), TestExternal::complement);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + std::ops::Not<Output = T> + Copy>(
|
||||
expected: T::Bits,
|
||||
value: T,
|
||||
inherent: impl FnOnce(T) -> T,
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(expected, inherent(value).bits(), "{:?}.complement()", value);
|
||||
assert_eq!(
|
||||
expected,
|
||||
Flags::complement(value).bits(),
|
||||
"Flags::complement({:?})",
|
||||
value
|
||||
);
|
||||
assert_eq!(expected, (!value).bits(), "!{:?}", value);
|
||||
}
|
108
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/contains.rs
vendored
Normal file
108
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/contains.rs
vendored
Normal file
@@ -0,0 +1,108 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(
|
||||
TestFlags::empty(),
|
||||
&[
|
||||
(TestFlags::empty(), true),
|
||||
(TestFlags::A, false),
|
||||
(TestFlags::B, false),
|
||||
(TestFlags::C, false),
|
||||
(TestFlags::from_bits_retain(1 << 3), false),
|
||||
],
|
||||
TestFlags::contains,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::A,
|
||||
&[
|
||||
(TestFlags::empty(), true),
|
||||
(TestFlags::A, true),
|
||||
(TestFlags::B, false),
|
||||
(TestFlags::C, false),
|
||||
(TestFlags::ABC, false),
|
||||
(TestFlags::from_bits_retain(1 << 3), false),
|
||||
(TestFlags::from_bits_retain(1 | (1 << 3)), false),
|
||||
],
|
||||
TestFlags::contains,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::ABC,
|
||||
&[
|
||||
(TestFlags::empty(), true),
|
||||
(TestFlags::A, true),
|
||||
(TestFlags::B, true),
|
||||
(TestFlags::C, true),
|
||||
(TestFlags::ABC, true),
|
||||
(TestFlags::from_bits_retain(1 << 3), false),
|
||||
],
|
||||
TestFlags::contains,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::from_bits_retain(1 << 3),
|
||||
&[
|
||||
(TestFlags::empty(), true),
|
||||
(TestFlags::A, false),
|
||||
(TestFlags::B, false),
|
||||
(TestFlags::C, false),
|
||||
(TestFlags::from_bits_retain(1 << 3), true),
|
||||
],
|
||||
TestFlags::contains,
|
||||
);
|
||||
|
||||
case(
|
||||
TestZero::ZERO,
|
||||
&[(TestZero::ZERO, true)],
|
||||
TestZero::contains,
|
||||
);
|
||||
|
||||
case(
|
||||
TestOverlapping::AB,
|
||||
&[
|
||||
(TestOverlapping::AB, true),
|
||||
(TestOverlapping::BC, false),
|
||||
(TestOverlapping::from_bits_retain(1 << 1), true),
|
||||
],
|
||||
TestOverlapping::contains,
|
||||
);
|
||||
|
||||
case(
|
||||
TestExternal::all(),
|
||||
&[
|
||||
(TestExternal::A, true),
|
||||
(TestExternal::B, true),
|
||||
(TestExternal::C, true),
|
||||
(TestExternal::from_bits_retain(1 << 5 | 1 << 7), true),
|
||||
],
|
||||
TestExternal::contains,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + Copy>(
|
||||
value: T,
|
||||
inputs: &[(T, bool)],
|
||||
mut inherent: impl FnMut(&T, T) -> bool,
|
||||
) {
|
||||
for (input, expected) in inputs {
|
||||
assert_eq!(
|
||||
*expected,
|
||||
inherent(&value, *input),
|
||||
"{:?}.contains({:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
Flags::contains(&value, *input),
|
||||
"Flags::contains({:?}, {:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
}
|
||||
}
|
92
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/difference.rs
vendored
Normal file
92
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/difference.rs
vendored
Normal file
@@ -0,0 +1,92 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(
|
||||
TestFlags::A | TestFlags::B,
|
||||
&[
|
||||
(TestFlags::A, 1 << 1),
|
||||
(TestFlags::B, 1),
|
||||
(TestFlags::from_bits_retain(1 << 3), 1 | 1 << 1),
|
||||
],
|
||||
TestFlags::difference,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::from_bits_retain(1 | 1 << 3),
|
||||
&[
|
||||
(TestFlags::A, 1 << 3),
|
||||
(TestFlags::from_bits_retain(1 << 3), 1),
|
||||
],
|
||||
TestFlags::difference,
|
||||
);
|
||||
|
||||
case(
|
||||
TestExternal::from_bits_retain(!0),
|
||||
&[(TestExternal::A, 0b1111_1110)],
|
||||
TestExternal::difference,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
0b1111_1110,
|
||||
(TestExternal::from_bits_retain(!0) & !TestExternal::A).bits()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
0b1111_1110,
|
||||
(TestFlags::from_bits_retain(!0).difference(TestFlags::A)).bits()
|
||||
);
|
||||
|
||||
// The `!` operator unsets bits that don't correspond to known flags
|
||||
assert_eq!(
|
||||
1 << 1 | 1 << 2,
|
||||
(TestFlags::from_bits_retain(!0) & !TestFlags::A).bits()
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + std::ops::Sub<Output = T> + std::ops::SubAssign + Copy>(
|
||||
value: T,
|
||||
inputs: &[(T, T::Bits)],
|
||||
mut inherent: impl FnMut(T, T) -> T,
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq + Copy,
|
||||
{
|
||||
for (input, expected) in inputs {
|
||||
assert_eq!(
|
||||
*expected,
|
||||
inherent(value, *input).bits(),
|
||||
"{:?}.difference({:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
Flags::difference(value, *input).bits(),
|
||||
"Flags::difference({:?}, {:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
(value - *input).bits(),
|
||||
"{:?} - {:?}",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
value -= *input;
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?} -= {:?}",
|
||||
value,
|
||||
input,
|
||||
);
|
||||
}
|
||||
}
|
23
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/empty.rs
vendored
Normal file
23
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/empty.rs
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(0, TestFlags::empty);
|
||||
|
||||
case(0, TestZero::empty);
|
||||
|
||||
case(0, TestEmpty::empty);
|
||||
|
||||
case(0, TestExternal::empty);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags>(expected: T::Bits, inherent: impl FnOnce() -> T)
|
||||
where
|
||||
<T as Flags>::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(expected, inherent().bits(), "T::empty()");
|
||||
assert_eq!(expected, T::empty().bits(), "Flags::empty()");
|
||||
}
|
10
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/eq.rs
vendored
Normal file
10
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/eq.rs
vendored
Normal file
@@ -0,0 +1,10 @@
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
assert_eq!(TestFlags::empty(), TestFlags::empty());
|
||||
assert_eq!(TestFlags::all(), TestFlags::all());
|
||||
|
||||
assert!(TestFlags::from_bits_retain(1) < TestFlags::from_bits_retain(2));
|
||||
assert!(TestFlags::from_bits_retain(2) > TestFlags::from_bits_retain(1));
|
||||
}
|
42
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/extend.rs
vendored
Normal file
42
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/extend.rs
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
let mut flags = TestFlags::empty();
|
||||
|
||||
flags.extend(TestFlags::A);
|
||||
|
||||
assert_eq!(TestFlags::A, flags);
|
||||
|
||||
flags.extend(TestFlags::A | TestFlags::B | TestFlags::C);
|
||||
|
||||
assert_eq!(TestFlags::ABC, flags);
|
||||
|
||||
flags.extend(TestFlags::from_bits_retain(1 << 5));
|
||||
|
||||
assert_eq!(TestFlags::ABC | TestFlags::from_bits_retain(1 << 5), flags);
|
||||
}
|
||||
|
||||
mod external {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
let mut flags = TestExternal::empty();
|
||||
|
||||
flags.extend(TestExternal::A);
|
||||
|
||||
assert_eq!(TestExternal::A, flags);
|
||||
|
||||
flags.extend(TestExternal::A | TestExternal::B | TestExternal::C);
|
||||
|
||||
assert_eq!(TestExternal::ABC, flags);
|
||||
|
||||
flags.extend(TestExternal::from_bits_retain(1 << 5));
|
||||
|
||||
assert_eq!(
|
||||
TestExternal::ABC | TestExternal::from_bits_retain(1 << 5),
|
||||
flags
|
||||
);
|
||||
}
|
||||
}
|
46
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/flags.rs
vendored
Normal file
46
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/flags.rs
vendored
Normal file
@@ -0,0 +1,46 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
let flags = TestFlags::FLAGS
|
||||
.iter()
|
||||
.map(|flag| (flag.name(), flag.value().bits()))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
assert_eq!(
|
||||
vec![
|
||||
("A", 1u8),
|
||||
("B", 1 << 1),
|
||||
("C", 1 << 2),
|
||||
("ABC", 1 | 1 << 1 | 1 << 2),
|
||||
],
|
||||
flags,
|
||||
);
|
||||
|
||||
assert_eq!(0, TestEmpty::FLAGS.iter().count());
|
||||
}
|
||||
|
||||
mod external {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
let flags = TestExternal::FLAGS
|
||||
.iter()
|
||||
.map(|flag| (flag.name(), flag.value().bits()))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
assert_eq!(
|
||||
vec![
|
||||
("A", 1u8),
|
||||
("B", 1 << 1),
|
||||
("C", 1 << 2),
|
||||
("ABC", 1 | 1 << 1 | 1 << 2),
|
||||
("", !0),
|
||||
],
|
||||
flags,
|
||||
);
|
||||
}
|
||||
}
|
97
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/fmt.rs
vendored
Normal file
97
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/fmt.rs
vendored
Normal file
@@ -0,0 +1,97 @@
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(TestFlags::empty(), "TestFlags(0x0)", "0", "0", "0", "0");
|
||||
case(TestFlags::A, "TestFlags(A)", "1", "1", "1", "1");
|
||||
case(
|
||||
TestFlags::all(),
|
||||
"TestFlags(A | B | C)",
|
||||
"7",
|
||||
"7",
|
||||
"7",
|
||||
"111",
|
||||
);
|
||||
case(
|
||||
TestFlags::from_bits_retain(1 << 3),
|
||||
"TestFlags(0x8)",
|
||||
"8",
|
||||
"8",
|
||||
"10",
|
||||
"1000",
|
||||
);
|
||||
case(
|
||||
TestFlags::A | TestFlags::from_bits_retain(1 << 3),
|
||||
"TestFlags(A | 0x8)",
|
||||
"9",
|
||||
"9",
|
||||
"11",
|
||||
"1001",
|
||||
);
|
||||
|
||||
case(TestZero::ZERO, "TestZero(0x0)", "0", "0", "0", "0");
|
||||
case(
|
||||
TestZero::ZERO | TestZero::from_bits_retain(1),
|
||||
"TestZero(0x1)",
|
||||
"1",
|
||||
"1",
|
||||
"1",
|
||||
"1",
|
||||
);
|
||||
|
||||
case(TestZeroOne::ONE, "TestZeroOne(ONE)", "1", "1", "1", "1");
|
||||
|
||||
case(
|
||||
TestOverlapping::from_bits_retain(1 << 1),
|
||||
"TestOverlapping(0x2)",
|
||||
"2",
|
||||
"2",
|
||||
"2",
|
||||
"10",
|
||||
);
|
||||
|
||||
case(
|
||||
TestExternal::from_bits_retain(1 | 1 << 1 | 1 << 3),
|
||||
"TestExternal(A | B | 0x8)",
|
||||
"B",
|
||||
"b",
|
||||
"13",
|
||||
"1011",
|
||||
);
|
||||
|
||||
case(
|
||||
TestExternal::all(),
|
||||
"TestExternal(A | B | C | 0xf8)",
|
||||
"FF",
|
||||
"ff",
|
||||
"377",
|
||||
"11111111",
|
||||
);
|
||||
|
||||
case(
|
||||
TestExternalFull::all(),
|
||||
"TestExternalFull(0xff)",
|
||||
"FF",
|
||||
"ff",
|
||||
"377",
|
||||
"11111111",
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<
|
||||
T: std::fmt::Debug + std::fmt::UpperHex + std::fmt::LowerHex + std::fmt::Octal + std::fmt::Binary,
|
||||
>(
|
||||
value: T,
|
||||
debug: &str,
|
||||
uhex: &str,
|
||||
lhex: &str,
|
||||
oct: &str,
|
||||
bin: &str,
|
||||
) {
|
||||
assert_eq!(debug, format!("{:?}", value));
|
||||
assert_eq!(uhex, format!("{:X}", value));
|
||||
assert_eq!(lhex, format!("{:x}", value));
|
||||
assert_eq!(oct, format!("{:o}", value));
|
||||
assert_eq!(bin, format!("{:b}", value));
|
||||
}
|
45
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits.rs
vendored
Normal file
45
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits.rs
vendored
Normal file
@@ -0,0 +1,45 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(Some(0), 0, TestFlags::from_bits);
|
||||
case(Some(1), 1, TestFlags::from_bits);
|
||||
case(
|
||||
Some(1 | 1 << 1 | 1 << 2),
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
TestFlags::from_bits,
|
||||
);
|
||||
|
||||
case(None, 1 << 3, TestFlags::from_bits);
|
||||
case(None, 1 | 1 << 3, TestFlags::from_bits);
|
||||
|
||||
case(Some(1 | 1 << 1), 1 | 1 << 1, TestOverlapping::from_bits);
|
||||
|
||||
case(Some(1 << 1), 1 << 1, TestOverlapping::from_bits);
|
||||
|
||||
case(Some(1 << 5), 1 << 5, TestExternal::from_bits);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags>(
|
||||
expected: Option<T::Bits>,
|
||||
input: T::Bits,
|
||||
inherent: impl FnOnce(T::Bits) -> Option<T>,
|
||||
) where
|
||||
<T as Flags>::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(
|
||||
expected,
|
||||
inherent(input).map(|f| f.bits()),
|
||||
"T::from_bits({:?})",
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
expected,
|
||||
T::from_bits(input).map(|f| f.bits()),
|
||||
"Flags::from_bits({:?})",
|
||||
input
|
||||
);
|
||||
}
|
38
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits_retain.rs
vendored
Normal file
38
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits_retain.rs
vendored
Normal file
@@ -0,0 +1,38 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(0, TestFlags::from_bits_retain);
|
||||
case(1, TestFlags::from_bits_retain);
|
||||
case(1 | 1 << 1 | 1 << 2, TestFlags::from_bits_retain);
|
||||
|
||||
case(1 << 3, TestFlags::from_bits_retain);
|
||||
case(1 | 1 << 3, TestFlags::from_bits_retain);
|
||||
|
||||
case(1 | 1 << 1, TestOverlapping::from_bits_retain);
|
||||
|
||||
case(1 << 1, TestOverlapping::from_bits_retain);
|
||||
|
||||
case(1 << 5, TestExternal::from_bits_retain);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags>(input: T::Bits, inherent: impl FnOnce(T::Bits) -> T)
|
||||
where
|
||||
<T as Flags>::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(
|
||||
input,
|
||||
inherent(input).bits(),
|
||||
"T::from_bits_retain({:?})",
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
input,
|
||||
T::from_bits_retain(input).bits(),
|
||||
"Flags::from_bits_retain({:?})",
|
||||
input
|
||||
);
|
||||
}
|
42
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits_truncate.rs
vendored
Normal file
42
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_bits_truncate.rs
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(0, 0, TestFlags::from_bits_truncate);
|
||||
case(1, 1, TestFlags::from_bits_truncate);
|
||||
case(
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
TestFlags::from_bits_truncate,
|
||||
);
|
||||
|
||||
case(0, 1 << 3, TestFlags::from_bits_truncate);
|
||||
case(1, 1 | 1 << 3, TestFlags::from_bits_truncate);
|
||||
|
||||
case(1 | 1 << 1, 1 | 1 << 1, TestOverlapping::from_bits_truncate);
|
||||
|
||||
case(1 << 1, 1 << 1, TestOverlapping::from_bits_truncate);
|
||||
|
||||
case(1 << 5, 1 << 5, TestExternal::from_bits_truncate);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags>(expected: T::Bits, input: T::Bits, inherent: impl FnOnce(T::Bits) -> T)
|
||||
where
|
||||
<T as Flags>::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(
|
||||
expected,
|
||||
inherent(input).bits(),
|
||||
"T::from_bits_truncate({:?})",
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
expected,
|
||||
T::from_bits_truncate(input).bits(),
|
||||
"Flags::from_bits_truncate({:?})",
|
||||
input
|
||||
);
|
||||
}
|
42
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_name.rs
vendored
Normal file
42
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/from_name.rs
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(Some(1), "A", TestFlags::from_name);
|
||||
case(Some(1 << 1), "B", TestFlags::from_name);
|
||||
case(Some(1 | 1 << 1 | 1 << 2), "ABC", TestFlags::from_name);
|
||||
|
||||
case(None, "", TestFlags::from_name);
|
||||
case(None, "a", TestFlags::from_name);
|
||||
case(None, "0x1", TestFlags::from_name);
|
||||
case(None, "A | B", TestFlags::from_name);
|
||||
|
||||
case(Some(0), "ZERO", TestZero::from_name);
|
||||
|
||||
case(Some(2), "二", TestUnicode::from_name);
|
||||
|
||||
case(None, "_", TestExternal::from_name);
|
||||
|
||||
case(None, "", TestExternal::from_name);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags>(expected: Option<T::Bits>, input: &str, inherent: impl FnOnce(&str) -> Option<T>)
|
||||
where
|
||||
<T as Flags>::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(
|
||||
expected,
|
||||
inherent(input).map(|f| f.bits()),
|
||||
"T::from_name({:?})",
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
expected,
|
||||
T::from_name(input).map(|f| f.bits()),
|
||||
"Flags::from_name({:?})",
|
||||
input
|
||||
);
|
||||
}
|
91
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/insert.rs
vendored
Normal file
91
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/insert.rs
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(
|
||||
TestFlags::empty(),
|
||||
&[
|
||||
(TestFlags::A, 1),
|
||||
(TestFlags::A | TestFlags::B, 1 | 1 << 1),
|
||||
(TestFlags::empty(), 0),
|
||||
(TestFlags::from_bits_retain(1 << 3), 1 << 3),
|
||||
],
|
||||
TestFlags::insert,
|
||||
TestFlags::set,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::A,
|
||||
&[
|
||||
(TestFlags::A, 1),
|
||||
(TestFlags::empty(), 1),
|
||||
(TestFlags::B, 1 | 1 << 1),
|
||||
],
|
||||
TestFlags::insert,
|
||||
TestFlags::set,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + Copy>(
|
||||
value: T,
|
||||
inputs: &[(T, T::Bits)],
|
||||
mut inherent_insert: impl FnMut(&mut T, T),
|
||||
mut inherent_set: impl FnMut(&mut T, T, bool),
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq + Copy,
|
||||
{
|
||||
for (input, expected) in inputs {
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
inherent_insert(&mut value, *input);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?}.insert({:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
Flags::insert(&mut value, *input);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"Flags::insert({:?}, {:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
inherent_set(&mut value, *input, true);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?}.set({:?}, true)",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
Flags::set(&mut value, *input, true);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"Flags::set({:?}, {:?}, true)",
|
||||
value,
|
||||
input
|
||||
);
|
||||
}
|
||||
}
|
79
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/intersection.rs
vendored
Normal file
79
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/intersection.rs
vendored
Normal file
@@ -0,0 +1,79 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(
|
||||
TestFlags::empty(),
|
||||
&[(TestFlags::empty(), 0), (TestFlags::all(), 0)],
|
||||
TestFlags::intersection,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::all(),
|
||||
&[
|
||||
(TestFlags::all(), 1 | 1 << 1 | 1 << 2),
|
||||
(TestFlags::A, 1),
|
||||
(TestFlags::from_bits_retain(1 << 3), 0),
|
||||
],
|
||||
TestFlags::intersection,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::from_bits_retain(1 << 3),
|
||||
&[(TestFlags::from_bits_retain(1 << 3), 1 << 3)],
|
||||
TestFlags::intersection,
|
||||
);
|
||||
|
||||
case(
|
||||
TestOverlapping::AB,
|
||||
&[(TestOverlapping::BC, 1 << 1)],
|
||||
TestOverlapping::intersection,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + std::ops::BitAnd<Output = T> + std::ops::BitAndAssign + Copy>(
|
||||
value: T,
|
||||
inputs: &[(T, T::Bits)],
|
||||
mut inherent: impl FnMut(T, T) -> T,
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq + Copy,
|
||||
{
|
||||
for (input, expected) in inputs {
|
||||
assert_eq!(
|
||||
*expected,
|
||||
inherent(value, *input).bits(),
|
||||
"{:?}.intersection({:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
Flags::intersection(value, *input).bits(),
|
||||
"Flags::intersection({:?}, {:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
(value & *input).bits(),
|
||||
"{:?} & {:?}",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
value &= *input;
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?} &= {:?}",
|
||||
value,
|
||||
input,
|
||||
);
|
||||
}
|
||||
}
|
91
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/intersects.rs
vendored
Normal file
91
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/intersects.rs
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(
|
||||
TestFlags::empty(),
|
||||
&[
|
||||
(TestFlags::empty(), false),
|
||||
(TestFlags::A, false),
|
||||
(TestFlags::B, false),
|
||||
(TestFlags::C, false),
|
||||
(TestFlags::from_bits_retain(1 << 3), false),
|
||||
],
|
||||
TestFlags::intersects,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::A,
|
||||
&[
|
||||
(TestFlags::empty(), false),
|
||||
(TestFlags::A, true),
|
||||
(TestFlags::B, false),
|
||||
(TestFlags::C, false),
|
||||
(TestFlags::ABC, true),
|
||||
(TestFlags::from_bits_retain(1 << 3), false),
|
||||
(TestFlags::from_bits_retain(1 | (1 << 3)), true),
|
||||
],
|
||||
TestFlags::intersects,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::ABC,
|
||||
&[
|
||||
(TestFlags::empty(), false),
|
||||
(TestFlags::A, true),
|
||||
(TestFlags::B, true),
|
||||
(TestFlags::C, true),
|
||||
(TestFlags::ABC, true),
|
||||
(TestFlags::from_bits_retain(1 << 3), false),
|
||||
],
|
||||
TestFlags::intersects,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::from_bits_retain(1 << 3),
|
||||
&[
|
||||
(TestFlags::empty(), false),
|
||||
(TestFlags::A, false),
|
||||
(TestFlags::B, false),
|
||||
(TestFlags::C, false),
|
||||
(TestFlags::from_bits_retain(1 << 3), true),
|
||||
],
|
||||
TestFlags::intersects,
|
||||
);
|
||||
|
||||
case(
|
||||
TestOverlapping::AB,
|
||||
&[
|
||||
(TestOverlapping::AB, true),
|
||||
(TestOverlapping::BC, true),
|
||||
(TestOverlapping::from_bits_retain(1 << 1), true),
|
||||
],
|
||||
TestOverlapping::intersects,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + Copy>(
|
||||
value: T,
|
||||
inputs: &[(T, bool)],
|
||||
mut inherent: impl FnMut(&T, T) -> bool,
|
||||
) {
|
||||
for (input, expected) in inputs {
|
||||
assert_eq!(
|
||||
*expected,
|
||||
inherent(&value, *input),
|
||||
"{:?}.intersects({:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
Flags::intersects(&value, *input),
|
||||
"Flags::intersects({:?}, {:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
}
|
||||
}
|
32
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/is_all.rs
vendored
Normal file
32
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/is_all.rs
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(false, TestFlags::empty(), TestFlags::is_all);
|
||||
case(false, TestFlags::A, TestFlags::is_all);
|
||||
|
||||
case(true, TestFlags::ABC, TestFlags::is_all);
|
||||
|
||||
case(
|
||||
true,
|
||||
TestFlags::ABC | TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::is_all,
|
||||
);
|
||||
|
||||
case(true, TestZero::empty(), TestZero::is_all);
|
||||
|
||||
case(true, TestEmpty::empty(), TestEmpty::is_all);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug>(expected: bool, value: T, inherent: impl FnOnce(&T) -> bool) {
|
||||
assert_eq!(expected, inherent(&value), "{:?}.is_all()", value);
|
||||
assert_eq!(
|
||||
expected,
|
||||
Flags::is_all(&value),
|
||||
"Flags::is_all({:?})",
|
||||
value
|
||||
);
|
||||
}
|
31
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/is_empty.rs
vendored
Normal file
31
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/is_empty.rs
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(true, TestFlags::empty(), TestFlags::is_empty);
|
||||
|
||||
case(false, TestFlags::A, TestFlags::is_empty);
|
||||
case(false, TestFlags::ABC, TestFlags::is_empty);
|
||||
case(
|
||||
false,
|
||||
TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::is_empty,
|
||||
);
|
||||
|
||||
case(true, TestZero::empty(), TestZero::is_empty);
|
||||
|
||||
case(true, TestEmpty::empty(), TestEmpty::is_empty);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug>(expected: bool, value: T, inherent: impl FnOnce(&T) -> bool) {
|
||||
assert_eq!(expected, inherent(&value), "{:?}.is_empty()", value);
|
||||
assert_eq!(
|
||||
expected,
|
||||
Flags::is_empty(&value),
|
||||
"Flags::is_empty({:?})",
|
||||
value
|
||||
);
|
||||
}
|
209
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/iter.rs
vendored
Normal file
209
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/iter.rs
vendored
Normal file
@@ -0,0 +1,209 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))] // Very slow in miri
|
||||
fn roundtrip() {
|
||||
for a in 0u8..=255 {
|
||||
for b in 0u8..=255 {
|
||||
let f = TestFlags::from_bits_retain(a | b);
|
||||
|
||||
assert_eq!(f, f.iter().collect::<TestFlags>());
|
||||
assert_eq!(
|
||||
TestFlags::from_bits_truncate(f.bits()),
|
||||
f.iter_names().map(|(_, f)| f).collect::<TestFlags>()
|
||||
);
|
||||
|
||||
let f = TestExternal::from_bits_retain(a | b);
|
||||
|
||||
assert_eq!(f, f.iter().collect::<TestExternal>());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mod collect {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
assert_eq!(0, [].into_iter().collect::<TestFlags>().bits());
|
||||
|
||||
assert_eq!(1, [TestFlags::A,].into_iter().collect::<TestFlags>().bits());
|
||||
|
||||
assert_eq!(
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
[TestFlags::A, TestFlags::B | TestFlags::C,]
|
||||
.into_iter()
|
||||
.collect::<TestFlags>()
|
||||
.bits()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
1 | 1 << 3,
|
||||
[
|
||||
TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::empty(),
|
||||
TestFlags::A,
|
||||
]
|
||||
.into_iter()
|
||||
.collect::<TestFlags>()
|
||||
.bits()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
1 << 5 | 1 << 7,
|
||||
[
|
||||
TestExternal::empty(),
|
||||
TestExternal::from_bits_retain(1 << 5),
|
||||
TestExternal::from_bits_retain(1 << 7),
|
||||
]
|
||||
.into_iter()
|
||||
.collect::<TestExternal>()
|
||||
.bits()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
mod iter {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(&[], TestFlags::empty(), TestFlags::iter);
|
||||
|
||||
case(&[1], TestFlags::A, TestFlags::iter);
|
||||
case(&[1, 1 << 1], TestFlags::A | TestFlags::B, TestFlags::iter);
|
||||
case(
|
||||
&[1, 1 << 1, 1 << 3],
|
||||
TestFlags::A | TestFlags::B | TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::iter,
|
||||
);
|
||||
|
||||
case(&[1, 1 << 1, 1 << 2], TestFlags::ABC, TestFlags::iter);
|
||||
case(
|
||||
&[1, 1 << 1, 1 << 2, 1 << 3],
|
||||
TestFlags::ABC | TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::iter,
|
||||
);
|
||||
|
||||
case(
|
||||
&[1 | 1 << 1 | 1 << 2],
|
||||
TestFlagsInvert::ABC,
|
||||
TestFlagsInvert::iter,
|
||||
);
|
||||
|
||||
case(&[], TestZero::ZERO, TestZero::iter);
|
||||
|
||||
case(
|
||||
&[1, 1 << 1, 1 << 2, 0b1111_1000],
|
||||
TestExternal::all(),
|
||||
TestExternal::iter,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + IntoIterator<Item = T> + Copy>(
|
||||
expected: &[T::Bits],
|
||||
value: T,
|
||||
inherent: impl FnOnce(&T) -> crate::iter::Iter<T>,
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(
|
||||
expected,
|
||||
inherent(&value).map(|f| f.bits()).collect::<Vec<_>>(),
|
||||
"{:?}.iter()",
|
||||
value
|
||||
);
|
||||
assert_eq!(
|
||||
expected,
|
||||
Flags::iter(&value).map(|f| f.bits()).collect::<Vec<_>>(),
|
||||
"Flags::iter({:?})",
|
||||
value
|
||||
);
|
||||
assert_eq!(
|
||||
expected,
|
||||
value.into_iter().map(|f| f.bits()).collect::<Vec<_>>(),
|
||||
"{:?}.into_iter()",
|
||||
value
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
mod iter_names {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(&[], TestFlags::empty(), TestFlags::iter_names);
|
||||
|
||||
case(&[("A", 1)], TestFlags::A, TestFlags::iter_names);
|
||||
case(
|
||||
&[("A", 1), ("B", 1 << 1)],
|
||||
TestFlags::A | TestFlags::B,
|
||||
TestFlags::iter_names,
|
||||
);
|
||||
case(
|
||||
&[("A", 1), ("B", 1 << 1)],
|
||||
TestFlags::A | TestFlags::B | TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::iter_names,
|
||||
);
|
||||
|
||||
case(
|
||||
&[("A", 1), ("B", 1 << 1), ("C", 1 << 2)],
|
||||
TestFlags::ABC,
|
||||
TestFlags::iter_names,
|
||||
);
|
||||
case(
|
||||
&[("A", 1), ("B", 1 << 1), ("C", 1 << 2)],
|
||||
TestFlags::ABC | TestFlags::from_bits_retain(1 << 3),
|
||||
TestFlags::iter_names,
|
||||
);
|
||||
|
||||
case(
|
||||
&[("ABC", 1 | 1 << 1 | 1 << 2)],
|
||||
TestFlagsInvert::ABC,
|
||||
TestFlagsInvert::iter_names,
|
||||
);
|
||||
|
||||
case(&[], TestZero::ZERO, TestZero::iter_names);
|
||||
|
||||
case(
|
||||
&[("A", 1)],
|
||||
TestOverlappingFull::A,
|
||||
TestOverlappingFull::iter_names,
|
||||
);
|
||||
case(
|
||||
&[("A", 1), ("D", 1 << 1)],
|
||||
TestOverlappingFull::A | TestOverlappingFull::D,
|
||||
TestOverlappingFull::iter_names,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug>(
|
||||
expected: &[(&'static str, T::Bits)],
|
||||
value: T,
|
||||
inherent: impl FnOnce(&T) -> crate::iter::IterNames<T>,
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq,
|
||||
{
|
||||
assert_eq!(
|
||||
expected,
|
||||
inherent(&value)
|
||||
.map(|(n, f)| (n, f.bits()))
|
||||
.collect::<Vec<_>>(),
|
||||
"{:?}.iter_names()",
|
||||
value
|
||||
);
|
||||
assert_eq!(
|
||||
expected,
|
||||
Flags::iter_names(&value)
|
||||
.map(|(n, f)| (n, f.bits()))
|
||||
.collect::<Vec<_>>(),
|
||||
"Flags::iter_names({:?})",
|
||||
value
|
||||
);
|
||||
}
|
||||
}
|
116
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/parser.rs
vendored
Normal file
116
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/parser.rs
vendored
Normal file
@@ -0,0 +1,116 @@
|
||||
use super::*;
|
||||
|
||||
use crate::{
|
||||
parser::{from_str, to_writer},
|
||||
Flags,
|
||||
};
|
||||
|
||||
#[test]
|
||||
#[cfg(not(miri))] // Very slow in miri
|
||||
fn roundtrip() {
|
||||
let mut s = String::new();
|
||||
|
||||
for a in 0u8..=255 {
|
||||
for b in 0u8..=255 {
|
||||
let f = TestFlags::from_bits_retain(a | b);
|
||||
|
||||
s.clear();
|
||||
to_writer(&f, &mut s).unwrap();
|
||||
|
||||
assert_eq!(f, from_str::<TestFlags>(&s).unwrap());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mod from_str {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn valid() {
|
||||
assert_eq!(0, from_str::<TestFlags>("").unwrap().bits());
|
||||
|
||||
assert_eq!(1, from_str::<TestFlags>("A").unwrap().bits());
|
||||
assert_eq!(1, from_str::<TestFlags>(" A ").unwrap().bits());
|
||||
assert_eq!(
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
from_str::<TestFlags>("A | B | C").unwrap().bits()
|
||||
);
|
||||
assert_eq!(
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
from_str::<TestFlags>("A\n|\tB\r\n| C ").unwrap().bits()
|
||||
);
|
||||
assert_eq!(
|
||||
1 | 1 << 1 | 1 << 2,
|
||||
from_str::<TestFlags>("A|B|C").unwrap().bits()
|
||||
);
|
||||
|
||||
assert_eq!(1 << 3, from_str::<TestFlags>("0x8").unwrap().bits());
|
||||
assert_eq!(1 | 1 << 3, from_str::<TestFlags>("A | 0x8").unwrap().bits());
|
||||
assert_eq!(
|
||||
1 | 1 << 1 | 1 << 3,
|
||||
from_str::<TestFlags>("0x1 | 0x8 | B").unwrap().bits()
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
1 | 1 << 1,
|
||||
from_str::<TestUnicode>("一 | 二").unwrap().bits()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid() {
|
||||
assert!(from_str::<TestFlags>("a")
|
||||
.unwrap_err()
|
||||
.to_string()
|
||||
.starts_with("unrecognized named flag"));
|
||||
assert!(from_str::<TestFlags>("A & B")
|
||||
.unwrap_err()
|
||||
.to_string()
|
||||
.starts_with("unrecognized named flag"));
|
||||
|
||||
assert!(from_str::<TestFlags>("0xg")
|
||||
.unwrap_err()
|
||||
.to_string()
|
||||
.starts_with("invalid hex flag"));
|
||||
assert!(from_str::<TestFlags>("0xffffffffffff")
|
||||
.unwrap_err()
|
||||
.to_string()
|
||||
.starts_with("invalid hex flag"));
|
||||
}
|
||||
}
|
||||
|
||||
mod to_writer {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
assert_eq!("", write(TestFlags::empty()));
|
||||
assert_eq!("A", write(TestFlags::A));
|
||||
assert_eq!("A | B | C", write(TestFlags::all()));
|
||||
assert_eq!("0x8", write(TestFlags::from_bits_retain(1 << 3)));
|
||||
assert_eq!(
|
||||
"A | 0x8",
|
||||
write(TestFlags::A | TestFlags::from_bits_retain(1 << 3))
|
||||
);
|
||||
|
||||
assert_eq!("", write(TestZero::ZERO));
|
||||
|
||||
assert_eq!("ABC", write(TestFlagsInvert::all()));
|
||||
|
||||
assert_eq!("A", write(TestOverlappingFull::C));
|
||||
assert_eq!(
|
||||
"A | D",
|
||||
write(TestOverlappingFull::C | TestOverlappingFull::D)
|
||||
);
|
||||
}
|
||||
|
||||
fn write<F: Flags>(value: F) -> String
|
||||
where
|
||||
F::Bits: crate::parser::WriteHex,
|
||||
{
|
||||
let mut s = String::new();
|
||||
|
||||
to_writer(&value, &mut s).unwrap();
|
||||
s
|
||||
}
|
||||
}
|
100
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/remove.rs
vendored
Normal file
100
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/remove.rs
vendored
Normal file
@@ -0,0 +1,100 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(
|
||||
TestFlags::empty(),
|
||||
&[
|
||||
(TestFlags::A, 0),
|
||||
(TestFlags::empty(), 0),
|
||||
(TestFlags::from_bits_retain(1 << 3), 0),
|
||||
],
|
||||
TestFlags::remove,
|
||||
TestFlags::set,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::A,
|
||||
&[
|
||||
(TestFlags::A, 0),
|
||||
(TestFlags::empty(), 1),
|
||||
(TestFlags::B, 1),
|
||||
],
|
||||
TestFlags::remove,
|
||||
TestFlags::set,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::ABC,
|
||||
&[
|
||||
(TestFlags::A, 1 << 1 | 1 << 2),
|
||||
(TestFlags::A | TestFlags::C, 1 << 1),
|
||||
],
|
||||
TestFlags::remove,
|
||||
TestFlags::set,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + Copy>(
|
||||
value: T,
|
||||
inputs: &[(T, T::Bits)],
|
||||
mut inherent_remove: impl FnMut(&mut T, T),
|
||||
mut inherent_set: impl FnMut(&mut T, T, bool),
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq + Copy,
|
||||
{
|
||||
for (input, expected) in inputs {
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
inherent_remove(&mut value, *input);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?}.remove({:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
Flags::remove(&mut value, *input);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"Flags::remove({:?}, {:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
inherent_set(&mut value, *input, false);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?}.set({:?}, false)",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
Flags::set(&mut value, *input, false);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"Flags::set({:?}, {:?}, false)",
|
||||
value,
|
||||
input
|
||||
);
|
||||
}
|
||||
}
|
110
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/symmetric_difference.rs
vendored
Normal file
110
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/symmetric_difference.rs
vendored
Normal file
@@ -0,0 +1,110 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(
|
||||
TestFlags::empty(),
|
||||
&[
|
||||
(TestFlags::empty(), 0),
|
||||
(TestFlags::all(), 1 | 1 << 1 | 1 << 2),
|
||||
(TestFlags::from_bits_retain(1 << 3), 1 << 3),
|
||||
],
|
||||
TestFlags::symmetric_difference,
|
||||
TestFlags::toggle,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::A,
|
||||
&[
|
||||
(TestFlags::empty(), 1),
|
||||
(TestFlags::A, 0),
|
||||
(TestFlags::all(), 1 << 1 | 1 << 2),
|
||||
],
|
||||
TestFlags::symmetric_difference,
|
||||
TestFlags::toggle,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::A | TestFlags::B | TestFlags::from_bits_retain(1 << 3),
|
||||
&[
|
||||
(TestFlags::ABC, 1 << 2 | 1 << 3),
|
||||
(TestFlags::from_bits_retain(1 << 3), 1 | 1 << 1),
|
||||
],
|
||||
TestFlags::symmetric_difference,
|
||||
TestFlags::toggle,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + std::ops::BitXor<Output = T> + std::ops::BitXorAssign + Copy>(
|
||||
value: T,
|
||||
inputs: &[(T, T::Bits)],
|
||||
mut inherent_sym_diff: impl FnMut(T, T) -> T,
|
||||
mut inherent_toggle: impl FnMut(&mut T, T),
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq + Copy,
|
||||
{
|
||||
for (input, expected) in inputs {
|
||||
assert_eq!(
|
||||
*expected,
|
||||
inherent_sym_diff(value, *input).bits(),
|
||||
"{:?}.symmetric_difference({:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
Flags::symmetric_difference(value, *input).bits(),
|
||||
"Flags::symmetric_difference({:?}, {:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
(value ^ *input).bits(),
|
||||
"{:?} ^ {:?}",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
value ^= *input;
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?} ^= {:?}",
|
||||
value,
|
||||
input,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
inherent_toggle(&mut value, *input);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?}.toggle({:?})",
|
||||
value,
|
||||
input,
|
||||
);
|
||||
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
Flags::toggle(&mut value, *input);
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?}.toggle({:?})",
|
||||
value,
|
||||
input,
|
||||
);
|
||||
}
|
||||
}
|
71
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/union.rs
vendored
Normal file
71
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/tests/union.rs
vendored
Normal file
@@ -0,0 +1,71 @@
|
||||
use super::*;
|
||||
|
||||
use crate::Flags;
|
||||
|
||||
#[test]
|
||||
fn cases() {
|
||||
case(
|
||||
TestFlags::empty(),
|
||||
&[
|
||||
(TestFlags::A, 1),
|
||||
(TestFlags::all(), 1 | 1 << 1 | 1 << 2),
|
||||
(TestFlags::empty(), 0),
|
||||
(TestFlags::from_bits_retain(1 << 3), 1 << 3),
|
||||
],
|
||||
TestFlags::union,
|
||||
);
|
||||
|
||||
case(
|
||||
TestFlags::A | TestFlags::C,
|
||||
&[
|
||||
(TestFlags::A | TestFlags::B, 1 | 1 << 1 | 1 << 2),
|
||||
(TestFlags::A, 1 | 1 << 2),
|
||||
],
|
||||
TestFlags::union,
|
||||
);
|
||||
}
|
||||
|
||||
#[track_caller]
|
||||
fn case<T: Flags + std::fmt::Debug + std::ops::BitOr<Output = T> + std::ops::BitOrAssign + Copy>(
|
||||
value: T,
|
||||
inputs: &[(T, T::Bits)],
|
||||
mut inherent: impl FnMut(T, T) -> T,
|
||||
) where
|
||||
T::Bits: std::fmt::Debug + PartialEq + Copy,
|
||||
{
|
||||
for (input, expected) in inputs {
|
||||
assert_eq!(
|
||||
*expected,
|
||||
inherent(value, *input).bits(),
|
||||
"{:?}.union({:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
Flags::union(value, *input).bits(),
|
||||
"Flags::union({:?}, {:?})",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
(value | *input).bits(),
|
||||
"{:?} | {:?}",
|
||||
value,
|
||||
input
|
||||
);
|
||||
assert_eq!(
|
||||
*expected,
|
||||
{
|
||||
let mut value = value;
|
||||
value |= *input;
|
||||
value
|
||||
}
|
||||
.bits(),
|
||||
"{:?} |= {:?}",
|
||||
value,
|
||||
input,
|
||||
);
|
||||
}
|
||||
}
|
430
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/traits.rs
vendored
Normal file
430
third_party/rust/chromium_crates_io/vendor/bitflags-2.4.2/src/traits.rs
vendored
Normal file
@@ -0,0 +1,430 @@
|
||||
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};
|
||||
}
|
Reference in New Issue
Block a user