IString.h

#ifndef IString_h
#define IString_h
 
/* SPDX-License-Identifier: CC0-1.0 */
#include <string>
#include <vector>
 
#include <QString>
#include <QStringList>
 
#include "Constants.h"
 
namespace Isis {
  class IString;
 
  bool toBool(const QString &);
  int toInt(const QString &);
  BigInt toBigInt(const QString &);
  double toDouble(const QString &);
 
  QString toString(bool);
  QString toString(char);
  QString toString(const int &);
  QString toString(const unsigned int &);
  QString toString(const BigInt &);
  QString toString(double, int precision = 14);
 
  class IString : public std::string {
    public:
      IString();
 
      IString(const std::string &str);
      IString(const IString &str);
      IString(const char *str);
      IString(const int &num);
      IString(const double &num, const int piPrecision = 14);
      IString(const BigInt &num);
      IString(const QString &str);
 
      ~IString();
 
      IString Trim(const std::string &chars);
      static std::string Trim(const std::string &chars, const std::string &str);
 
      IString TrimHead(const std::string &chars);
      static std::string TrimHead(const std::string &chars, const std::string &str);
 
      IString TrimTail(const std::string &chars);
      static std::string TrimTail(const std::string &chars, const std::string &str);
 
      IString UpCase();
      static std::string UpCase(const std::string &str);
 
      IString DownCase();
      static std::string DownCase(const std::string &str);
 
      int ToInteger() const;
      static int ToInteger(const std::string &str);
 
      BigInt ToBigInteger() const;
      static BigInt ToBigInteger(const std::string &str);
 
      double ToDouble() const;
      static double ToDouble(const std::string &str);
 
      QString ToQt() const;
      static QString ToQt(const std::string &str);
 
      IString Token(const IString &separator);
      static int Split(const char separator, const std::string &instr,
                       std::vector<std::string> &tokens,
                       bool allowEmptyEntries = true);
 
      IString Compress(bool force = false);
      static std::string Compress(const std::string &str, bool force = false);
 
      IString Replace(const std::string &from, const std::string &to,
                      int maxReplaceCount = 20);
      static std::string  Replace(const std::string &str,
                                  const std::string &from,
                                  const std::string &to,
                                  int maxReplacementCount = 20);
 
      IString Replace(const std::string &from, const std::string &to , bool honorquotes);
      static IString Replace(const std::string &str, const std::string &from,
                             const std::string &to , bool honorquotes);
 
      IString Convert(const std::string &listofchars, const char &to);
      static std::string Convert(const std::string &str,
                                 const std::string &listofchars,
                                 const char &to);
 
      IString ConvertWhiteSpace();
      static std::string ConvertWhiteSpace(const std::string &str);
 
      IString Remove(const std::string &del);
      static std::string Remove(const std::string &del, const std::string &str);
 
      operator int() const {
        return ToInteger();
      };
 
      operator BigInt() const {
        return ToBigInteger();
      };
 
      operator double() const {
        return ToDouble();
      };
 
#if 0
      operator IString() const {
        return ToQt();
      };
#endif
 
      IString &operator= (const int &value);
 
      IString &operator= (const BigInt &value);
 
      IString &operator= (const double &value) {
        SetDouble(value);
        return *this;
      }
 
      bool Equal(const std::string &str) const;
      static bool Equal(const std::string &str1, const std::string &str2);
 
      static std::string ToStd(const QString &str);
 
      static QStringList ToQt(const std::vector<std::string> &sl);
      static std::vector<std::string> ToStd(const QStringList &sl);
 
    private:
      void SetDouble(const double &value, const int piPrecision = 14);
  };
 
  std::ostream &operator<<(std::ostream &os, const QString &string);
  std::ostream &operator<<(std::ostream &os, const QStringRef &string);
}
 
#endif