StringConv.h

// -*- indent-tabs-mode: nil -*-

#ifndef ARCLIB_STRINGCONV
#define ARCLIB_STRINGCONV

#include <iomanip>
#include <sstream>
#include <string>
#include <vector>

#include <arc/Logger.h>

namespace Arc {

  extern Logger stringLogger;

  template<typename T>
  T stringto(const std::string& s) {
    T t;
    if (s.empty()) {
      stringLogger.msg(ERROR, "Empty string");
      return 0;
    }
    std::stringstream ss(s);
    ss >> t;
    if (ss.fail()) {
      stringLogger.msg(ERROR, "Conversion failed: %s", s);
      return 0;
    }
    if (!ss.eof())
      stringLogger.msg(WARNING, "Full string not used: %s", s);
    return t;
  }

  template<typename T>
  bool stringto(const std::string& s, T& t) {
    t = 0;
    if (s.empty())
      return false;
    std::stringstream ss(s);
    ss >> t;
    if (ss.fail())
      return false;
    if (!ss.eof())
      return false;
    return true;
  }



#define stringtoi(A) stringto < int > ((A))
#define stringtoui(A) stringto < unsigned int > ((A))
#define stringtol(A) stringto < long > ((A))
#define stringtoll(A) stringto < long long > ((A))
#define stringtoul(A) stringto < unsigned long > ((A))
#define stringtoull(A) stringto < unsigned long long > ((A))
#define stringtof(A) stringto < float > ((A))
#define stringtod(A) stringto < double > ((A))
#define stringtold(A) stringto < long double > ((A))


  bool strtoint(const std::string& s, signed int& t, int base = 10);


  bool strtoint(const std::string& s, unsigned int& t, int base = 10);


  bool strtoint(const std::string& s, signed long& t, int base = 10);


  bool strtoint(const std::string& s, unsigned long& t, int base = 10);


  bool strtoint(const std::string& s, signed long long& t, int base = 10);


  bool strtoint(const std::string& s, unsigned long long& t, int base = 10);

  template<typename T>
  std::string tostring(T t, int width = 0, int precision = 0) {
    std::stringstream ss;
    if (precision)
      ss << std::setprecision(precision);
    ss << std::setw(width) << t;
    return ss.str();
  }


  std::string inttostr(signed long long t, int base = 10, int width = 0);


  std::string inttostr(unsigned long long t, int base = 10, int width = 0);


  inline std::string inttostr(signed int t, int base = 10, int width = 0) {
    return inttostr((signed long long)t,base,width);
  }


  inline std::string inttostr(unsigned int t, int base = 10, int width = 0) {
    return inttostr((unsigned long long)t,base,width);
  }


  inline std::string inttostr(signed long t, int base = 10, int width = 0) {
    return inttostr((signed long long)t,base,width);
  }


  inline std::string inttostr(unsigned long t, int base = 10, int width = 0) {
    return inttostr((unsigned long long)t,base,width);
  }

  inline std::string booltostr(bool b) {
    return b ? "true" : "false";
  }

  inline bool strtobool(const std::string& s) {
    return s == "true" || s == "1";
  }


  inline bool strtobool(const std::string& s, bool& b) {
    if (s == "true" || s == "1" || s == "false" || s == "0") {
      b = (s == "true" || s == "1");
      return true;
    }
    return false;
  }

  std::string lower(const std::string& s);

  std::string upper(const std::string& s);

  void tokenize(const std::string& str, std::vector<std::string>& tokens,
                const std::string& delimiters = " ",
                const std::string& start_quotes = "", const std::string& end_quotes = "");

  void tokenize(const std::string& str, std::list<std::string>& tokens,
                const std::string& delimiters = " ",
                const std::string& start_quotes = "", const std::string& end_quotes = "");

  std::string::size_type get_token(std::string& token,
                const std::string& str, std::string::size_type pos,
                const std::string& delimiters = " ",
                const std::string& start_quotes = "", const std::string& end_quotes = "");


  std::string trim(const std::string& str, const char *sep = NULL);

  std::string strip(const std::string& str);


  std::string uri_encode(const std::string& str, bool encode_slash);

  std::string uri_unencode(const std::string& str);

  std::string convert_to_rdn(const std::string& dn);

  typedef enum {
    escape_char,  
    escape_octal, 
    escape_hex    
  } escape_type;


  std::string escape_chars(const std::string& str, const std::string& chars, char esc, bool excl, escape_type type = escape_char);

  std::string unescape_chars(const std::string& str, char esc, escape_type type = escape_char);

} // namespace Arc

#endif // ARCLIB_STRINGCONV