---

pointermap.h

Go to the documentation of this file.

#ifndef __POINTERMAP_H__
#define __POINTERMAP_H__

#include <map>
#include <string>
using std::string;
#include <algorithm>
#include <functional>

#include "generic_stdlib.h"
#include "pointerlookup.h"


template<class T, class K=string, bool owns_objects=true>
class PointerMap : public PointerLookup<T,K> {
public:
  typedef PointerMap<T,K,owns_objects> self;
  
  typedef K  key_type;

  typedef T* data_type;

  typedef std::pair<const key_type, data_type> value_type;

  typedef std::map< key_type, data_type > map_type;

  typedef typename map_type::iterator iterator;

  typedef typename map_type::const_iterator const_iterator;  

  typedef typename map_type::size_type size_type;

  
  PointerMap() { }
  virtual ~PointerMap() {  erase();  }

  PointerMap(const self& o)       { assert(0); abort(); }
  self& operator=( const self& o) { assert(0); abort(); }
  
  iterator       begin()       {  return m.begin();  } 
  const_iterator begin() const {  return m.begin();  } 
  iterator       end()         {  return m.end();    } 
  const_iterator end()   const {  return m.end();    } 
  std::pair<iterator,bool> insert(const value_type& x)  {  return m.insert(x);  }  

  void set(const key_type& k, const data_type d) {
    iterator existing = m.find(k);
    if (existing == end())
      insert(Generic::make_pair_leftconst(k,d));
    else {
      if (owns_objects) delete (*existing).second;
      (*existing).second=d;
    }
  }

  
  T* getptr(const key_type& k) {
    const_iterator existing = m.find(k);
    return (existing == end() ? 0 : (*existing).second);
  }

  const T* getptr(const key_type& k) const {
    const_iterator existing = m.find(k);
    return (existing == end() ? 0 : (*existing).second);
  }

    
  //  virtual T* clone() const { return new PointerMap(*this); };

  void erase() {
    if (owns_objects) 
      Generic::delete_contents(m);
    else
      m.erase(m.begin(),m.end());
  }

  void erase(const key_type& k) {
    T* ptr = getptr(k);
    if (ptr) {
      if (owns_objects) delete ptr;
      m.erase(k);
    }
  }

  size_type size() {  return m.size();  }
  
protected:
  map_type m;
};




template <class BaseType, class TableType=PointerMap<BaseType> >
class HasTable {
public:
  typedef TableType Table;
  typedef typename Table::key_type key_type;
  
  void table_set(const key_type& name, BaseType* i) {
    assert (i);  assert (name!=key_type());
    table_.set(name,i);
  }

  const Table& table() const {  return table_;  }

private:
  Table table_;
};


#endif /* __POINTERMAP_H__ */

---