---

generic_stdlib.h

Go to the documentation of this file.

#ifndef __GENERIC_STDLIB_H__
#define __GENERIC_STDLIB_H__

#include <map>
#include <utility>
#include <functional>
#include <string>
using std::string;
#include <vector>
#include <complex>

#include "genericalgs.h"


namespace Generic {

template<class key_type, class data_type>
void delete_contents(std::map<key_type, data_type*>& m)
{
  typedef typename std::map<key_type, data_type*>::iterator iterator;
  for (iterator i=m.begin(); i!=m.end(); i++) {
    delete (*i).second;
    m.erase(i);
  }
}


template <class T1, class T2>
inline std::pair<const T1, T2> make_pair_leftconst(const T1& x, const T2& y) {
  return std::pair<const T1, T2>(x, y);
}


template <class Arg, class Result>
struct unary_virtual_function : public std::unary_function<Arg, Result> {
  virtual ~unary_virtual_function() { }
  virtual Result operator() ( Arg ) =0;
};



template <class T, class N=string>
struct name_match : public std::unary_function<T*,bool> {
  name_match(const N& name_i) : name(name_i) { }
  bool operator() ( T* a) {  return name == a->name();  }
private:
  const N& name;
};



template <class T>
struct max_fnobj : public std::binary_function<T, T, T> {
  T operator()(const T& x, const T& y) const { return std::max(x,y); }
};



template <class T, class C, class N>
void insert_named(C& container, const N& name, T* objptr)
{
  typename C::iterator i =
    std::find_if(container.begin(),container.end(),name_match<T>(name));
  if (i==container.end())
    container.push_back(objptr);
  else {
    delete (*i);
    (*i) = objptr;
  }
}


template <class T, class C, class N>
T* find_named(C& container, const N& name)
{
  typename C::iterator i =
    std::find_if(container.begin(),container.end(),name_match<T>(name));
  return (i==container.end() ? 0 : (*i));
}



template <class T, class C, class N>
const T* find_named_const(const C& container, const N& name)
{
  typename C::const_iterator i =
    std::find_if(container.begin(),container.end(),name_match<T>(name));
  return (i==container.end() ? 0 : (*i));
}



template <class T> inline T sum(const std::vector<T>& A)
{  return std::accumulate(A.begin(),A.end(),T(0));  }
 


template<class T>
struct Polar : public std::binary_function<T,T,std::complex<T> > {
  inline std::complex<T> operator() (const T& rho,const T& theta) const

/* Workaround for bug in at least egcs-1.1.2, possibly GCC 2.95 as well */
#if (__GNUC__ && (__GNUC__ < 3))
    {  return polar<T>(rho,theta);  }
#else
    {  return std::polar<T>(rho,theta);  }
#endif
    
};


} /* namespace Generic */ 
#endif /* __GENERIC_STDLIB_H__ */

---