IString.h

Go to the documentation of this file.

#ifndef IString_h
#define IString_h

#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