/home/cypheon/dev/limiro/trunk/src/utils.h

// -*- C++ -*-
/* Copyright (C) 2007-2008 Johann Rudloff
 * License: GNU GPLv2 or later, see file "COPYING". No warranty of any kind! */

#ifndef _UTILS_H_
#define _UTILS_H_

#include <config.h>

#include <cstdlib>
#include <ctime>
#include <string>
#include <sstream>

#include "lua/lua.hpp"

namespace Limiro
{
namespace utils
{

int randint(int min, int max);

void luaL_openlibs_safe(lua_State *L);

inline int toInt(const char *ptr)
{
  int n = std::strtol(ptr, NULL, 10);
  return n;
}

inline int toInt(const std::string& str)
{
  return toInt(str.c_str());
}

template<class T>
inline std::string toString(const T& value)
{
  static std::ostringstream os;
  os.str("");
  os << value;
  return os.str();
}

inline std::string strFromTime(const char *format, const std::tm *tm)
{
  char buf[1024];
  int len = std::strftime(buf, sizeof(buf), format, tm);

  return std::string(buf, len);
}

inline std::string strFromTime(const char *format, const time_t t)
{
  return strFromTime(format, std::localtime(&t));
}

inline std::string strFromNow(const char *format)
{
  return strFromTime(format, std::time(NULL));
}

inline std::string stripWhitespace(const std::string& str)
{
  static const char *ws = " \t\n";

  std::string::size_type start = str.find_first_not_of(ws);
  if(start == std::string::npos)
  {
    // Kein Nicht-Whitespace-Zeichen gefunden
    return std::string();
  }
  else
  {
    std::string::size_type end = str.find_first_of(ws, start);
    if(end == std::string::npos)
    {
      return str.substr(start);
    }
    else
    {
      return str.substr(start, end-start);
    }
  }
}

inline std::string userDate(const std::string& str)
{
  std::string::size_type p1, p2;
  int y, m, d;

  p1 = str.find_first_of("-");
  p2 = str.find_first_of("-", p1+1);

  y = toInt(str.substr(0, p1));
  m = toInt(str.substr(p1+1, p2-p1-1));
  d = toInt(str.substr(p2+1));

  return (toString(d) + ". " + toString(m) + ". " + toString(y));
}

inline std::string answerDate(int year, int month, int day)
{
  return (toString(year) + "-" + toString(month) + "-" + toString(day));
}


inline int strtol_safe(const char *ptr, int _default=0, bool full=false)
{
  char *endptr;
  int n = std::strtol(ptr, &endptr, 10);
  if((endptr == ptr) || (full && (*endptr != '\0')))
  {
    return _default;
  }
  return n;
}

inline bool endswith(const std::string& str, const std::string& end)
{
  if(end.length() > str.length()) return false;
  return (str.substr(str.length()-end.length()) == end);
}

inline bool startswith(const std::string& str, const std::string& start)
{
  if(start.length() > str.length()) return false;
  return (str.substr(0, start.length()) == start);
}

template <class T>
inline T clamp(T min, T value, T max)
{
  if(value > max) return max;
  if(value < min) return min;
  return value;
}

}
}

#endif // _UTILS_H_

---