use std::any::TypeId;
use std::marker;
use std::collections::HashMap;

#[derive(Clone, Copy)]
struct Database<KC, DC> {
    dbi: i32,
    marker: marker::PhantomData<(KC, DC)>,
}

impl<KC, DC> Database<KC, DC> {
    fn new(dbi: i32) -> Database<KC, DC> {
        Database { dbi, marker: marker::PhantomData }
    }
}

#[derive(Default)]
struct DatabaseStore {
    store: HashMap<String, (TypeId, TypeId, i32)>,
}

impl DatabaseStore {
    pub fn store_db<KC, DC>(&mut self, name: &str, db: Database<KC, DC>)
    where KC: 'static, DC: 'static,
    {
        let kc = TypeId::of::<KC>();
        let dc = TypeId::of::<DC>();
        self.store.insert(name.to_owned(), (kc, dc, db.dbi));
    }

    pub fn open_db<KC, DC>(&self, name: &str) -> Option<Database<KC, DC>>
    where KC: 'static, DC: 'static,
    {
        let curr_kc = TypeId::of::<KC>();
        let curr_dc = TypeId::of::<DC>();

        let (kc, dc, dbi) = self.store.get(name).cloned()?;

        if curr_kc == kc && curr_dc == dc {
            Some(Database::new(dbi))
        } else {
            None
        }
    }
}

fn main() {
    let mut store = DatabaseStore::default();

    let db = Database::<i32, u64>::new(32);
    store.store_db("i32-u64", db);

    let db = store.open_db::<u32, i64>("i32-u64");
    assert!(db.is_none());

    let db = store.open_db::<u32, String>("i32-u64");
    assert!(db.is_none());

    let db = store.open_db::<i32, u64>("i32-u64");
    assert!(db.is_some());
}