collectionFunctions.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef collectionFunctions_H_
#define collectionFunctions_H_

#include <algorithm>
#include <functional>
#include <map>

namespace MAKLogger
{

   template< typename TPtr >
   struct DtSortByPtrObject
   {      
      bool operator() ( const TPtr left,const TPtr right ) const
      {
         return *left < *right;
      }
   };


   template <typename ColT,typename T>
   void DtCallMemberFunction(ColT& col,void (T::*func)())
   {
      std::mem_fun_t<void,T> mf = std::mem_fun(func);
      std::for_each(col.begin(),col.end(),mf);
   }

   template <typename K,typename V>
   void DtCallMemberFunction(std::map<K,V>& col,void (V::*func)())
   {
      std::mem_fun_t<void,V> mf = std::mem_fun(func);
      typename std::map<K,V>::iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         mf(iter->second);
      }
   }

   template <typename K,typename V>
   void DtCallMemberFunction(std::map<K,V*>& col,void (V::*func)())
   {
      std::mem_fun_t<void,V> mf = std::mem_fun(func);
      typename std::map<K,V*>::iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         mf(iter->second);
      }
   }

   template <typename ColT,typename T,typename Arg>
   void DtCallMemberFunction(ColT& col,void (T::*func)(Arg),Arg arg)
   {
      std::mem_fun1_t<void,T,Arg> mf = std::mem_fun(func);
      typename ColT::iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         mf(*iter,arg);
      }
   }


   template <typename K,typename V,typename Arg>
   void DtCallMemberFunction(std::map<K,V>& col,void (V::*func)(Arg),Arg arg)
   {
      std::mem_fun1_t<void,V,Arg> mf = std::mem_fun(func);
      typename std::map<K,V>::iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         mf(iter->second,arg);
      }
   }

   template <typename K,typename V,typename Arg>
      void DtCallMemberFunction(std::map<K,V*>& col,void (V::*func)(Arg),Arg arg)
   {
      std::mem_fun1_t<void,V,Arg> mf = std::mem_fun(func);
      typename std::map<K,V*>::iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         mf(iter->second,arg);
      }
   }

   template <typename T>
   void DtDeletePointerAndClear(T& col)
   {
      typename T::const_iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         delete *iter;
      }
      col.clear();
   }

   template <typename T>
      void DtDeleteArrayAndClear(T& col)
   {
      typename T::const_iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         delete[] *iter;
      }
      col.clear();
   }

   template <typename K,typename V>
   void DtDeletePointerAndClear(std::map<K,V>& col)
   {
      typename std::map<K,V>::const_iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         delete iter->second;
      }
      col.clear();
   }

   template <typename K,typename V>
   void DtDeleteArrayAndClear(std::map<K,V>& col)
   {
      typename std::map<K,V>::const_iterator iter = col.begin();
      for(;iter != col.end();++iter)
      {
         delete[] iter->second;
      }
      col.clear();
   }
}

#endif