---

valuegenmap.h

Go to the documentation of this file.

#ifndef __VALUEGENMAP_H__
#define __VALUEGENMAP_H__

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

#include "valuegen.h"
#include "generic_stdlib.h"

/*
   Note: the various (*iterator).item constructions were originally
   written in the more natural form iterator->item, but they were
   changed to the uglier notation because the Cray T3E compiler (PE
   3.1) couldn't handle them.
*/

/******************************************************************************/
/* ValueGeneratorMap class hierarchy                                          */
/******************************************************************************/

template<class T, class K=string>
class ValueGeneratorMap : public ValueGen {
public:
  typedef K key_type;

  typedef ValueGenerator<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; 
  
  ValueGeneratorMap() { }

  ValueGeneratorMap(const ValueGeneratorMap& b)  /* Copy constructor */
    : ValueGen(b) {
    for (const_iterator i=b.begin(); i!=b.end(); i++)
      set((*i).first,(*i).second->clone());
  }
  
  ~ValueGeneratorMap() {  Generic::delete_contents(m);  }

  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);
  
  void set_default(const key_type& k, const T d);

  T get(const key_type& k) const;
    
  T* getptr(const key_type& k);

  const data_type getvalgenptr(const key_type& k) const;

  virtual bool next();
  virtual void reset();

  virtual void relink(const ValueGeneratorMap<T,K>* b);

  virtual void merge(const ValueGeneratorMap<T,K>& b);

  virtual ValueGeneratorMap<T,K>* clone() const { return new ValueGeneratorMap(*this); };

private:
  map_type m;
};



template<class T, class K>
void ValueGeneratorMap<T,K>::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 {
    delete (*existing).second;
    (*existing).second=d;
  }
}


template<class T, class K>
void ValueGeneratorMap<T,K>::set_default(const key_type& k, const T d)
{
  iterator existing = m.find(k);
  if (existing == end()) {
    insert(Generic::make_pair_leftconst(k,new ValueGenerator<T>(d)));
  }
}



template<class T, class K>
T ValueGeneratorMap<T,K>::get(const key_type& k) const
{
  const_iterator existing = m.find(k);
  return (existing == end() ? 0 : (*existing).second->value());
}



template<class T, class K>
T* ValueGeneratorMap<T,K>::getptr(const key_type& k)
{
  const_iterator existing = m.find(k);
  data_type secptr = (existing == end() ?
                        (*((insert(Generic::make_pair_leftconst(k,new ValueGenerator<T>(T())))).first)).second
                        : (*existing).second);

  return secptr->valueptr();
}



template<class T, class K>
const typename ValueGeneratorMap<T,K>::data_type ValueGeneratorMap<T,K>::getvalgenptr(const key_type& k) const
{
  const_iterator existing = m.find(k);
  return (existing == end() ? 0 : (*existing).second);
}



template<class T, class K>
bool ValueGeneratorMap<T,K>::next()
{
  bool status=true;
  for (iterator i=m.begin(); i!=m.end(); i++) {
    const bool newstatus = (*i).second->next();
    if (!newstatus) status=newstatus;
  }
  return status;
}



template<class T, class K>
void ValueGeneratorMap<T,K>::reset()
{
  for (iterator i=m.begin(); i!=m.end(); i++)
    (*i).second->reset();
}



template<class T, class K>
void ValueGeneratorMap<T,K>::relink(const ValueGeneratorMap<T,K>* b)
{
  if (b)
    for (iterator i=m.begin(); i!=m.end(); i++) {
      const_iterator lookup = b->m.find((*i).first);
      if (lookup != b->end())
        (*i).second->relink((*lookup).second->valueptr());
    }
}



template<class T, class K>
void ValueGeneratorMap<T,K>::merge(const ValueGeneratorMap<T,K>& b)
{
  for (const_iterator i=b.begin(); i!=b.end(); i++)
    set((*i).first,(*i).second->clone());
}
  


typedef ValueGeneratorMap<double> DGenMap;



#endif

---