Rustでのトレイトの動的キャスト方法と安全な実践例を徹底解説

use std::any::Any;

fn print_if_string(value: &dyn Any) {
    if let Some(string_value) = value.downcast_ref::<String>() {
        println!("String value: {}", string_value);
    } else {
        println!("Not a String");
    }
}

fn main() {
    let my_string = String::from("Hello, Rust!");
    let my_number = 42;

    print_if_string(&my_string); // "String value: Hello, Rust!"と出力
    print_if_string(&my_number); // "Not a String"と出力
}

use std::any::Any;

fn identify_type(value: &dyn Any) {
    if let Some(v) = value.downcast_ref::<i32>() {
        println!("Value is an i32: {}", v);
    } else if let Some(v) = value.downcast_ref::<f64>() {
        println!("Value is an f64: {}", v);
    } else if let Some(v) = value.downcast_ref::<String>() {
        println!("Value is a String: {}", v);
    } else {
        println!("Unknown type");
    }
}

fn main() {
    let my_int = 42;
    let my_float = 3.14;
    let my_string = String::from("Hello, world!");

    identify_type(&my_int);    // "Value is an i32: 42"
    identify_type(&my_float);  // "Value is an f64: 3.14"
    identify_type(&my_string); // "Value is a String: Hello, world!"
}

fn execute_action(value: &dyn Any) {
    if let Some(v) = value.downcast_ref::<i32>() {
        println!("Doubling the i32: {}", v * 2);
    } else if let Some(v) = value.downcast_ref::<String>() {
        println!("Reversing the String: {}", v.chars().rev().collect::<String>());
    } else {
        println!("Action not defined for this type");
    }
}

fn main() {
    let my_int = 10;
    let my_string = String::from("Rust");

    execute_action(&my_int);    // "Doubling the i32: 20"
    execute_action(&my_string); // "Reversing the String: tsuR"
}

fn handle_cast(value: &dyn Any) {
    if let Some(v) = value.downcast_ref::<i32>() {
        println!("Integer: {}", v);
    } else {
        println!("Value is not an i32");
    }
}

trait Describable {
    fn describe(&self) -> String;
}

impl Describable for i32 {
    fn describe(&self) -> String {
        format!("I am an integer: {}", self)
    }
}

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
}

fn print_area(shape: &dyn Shape) {
    println!("Area: {}", shape.area());
}

fn main() {
    let circle = Circle { radius: 3.0 };
    let rectangle = Rectangle { width: 4.0, height: 5.0 };

    print_area(&circle);      // "Area: 28.274333882308138"
    print_area(&rectangle);   // "Area: 20.0"
}

trait NonObjectSafe {
    fn clone(&self) -> Self; // `Self`を返すためオブジェクトセーフではない
}

fn print_with_lifetime<'a>(shape: &'a dyn Shape) {
    println!("Area: {}", shape.area());
}

fn main() {
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { radius: 3.0 }),
        Box::new(Rectangle { width: 4.0, height: 5.0 }),
    ];

    for shape in shapes {
        print_area(&*shape);
    }
}

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }
}

fn print_area<T: Shape>(shape: &T) {
    println!("Area: {}", shape.area());
}

fn main() {
    let circle = Circle { radius: 3.0 };
    let rectangle = Rectangle { width: 4.0, height: 5.0 };

    print_area(&circle);      // "Area: 28.274333882308138"
    print_area(&rectangle);   // "Area: 20.0"
}

fn print_area(shape: &dyn Shape) {
    println!("Area: {}", shape.area());
}

fn main() {
    let circle = Circle { radius: 3.0 };
    let rectangle = Rectangle { width: 4.0, height: 5.0 };

    print_area(&circle);      // "Area: 28.274333882308138"
    print_area(&rectangle);   // "Area: 20.0"
}

trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}

struct HelloPlugin;

impl Plugin for HelloPlugin {
    fn name(&self) -> &str {
        "HelloPlugin"
    }

    fn execute(&self) {
        println!("Hello from HelloPlugin!");
    }
}

struct GoodbyePlugin;

impl Plugin for GoodbyePlugin {
    fn name(&self) -> &str {
        "GoodbyePlugin"
    }

    fn execute(&self) {
        println!("Goodbye from GoodbyePlugin!");
    }
}

struct PluginManager {
    plugins: Vec<Box<dyn Plugin>>,
}

impl PluginManager {
    fn new() -> Self {
        PluginManager { plugins: Vec::new() }
    }

    fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        self.plugins.push(plugin);
    }

    fn execute_all(&self) {
        for plugin in &self.plugins {
            println!("Executing plugin: {}", plugin.name());
            plugin.execute();
        }
    }
}

fn main() {
    let mut manager = PluginManager::new();

    manager.add_plugin(Box::new(HelloPlugin));
    manager.add_plugin(Box::new(GoodbyePlugin));

    manager.execute_all();
}

Executing plugin: HelloPlugin
Hello from HelloPlugin!
Executing plugin: GoodbyePlugin
Goodbye from GoodbyePlugin!

use std::any::Any;

impl PluginManager {
    fn get_plugin<T: 'static>(&self) -> Option<&T> {
        for plugin in &self.plugins {
            if let Some(plugin) = plugin.as_any().downcast_ref::<T>() {
                return Some(plugin);
            }
        }
        None
    }
}

trait PluginExt: Plugin {
    fn as_any(&self) -> &dyn Any;
}

impl<T: Plugin + 'static> PluginExt for T {
    fn as_any(&self) -> &dyn Any {
        self
    }
}

fn main() {
    let mut manager = PluginManager::new();

    manager.add_plugin(Box::new(HelloPlugin));
    manager.add_plugin(Box::new(GoodbyePlugin));

    if let Some(hello_plugin) = manager.get_plugin::<HelloPlugin>() {
        println!("Found plugin: {}", hello_plugin.name());
    }

    manager.execute_all();
}

Found plugin: HelloPlugin
Executing plugin: HelloPlugin
Hello from HelloPlugin!
Executing plugin: GoodbyePlugin
Goodbye from GoodbyePlugin!

use std::any::Any;

trait ErrorTrait: Any {
    fn description(&self) -> &str;
    fn as_any(&self) -> &dyn Any;
}

struct NotFoundError;
struct PermissionError;

impl ErrorTrait for NotFoundError {
    // TODO: 実装
}

impl ErrorTrait for PermissionError {
    // TODO: 実装
}

fn handle_error(error: &dyn ErrorTrait) {
    if let Some(_) = error.as_any().downcast_ref::<NotFoundError>() {
        println!("Error: Resource not found!");
    } else if let Some(_) = error.as_any().downcast_ref::<PermissionError>() {
        println!("Error: Permission denied!");
    } else {
        println!("Unknown error!");
    }
}

fn main() {
    let not_found = NotFoundError;
    let permission = PermissionError;

    handle_error(&not_found);
    handle_error(&permission);
}

use std::any::Any;

trait Plugin {
    fn as_any(&self) -> &dyn Any;
    fn execute(&self);
}

struct LoggingPlugin;
struct AnalyticsPlugin;

impl Plugin for LoggingPlugin {
    // TODO: 実装
}

impl Plugin for AnalyticsPlugin {
    // TODO: 実装
}

struct PluginManager {
    plugins: Vec<Box<dyn Plugin>>,
}

impl PluginManager {
    fn new() -> Self {
        PluginManager { plugins: Vec::new() }
    }

    fn add_plugin(&mut self, plugin: Box<dyn Plugin>) {
        self.plugins.push(plugin);
    }

    fn execute_logging_plugins(&self) {
        for plugin in &self.plugins {
            if let Some(_) = plugin.as_any().downcast_ref::<LoggingPlugin>() {
                plugin.execute();
            }
        }
    }
}

fn main() {
    let mut manager = PluginManager::new();

    manager.add_plugin(Box::new(LoggingPlugin));
    manager.add_plugin(Box::new(AnalyticsPlugin));

    manager.execute_logging_plugins();
}

fn process_data(data: &dyn Any) {
    // TODO: 型判定と処理を実装
}

fn main() {
    let int_data = 10;
    let string_data = String::from("Rust");

    process_data(&int_data);
    process_data(&string_data);
}