string.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/util/half.hpp>
 
// includes, system
#include <locale>
#include <stdexcept>
#include <string>
#include <sstream>
#include <vector>
#include <deque>
#include <iomanip>
#include <cstddef>
 
#ifdef FEAT_COMPILER_MICROSOFT
#  include <string.h> // for _stricmp
#endif
 
#ifndef __CUDACC__
#ifdef FEAT_HAVE_QUADMATH
extern "C"
{
#    include <quadmath.h>
}
#endif // FEAT_HAVE_QUADMATH
#endif // __CUDACC__
 
namespace FEAT
{
  class String
    : public std::string
  {
  public:
    class NoCaseLess
    {
    public:
      bool operator()(const String& left, const String& right) const
      {
        return left.compare_no_case(right) < 0;
      }
    }; // class NoCaseLess
 
  public:
    inline String()
      : std::string()
    {
    }
 
    inline String(const char* str)
      : std::string(str)
    {
    }
 
    inline String(const char* str, size_type count)
      : std::string(str, count)
    {
    }
 
    inline String(const std::string& str)
      : std::string(str)
    {
    }
 
#ifndef __CUDACC__
    inline String(std::string&& str)
      : std::string(str)
    {
    }
#endif
 
    inline String(const String& str)
      : std::string(str)
    {
    }
 
#ifndef __CUDACC__
    inline String(String&& str)
      : std::string(str)
    {
    }
#endif
 
    inline String(const std::string& str, size_type offset, size_type count = npos)
      : std::string(str, offset, count)
    {
    }
 
    inline String(size_type count, char c)
      : std::string(count, c)
    {
    }
 
    String& operator=(const std::string& str)
    {
      std::string::operator=(str);
      return *this;
    }
 
#ifndef __CUDACC__
    String& operator=(std::string&& str)
    {
      std::string::operator=(str);
      return *this;
    }
#endif
 
    String& operator=(const String& str)
    {
      std::string::operator=(str);
      return *this;
    }
 
#ifndef __CUDACC__
    String& operator=(String&& str)
    {
      std::string::operator=(str);
      return *this;
    }
#endif
 
    String& operator=(const char* s)
    {
      std::string::operator=(s);
      return *this;
    }
 
    String& append(const std::string& str)
    {
      std::string::append(str);
      return *this;
    }
 
    String& append(const std::string& str, size_type pos, size_type n)
    {
      std::string::append(str, pos, n);
      return *this;
    }
 
    String& append(const char* s, size_type n)
    {
      std::string::append(s, n);
      return *this;
    }
 
    String& append(const char* s)
    {
      std::string::append(s);
      return *this;
    }
 
    String& append(size_type n, char c)
    {
      std::string::append(n, c);
      return *this;
    }
 
    String& operator+=(const std::string& str)
    {
      return append(str);
    }
 
    String& operator+=(const char* s)
    {
      return append(s);
    }
 
    String substr(size_type pos = size_type(0), size_type n = npos) const
    {
      return String(std::string::substr(pos, n));
    }
 
    static const char* whitespaces()
    {
      return " \a\b\f\n\r\t\v";
    }
 
    void push_front(char value)
    {
      insert(size_type(0), size_type(1), value);
    }
 
    void pop_front()
    {
      erase(size_type(0), size_type(1));
    }
 
    void pop_back()
    {
      erase(size() - size_type(1), size_type(1));
    }
 
    String trim_front(const String & charset) const
    {
      // find first character not to be trimmed
      size_type pos = find_first_not_of(charset);
      if(pos == npos)
        return String();
      else
        return substr(pos);
    }
 
    String trim_front() const
    {
      return trim_front(whitespaces());
    }
 
    String trim_back(const String & charset) const
    {
      // find last character not to be trimmed
      size_type pos = find_last_not_of(charset);
      if(pos == npos)
        return String();
      else
        return substr(size_type(0), pos + size_type(1));
    }
 
    String trim_back() const
    {
      return trim_back(whitespaces());
    }
 
    String trim(const String & charset) const
    {
      // trim front and back
      return trim_front(charset).trim_back(charset);
    }
 
    String trim() const
    {
      return trim(whitespaces());
    }
 
    String& trim_me(const String & charset)
    {
      return (*this = trim(charset));
    }
 
    String& trim_me()
    {
      return (*this = trim());
    }
 
    String pad_front(size_type len, char c = ' ') const
    {
      size_type l(length());
      return (l < len) ? String(len - l, c).append(*this) : *this;
    }
 
    String pad_back(size_type len, char c = ' ') const
    {
      size_type l(length());
      return (l < len) ? String(*this).append(len - l, c) : *this;
    }
 
    String trunc_front(size_type len) const
    {
      return length() <= len ? *this : substr(length() - len);
    }
 
    String trunc_back(size_type len) const
    {
      return length() <= len ? *this : substr(size_type(0), len);
    }
 
    std::deque<String> split_by_charset(const String & charset) const
    {
      std::deque<String> words;
      if(empty() || charset.empty())
      {
        return words;
      }
 
      // find first occurrence of split substring
      size_type off1(find_first_not_of(charset));
      if(off1 == npos)
      {
        // only delimiter characters; nothing to be extracted
        return words;
      }
 
      // go splitting
      while(off1 != npos)
      {
        // find next occurrence of delimiter string
        size_type off2(find_first_of(charset, off1));
 
        // add next split substring to vector
        if(off2 == npos)
        {
          // extract last substring
          words.push_back(substr(off1));
          return words;
        }
        else
        {
          // extract next substring
          words.push_back(substr(off1, (off2 == npos ? npos : off2 - off1)));
        }
 
        // find next occurrence of split substring
        off1 = find_first_not_of(charset, off2);
      }
 
      // okay
      return words;
    }
 
    std::deque<String> split_by_whitespaces() const
    {
      return split_by_charset(whitespaces());
    }
 
    std::deque<String> split_by_string(const String & delimiter) const
    {
      std::deque<String> words;
      if(empty() || delimiter.empty())
        return words;
 
      // find first occurrence of delimiter substring
      size_type off1(find(delimiter));
      words.push_back(substr(0, off1));
      if(off1 == npos)
        return words;
 
      // go splitting
      const size_type del_len(delimiter.size());
      while(off1 != npos)
      {
        // increase leading offset by delimiter length
        off1 += del_len;
 
        // find next substring occurrence
        size_type off2 = find(delimiter, off1);
        if(off2 == npos)
        {
          // extract last substring
          words.push_back(substr(off1));
          return words;
        }
        else
        {
          // extract next substring
          words.push_back(substr(off1, off2 - off1));
        }
 
        // update offset
        off1 = off2;
      }
 
      // okay
      return words;
    }
 
    size_type replace_all(const String & find_string, const String & replace_string)
    {
      size_type flen(find_string.size());
      size_type rlen(replace_string.size());
      if(flen <= 0)
        return size_type(0);
 
      // find first occurrence of find string
      size_type pos(find(find_string));
      size_type counter(size_type(0));
      while(pos != npos)
      {
        // replace substring
        replace(pos, flen, replace_string);
 
        // increment counter
        ++counter;
 
        // find next occurrence
        pos = find(find_string, pos + rlen);
      }
 
      // return replacement count
      return counter;
    }
 
    String upper() const
    {
      String str;
      str.reserve(size());
      for(const_iterator it(begin()); it != end(); ++it)
      {
#ifdef FEAT_COMPILER_MICROSOFT
        str.push_back(std::toupper(*it, std::locale::classic()));
#else
        std::locale loc;
        str.push_back(std::toupper<char>(*it, loc));
#endif
      }
      return str;
    }
 
    String lower() const
    {
      String str;
      str.reserve(size());
      for(const_iterator it(begin()); it != end(); ++it)
      {
#ifdef FEAT_COMPILER_MICROSOFT
        str.push_back(std::tolower(*it, std::locale::classic()));
#else
        std::locale loc;
        str.push_back(std::tolower<char>(*it, loc));
#endif
      }
      return str;
    }
 
    int compare_no_case(const String& other) const
    {
#ifdef FEAT_COMPILER_MICROSOFT
      // The MS C library offers a function for this task.
      return _stricmp(c_str(), other.c_str());
#else
      // reference implementation
      std::locale loc;
      size_type n1 = size();
      size_type n2 = other.size();
      size_type n = std::min(n1, n2);
 
      // loop over all characters and compare them
      for(size_type i = 0; i < n; ++i)
      {
        int k = int(std::tolower<char>((*this)[i], loc)) - int(std::tolower<char>(other[i], loc));
        if(k < 0)
        {
          return -1;
        }
        else if(k > 0)
        {
          return 1;
        }
      }
 
      // If we come out here, then both strings are identical for the first n characters.
      // Now let's check whether their length is equal, too.
      if(n1 < n2)
      {
        return -1;
      }
      else if(n1 > n2)
      {
        return 1;
      }
      else
      {
        return 0;
      }
#endif
    }
 
    bool starts_with(const String& head) const
    {
      // every string starts with an empty string
      if(head.empty())
        return true;
 
      // check size
      if(this->size() <  head.size())
        return false;
 
      // compare head
      return (this->compare(std::size_t(0), head.size(), head) == 0);
    }
 
    bool ends_with(const String& tail) const
    {
      // every string ends with an empty string
      if(tail.empty())
        return true;
 
      // check size
      if(this->size() <  tail.size())
        return false;
 
      // compare tail
      return (this->compare(this->size() - tail.size(), tail.size(), tail) == 0);
    }
 
    bool starts_with(const char head) const
    {
      return (this->empty() ? false : this->front() == head);
    }
 
    bool ends_with(const char tail) const
    {
      return (this->empty() ? false : this->back() == tail);
    }
 
    bool is_one_of(const String& set, const String& sep = " ", bool case_insensitive = false) const
    {
      std::deque<String> sset = set.split_by_string(sep);
      for(const auto& s : sset)
      {
        if(case_insensitive)
        {
          if(this->compare_no_case(s) == 0)
            return true;
        }
        else if(this->compare(s) == 0)
          return true;
      }
      return false;
    }
 
    template<typename T_>
    bool parse(T_& t) const
    {
      std::istringstream iss(trim());
      iss >> t;
      return !iss.fail();
    }
 
    bool parse(bool& b) const
    {
      if(trim().compare_no_case("true") == 0)
      {
        b = true;
        return true;
      }
      if(trim().compare_no_case("false") == 0)
      {
        b = false;
        return true;
      }
      return false;
    }
 
    bool parse(std::string& s) const
    {
      s.assign(*this);
      return true;
    }
 
    // This one is really required, as otherwise some compilers choose the
    // generic template instead of the overload for std::string above...
    bool parse(String& s) const
    {
      s.assign(*this);
      return true;
    }
 
    // Overload for std::uint8_t. Required because the generic parsing via
    // input stream treats this type as a char and reads only a single character
    bool parse(std::uint8_t& var) const
    {
      try
      {
        std::uint64_t tmp = std::stoull(this->c_str());
        if(tmp <= 255)
        {
          var = std::uint8_t(tmp);
        }
        else
        {
          return false;
        }
      }
      catch(std::invalid_argument& /*e*/)
      {
        return false;
      }
 
      return true;
    }
 
    // Overload for std::int8_t. Required because the generic parsing via
    // input stream treats this type as a char and reads only a single character
    bool parse(std::int8_t& var) const
    {
      try
      {
        std::int64_t tmp = std::stoll(this->c_str());
        if(-128 <= tmp && tmp <= 127)
        {
          var = std::int8_t(tmp);
        }
        else
        {
          return false;
        }
      }
      catch(std::invalid_argument& /*e*/)
      {
        return false;
      }
 
      return true;
    }
 
  #ifdef FEAT_HAVE_HALFMATH
    bool parse(Half& t)
    {
      float tmp;
      bool ret = parse(tmp);
      t = __float2half(tmp);
      return ret;
    }
  #endif
 
#ifndef __CUDACC__
#ifdef FEAT_HAVE_QUADMATH
    bool parse(__float128& x) const
    {
      if(this->empty())
        return false;
 
      const char* nptr(this->c_str());
      char* endptr(nullptr);
      x = strtoflt128(nptr, &endptr);
      // Note: According to the C-Standard (ISO/IEC 9899:1190 (E), 7.10.1.4 The strod function),
      // the 'strtod' function sets 'endptr' to 'nptr' if the conversion fails, so we simply
      // hope that the quadmath function for __float128 honors this convention...
      return (nptr != endptr);
    }
#endif // FEAT_HAVE_QUADMATH
#endif // __CUDACC__
  }; // class String
 
  inline String operator+(const String& a, const String& b)
  {
    return String(a).append(b);
  }
 
  inline String operator+(const char* a, const String& b)
  {
    return String(a).append(b);
  }
 
  inline String operator+(const String& a, const char* b)
  {
    return String(a).append(b);
  }
 
  inline String operator+(const String& a, char c)
  {
    return String(a).append(String::size_type(1), c);
  }
 
  inline String operator+(char c, const String& b)
  {
    return String(String::size_type(1), c).append(b);
  }
 
  template<typename T_>
  inline String stringify(const T_& item)
  {
    std::ostringstream oss;
    oss << item;
    return oss.str();
  }
 
  inline String stringify(const char* item)
  {
    return String(item);
  }
 
  inline String stringify(const std::string& item)
  {
    return item;
  }
 
  inline String stringify(char item)
  {
    return String(1, item);
  }
 
  inline String stringify(bool item)
  {
    return String(item ? "true" : "false");
  }
 
#ifdef FEAT_HAVE_HALFMATH
  inline String stringify(const Half& item)
  {
    return stringify(__half2float(item));
  }
#endif
 
#ifndef __CUDACC__
  inline String stringify(std::nullptr_t)
  {
    return String("nullptr");
  }
 
#ifdef FEAT_HAVE_QUADMATH
  inline String stringify(__float128 value)
  {
    // get buffer length
    int len = ::quadmath_snprintf(nullptr, 0, "%Qg", value);
    // allocate buffer
    std::vector<char> buffer(len+16);
    // print to buffer
    quadmath_snprintf(buffer.data(), buffer.size(), "%Qg", value);
    // convert buffer to string
    return String(buffer.data());
  }
#endif // FEAT_HAVE_QUADMATH
#endif // __CUDACC__
 
  template<typename Iterator_>
  String stringify_join(
    Iterator_ first,
    Iterator_ last,
    const String & delimiter = "")
  {
    if(first == last)
      return String();
 
    Iterator_ it(first);
    String str = stringify(*it);
 
    for(++it; it != last; ++it)
      str.append(delimiter).append(stringify(*it));
 
    return str;
  }
 
  template<typename Container_>
  String stringify_join(
    const Container_& container,
    const String & delimiter = "")
  {
    return stringify_join(container.cbegin(), container.cend(), delimiter);
  }
 
  template<typename DataType_>
  inline String stringify_fp_sci(DataType_ value, int precision = 0, int width = 0, bool sign = false)
  {
    std::ostringstream oss;
    oss << std::scientific;
    if(precision > 0)
      oss << std::setprecision(precision);
    if(width > 0)
      oss << std::setw(width);
    if(sign)
      oss << std::showpos;
    oss << value;
    return oss.str();
  }
 
  #ifdef FEAT_HAVE_HALFMATH
  inline String stringify_fp_sci(Half value, int precision = 0, int width = 0, bool sign = false)
  {
    return stringify_fp_sci(__half2float(value), precision, width, sign);
  }
  #endif
 
  template<typename DataType_>
  inline String stringify_fp_fix(DataType_ value, int precision = 0, int width = 0, bool sign = false)
  {
    std::ostringstream oss;
    oss << std::fixed;
    if(precision > 0)
      oss << std::setprecision(precision);
    if(width > 0)
      oss << std::setw(width);
    if(sign)
      oss << std::showpos;
    oss << value;
    return oss.str();
  }
 
  #ifdef FEAT_HAVE_HALFMATH
  inline String stringify_fp_fix(Half value, int precision = 0, int width = 0, bool sign = false)
  {
    return stringify_fp_fix(__half2float(value), precision, width, sign);
  }
  #endif
 
#ifndef __CUDACC__
#ifdef FEAT_HAVE_QUADMATH
  inline String stringify_fp_sci(__float128 value, int precision = 0, int width = 0, bool sign = false)
  {
    String format("%");
    if(sign)
      format.append("+");
    if(width > 0)
      format.append(stringify(width));
    if(precision > 0)
    {
      format.append(".");
      format.append(stringify(precision));
    }
    format.append("Qe");
    // get buffer length
    int len = ::quadmath_snprintf(nullptr, 0, format.c_str(), value);
    // allocate buffer
    std::vector<char> buffer(len+16);
    // print to buffer
    quadmath_snprintf(buffer.data(), buffer.size(), format.c_str(), value);
    // convert buffer to string
    return String(buffer.data());
  }
 
  inline String stringify_fp_fix(__float128 value, int precision = 0, int width = 0, bool sign = false)
  {
    String format("%");
    if(sign)
      format.append("+");
    if(width > 0)
      format.append(stringify(width));
    if(precision > 0)
    {
      format.append(".");
      format.append(stringify(precision));
    }
    format.append("Qf");
    // get buffer length
    int len = ::quadmath_snprintf(nullptr, 0, format.c_str(), value);
    // allocate buffer
    std::vector<char> buffer(len+16);
    // print to buffer
    quadmath_snprintf(buffer.data(), buffer.size(), format.c_str(), value);
    // convert buffer to string
    return String(buffer.data());
  }
 
  inline std::istream& operator>>(std::istream& is, __float128& x)
  {
    String buffer;
    // try to parse a string
    if(!(is >> buffer).fail())
    {
      if(!buffer.parse(x))
      {
        // parse failed, so put back the string
        for(std::size_t i(0); i < buffer.size(); ++i)
          is.putback(buffer.at(i));
 
        // set failbit
        is.setstate(std::ios_base::failbit);
      }
    }
    return is;
  }
#endif // FEAT_HAVE_QUADMATH
#endif // __CUDACC__
 
  inline String stringify_bytes(std::uint64_t bytes, int precision = 3, int width = 7)
  {
    // the bounds are chosen such that the output will never have more than 3 leading digits
    if(bytes <= 999ull)
      return stringify(bytes).pad_front(std::size_t(width)) + " Bytes";
    else if(bytes <= 1'022'976ull) // = 999*1024
      return stringify_fp_fix(double(bytes) / (1024.), precision, width) + " KiB";
    else if(bytes <= 1'047'527'424ull)  // = 999*1024^2
      return stringify_fp_fix(double(bytes) / (1048576.), precision, width) + " MiB";
    else if(bytes <= 1'072'668'082'176ull)  // = 999*1024^3
      return stringify_fp_fix(double(bytes) / (1073741824.), precision, width) + " GiB";
    else if(bytes <= 1'098'412'116'148'224ull)  // = 999*1024^4
      return stringify_fp_fix(double(bytes) / (1099511627776.), precision, width) + " TiB";
    else
      return stringify_fp_fix(double(bytes) / (1125899906842624.), precision, width) + " PiB";
  }
} // namespace FEAT
 
// operator<<(__float128) must reside in the std namespace because gcc/icc search the namespace of ostream for a fitting op<< first
// and would otherwise only find op<< with conversions of __float128 to int/double/long etc, which would lead to ambiguous overloads, too.
#ifndef __CUDACC__
#ifdef FEAT_HAVE_QUADMATH
namespace std
{
  inline std::ostream& operator<<(std::ostream& os, __float128 x)
  {
    // write to stream
    return (os << FEAT::stringify(x));
  }
}
#endif // FEAT_HAVE_QUADMATH
#endif // __CUDACC__