#ifndef __RAT_Delete__
#define __RAT_Delete__

#include <vector>
#include <functional>
#include <map>

namespace RAT {

  template <typename T>
  void deepdelete_vector(std::vector<T*> &vect)
  {
    typename std::vector<T*>::iterator i;
    for (i=vect.begin(); i != vect.end(); i++)
      delete (*i);
    vect.clear();
  }

  template <typename T>
  void deepcopy_vector(std::vector<T*> &dest, const std::vector<T*> &src) {
    deepdelete_vector(dest);
    dest.resize(src.size());
    for (unsigned i=0; i < src.size(); i++)
      dest[i] = dynamic_cast<T*>(src[i]->Clone()); // Use Clone() for proper polymorphism
  }

  template <class T>
  class CompareFunc: public std::binary_function<T*, T*, bool> {
  public:
    virtual bool operator() (T*, T*) = 0;
  };

  // Clear a vector, forcing capacity to zero.
  // In C++98, std::vector::clear does not change capacity.
  template <class T>
  void clear_vector(std::vector<T>& vect) {
    std::vector<T>().swap(vect);
  }

  // Get the keys in a map
  //
  // target: map to get keys from
  // Returns vector of keys
  template <typename T, typename U>
  std::vector<T> keys_in_map( const std::map<T, U>& target )
  {
    std::vector<T> keys;
    for( typename std::map<T, U>::const_iterator iTer = target.begin(); iTer != target.end(); iTer++ )
      keys.push_back( iTer->first );
    return keys;
  }

  // Get the largest key in a map
  //
  // target: map to get keys from
  // Returns largest key
  template <typename T, typename U>
  T largest_key( const std::map<T, U>& target )
  {
    return target.rbegin()->first;
  }

} // namespace RAT

#endif