stringutil.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef COIL_STRINGUTIL_H
#define COIL_STRINGUTIL_H

#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <cassert>
#include <errno.h>
#include <cstdlib>

#if defined (_MSC_VER) && (_MSC_VER <=1500) // VC2008(VC9.0) or before
#else
#include <stdint.h>
#endif
// Cygwin's gcc does not provide wstring type
#if defined(Cygwin) && ( __GNUC__ < 4 )
namespace std
{
  typedef basic_string<wchar_t> wstring;
}
#endif

namespace coil
{
  typedef std::vector<std::string> vstring;
  typedef std::map<std::string, std::string> mapstring;
  std::wstring string2wstring(std::string str);

  std::string wstring2string(std::wstring wstr);

  void toUpper(std::string& str);

  void toLower(std::string& str);

  int getlinePortable(std::istream& istr, std::string& line);
  
  bool isEscaped(const std::string& str, std::string::size_type pos);
  
  std::string escape(const std::string str);
  
  std::string unescape(const std::string str);

  void eraseBlank(std::string& str);

  void eraseHeadBlank(std::string& str);
  
  void eraseTailBlank(std::string& str);

  void eraseBothEndsBlank(std::string& str);

  std::string normalize(std::string& str);
  
  unsigned int replaceString(std::string& str, const std::string from,
                             const std::string to);
  
  vstring split(const std::string& input,
                const std::string& delimiter,
                bool ignore_empty = false);
  
  bool toBool(std::string str, std::string yes, std::string no, 
              bool default_value = true);
  bool includes(const vstring& list, std::string value,
                bool ignore_case = true);

  bool includes(const std::string& list, std::string value,
                bool ignore_case = true);
  
  bool isAbsolutePath(const std::string& str);
  
  bool isURL(const std::string& str);
  bool isIPv4(const std::string& str);
  bool isIPv6(const std::string& str);
  coil::mapstring urlparam2map(const std::string& str);

  template <class Printable>
  std::string otos(Printable n)
  {
    std::stringstream str_stream;
    str_stream << n;
    return str_stream.str();
  };
  
  template <typename To>
  bool stringTo(To& val, const char* str)
  {
    if (str == 0) { return false; }

    std::stringstream s;
    if ((s << str).fail()) { return false; }
    if ((s >> val).fail()) { return false; }
    return true;
  }
  
  template<>
  bool stringTo<std::string>(std::string& val, const char* str);

  template <>
  bool stringTo<bool>(bool& val, const char* str);

  template<class T>
  std::string ptrToHex(T* n)
  {
    std::stringstream ss;
    ss << std::hex << std::showbase;
    ss << reinterpret_cast<uintptr_t>(n);
    return ss.str();
  };

  template <class T>
  bool hexToPtr(T*& ptr, const std::string str)
  {
    std::stringstream s;
    if ((s << std::hex << str).fail()) { return false; }
    uintptr_t intval;
    if ((s >> intval).fail()) { return false; }
    ptr = reinterpret_cast<T*>(intval);
    if (ptr == NULL) { return false; }
    return true;
  }

  vstring unique_sv(vstring sv);
  
  std::string flatten(vstring sv, std::string delimiter = ", ");
  
  char** toArgv(const vstring& args); 


  std::string sprintf(char const * __restrict fmt, ...);

  std::string replaceEnv(std::string str);
  
}; // namepsace coil
#endif // COIL_STRINGUTIL_H