Метод 1: оператор сопоставления

Один из самых простых и понятных способов преобразования целого числа в вариант перечисления — использование оператора сопоставления. Вот пример:

enum MyEnum {
    VariantA,
    VariantB,
    VariantC,
}
fn convert_int_to_enum(value: i32) -> Option<MyEnum> {
    match value {
        0 => Some(MyEnum::VariantA),
        1 => Some(MyEnum::VariantB),
        2 => Some(MyEnum::VariantC),
        _ => None,
    }
}
fn main() {
    let value = 1;
    let result = convert_int_to_enum(value);
    println!("Converted: {:?}", result);
}

В этом примере функция convert_int_to_enumпринимает целое число valueи использует оператор сопоставления, чтобы сопоставить его с соответствующим вариантом перечисления. Если значение соответствует одному из случаев, оно возвращает Some(enum_variant). В противном случае возвращается None.

Метод 2: на основе примитивного признака

Rust предоставляет встроенный признак From, который позволяет вам определять преобразования между типами. Реализуя эту черту для вашего перечисления, вы можете напрямую преобразовать целое число в вариант перечисления. Вот пример:

enum MyEnum {
    VariantA,
    VariantB,
    VariantC,
}
impl From<i32> for MyEnum {
    fn from(value: i32) -> Self {
        match value {
            0 => MyEnum::VariantA,
            1 => MyEnum::VariantB,
            2 => MyEnum::VariantC,
            _ => panic!("Invalid value for conversion"),
        }
    }
}
fn main() {
    let value = 2;
    let result: MyEnum = value.into();
    println!("Converted: {:?}", result);
}

В этом примере мы реализуем признак From<i32>для нашего перечисления MyEnum. Функция fromвнутри реализации сопоставляет целочисленное значение соответствующему варианту перечисления. Затем мы можем использовать метод intoдля преобразования целого числа непосредственно в вариант перечисления.

Метод 3: пользовательская функция преобразования

Если вы предпочитаете более гибкий подход, вы можете создать собственную функцию преобразования, которая принимает целое число и возвращает вариант перечисления. Это позволяет вам настроить логику преобразования в соответствии с вашими конкретными требованиями. Вот пример:

enum MyEnum {
    VariantA,
    VariantB,
    VariantC,
}
fn convert_int_to_enum(value: i32) -> Result<MyEnum, String> {
    match value {
        0 => Ok(MyEnum::VariantA),
        1 => Ok(MyEnum::VariantB),
        2 => Ok(MyEnum::VariantC),
        _ => Err("Invalid value for conversion".to_string()),
    }
}
fn main() {
    let value = 0;
    let result = convert_int_to_enum(value);

    match result {
        Ok(enum_variant) => println!("Converted: {:?}", enum_variant),
        Err(error) => println!("Error: {}", error),
    }
}

В этом примере функция convert_int_to_enumвозвращает тип Result, что позволяет нам обрабатывать как успешные преобразования (Ok), так и ошибки (Err). Вы можете настроить сообщение об ошибке или вернуть более сложный тип ошибки, чтобы при необходимости предоставить дополнительную информацию.

Заключение

И вот оно! Мы рассмотрели три различных метода преобразования целых чисел в варианты перечислений в Rust. Независимо от того, предпочитаете ли вы простоту оператора сопоставления, элегантность признака Fromили гибкость пользовательской функции преобразования, эти методы помогут вам с легкостью справиться с такими преобразованиями.

Не забудьте выбрать метод, который лучше всего подходит для вашего случая использования. Приятного программирования на Rust!