IString.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include "IString.h"
 
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <stdio.h>
#include <string>
 
#include <QMap>
#include <QObject>
 
#include "IException.h"
#include "SpecialPixel.h"
 
using namespace std;
 
namespace Isis {
  bool toBool(const QString &string) {
    QStringList trues;
    trues.append("true");
    trues.append("t");
    trues.append("yes");
    trues.append("y");
    trues.append("on");
    trues.append("1");
 
    QStringList falses;
    falses.append("false");
    falses.append("f");
    falses.append("no");
    falses.append("n");
    falses.append("off");
    falses.append("0");
 
    bool result = true;
    bool foundMatch = false;
 
    QListIterator<QString> truesIterator(trues);
    while (!foundMatch && truesIterator.hasNext()) {
      foundMatch = (string.compare(truesIterator.next(), Qt::CaseInsensitive) == 0);
    }
 
    if (!foundMatch) {
      result = false;
 
      QListIterator<QString> falsesIterator(falses);
      while (!foundMatch && falsesIterator.hasNext()) {
        foundMatch = (string.compare(falsesIterator.next(), Qt::CaseInsensitive) == 0);
      }
    }
 
    if (!foundMatch) {
      qSort(trues);
      qSort(falses);
      QString message = QObject::tr("Failed to convert string [%1] to a boolean. "
          "Please specify one of [%2] for true, or one of [%3] for false.")
            .arg(string).arg(trues.join(", ")).arg(falses.join(", "));
      throw IException(IException::Unknown, message, _FILEINFO_);
    }
 
    return result;
  }
 
 
  int toInt(const QString &string) {
    bool ok = true;
 
    int result = string.toInt(&ok);
 
    if (!ok) {
      QString message = QObject::tr("Failed to convert string [%1] to an integer").arg(string);
      throw IException(IException::Unknown, message, _FILEINFO_);
    }
 
    return result;
  }
 
 
  BigInt toBigInt(const QString &string) {
    BigInt result;
 
    try {
      std::stringstream s;
      s << string.toStdString();            // Put the string into a stream
      s.seekg(0, std::ios::beg);     // Move the input pointer to the beginning
      s >> result;               // read/get "type T" out of the stream
      std::ios::iostate state = s.rdstate();
      if((state & std::ios::failbit) || (state & std::ios::badbit) ||
          (!(state & std::ios::eofbit))) {  // Make sure the stream is empty
        throw (int)-1;
      }
    }
    catch(...) {
      QString message = QObject::tr("Failed to convert string [%1] to a big integer").arg(string);
      throw IException(IException::Unknown, message, _FILEINFO_);
    }
 
    return result;
  }
 
 
  double toDouble(const QString &string) {
    double result = 0.0;
 
    if (string.startsWith("16#") && string.endsWith("#")) {
      try {
        stringstream s;
        s << string.mid(3, string.size() - 3);
        s.seekg(0, ios::beg);
 
        union {
          unsigned int intData;
          float floatData;
        } raw;
 
        s >> hex >> raw.intData;
 
        ios::iostate state = s.rdstate();
        if((state & ios::failbit) || (state & ios::badbit)) {
          throw IException();
        }
 
        result = raw.floatData;
      }
      catch(...) {
        QString message = QObject::tr("Failed to convert HEX string [%1] to a "
                            "double").arg(string);
        throw IException(IException::Unknown, message, _FILEINFO_);
      }
    }
    else {
      static QMap<QString, double> knownStrings;
      if (knownStrings.isEmpty()) {
        // Special case: user called toDouble(toString(DBL_MAX))
        knownStrings["1.79769313486232e+308"]  = DBL_MAX;
        knownStrings["-1.79769313486232e+308"] = -DBL_MAX;
      }
 
      bool ok = true;
      if (!knownStrings.contains(string)) {
        result = string.toDouble(&ok);
      }
      else {
        result = knownStrings[string];
      }
 
      if (!ok) {
        QString message = QObject::tr("Failed to convert string [%1] to a double").arg(string);
        throw IException(IException::Unknown, message, _FILEINFO_);
      }
    }
 
    return result;
  }
 
 
  QString toString(bool boolToConvert) {
    return boolToConvert? "Yes" : "No";
  }
 
 
  QString toString(char charToConvert) {
    QString result;
    result += QChar(charToConvert);
    return result;
  }
 
 
  QString toString(const int &intToConvert) {
    return QString::number(intToConvert);
  }
 
 
  QString toString(const unsigned int &intToConvert) {
    return QString::number(intToConvert);
  }
 
 
  QString toString(const BigInt &intToConvert) {
    return QString::number(intToConvert);
  }
 
 
  QString toString(double doubleToConvert, int precision) {
    // If number is zero, then it is not valid to do a log10 on it. To avoid this,
    // check for zero ahead of time and handle it.
    QString result;
 
    if(doubleToConvert == 0.0) {
      result = "0.0";
    }
    else if (std::isnan(doubleToConvert) ) {
      result = "nan";
    }
 
    if(doubleToConvert > DBL_MAX) {
      doubleToConvert = DBL_MAX;
    }
 
    if(doubleToConvert < -DBL_MAX) {
      doubleToConvert = -DBL_MAX;
    }
 
    if (result == "") {
      // First determine the number of digits preceding the decimal point
      // Numbers of the form 0.ABCDEFG where A is non-zero are assumed to
      // have a leading digit of zero.  Numbers of the form 0.0ABCDEFG,
      // 0.00ABCEFEG and so on are not considered to have a leading digit
      // (pre = 0).
      double temp = qAbs(doubleToConvert);
      int pre = (int)(log10(temp)) + 1;
 
      // If preceding number of digits is too large then we will need to create a
      // scientific notation string.  We will need 14 spaces for numbers, 2 spaces
      // for exponents, 2 spaces for signs, and 1 for the letter E, 1 for a decimal
      // place, and 1 extra in case of a leading 0.  A grand total
      // of 21 spaces is required.  Therefore our format can be %22e
 
      // If the preceding number of digits is zero then we likely have a
      // really small number (e.g., 0.000331236236). So let's put those in
      // scientific notation as well
 
      // Finally, remove any zeroes before the E and if the exponent is zero
      // then strip it off as well.
 
      char doubleString[23];
 
      if((log10(temp) > 13.0) || (log10(temp) < -3.0)) {
        char format[8], buffer[8];
        snprintf(buffer, 8, "%de", precision);
        strcpy(format, "%21.");
        strcat(format, buffer);
        snprintf(doubleString, 23, format, doubleToConvert);
 
        char *e = strchr(doubleString, 'e');
        char *sptr = e - 1;
 
        while(*sptr == '0') {
          sptr--;
        }
 
        if(*sptr == '.') {
          sptr++;
        }
 
        sptr++;
        char tmp[22];
        strcpy(tmp, e);
        strcpy(sptr, tmp);
 
        e = strchr(doubleString, 'e');
        int allzero = 1;
 
        for(sptr = e + 2; *sptr; sptr++) {
          if(*sptr != '0') {
            allzero = 0;
          }
        }
 
        if(allzero) {
          *e = 0;
        }
      }
      else {
        // Ok it can be presented as a normal floating point num.  So we will need
        // 14 spaces for nums, 1 for the sign, 1 for the decimal, and 1 more
        // for a possible leading 0.  A grand total of 17 spaces.  Therefore our
        // format can be "%17.postf".  Finally remove any trailing zeroes.
 
        if(temp < 1.0) {
          pre--;
        }
        int post = precision - pre;
 
        char tempStr[3], format[8];
        strcpy(format, "%17.");
        snprintf(tempStr, 3, "%d", post);
        strcat(format, tempStr);
        strcat(format, "f");
 
        snprintf(doubleString, 23, format, doubleToConvert);
 
        if(post > 0) {
          char *sptr = doubleString + strlen(doubleString) - 1;
          while((*sptr == '0') && (*(sptr - 1) != '.')) {
            *sptr = 0;
            sptr--;
          }
        }
      }
 
      while(doubleString[0] == ' ') {
        for(unsigned int i = 0; i < strlen(doubleString); i++) {
          doubleString[i] = doubleString[i + 1];
        }
      }
 
      result = QString(doubleString);
    }
 
    return result;
  }
 
 
  IString::IString() : string() {
  }
 
  IString::IString(const std::string &str) : string(str) {
  }
 
  IString::IString(const IString &str) : string(str) {
  }
 
  IString::IString(const char *str) : string(str) {
  }
 
  IString::IString(const int &num) : string() {
    ostringstream str;
    str << num;
    assign(str.str());
  }
 
  IString::IString(const BigInt &num) : string() {
    ostringstream str;
    str << num;
    assign(str.str());
  }
 
  IString::IString(const double &num, const int piPrecision) : string() {
    SetDouble(num, piPrecision);
  }
 
 
  void IString::SetDouble(const double &num, const int piPrecision) {
    *this = toString(num, piPrecision).toStdString();
  }
 
  IString::IString(const QString &str) : string() {
    assign(str.toStdString());
  }
 
  IString::~IString() {}
 
  IString IString::Trim(const std::string &chars) {
    TrimHead(chars);
    TrimTail(chars);
    return *this;
  }
 
  std::string IString::Trim(const std::string &chars, const std::string &str) {
    //string result = str;
    //result.replace (0,str.find_first_not_of (chars), "");
    return TrimTail(chars, TrimHead(chars, str));
  }
 
  IString IString::TrimHead(const std::string &chars) {
    *this = replace(0, find_first_not_of(chars), "");
    return *this;
  }
 
  std::string IString::TrimHead(const std::string &chars, const std::string &str) {
    string result = str;
    result.replace(0, str.find_first_not_of(chars), "");
    return result;
  }
 
  IString IString::TrimTail(const std::string &chars) {
    *this = erase(find_last_not_of(chars) + 1);
    return *this;
  }
 
  std::string IString::TrimTail(const std::string &chars, const std::string &str) {
    string result = str;
    result.erase(str.find_last_not_of(chars) + 1);
    return result;
  }
 
  IString IString::UpCase() {
    string temp = *this;
    *this = UpCase(temp);
    return *this;
  }
 
  std::string IString::UpCase(const std::string &str) {
    string sOut(str);
    transform(str.begin(), str.end(), sOut.begin(), (int ( *)(int)) toupper);
    return(sOut);
  }
 
  IString IString::DownCase() {
    *this = DownCase((string) * this);
    return *this;
  }
 
  std::string IString::DownCase(const std::string &str) {
    string sOut(str);
    transform(str.begin(), str.end(), sOut.begin(), (int ( *)(int))tolower);
    return sOut;
  }
 
  static bool nocase_compare(const char c1, const char c2) {
    return(toupper(c1) == toupper(c2));
  }
 
  bool IString::Equal(const std::string &str) const {
    string temp = *this;
    return Equal(str, temp);
  }
 
  bool IString::Equal(const std::string &str1, const std::string &str2) {
    if(str1.size() != str2.size()) return(false);
    return(std::equal(str1.begin(), str1.end(), str2.begin(), nocase_compare));
  }
 
 
  int IString::ToInteger() const {
    return ToInteger(*this);
  }
 
  int IString::ToInteger(const std::string &str) {
    int v_out;
    try {
      stringstream s;
      s << str;               // Put the string into a stream
      s.seekg(0, ios::beg);     // Move the input pointer to the beginning
      s >> v_out;               // read/get "type T" out of the stream
      ios::iostate state = s.rdstate();
      if((state & ios::failbit) || (state & ios::badbit) ||
          (!(state & ios::eofbit))) {  // Make sure the stream is empty
        throw(int) - 1;
      }
    }
    catch(...) {
      string message = "Failed to convert string [" + str + "] to an integer";
      throw IException(IException::Unknown, message, _FILEINFO_);
    }
    return(v_out);
  }
 
  BigInt IString::ToBigInteger() const {
    return ToBigInteger(*this);
  }
 
  BigInt IString::ToBigInteger(const std::string &str) {
    BigInt v_out;
    try {
      stringstream s;
      s << str;            // Put the string into a stream
      s.seekg(0, ios::beg);     // Move the input pointer to the beginning
      s >> v_out;               // read/get "type T" out of the stream
      ios::iostate state = s.rdstate();
      if((state & ios::failbit) || (state & ios::badbit) ||
          (!(state & ios::eofbit))) {  // Make sure the stream is empty
        throw(int) - 1;
      }
    }
    catch(...) {
      string message = "Failed to convert string [" + str + "] to a big "
                       "integer";
      throw IException(IException::Unknown, message, _FILEINFO_);
    }
    return(v_out);
  }
 
  double IString::ToDouble() const {
    return ToDouble(*this);
  }
 
  double IString::ToDouble(const std::string &str) {
 
    double v_out;
 
    // Convert a hex value
    if(str.substr(0, 3) == "16#" && str.substr(str.length() - 1, 1) == "#") {
      try {
        stringstream s;
        s << str.substr(3, str.find_last_of("#") - 3);
        s.seekg(0, ios::beg);
 
        union {
          unsigned int i;
          float f;
        } u;
 
        s >> hex >> u.i;
 
        ios::iostate state = s.rdstate();
        if((state & ios::failbit) || (state & ios::badbit)) {
          throw(int) - 1;
        }
        v_out = u.f;
      }
      catch(...) {
        string message = "Failed to convert HEX string [" + str + "] to a "
                         "double";
        throw IException(IException::Unknown, message, _FILEINFO_);
      }
    }
    // Convert a decimal value
    else {
      try {
        stringstream s;
        s << str;               // Put the string into a stream
        s.seekg(0, ios::beg);     // Move the input pointer to the beginning
        s >> v_out;               // read/get "type T" out of the stream
        ios::iostate state = s.rdstate();
        if((state & ios::failbit) || (state & ios::badbit) ||
            (!(state & ios::eofbit))) {  // Make sure the stream is empty
          throw(int) - 1;
        }
      }
      catch(...) {
        string message = "Failed to convert string [" + str + "] to a double";
        throw IException(IException::Unknown, message, _FILEINFO_);
      }
    }
 
    return(v_out);
  }
 
  QString IString::ToQt() const {
    return QString::fromStdString(*this);
  }
 
  QString IString::ToQt(const std::string &s) {
    return(QString::fromStdString(s));
  }
 
  IString IString::Token(const IString &separator) {
    IString retstr = "" ;
 
    for(unsigned int i = 0; i < size(); i++) {
      for(unsigned int sep = 0; sep < separator.size(); sep++) {
        if(separator[sep] == at(i)) {
          retstr = substr(0, i);
          replace(0, i + 1, "");
          return retstr;
        }
      }
    }
 
    if(retstr == "") {
      retstr = (*this);
      replace(0, size(), "");
    }
 
    return retstr;
  }
 
  int IString::Split(const char separator, const std::string &str,
                     std::vector<std::string> &tokens,
                     bool allowEmptyEntries) {
    string::size_type idx(0), idx2(0);
    unsigned int ksize = str.size();
    tokens.clear();
 
    if(ksize > 0) {
      if(str[idx] == separator) idx++;
      while((idx2 = str.find(separator, idx)) != string::npos) {
        if(idx2 == idx) {
          if(allowEmptyEntries) tokens.push_back("");
        }
        else {
          string::size_type len(idx2 - idx);
          tokens.push_back(str.substr(idx, len));
        }
        idx = idx2 + 1;
      }
      if(idx < ksize) tokens.push_back(str.substr(idx));
    }
    return(tokens.size());
  }
 
 
  IString IString::Compress(bool force) {
    *this =  Compress((string) * this, force);
    return *this;
  }
 
  std::string IString::Compress(const std::string &str, bool force) {
    string result(str);
    if(force == false) {
      int spaces = 0;
      int leftquote = result.find_first_of("\"\'");
      while((spaces = result.find("  ", spaces)) >= 0) {
        int rightquote = result.find_first_of("\"\'", leftquote + 1);
        if(spaces < leftquote) { //spaces are before quotation
          result.erase(spaces, 1);
          leftquote = result.find_first_of("\"\'", spaces);
        }
        else if((spaces > leftquote) && (spaces < rightquote)) {   //spaces are within quotation
          spaces = rightquote + 1;
          leftquote = result.find_first_of("\"\'", rightquote + 1);
        }
        else if(leftquote == (int)npos) {   //there are no quotations
          result.erase(spaces, 1);
        }
        else {  //spaces are after quotation
          leftquote = result.find_first_of("\"\'", rightquote + 1);
        }
      }
      return result;
    }
    else {
      int spaces = 0;
      while((spaces = result.find("  ", spaces)) >= 0) {
        result.erase(spaces, 1);
      }
      return result;
    }
  }
 
  IString IString::Replace(const std::string &from, const std::string &to,
                           int maxReplaceCount) {
    *this = IString(Replace((string) * this, from, to, maxReplaceCount));
    return *this;
  }
 
  std::string IString::Replace(const std::string &str, const std::string &from,
                               const std::string &to, int maxReplaceCount) {
    if(str.empty()) return(str);
    if(from.empty()) return(str);
    string sRet(str);
    string::size_type pos;
    int nReplaced = 0;
    while((nReplaced < maxReplaceCount) &&
          (pos = sRet.find(from)) != string::npos) {
      sRet.replace(pos, from.size(), to);
      nReplaced++;
    }
    return(sRet);
  }
 
 
  IString IString::Replace(const std::string &from, const std::string &to,
                           bool honorquotes) {
    *this = Replace((string) * this, from, to, honorquotes);
    return *this;
  }
 
  IString IString::Replace(const std::string &str, const std::string &from,
                           const std::string &to , bool honorquotes) {
 
    string result = str;
    if(honorquotes == true) {
      int instances = 0;
      int quote = result.find_first_of("\"\'");
      while((instances = result.find(from, instances)) >= 0) {
 
        int nextquote = result.find_first_of("\"\'", quote + 1);
        if(instances < quote) {
          result.replace(instances, from.length(), to);
          quote = result.find_first_of("\"\'", instances);
        }
        else if((instances > quote) && (instances < nextquote)) {
          instances = nextquote + 1;
          quote = result.find_first_of("\"\'", nextquote);
        }
        else if(quote == (int)npos) {
          result.replace(instances, from.length(), to);
        }
        else {
          quote = result.find_first_of("\"\'", nextquote);
        }
      }
      return (IString) result;
    }
    else {
      int instances = 0;
      while((instances = result.find(from, instances)) >= 0) {
        result.replace(instances, from.length(), to);
      }
      return (IString) result;
    }
  }
 
  IString IString::Convert(const std::string &listofchars, const char &to) {
    *this = Convert((string) * this, listofchars, to);
    return *this;
  }
 
  string IString::Convert(const std::string &str, const std::string &listofchars,
                          const char &to) {
    std::string::size_type pos = 0;
    string result = str;
    string tmp;
    tmp = to;
    while((pos = result.find_first_of(listofchars, pos)) != npos) {
      result.replace(pos, 1, tmp);
      pos++;
    }
    return result;
  }
 
  IString IString::ConvertWhiteSpace() {
    *this = ConvertWhiteSpace((string) * this);
    return *this;
  }
 
  std::string IString::ConvertWhiteSpace(const std::string &str) {
    return Convert(str, "\n\r\t\f\v\b", ' ');
  }
 
  IString IString::Remove(const std::string &del) {
    std::string::size_type pos;
    while((pos = find_first_of(del)) != npos) this->erase(pos, 1);
    return *this;
  }
 
  std::string IString::Remove(const std::string &str, const std::string &del) {
    string::size_type pos;
    string result(str);
    while((pos = result.find_first_of(del)) != npos) result.erase(pos, 1);
    return result;
  }
 
  IString &IString::operator= (const int &value) {
    ostringstream str;
    str << value;
    assign(str.str());
    return *this;
  }
 
  IString &IString::operator= (const BigInt &value) {
    ostringstream str;
    str << value;
    assign(str.str());
    return *this;
  }
 
  std::string IString::ToStd(const QString &str) {
    return(str.toStdString());
  }
 
  QStringList IString::ToQt(const std::vector<std::string> &sl) {
    QStringList Qsl;
    for(unsigned int i = 0 ; i < sl.size() ; i++) {
      Qsl << ToQt(sl[i]);
    }
    return Qsl;
  }
 
  std::vector<std::string> IString::ToStd(const QStringList &sl) {
    std::vector<std::string> Stdsl;
    for(int i = 0 ; i < sl.size() ; i++) {
      Stdsl.push_back(ToStd(sl.at(i)));
    }
 
    return(Stdsl);
  }
 
 
  std::ostream &operator<<(std::ostream &outputStream, const QString &string) {
    return (outputStream << string.toLatin1().data());
  }
 
 
  std::ostream &operator<<(std::ostream &outputStream, const QStringRef &string) {
    return (outputStream << string.toString().toLatin1().data());
  }
}