kinoko dev

// 基本的なモンスターの行動を定義するtrait
trait Monster {
    fn name(&self) -> &str;
    fn health(&self) -> u32;
    fn attack_power(&self) -> u32;
    
    // デフォルト実装を持つメソッド
    fn attack(&self) -> String {
        format!("{}が{}のダメージで攻撃した！", self.name(), self.attack_power())
    }
    
    fn is_alive(&self) -> bool {
        self.health() > 0
    }
}

// 魔法使いの特殊能力を定義するtrait
trait Spellcaster {
    fn mana(&self) -> u32;
    fn cast_spell(&self, spell_name: &str) -> String;
}

// 特殊能力を持つエリートモンスターのtrait
trait Elite {
    fn special_ability(&self) -> String;
    fn leadership_bonus(&self) -> u32;
}

// 通常のゴブリン
#[derive(Debug)]
struct Goblin {
    name: String,
    health: u32,
    attack_power: u32,
}

impl Goblin {
    fn new(name: String) -> Self {
        Self {
            name,
            health: 25,
            attack_power: 8,
        }
    }
}

// Goblin用のMonster trait実装
impl Monster for Goblin {
    fn name(&self) -> &str {
        &self.name
    }
    
    fn health(&self) -> u32 {
        self.health
    }
    
    fn attack_power(&self) -> u32 {
        self.attack_power
    }
    
    // デフォルト実装をそのまま使用（オーバーライドしない）
}

// ゴブリンメイジ
#[derive(Debug)]
struct GoblinMage {
    name: String,
    health: u32,
    attack_power: u32,
    mana: u32,
}

impl GoblinMage {
    fn new(name: String) -> Self {
        Self {
            name,
            health: 20,
            attack_power: 5,
            mana: 30,
        }
    }
}

// GoblinMage用のMonster trait実装
impl Monster for GoblinMage {
    fn name(&self) -> &str {
        &self.name
    }
    
    fn health(&self) -> u32 {
        self.health
    }
    
    fn attack_power(&self) -> u32 {
        self.attack_power
    }
    
    // デフォルト実装をオーバーライド
    fn attack(&self) -> String {
        if self.mana > 0 {
            format!("{}が魔法で{}のダメージを与えた！（残りマナ: {}）", 
                   self.name(), self.attack_power() + 3, self.mana - 5)
        } else {
            format!("{}がスタッフで{}のダメージで攻撃した！", 
                   self.name(), self.attack_power())
        }
    }
}

// GoblinMage用のSpellcaster trait実装
impl Spellcaster for GoblinMage {
    fn mana(&self) -> u32 {
        self.mana
    }
    
    fn cast_spell(&self, spell_name: &str) -> String {
        match spell_name {
            "fireball" => format!("{}がファイアボールを詠唱した！15ダメージ！", self.name()),
            "heal" => format!("{}がヒールを唱えて10HP回復した！", self.name()),
            _ => format!("{}は{}という呪文を知らない...", self.name(), spell_name),
        }
    }
}

// エリートゴブリン
#[derive(Debug)]
struct EliteGoblin {
    name: String,
    health: u32,
    attack_power: u32,
    experience: u32,
}

impl EliteGoblin {
    fn new(name: String) -> Self {
        Self {
            name,
            health: 45,
            attack_power: 15,
            experience: 100,
        }
    }
}

// EliteGoblin用のMonster trait実装
impl Monster for EliteGoblin {
    fn name(&self) -> &str {
        &self.name
    }
    
    fn health(&self) -> u32 {
        self.health
    }
    
    fn attack_power(&self) -> u32 {
        self.attack_power
    }
    
    fn attack(&self) -> String {
        format!("{}が渾身の力で{}のダメージで攻撃した！クリティカルヒット！", 
               self.name(), self.attack_power() + 5)
    }
}

// EliteGoblin用のElite trait実装
impl Elite for EliteGoblin {
    fn special_ability(&self) -> String {
        format!("{}が「戦闘の雄叫び」を発動！周囲の味方の攻撃力が上がった！", self.name())
    }
    
    fn leadership_bonus(&self) -> u32 {
        5
    }
}
.....

use std::sync::mpsc;
use std::thread;

#[derive(Debug, Clone)]
enum Event {
    UserLoggedIn(String),
    UserLoggedOut(String),
    DataUpdated(String),
}

struct EventPublisher {
    senders: Vec<mpsc::Sender<Event>>,
}

impl EventPublisher {
    fn new() -> Self {
        Self {
            senders: Vec::new(),
        }
    }
    
    fn subscribe(&mut self) -> mpsc::Receiver<Event> {
        let (tx, rx) = mpsc::channel();
        self.senders.push(tx);
        rx
    }
    
    fn publish(&self, event: Event) {
        // 失効したチャネルは自動的に除去される
        self.senders.retain(|sender| {
            sender.send(event.clone()).is_ok()
        });
    }
}

// 使用例
fn main() {
    let mut publisher = EventPublisher::new();
    
    // 複数のオブザーバーを登録
    let observer1 = publisher.subscribe();
    let observer2 = publisher.subscribe();
    
    // 各オブザーバーを別スレッドで実行
    thread::spawn(move || {
        while let Ok(event) = observer1.recv() {
            println!("Observer 1 received: {:?}", event);
        }
    });
    
    thread::spawn(move || {
        while let Ok(event) = observer2.recv() {
            println!("Observer 2 received: {:?}", event);
        }
    });
    
    // イベント発行
    publisher.publish(Event::UserLoggedIn("Alice".to_string()));
    publisher.publish(Event::DataUpdated("config.json".to_string()));
}

trait Logger {
    fn log(&self, message: &str);
}

trait DatabaseConnection {
    fn query(&self, sql: &str) -> Result<Vec<String>, String>;
}

struct ConsoleLogger;
impl Logger for ConsoleLogger {
    fn log(&self, message: &str) {
        println!("[LOG] {}", message);
    }
}

struct PostgresConnection {
    connection_string: String,
}

impl DatabaseConnection for PostgresConnection {
    fn query(&self, sql: &str) -> Result<Vec<String>, String> {
        // 実際のDB処理
        Ok(vec![format!("Result for: {}", sql)])
    }
}

// Singletonの代わりに、依存性を注入される構造体
struct UserService<L: Logger, D: DatabaseConnection> {
    logger: L,
    db: D,
}

impl<L: Logger, D: DatabaseConnection> UserService<L, D> {
    fn new(logger: L, db: D) -> Self {
        Self { logger, db }
    }
    
    fn get_user(&self, id: u32) -> Result<String, String> {
        self.logger.log(&format!("Getting user {}", id));
        let query = format!("SELECT * FROM users WHERE id = {}", id);
        self.db.query(&query)
            .map(|results| results.get(0).cloned().unwrap_or_default())
    }
}

// 使用例 - アプリケーションのエントリーポイントで依存性を構築
fn main() {
    let logger = ConsoleLogger;
    let db = PostgresConnection {
        connection_string: "postgres://localhost:5432/mydb".to_string(),
    };
    
    let user_service = UserService::new(logger, db);
    let _ = user_service.get_user(123);
}

use std::collections::HashMap;
use serde::Deserialize;

// Strategy trait
trait ProcessingStrategy {
    fn process(&self, data: &str) -> Result<String, String>;
    fn name(&self) -> &'static str;
}

// 具体的なStrategyの実装
struct DatabaseStrategy;
impl ProcessingStrategy for DatabaseStrategy {
    fn process(&self, data: &str) -> Result<String, String> {
        Ok(format!("Saved to database: {}", data))
    }
    fn name(&self) -> &'static str { "database" }
}

struct FileStrategy;
impl ProcessingStrategy for FileStrategy {
    fn process(&self, data: &str) -> Result<String, String> {
        Ok(format!("Saved to file: {}", data))
    }
    fn name(&self) -> &'static str { "file" }
}

struct CacheStrategy;
impl ProcessingStrategy for CacheStrategy {
    fn process(&self, data: &str) -> Result<String, String> {
        Ok(format!("Cached: {}", data))
    }
    fn name(&self) -> &'static str { "cache" }
}

// Strategy Registry（Reflectionの代替）
struct StrategyRegistry {
    strategies: HashMap<String, Box<dyn ProcessingStrategy>>,
}

impl StrategyRegistry {
    fn new() -> Self {
        let mut strategies: HashMap<String, Box<dyn ProcessingStrategy>> = HashMap::new();
        
        // Strategyを登録（Reflectionの動的インスタンス生成の代替）
        strategies.insert("database".to_string(), Box::new(DatabaseStrategy));
        strategies.insert("file".to_string(), Box::new(FileStrategy));
        strategies.insert("cache".to_string(), Box::new(CacheStrategy));
        
        Self { strategies }
    }
    
    fn get_strategy(&self, name: &str) -> Option<&dyn ProcessingStrategy> {
        self.strategies.get(name).map(|s| s.as_ref())
    }
    
    fn list_strategies(&self) -> Vec<&str> {
        self.strategies.keys().map(|s| s.as_str()).collect()
    }
}

// 設定ドリブンのプロセッサー（Reflectionの代替）
#[derive(Deserialize)]
struct ProcessConfig {
    strategy_name: String,
    data: String,
}

struct DataProcessor {
    registry: StrategyRegistry,
}

impl DataProcessor {
    fn new() -> Self {
        Self {
            registry: StrategyRegistry::new(),
        }
    }
    
    // 設定に基づいて動的に処理（Reflectionの代替）
    fn process_with_config(&self, config: &ProcessConfig) -> Result<String, String> {
        let strategy = self.registry.get_strategy(&config.strategy_name)
            .ok_or_else(|| format!("Strategy '{}' not found", config.strategy_name))?;
        
        strategy.process(&config.data)
    }
    
    // 文字列名から動的に処理（Reflectionの代替）
    fn process_by_name(&self, strategy_name: &str, data: &str) -> Result<String, String> {
        let strategy = self.registry.get_strategy(strategy_name)
            .ok_or_else(|| format!("Strategy '{}' not found", strategy_name))?;
        
        strategy.process(data)
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let processor = DataProcessor::new();
    
    // 利用可能なStrategy一覧（Reflectionのクラス一覧の代替）
    println!("Available strategies: {:?}", processor.registry.list_strategies());
    
    // 動的な処理実行（Reflectionの代替）
    let result1 = processor.process_by_name("database", "user data")?;
    println!("Result 1: {}", result1);
    
    let result2 = processor.process_by_name("file", "log entry")?;
    println!("Result 2: {}", result2);
    
    // 設定駆動の処理（Reflectionの代替）
    let config_json = r#"
    {
        "strategy_name": "cache",
        "data": "cached item"
    }
    "#;
    
    let config: ProcessConfig = serde_json::from_str(config_json)?;
    let result3 = processor.process_with_config(&config)?;
    println!("Config-driven result: {}", result3);
    
    // 存在しない戦略のテスト
    match processor.process_by_name("nonexistent", "data") {
        Ok(_) => println!("Unexpected success"),
        Err(e) => println!("Expected error: {}", e),
    }
    
    Ok(())
}