DBase.hh

Go to the documentation of this file.

#ifndef __DBASE_HH__
#define __DBASE_HH__

#include <string>
#include <map>

#include "kk_defines.hh"
#include "kk_ptr.hh"

namespace DBase
{

  class DBErr : public KK::Err
  {
  public:
    DBErr(std::string s="") : KK::Err(s) { }
  };

  enum EntryTrait {
    persistent=0x1, 
    distributed=persistent<<1 
  };

  class Entry
  {
  public:
    Entry() : traits(0x0) { }

    virtual ~Entry() { }

    unsigned int traits;
    
  };

  template<typename T>
  class SpecializedEntry : public Entry
  {
  public:

    EXPLICIT SpecializedEntry(const T &e, void (*dd)(T &)=0) : 
      Entry(), entry(e), destroy_data(dd) { }

    EXPLICIT SpecializedEntry(void (*dd)(T &)) : Entry(), destroy_data(dd) { }

    EXPLICIT SpecializedEntry() : Entry(), destroy_data(0) { }

    virtual ~SpecializedEntry() 
    { if (destroy_data) destroy_data(entry); }

    T & operator*() { return entry; }

    const T & operator*() const { return entry; }

  private:

    SpecializedEntry(SpecializedEntry<T> &t) { }

    T entry;

    void (*destroy_data)(T &);

  };

  typedef KK::sptr<Entry> EntryP;

  template<typename T> 
  bool can_cast_entry(Entry &e)
  { return dynamic_cast< SpecializedEntry< T > * >(&e); }

  template<typename T> 
  bool can_cast_entry(EntryP &e)
  { return KK::sptr_dynamic_cast< SpecializedEntry<T> >(e); }

  template<typename T> 
  T & cast_entry(Entry &e)
  { 
    KK::Assert<DBErr> ( can_cast_entry<T>(e), " cannot cast entry to mismatched type");
    SpecializedEntry<T> & p = dynamic_cast< SpecializedEntry< T > & > (e);
    return *p;
  }

  template<typename T> 
  T & cast_entry(EntryP &e)
  { 
    KK::Assert<DBErr> ( can_cast_entry<T>(e), " cannot cast entry to mismatched type");
    SpecializedEntry<T> & p = *KK::sptr_dynamic_cast< SpecializedEntry< T > > (e);
    return *p;
  }

  class DataBase
  {
    typedef std::map< std::string, DBase::EntryP > dbtype;
    //    typedef std::map< std::string, Entry *> dbtype;

  public:
    DataBase() { }


    DataBase(const DataBase &d) : db(d.db) { }

    virtual ~DataBase() 
    { 
      clear();
    }

    virtual void clear()
    {

      // sptr now takes care of deletes
//       for ( dbtype::iterator i=this->db.begin(); i!=this->db.end(); i++ )
//      //      if ( (*i).second !=NULL ) 
//      if ( (*i).second  ) 
//        delete (*i).second;
//      else
//        throw DBErr();

      this->db.clear();
    }


    template<typename T>
    inline
    T &
    put(std::string name, const T &entry, void (*entry_destructor)(T&)=0) 
    {
      KK::Assert<DBErr> ( name!="", "cannot use empty name" );
      KK::Assert<DBErr> ( this->db.count(name)==0, "name "+name+" already in use!");
      KK::sptr< SpecializedEntry<T> > spece = new SpecializedEntry<T>(entry,entry_destructor); 
      this->db[name] = KK::sptr_dynamic_cast<Entry>( spece );
      //      this->db[name] = dynamic_cast<Entry *>( spece );

      return get<T>(name);
    }

    template<typename T>
    inline
    T &
    put(std::string name, void (*entry_destructor)(T&)=0) 
    {
      KK::Assert<DBErr> ( name!="", "cannot use empty name" );
      KK::Assert<DBErr> ( this->db.count(name)==0, "name "+name+" already in use!");
      KK::sptr< SpecializedEntry<T> > spece = new SpecializedEntry<T>(entry_destructor); 
      this->db[name] = KK::sptr_dynamic_cast<Entry>( spece );
      //      this->db[name] = dynamic_cast<Entry *>( spece );

      return get<T>(name);
    }

    template<typename T>
    inline
    T &
    get(std::string name)
    {
      KK::Assert<DBErr> ( this->db.count(name)==1, "name "+name+" not in database!" );

      KK::sptr< SpecializedEntry<T> > p = KK::sptr_dynamic_cast< SpecializedEntry< T >  > (this->db[name]);
      //      SpecializedEntry<T> * p = dynamic_cast< SpecializedEntry< T > * > (this->db[name]);

      KK::Assert<DBErr> ( p , "type mismatch for variable "+name );
      return **p;
    }

    template<typename T>
    inline
    const T &
    get(std::string name) const
    {
      KK::Assert<DBErr> ( this->db.count(name)==1, "name "+name+" not in database!" );

      KK::sptr< SpecializedEntry<T> > p = KK::sptr_dynamic_cast< SpecializedEntry< T >  > (this->db[name]);
      //      SpecializedEntry<T> * p = dynamic_cast< SpecializedEntry< T > * > (this->db[name]);

      KK::Assert<DBErr> ( p , "type mismatch for variable "+name );

      return **p;
    }

    inline
    const KK::sptr< Entry >
    getEntry(std::string name) const
    {
      KK::Assert<DBErr> ( this->db.count(name)==1, "name "+name+" not in database!" );
      return this->db[name];
    }

    void
    remove(std::string name) 
    {
      KK::Assert<DBErr> ( this->db.count(name)==1, "name "+name+" not in database!" );
      
      //sptr takes care of this      if ( this->db[name]!=NULL ) delete this->db[name];
      
      this->db.erase(name);
    }

    void toggleTrait(std::string name, int t)
    { 
      KK::Assert<DBErr> ( this->db.count(name)==1, "name "+name+" not in database!" );
      
      if ( this->db[name]->traits & t )
        this->db[name]->traits ^= t;
      else
        this->db[name]->traits |= t;

    }

    bool traitActive(std::string name, int t)
    {
      KK::Assert<DBErr> ( this->db.count(name)==1, "name "+name+" not in database!" );
      
      return this->db[name]->traits & t;
    }

    bool has_key(std::string name) const { return this->db.count(name)!=0; }

    size_t size() const { return db.size(); }

    typedef void (*EntryProcessingFunction)(std::string , Entry &);

    void processEntries(EntryProcessingFunction func)
    {
      for ( dbtype::iterator i=this->db.begin(); i!=this->db.end(); i++ )
        func((*i).first, *((*i).second));
    }

    template<class F>
    inline
    void processEntries(F &func)
    {
      for ( dbtype::iterator i=this->db.begin(); i!=this->db.end(); i++ )
        func((*i).first, *((*i).second));
    }

    template<class F>
    inline
    void processEntries(const F &func)
    {
      for ( dbtype::iterator i=this->db.begin(); i!=this->db.end(); i++ )
        func((*i).first, *((*i).second));
    }

    void merge( DataBase &db_in ) throw(DBErr)
    {
      for ( iterator n=db_in.begin(); n!=db_in.end(); n++ )
        {
          if ( !has_key( n->first ) )
            db.insert(*n);
          else
            throw DBErr("cannot merge databases with duplicate entries");
        }
    }


    void link( DataBase &from, std::string from_nm, std::string to_nm )
    {
      KK::Assert<DBErr> ( !has_key(to_nm), "name "+to_nm+" already in use!");
      KK::Assert<DBErr> ( from.has_key(from_nm), "name "+to_nm+" not in link database!");

      db[to_nm] = from.db[from_nm];
    }


    void link( DBase::EntryP &from, std::string to_nm )
    {
      KK::Assert<DBErr> ( !has_key(to_nm), "name "+to_nm+" already in use!");

      db[to_nm] = from;
    }

    typedef dbtype::iterator iterator;
    typedef dbtype::const_iterator const_iterator;

    iterator begin() { return db.begin(); }
    const_iterator begin() const { return db.begin(); }
    iterator end() { return db.end(); }
    const_iterator end() const { return db.end(); }

  private:
    mutable dbtype db;
  };
}

#endif