templateUtil.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (c) 2012 MAK Technologies, Inc.
 * All rights reserved.
 *****************************************************************************/


#pragma once

#include <vlutil/vlExceptions.h>
#include <functional>
#include <algorithm>
#include <vector>
#include <map>

// Expand the provide macro.
#define DO_PP(MACRO) MACRO

// Theses macros make it easy to define VAR-ARG template classes.

// Make stream puts an 'word' with the index prepended separated by "<<"
// Example MAKE_STREAM_1(A) output A1
// Example MAKE_STREAM_2(A) output A1 << A2
#define MAKE_STREAM_1(word) word##1
#define MAKE_STREAM_2(word) MAKE_STREAM_1(word)<<word##2
#define MAKE_STREAM_3(word) MAKE_STREAM_2(word)<<word##3
#define MAKE_STREAM_4(word) MAKE_STREAM_3(word)<<word##4
#define MAKE_STREAM_5(word) MAKE_STREAM_4(word)<<word##5
#define MAKE_STREAM_6(word) MAKE_STREAM_5(word)<<word##6
#define MAKE_STREAM_7(word) MAKE_STREAM_6(word)<<word##7
#define MAKE_STREAM_8(word) MAKE_STREAM_7(word)<<word##8
#define MAKE_STREAM_9(word) MAKE_STREAM_8(word)<<word##9

#define MAKE_STREAM(word,count) DO_PP(MAKE_STREAM_##count(word))


// Make stream puts an 'word' with the index prepended separated by ">>"
// Example MAKE_STREAMOUT_1(A) output A1
// Example MAKE_STREAMOUT_2(A) output A1 >> A2
#define MAKE_STREAMOUT_1(word) word##1
#define MAKE_STREAMOUT_2(word) MAKE_STREAMOUT_1(word)>>word##2
#define MAKE_STREAMOUT_3(word) MAKE_STREAMOUT_2(word)>>word##3
#define MAKE_STREAMOUT_4(word) MAKE_STREAMOUT_3(word)>>word##4
#define MAKE_STREAMOUT_5(word) MAKE_STREAMOUT_4(word)>>word##5
#define MAKE_STREAMOUT_6(word) MAKE_STREAMOUT_5(word)>>word##6
#define MAKE_STREAMOUT_7(word) MAKE_STREAMOUT_6(word)>>word##7
#define MAKE_STREAMOUT_8(word) MAKE_STREAMOUT_7(word)>>word##8
#define MAKE_STREAMOUT_9(word) MAKE_STREAMOUT_8(word)>>word##9

#define MAKE_STREAMOUT(word,count) DO_PP(MAKE_STREAMOUT_##count(word))



//Make list puts an 'word' with the index prepended separated by ","
//Example MAKE_LIST_1(A) output A1
//Example MAKE_LIST_2(A) output A1,A2
#define MAKE_LIST_1(word) word##1
#define MAKE_LIST_2(word) MAKE_LIST_1(word),word##2
#define MAKE_LIST_3(word) MAKE_LIST_2(word),word##3
#define MAKE_LIST_4(word) MAKE_LIST_3(word),word##4
#define MAKE_LIST_5(word) MAKE_LIST_4(word),word##5
#define MAKE_LIST_6(word) MAKE_LIST_5(word),word##6
#define MAKE_LIST_7(word) MAKE_LIST_6(word),word##7
#define MAKE_LIST_8(word) MAKE_LIST_7(word),word##8
#define MAKE_LIST_9(word) MAKE_LIST_8(word),word##9

#define MAKE_LIST(word,count) DO_PP(MAKE_LIST_##count(word))

//Make multilist puts two words 'first' then 'second' each with the index of the 
//pair, prepended separated by ","
//Example MAKE_MULTILIST_1(A,::B) output A1::B1
//Example MAKE_MULTILIST_2(A,::B) output A1::B1,A2::B2
#define MAKE_MULTILIST_1(first,second) first##1 second##1
#define MAKE_MULTILIST_2(first,second) MAKE_MULTILIST_1(first,second),first##2 second##2
#define MAKE_MULTILIST_3(first,second) MAKE_MULTILIST_2(first,second),first##3 second##3
#define MAKE_MULTILIST_4(first,second) MAKE_MULTILIST_3(first,second),first##4 second##4
#define MAKE_MULTILIST_5(first,second) MAKE_MULTILIST_4(first,second),first##5 second##5
#define MAKE_MULTILIST_6(first,second) MAKE_MULTILIST_5(first,second),first##6 second##6
#define MAKE_MULTILIST_7(first,second) MAKE_MULTILIST_6(first,second),first##7 second##7
#define MAKE_MULTILIST_8(first,second) MAKE_MULTILIST_7(first,second),first##8 second##8
#define MAKE_MULTILIST_9(first,second) MAKE_MULTILIST_8(first,second),first##9 second##9

#define MAKE_MULTILIST(first,second,count) DO_PP(MAKE_MULTILIST_##count(first,second))


//A slightly odd macro, needed to for a series of inline functions. 
//pair, prepended separated by ","
//Example MAKE_CAST_CALL_1(A,B,C,D) output A1B(C,D1)
//Example MAKE_CAST_CALL_2(A,::B,C)output A1B(C,D1),A2B(C,D2)
#define MAKE_CAST_CALL_1(first,second,third,forth) first##1 second(third,forth##1)
#define MAKE_CAST_CALL_2(first,second,third,forth) MAKE_CAST_CALL_1(first,second,third,forth),first##2 second(third,forth##2)
#define MAKE_CAST_CALL_3(first,second,third,forth) MAKE_CAST_CALL_2(first,second,third,forth),first##3 second(third,forth##3)
#define MAKE_CAST_CALL_4(first,second,third,forth) MAKE_CAST_CALL_3(first,second,third,forth),first##4 second(third,forth##4)
#define MAKE_CAST_CALL_5(first,second,third,forth) MAKE_CAST_CALL_4(first,second,third,forth),first##5 second(third,forth##5)
#define MAKE_CAST_CALL_6(first,second,third,forth) MAKE_CAST_CALL_5(first,second,third,forth),first##6 second(third,forth##6)
#define MAKE_CAST_CALL_7(first,second,third,forth) MAKE_CAST_CALL_6(first,second,third,forth),first##7 second(third,forth##7)
#define MAKE_CAST_CALL_8(first,second,third,forth) MAKE_CAST_CALL_7(first,second,third,forth),first##8 second(third,forth##8)
#define MAKE_CAST_CALL_9(first,second,third,forth) MAKE_CAST_CALL_8(first,second,third,forth),first##9 second(third,forth##9)

#define MAKE_CAST_CALL(first,second,third,forth,count) DO_PP(MAKE_CAST_CALL_##count(first,second,third,forth))


//Make list puts an 'word' with the index prepended separated by ";"
//Example MAKE_DECL_LIST_1(int A) output int A
//Example MAKE_DECL_LIST_1(int A) output int A1; int A2
#define MAKE_DECL_LIST_1(word) word##1
#define MAKE_DECL_LIST_2(word) MAKE_DECL_LIST_1(word);word##2
#define MAKE_DECL_LIST_3(word) MAKE_DECL_LIST_2(word);word##3
#define MAKE_DECL_LIST_4(word) MAKE_DECL_LIST_3(word);word##4
#define MAKE_DECL_LIST_5(word) MAKE_DECL_LIST_4(word);word##5
#define MAKE_DECL_LIST_6(word) MAKE_DECL_LIST_5(word);word##6
#define MAKE_DECL_LIST_7(word) MAKE_DECL_LIST_6(word);word##7
#define MAKE_DECL_LIST_8(word) MAKE_DECL_LIST_7(word);word##8
#define MAKE_DECL_LIST_9(word) MAKE_DECL_LIST_8(word);word##9

#define MAKE_DECL_LIST(word,count) DO_PP(MAKE_DECL_LIST_##count(word))

//Make list puts an 'word' with the index prepended separated by ";"
//Example MAKE_DECL_LIST_1(int A) output int A
//Example MAKE_DECL_LIST_1(int A) output int A1; int A2
#define MAKE_DECL_MULTILIST_1(first,second) first##1 second##1
#define MAKE_DECL_MULTILIST_2(first,second) MAKE_DECL_MULTILIST_1(first,second);first##2 second##2
#define MAKE_DECL_MULTILIST_3(first,second) MAKE_DECL_MULTILIST_2(first,second);first##3 second##3
#define MAKE_DECL_MULTILIST_4(first,second) MAKE_DECL_MULTILIST_3(first,second);first##4 second##4
#define MAKE_DECL_MULTILIST_5(first,second) MAKE_DECL_MULTILIST_4(first,second);first##5 second##5
#define MAKE_DECL_MULTILIST_6(first,second) MAKE_DECL_MULTILIST_5(first,second);first##6 second##6
#define MAKE_DECL_MULTILIST_7(first,second) MAKE_DECL_MULTILIST_6(first,second);first##7 second##7
#define MAKE_DECL_MULTILIST_8(first,second) MAKE_DECL_MULTILIST_7(first,second);first##8 second##8
#define MAKE_DECL_MULTILIST_9(first,second) MAKE_DECL_MULTILIST_8(first,second);first##9 second##9

#define MAKE_DECL_MULTILIST(first,second,count) DO_PP(MAKE_DECL_MULTILIST_##count(first,second))

#ifdef _WIN32
#define EXPORT_TEMPLATE_TYPEDEF(C,TD)\
   typedef C TD;
#else
#define EXPORT_TEMPLATE_TYPEDEF(C,TD)\
   typedef C TD;\
   template class C;
#endif

// FAST_REPEATED_CALL implements/mimics Duff's Device.
// A Google search will provide examples and explanations.
#define FAST_REPEATED_CALL(count,x) \
{ \
   if(count > 0) \
   { \
      size_t __FAST_ITERATE_count = count;\
      size_t __FAST_ITERATE_n = (__FAST_ITERATE_count + 7) >> 3; \
      switch (__FAST_ITERATE_count & 7) \
      { \
         case 0: do { x;\
         case 7: x; \
         case 6: x; \
         case 5: x; \
         case 4: x; \
         case 3: x; \
         case 2: x; \
         case 1: x; \
         } while (--__FAST_ITERATE_n > 0);\
      }\
   }\
}


namespace makVrv
{

//Used to search a key in a map, and return NULL if it is not found.
template <typename K,typename V, typename Pr,typename Alloc>
V* DtFindPointerInMap(const std::map<K,V,Pr,Alloc>& map,K key)
{
   typename std::map<K,V,Pr,Alloc>::const_iterator iter = map.find(key);
   if(iter == map.end())
   {
      return 0;
   }
   else
   {
      return const_cast<V*>(&iter->second);
   }
}

template <typename M>
void DtClearAndDeletePointersInMap( M& map )
{
   typename M::mapped_type ptr;
   typename M::iterator curIter = map.begin();
   typename M::const_iterator endIter = map.end();
   for ( ; curIter != endIter; ++curIter )
   {
      ptr = curIter->second;
      curIter->second = 0;
      delete ptr;
   }
   map.clear();
}

template <typename V>
void DtClearAndDeletePointersInVector( V& vec )
{
   typename V::value_type ptr;
   typename V::iterator curIter = vec.begin();
   typename V::iterator endIter = vec.end();
   for ( ; curIter != endIter; ++curIter )
   {
      ptr = *curIter;
      (*curIter) = 0;
      delete ptr;
   }
   vec.clear();
}

template <typename Iter>
void DtDeletePointersInIterators(Iter begin, Iter end)
{
   for(Iter cur = begin;cur != end;++cur)
   {
      delete *cur;
   }
}

template <typename Key, typename Value>
struct SortByFirst
{
   inline bool operator()(const std::pair<Key,Value>& a, const std::pair<Key,Value>& b) const
   {
      return a.first < b.first;
   }
};


template <typename T,typename R,typename A>
std::binder1st<std::mem_fun1_t<R,T,A> > callMemberFunction(R (T::*memfun)(A),T* ptr)
{
   return std::bind1st(std::mem_fun(memfun),ptr);
}

template <typename T,typename R,typename A>
std::binder1st<std::mem_fun1_t<R,T,A> > callMemberRefFunction(R (T::*memfun)(A&),T* ptr)
{
   return std::bind1st(std::mem_fun(memfun),ptr);
}

template <typename T,typename R,typename A>
std::binder1st<std::mem_fun1_t<R,T,A> > callMemberConstRefFunction(R (T::*memfun)(const A&),T* ptr)
{
   return std::bind1st(std::mem_fun(memfun),ptr);
}

template <typename T,typename R,typename A,typename Col>
void forEachCallMember( T* _this, R (T::*memfun)(A),Col& col)
{
   typename Col::iterator curIter = col.begin();
   typename Col::iterator endIter = col.end();
   for(;curIter != endIter;++curIter)
   {
      (_this->*memfun)(*curIter);
   }
}

template <typename Ret,typename AT,typename Class>
Ret callConstFunction1(const Class* _this,
                       const Ret (Class::* memberPtr)(AT) const,
                       AT param)
{
  return const_cast<Ret>(_this->*(memberPtr)(param));
}

class DtDe;

template <typename T, void(T::*MF)()>
void DtMemberFunctionCallback(DtDe* de,void* data)
{
   (((T*)data)->*MF)();
}

template <class InputIterator1, class InputIterator2, class OutputIterator1,class OutputIterator2>
void set_split_difference ( InputIterator1 first1, InputIterator1 last1,
   InputIterator2 first2, InputIterator2 last2,
   OutputIterator1 result1,
   OutputIterator2 result2 )
{
   while (first1!=last1 && first2!=last2)
   {
      if (*first1<*first2) 
      {
         *result1++ = *first1++;
      }
      else if (*first2<*first1) 
      {
         *result2++ = *first2++;
      }
      else
      {
         first1++;
         first2++;
      }

   }
   copy(first1,last1,result1);
   copy(first2,last2,result2);
}

//#include <boost/bind.hpp>
//#include <boost/signals.hpp>
//
//template <typename Argument>
//void forwardSignal(boost::signal<void (Argument)>& emitter,
//{
//}
//
//template <typename Argument,typename Argument2>
//void forwardSignal(boost::signal<void (Argument,Argument2)>& emitter,
//{
//}

template <typename iter, typename T>
iter fasterFind(size_t size, iter begin, iter end,const T& value)
{
   FAST_REPEATED_CALL(size, {if(*begin == value) return begin; else ++begin;} )
   return end;
}

template <typename iter, typename F>
iter fastFindPred(size_t size, iter begin, iter end,const F& pred)
{
   FAST_REPEATED_CALL(size, {if(pred(*begin)) return begin; else ++begin;} )
   return end;
}

template <typename T, typename Ax >
void fastEraseFromUnsortedVector(std::vector<T,Ax>& list, const T& value)
{
   size_t size = list.size();
   if(size == 0)
   {
      return;
   }
   else
   {
      typename std::vector<T,Ax>::iterator i = fasterFind(size,list.begin(),list.end(),value);
      if(i != list.end())
      {
         if(size == 1)
         {
            list.resize(0);
         }
         else
         {
            if(&(*i) != &list.back())
            {
               *i = list.back();
            }
            list.resize(size - 1);
         }
      }
   }
}

template <typename T, typename Ax >
void fastEraseFromUnsortedVector(std::vector<T*,Ax>& list, const T* value)
{
   size_t size = list.size();
   if(size == 0)
   {
      return;
   }
   else if(size == 1)
   {
      list.resize(0);
   }
   else
   {
      typename std::vector<T*,Ax>::iterator i = fasterFind(size,list.begin(),list.end(),value);
      if(i != list.end())
      {
         if(&(*i) != &list.back())
         {
            *i = list.back();
         }
         list.resize(size - 1);
      }
   }
}

template <typename T, typename Ax, typename Function >
void fastEraseFromUnsortedVectorPred(std::vector<T,Ax>& list, const Function& f)
{
   size_t size = list.size();
   if(size == 0)
   {
      return;
   }
   else if(size == 1)
   {
      list.resize(0);
   }
   else
   {
      typename std::vector<T,Ax>::iterator i = fastFindPred(size,list.begin(),list.end(),f);
      if(i != list.end())
      {
         if(&(*i) != &list.back())
         {
            *i = list.back();
         }
         list.resize(size - 1);
      }
   }
}

template <typename T, typename Ax, typename Function>
void fastEraseFromUnsortedVectorPred(std::vector<T*,Ax>& list, const Function& f)
{
   size_t size = list.size();
   if(size == 0)
   {
      return;
   }
   else if(size == 1)
   {
      list.resize(0);
   }
   else
   {
      typename std::vector<T*,Ax>::iterator i =fastFindPred(size,list.begin(),list.end(), f );
      if(i != list.end())
      {
         if(&(*i) != &list.back())
         {
            *i = list.back();
         }
         list.resize(size - 1);
      }
   }
}

template <typename Ret, typename T>
struct SortPointersByFunction_T
{
   typedef Ret (T::*MemberFnPtr)() const;
   MemberFnPtr myPtr;

   SortPointersByFunction_T(MemberFnPtr memFun)
      : myPtr(memFun)
   {
   }

   SortPointersByFunction_T(const SortPointersByFunction_T<Ret,T>& second)
      : myPtr(second.myPtr)
   {
   }

   bool operator()(const T* a, const T* b) const
   {
      return (a->*myPtr)() < (b->*myPtr)();
   }
};

template <typename Ret, typename T>
inline SortPointersByFunction_T<Ret,T> SortPointersByFunction(Ret (T::*ptr)() const)
{
   return SortPointersByFunction_T<Ret,T>(ptr);
}

template <typename Ret, typename T>
struct EqualPointerByFunction_T
{
   typedef Ret (T::*MemberFnPtr)() const;
   MemberFnPtr myPtr;
   Ret myValue;

   EqualPointerByFunction_T(MemberFnPtr memFun, Ret value)
   : myPtr(memFun)
   , myValue(value)
   {
   }

   EqualPointerByFunction_T(const SortPointersByFunction_T<Ret,T>& second)
   : myPtr(second.myPtr)
   , myValue(second.myValue)
   {
   }

   bool operator()(const T* a) const
   {
      return (a->*myPtr)() == myValue;
   }
};

template <typename Ret, typename T>
inline EqualPointerByFunction_T<Ret,T> EqualPointerByFunction(Ret (T::*ptr)() const,Ret value)
{
   return EqualPointerByFunction_T<Ret,T>(ptr,value);
}

template <typename K,typename V>
const V& findOrThrow(const std::map<K,V,std::less<K>, std::allocator<std::pair<const K, V> > >& map, K key)
{
   typename std::map<K,V>::const_iterator iter = map.find(key);
   if(iter == map.end())
   {
      DtTHROW_NEW(DtInvalidInput,"Unable to find key");
   }
   return iter->second;
}

template <typename K,typename V>
const V& findByIndexOrThrow(const std::map<K,V,std::less<K>, std::allocator<std::pair<const K, V> > >& map, int index)
{
   if(index >= (int)map.size())
   {
      DtTHROW_NEW(DtInvalidInput,"Index out of range.");
   }
   typename std::map<K,V>::const_iterator i = map.begin();
   std::advance(i,index);
   return i->second;
}

template <typename V>
const V& findByIndexOrThrow(const std::vector<V>& vec, int index)
{
   if(index >= (int)vec.size())
   {
      DtTHROW_NEW(DtInvalidInput,"Index out of range.");
   }
   typename std::vector<V>::const_iterator i = vec.begin();
   std::advance(i,index);
   return *i;
}


}