Polaris: Database.h Source File

Database.h Go to the documentation of this file. #ifndef _DATABASE_H #define _DATABASE_H /// /// /// /// \class Database /// \brief /// /// \endcode /// \section DESCRIPTION DESCRIPTION /// Database<key,data> /// owns(data), value(key) /// /// A template for a database for keys of type S /// to owned objects of type T where: /// /// \code /// 1. 'S' is a class with: /// /// a) <, == and << operators taking S& arguments. /// b) a copy constructor S(S &) to clone the /// input object or simple enough structure /// for the default copy constructor to work. /// /// 2. 'T' is a class derived from Listable. /// \endcode /// /// The database is implemented as a tree of pointers to /// whatever type is specified. Thus, all methods to /// insert elements into a database take a reference to the /// key and a pointer to the data and do not allocate space. /// (i.e., the database aliases whatever is inserted). However, /// the database takes over ownership of the data on insert /// and will delete only a map element and not its associated key. /// #include "ProtoDatabase.h" /// template <class S, class T> class Database : public ProtoDatabase<S, T> { protected: virtual INLINE void _kill_key(BMKey &key); ///< kill key (in this class, kill the owned key copy) public: INLINE Database(); INLINE Database(const Database<S, T> &m); virtual INLINE ~Database(); INLINE T &ins(const S &key, T *data); ///< Insert element with (key, data) into the database, and ///< return a reference to '*data' (for purposes of ///< programming convenience). ///< If a node with the equivalent key already exists, ///< delete the old one and replace it with the new one. INLINE void del(S &del_key); ///< delete element with key del_key INLINE T *grab(const S &del_key); ///< grab an element with key del_key INLINE void print(ostream & out, char *sep1, char *sep2) const; ///< print map to out with sep1 between key and data and sep2 between each ///< element of the map INLINE Database<S, T> & operator = (const Database<S, T> &l); ///< Copy operator completely copies the Database INLINE Listable *listable_clone() const; ///< Needed for Listable class. INLINE void print(ostream &o) const; ///< Needed for Listable class. }; #include "KeyIterator.h" ///< implementation template <class S, class T> INLINE void Database<S,T>::_kill_key(BMKey & key) { ///< Kill the owned copy of the original key S *key_ptr = (S *) key._keyptr; delete key_ptr; } template <class S, class T> INLINE Database<S, T>::Database() { ///< nothing to do } template <class S, class T> INLINE Database<S, T>::Database(const Database<S, T> &m) { ///< Invoke copy constructor (*this) = m; } template <class S, class T> INLINE Database<S, T>::~Database() { ///< Delete the information before the class disappears. clear(); } template <class S, class T> INLINE void Database<S,T>::print(ostream & out, char *sep1, char *sep2) const { out << "{"; for (KeyIterator<S,T> map_iter = *this; map_iter.valid(); ++map_iter) { BMKey printkey; printkey._keyptr = (void *) &map_iter.current_key(); _print(out, printkey); out << sep1 << map_iter.current_data() << sep2; } out << "}"; } template <class S, class T> INLINE T & Database<S, T>::ins(const S &key, T *data) { BMKey inskey; inskey._keyptr = (void *) new S(key); T *exists = (T *) BaseMapRoot::remove(inskey); if (exists) delete exists; BaseMap::ins(inskey, data); return CASTAWAY(T &) *data; } template <class S, class T> INLINE void Database<S, T>::del(S &key) { BMKey delkey; T *el; delkey._keyptr = (void *) &key; el = (T *) BaseMapRoot::remove(delkey); p_assert(el, "Database<S,T>::del(): No node found with specified key"); delete el; } template <class S, class T> INLINE T * Database<S, T>::grab(const S &key) { BMKey delkey; delkey._keyptr = (void *) &key; return (T *) BaseMapRoot::remove(delkey); } template <class S, class T> INLINE Database<S, T> & Database<S, T>::operator = (const Database<S, T> &m) { ///< Clear out current map clear(); ///< Copy all the items one by one for (KeyIterator<S, T> map_iter = m; map_iter.valid(); ++map_iter) ins( map_iter.current_key(), (T *) map_iter.current_data().listable_clone()); return *this; } template <class S, class T> INLINE Listable * Database<S, T>::listable_clone() const { return (Listable *) new Database<S,T>( *this ); } template <class S, class T> INLINE void Database<S, T>::print(ostream &o) const { print( o, ": ", ", " ); } ///< This interface is for testing purposes only. It invokes a non-virtual ///< member function to print a representation of the data structure at this ///< level of the Collection hierarchy, and, since it is not a class member ///< function, it must be explicitly instantiated before use. template <class S, class T> ostream & operator << (ostream & o, const Database<S, T> &m) { m.print(o, ": ", ", "); return o; } #endif

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:05:43 2005