第21章 トレイトオブジェクトと関連型.

trait Animal {
    fn name(&self) -> String;
    fn cry(&self) -> String;
}

struct Dog;
struct Cat;

impl Animal for Dog {
    fn name(&self) -> String {
        String::from("ポチ")
    }
    fn cry(&self) -> String {
        String::from("ワン")
    }
}

impl Animal for Cat {
    fn name(&self) -> String {
        String::from("タマ")
    }
    fn cry(&self) -> String {
        String::from("ニャー")
    }
}

fn main() {
    let dog = Dog;
    let cat = Cat;

    let animals = vec![&dog, &cat]; 
    let animals: Vec<&dyn Animal> = vec![&dog, &cat]; 

    for animal in &animals {
        println!("{}は{}と鳴く", animal.name(), animal.cry());
    }
}

trait Animal {
    fn name(&self) -> String;
    fn cry(&self) -> String;
}

struct Dog;
struct Cat;

impl Animal for Dog {
    fn name(&self) -> String {
        String::from("ポチ")
    }
    fn cry(&self) -> String {
        String::from("ワン")
    }
}

impl Animal for Cat {
    fn name(&self) -> String {
        String::from("タマ")
    }
    fn cry(&self) -> String {
        String::from("ニャー")
    }
}

// 関数introduceを定義せよ
//   引数: &dyn Animal
//   処理: 「〇〇と申します。△△！」と出力する（〇〇は名前、△△は鳴き声）
fn introduce(animal: &dyn Animal) { 
    println!("{}と申します。{}！", animal.name(), animal.cry()); 
} 

fn main() {
    let dog = Dog;
    let cat = Cat;

    introduce(&dog);
    introduce(&cat);
}

trait Animal {
    fn name(&self) -> String;
    fn cry(&self) -> String;
}

struct Dog;
struct Cat;

impl Animal for Dog {
    fn name(&self) -> String {
        String::from("ポチ")
    }
    fn cry(&self) -> String {
        String::from("ワン")
    }
}

impl Animal for Cat {
    fn name(&self) -> String {
        String::from("タマ")
    }
    fn cry(&self) -> String {
        String::from("ニャー")
    }
}

// 関数introduce_implを定義せよ
//   引数: &impl Animal
//   処理: 「[impl] 〇〇と申します。△△！」と出力する
fn introduce_impl(animal: &impl Animal) { 
    println!("[impl] {}と申します。{}！", animal.name(), animal.cry()); 
} 

fn introduce_dyn(animal: &dyn Animal) {
    println!("[dyn] {}と申します。{}！", animal.name(), animal.cry());
}

fn main() {
    let dog = Dog;
    let cat = Cat;

    introduce_impl(&dog);
    introduce_impl(&cat);

    let animals: Vec<&dyn Animal> = vec![&dog, &cat];
    for animal in animals {
        introduce_dyn(animal);
    }
}

trait Sensor {
    type Value; // 測定値の型は実装側で決める
    fn read(&self) -> Self::Value;
}

struct Thermometer {
    celsius: f64,
}

struct DoorSensor {
    is_open: bool,
}

// Thermometer向けにSensorを実装せよ（Valueはf64、readはcelsiusを返す）
impl Sensor for Thermometer { 
    type Value = f64; 
    fn read(&self) -> f64 { 
        self.celsius 
    } 
} 

// DoorSensor向けにSensorを実装せよ（Valueはbool、readはis_openを返す）
impl Sensor for DoorSensor { 
    type Value = bool; 
    fn read(&self) -> bool { 
        self.is_open 
    } 
} 

fn main() {
    let thermometer = Thermometer { celsius: 23.5 };
    let door = DoorSensor { is_open: true };

    println!("温度: {}", thermometer.read());
    println!("ドアが開いている: {}", door.read());
}

trait Convert {
    type Output;
    fn convert(&self) -> Self::Output;
}

struct Meters(f64);

// センチメートル（整数）へ変換
impl Convert for Meters { 
    type Output = i32; 
    fn convert(&self) -> i32 { 
        (self.0 * 100.0) as i32
    } 
} 

// キロメートルへ変換
impl Convert for Meters {
    type Output = f64;
    fn convert(&self) -> f64 {
        self.0 / 1000.0
    }
}

fn main() {
    let distance = Meters(1500.0);
    println!("{}メートル = {}キロメートル", distance.0, distance.convert());
}

use std::ops::Add; 

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

impl Add for Point { 
    type Output = Point; 

    fn add(self, rhs: Point) -> Point { 
        Point { 
            x: self.x + rhs.x, 
            y: self.y + rhs.y, 
        } 
    } 
} 

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, y: 4 };

    let sum = p1 + p2;

    println!("{:?}", sum);
}

// トレイトShapeを定義せよ
//   メソッド: area(&self) -> f64  面積を返す
trait Shape { 
    fn area(&self) -> f64; 
} 

struct Circle {
    radius: f64,
}

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

struct Triangle {
    base: f64,
    height: f64,
}

// Circle・Rectangle・TriangleにShapeを実装せよ
//   Circle   : 半径 × 半径 × 円周率（std::f64::consts::PI）
//   Rectangle: 幅 × 高さ
//   Triangle : 底辺 × 高さ ÷ 2
impl Shape for Circle { 
    fn area(&self) -> f64 { 
        self.radius * self.radius * std::f64::consts::PI 
    } 
} 

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

impl Shape for Triangle { 
    fn area(&self) -> f64 { 
        self.base * self.height / 2.0
    } 
} 

// 関数total_areaを定義せよ
//   引数  : 図形の一覧（&[&dyn Shape]）
//   戻り値: すべての図形の面積の合計
fn total_area(shapes: &[&dyn Shape]) -> f64 { 
    let mut total = 0.0; 
    for shape in shapes { 
        total += shape.area(); 
    } 
    total 
} 

#[test]
fn test_each_area() {
    let circle = Circle { radius: 1.0 };
    let rectangle = Rectangle { width: 3.0, height: 4.0 };
    let triangle = Triangle { base: 6.0, height: 2.0 };
    assert_eq!(circle.area(), std::f64::consts::PI);
    assert_eq!(rectangle.area(), 12.0);
    assert_eq!(triangle.area(), 6.0);
}

#[test]
fn test_total_area() {
    let rectangle = Rectangle { width: 3.0, height: 4.0 };
    let triangle = Triangle { base: 6.0, height: 2.0 };
    let square = Rectangle { width: 2.0, height: 2.0 };
    let shapes: Vec<&dyn Shape> = vec![&rectangle, &triangle, &square];
    assert_eq!(total_area(&shapes), 22.0);
}

#[test]
fn test_total_area_empty() {
    let shapes: Vec<&dyn Shape> = vec![];
    assert_eq!(total_area(&shapes), 0.0);
}