Adapter Pattern

// Target interface that agents expect
pub trait DataSource {
    fn fetch_data(&self) -> Vec<String>;
    fn get_metadata(&self) -> String;
}
 
// Legacy system with incompatible interface
pub struct LegacyDatabase {
    connection_string: String,
}
 
impl LegacyDatabase {
    pub fn new(conn: &str) -> Self {
        Self {
            connection_string: conn.to_string(),
        }
    }
 
    pub fn query_records(&self) -> Vec<&str> {
        // Legacy method with different signature
        vec!["record1", "record2", "record3"]
    }
 
    pub fn get_schema_info(&self) -> &str {
        "Legacy database schema v1.0"
    }
}
 
// Adapter that makes legacy system compatible
pub struct DatabaseAdapter {
    legacy_db: LegacyDatabase,
}
 
impl DatabaseAdapter {
    pub fn new(legacy_db: LegacyDatabase) -> Self {
        Self { legacy_db }
    }
}
 
impl DataSource for DatabaseAdapter {
    fn fetch_data(&self) -> Vec<String> {
        // Convert legacy format to expected format
        self.legacy_db
            .query_records()
            .into_iter()
            .map(|s| s.to_string())
            .collect()
    }
 
    fn get_metadata(&self) -> String {
        format!("Adapted: {}", self.legacy_db.get_schema_info())
    }
}
 
// Agent that uses the standard interface
pub struct DataAnalysisAgent;
 
impl DataAnalysisAgent {
    pub fn analyze(&self, source: &dyn DataSource) -> String {
        let data = source.fetch_data();
        let metadata = source.get_metadata();
        format!("Analyzed {} records from {}", data.len(), metadata)
    }
}

let legacy_db = LegacyDatabase::new("legacy://localhost:5432");
let adapter = DatabaseAdapter::new(legacy_db);
let agent = DataAnalysisAgent;
 
let result = agent.analyze(&adapter);
println!("{}", result);