Util.h

   1 #ifndef UTIL_H
   2 #define UTIL_H
   3
   4 #include <vector>
   5 #include <string>
   6
   7 namespace {
   8
   9         template<class T> class Delete {
  10                 public:
  11                         inline void operator ()(T* & obj) {
  12                                 delete obj;
  13                                 obj = 0;
  14                         }
  15         };
  16
  17         template<class T> void trimVector(std::vector<T> & v) {
  18                 std::vector<T>(v).swap(v);
  19         }
  20
  21         template<typename InputIter, typename Type> const Type & setEach(
  22                 InputIter first, InputIter last, const Type & t) {
  23                 for (; first != last; ++first)
  24                         *first = t;
  25
  26                 return t;
  27         }
  28
  29         inline bool startsWith(const std::string & str, const std::string & prefix) {
  30                 return str.find(prefix) == 0;
  31         }
  32
  33         inline bool endsWith(const std::string & str, const std::string & postfix) {
  34                 size_t n = postfix.length();
  35                 return str.find(postfix, str.length()-n-1) != std::string::npos;
  36         }
  37
  38         // C++ memset */
  39         template<class T> inline void fill(T *ar, const T & val, unsigned long n) {
  40                 for (unsigned long i = 0; i < n; ++i)
  41                         ar[i] = val;
  42         }
  43
  44 #define SPACES " \t\r\n"
  45
  46         inline const std::string & trim_right(std::string & s,
  47                 const std::string & t = SPACES) {
  48                 std::string::size_type i(s.find_last_not_of(t) );
  49                 if (i != std::string::npos )
  50                         s.erase(s.find_last_not_of(t) + 1);
  51
  52                 return s;
  53         }
  54
  55         inline const std::string & trim_left(std::string & s,
  56                 const std::string & t = SPACES) {
  57                 return s.erase(0, s.find_first_not_of(t) );
  58         }
  59
  60         inline const std::string & trim(std::string & s,
  61                 const std::string & t = SPACES) {
  62                 trim_left(s, t);
  63                 trim_right(s, t);
  64                 return s;
  65         }
  66
  67         inline void stolower(std::string & s) {
  68                 std::transform(s.begin(), s.end(), s.begin(), tolower);
  69         }
  70
  71         inline void stoupper(std::string & s) {
  72                 std::transform(s.begin(), s.end(), s.begin(), toupper);
  73         }
  74
  75         template<class Class>
  76         class MethodCall {
  77                 public:
  78                         typedef void (Class::*Method)(void);
  79
  80                 public:
  81                         MethodCall(Method _method) {
  82                                 method = _method;
  83                         };
  84
  85                 public:
  86                         void operator()(Class *c) {
  87                                 if( c != 0 )
  88                                         (c->*method)();
  89                         }
  90
  91                 private:
  92                         Method method;
  93                 };
  94
  95 }
  96
  97 #endif /*UTIL_H*/