TemplateUtil.h

Go to the documentation of this file.

#ifndef _TemplateUtil_
#define _TemplateUtil_

#include <functional>
#include <iterator>
#include <iostream>

namespace TemplateUtil
{








template <class Predicate>
struct binary_deref : public binary_function<
                    typename Predicate::first_argument_type *,
                    typename Predicate::second_argument_type *, bool>
{
  typedef typename binary_function<typename Predicate::first_argument_type *,
                                  typename Predicate::second_argument_type *,
                              bool>::first_argument_type first_argument_type;
  typedef typename binary_function<typename Predicate::first_argument_type *,
                                  typename Predicate::second_argument_type *,
                              bool>::second_argument_type second_argument_type;
  typedef typename binary_function<typename Predicate::first_argument_type *,
                                  typename Predicate::second_argument_type *,
                              bool>::result_type result_type;

  explicit binary_deref(const Predicate& p)
  {
    myPred = p;
  }
  bool operator() (const first_argument_type &x,
                  const second_argument_type &y) const
  {
    return myPred(*x, *y);
  }


  Predicate myPred;
};

template <class Predicate>
struct unary_deref : public unary_function<typename Predicate::argument_type*,
                                  bool>
{
  typedef typename unary_function<typename Predicate::argument_type *,
                           bool>::argument_type argument_type;
  typedef typename unary_function<typename Predicate::argument_type *,
                           bool>::result_type result_type;

  explicit unary_deref(const Predicate& p)
  {
   myPred = p;
  }
  bool operator()(const argument_type &arg) const
  {
   return myPred(*arg);
  }
  Predicate myPred;
};

template <class Predicate>
unary_deref<Predicate> deref1(const Predicate& p)
{
  return unary_deref<Predicate>(p);
}
template <class Predicate>
binary_deref<Predicate> deref2(const Predicate& p)
{
  return binary_deref<Predicate>(p);
}


template <typename Return, typename T, typename Predicate>
struct const_comp_mem_fun_ref_t : public binary_function<T, T, bool>
{
  Return (T::*memberFunc) () const;
  Predicate myPred;

  explicit const_comp_mem_fun_ref_t(Return (T::*func) () const, Predicate p) :
    memberFunc(func), myPred(p)
  {}
  bool operator() (const T& argl, const T& arg2)
  {
   return myPred((argl.*memberFunc) (), (arg2.*memberFunc) ());
  }
};

template <typename Return, typename T, typename Pred>
inline const_comp_mem_fun_ref_t<Return,T,Pred>
                   const_comp_mem_fun_ref(Return (T::*f) () const, Pred p)
{
  return const_comp_mem_fun_ref_t<Return,T,Pred>(f, p);
}

template <typename Return, typename T, typename Predicate>
struct const_comp_mem_fun_t : public binary_function<T*, T*, bool>
{
  Return (T::*memberFunc) () const;
  Predicate myPred;

  explicit const_comp_mem_fun_t(Return (T::*func) () const, Predicate p) :
    memberFunc(func), myPred(p)
  {}
  bool operator() (const T* arg1, const T* arg2)
  {
    return myPred((arg1->*memberFunc) (), (arg2->*memberFunc) ());
  }
};

template <typename Return, typename T, typename Pred>
inline const_comp_mem_fun_t<Return,T,Pred>
                       const_comp_mem_fun(Return (T::*f) () const, Pred p)
{
  return const_comp_mem_fun_t<Return,T,Pred>(f, p);
}

template <typename Return, typename T, typename Predicate>
struct comp_mem_fun_ref_t : public binary_function<T, T, bool>
{
  Return (T::*memberFunc) ();
  Predicate myPred;

  explicit comp_mem_fun_ref_t(Return (T::*func) (), Predicate p) :
    memberFunc(func), myPred(p)
  {}
  bool operator() (const T& argl, const T& arg2)
  {
    return myPred((argl.*memberFunc) (), (arg2.*memberFunc) ());
  }
};

template <typename Return, typename T, typename Pred>
inline comp_mem_fun_ref_t<Return,T,Pred> comp_mem_fun_ref(Return (T::*f) (),
                                                          Pred p)
{
  return comp_mem_fun_ref_t<Return,T,Pred>(f, p);
}

template <typename Return, typename T, typename Predicate>
struct comp_mem_fun_t : public binary_function<T*, T*, bool>
{
  Return (T::*memberFunc) ();
  Predicate myPred;

  explicit comp_mem_fun_t(Return (T::*func) (), Predicate p) :
    memberFunc(func), myPred(p)
  {}
  bool operator() (const T* argl, const T* arg2)
  {
   return myPred((argl->*memberFunc) (), (arg2->*memberFunc) ());
  }
};

template <typename Return, typename T, typename Pred>
inline comp_mem_fun_t<Return,T,Pred> comp_mem_fun(Return (T::*f) () , Pred p)
{
  return comp_mem_fun_t<Return,T, Pred>(f, p);
}





template <typename T>
struct PtrLess : public binary_function<T*,T*,bool>
{
  bool operator() (const T* left, const T* right) const
  {
    return (*left < *right);
  }
};
template <typename T>
struct PtrGreater : public binary_function<T*,T*,bool>
{
  bool operator() (const T* left, const T* right) const
  {
     return (*right < *left);
  }
};

template <typename T>
struct PtrLessEq : public binary_function<T*,T*,bool>
{
  bool operator() (const T* left, const T* right) const
  {
    return (*left < *right) || (*left == *right);
  }
};

template <typename T>
struct PtrGreaterEq: public binary_function<T*,T*,bool>
{
  bool operator() (const T* left, const T* right) const
  {
    return !(*left < *right);
  }
};

template <typename T>
struct PtrEq: public binary_function<T*,T*,bool>
{
  bool operator() (const T* left, const T* right) const
  {
    return (*left == *right);
  }
};

template <typename T>
struct PtrNotEq: public binary_function<T*,T*,bool>
{
  bool operator() (const T* left, const T* right) const
  {
    return !(*left == *right);
  }
};

template<typename Arg>
struct AlwaysTrueComp : public unary_function<Arg, bool>
{
  bool operator() (const Arg&) { return true; }
};







template <typename T>
struct DeleteObj : public unary_function<T, void>
{
  void operator() (T ptr) const
  {
    delete ptr;
  }
};

template<typename Base, typename Arg>
struct InheritedFrom : public unary_function<Arg*, bool>
{
  bool operator() (const Arg* a)
  {
    return (dynamic_cast<const Base*>(a)!=0);
  }
};







template <typename C, typename Function>
void for_all(C &collection, Function f)
{
  for_each(collection.begin(), collection.end(), f);
}

template <typename T, typename Comparator>
void erase_if(T &collection, const Comparator &c)
{
  collection.erase(remove_if(collection.begin(), collection.end(), c),
                       collection.end());
}

template <typename T, typename InputIterator, typename Comparator>
void erase_if(T &collection, InputIterator begin,
           InputIterator end, const Comparator &c)
{
  collection.erase(remove_if(begin, end, c), end);
}

template <typename C>
void delete_all(C &collection)
{
  for_each(collection.begin(), collection.end(),
           DeleteObj<typename C::value_type>());
  collection.erase(collection.begin(), collection.end());
}

template <typename C>
void delete_all_second(C &collection)
{
  for( typename C::iterator i = collection.begin(); i != collection.end(); ++i)
    delete i->second;
  collection.erase(collection.begin(), collection.end());
}

template <typename C>
void print_col(C &collection, ostream &os = cout, const char *d = "\n")
{
  copy(collection.begin(), collection.end(),
       ostream_iterator<typename C::value_type>(os,d));
}

template <typename C>
void print_ptr_col(C &collection, ostream &os = cout, const char *d = "\n")
{
  for ( typename C::const_iterator i = collection.begin(); 
        i!=collection.end(); ++i)
    os<<**i<<d;
}

template <typename C>
void merge_ptr_col(C &dest, const C&source)
{
  for ( typename C::const_iterator i = source.begin(); i!=source.end(); ++i)
    dest.push_back((*i)->clone());
}

template <typename InputIterator, typename T>
InputIterator find_second( InputIterator first, InputIterator last,
                     const T& v)
{
  while( first != last && !(first->second == v))
   ++first;
  return first;
}

template <typename InputIterator, typename Type, typename Predicate>
InputIterator find_second_if( InputIterator first, InputIterator last,
                              const Predicate &c)
{
  while( first != last && !c(first->second))
    ++first;
  return first;
}

template <typename InputIterator, typename T>
InputIterator find_first( InputIterator first, InputIterator last,
                          const T& v)
{
  while( first != last && !(first->first == v))
    ++first;
  return first;
}

template <typename InputIterator, typename Type, typename Predicate>
InputIterator find_first_if( InputIterator first, InputIterator last,
                        const Predicate &c)
{
  while( first != last && !c(first->first))
    ++first;
  return first;
}

template <typename InputIterator, typename OutputIterator, typename Predicate>
OutputIterator copy_if( InputIterator first,
                              InputIterator last,
                              OutputIterator dest,
                              Predicate pred)
{
  while( first != last)
  {
    if( pred( *first)) *dest++ = *first;
    ++first;
  }
  return dest;
}

template <typename InputIterator, typename OutputIterator, typename Predicate>
OutputIterator copy_second_if( InputIterator first,
                                        InputIterator last,
                                        OutputIterator dest,
                                        Predicate pred)
{
  while( first != last)
  {
    if( pred(first->second)) *dest++ = first->second;
    ++first;
  }
  return dest;
}

template <typename type>
const type& max(const type &a, const type &b)
{
  return b<a? a:b;
}

template <typename type>
const type& min(const type &a, const type &b)
{
  return b<a? b:a;
}

} // End Namespace

#endif

---