Google Git
Sign in
android / platform / external / rust / crates / enumn / refs/heads/main-16k-with-phones
commit844b809b54f5c90bf640665914d7bf480c522eed[log] [tgz]
authorJeffrey Vander Stoep <jeffv@google.com>Mon Dec 12 08:24:50 2022 +0000
committerGerrit Code Review <noreply-gerritcodereview@google.com>Mon Dec 12 08:24:50 2022 +0000
tree756b4ec1462e264a790e7ad9e6fb03a9bbe66f6e
parent3ce70733cf93f1b59dbd706e7f1da9a5c594f8ae [diff]
parent0cbe8d7faf3f78d02296cc5d44a9eba097e4eeca [diff]
Merge "Upgrade enumn to 0.1.5"
tree: 756b4ec1462e264a790e7ad9e6fb03a9bbe66f6e
  1. .github/
  2. src/
  3. LICENSE ⇨ LICENSE-APACHE
  4. .cargo_vcs_info.json
  5. .clippy.toml
  6. .gitignore
  7. Android.bp
  8. Cargo.toml
  9. Cargo.toml.orig
  10. cargo2android.json
  11. LICENSE-APACHE
  12. LICENSE-MIT
  13. METADATA
  14. MODULE_LICENSE_APACHE2
  15. OWNERS
  16. README.md
  17. TEST_MAPPING
README.md

Convert number to enum

This crate provides a derive macro to generate a function for converting a primitive integer into the corresponding variant of an enum.

The generated function is named n and has the following signature:

impl YourEnum {
    pub fn n(value: Repr) -> Option<Self>;
}

where Repr is an integer type of the right size as described in more detail below.

Example

use enumn::N;

#[derive(PartialEq, Debug, N)]
enum Status {
    LegendaryTriumph,
    QualifiedSuccess,
    FortuitousRevival,
    IndeterminateStalemate,
    RecoverableSetback,
    DireMisadventure,
    AbjectFailure,
}

fn main() {
    let s = Status::n(1);
    assert_eq!(s, Some(Status::QualifiedSuccess));

    let s = Status::n(9);
    assert_eq!(s, None);
}

Signature

The generated signature depends on whether the enum has a #[repr(..)] attribute. If a repr is specified, the input to n will be required to be of that type.

#[derive(enumn::N)]
#[repr(u8)]
enum E {
    /* ... */
}

// expands to:
impl E {
    pub fn n(value: u8) -> Option<Self> {
        /* ... */
    }
}

On the other hand if no repr is specified then we get a signature that is generic over a variety of possible types.

impl E {
    pub fn n<REPR: Into<i64>>(value: REPR) -> Option<Self> {
        /* ... */
    }
}

Discriminants

The conversion respects explictly specified enum discriminants. Consider this enum:

#[derive(enumn::N)]
enum Letter {
    A = 65,
    B = 66,
}

Here Letter::n(65) would return Some(Letter::A).

License