checker_host/base/base.h

#ifndef BASE_H
#define BASE_H

#include "QByteArray"
#include "QList"
#include "QDebug"

class myarray : public QByteArray
{
public:
  myarray() {}
  myarray(const char *data, int len) : QByteArray(data, len) {}
  myarray(const char *data) : QByteArray()
  {
    int len = 0;
    if(data!=nullptr){
      len=strlen(data) + 1;
    }
    QByteArray::append(data, len);
  }
  myarray(int size, char data) : QByteArray(size, data) {}
  myarray(const myarray &data) : QByteArray(data) {}
  myarray(const QByteArray &data) : QByteArray(data) {}
  virtual ~myarray() {}
  char &operator[](int index)
  {
    int size = this->size();
    if (index < 0)
      index = size + index;
    if (index < 0 || index >= size)
      return data()[size-1];
    return data()[index];
  }
  bool operator==(const char *s){
    return QByteArray::operator==(s);
  }
  bool operator==(const myarray &s){
//    qDebug("s1=%s,s2=%s",data(),s.data());
    return strcmp(s.data(),data())==0;
  }
  myarray &operator=(const myarray &b)
  {
    QByteArray::operator=(b);
    return *this;
  }
  //    myarray &operator =(const myarray b){
  //        QByteArray::operator =(b);
  //        return *this;
  //    }
  myarray &operator=(const QByteArray &b)
  {
    QByteArray::operator=(b);
    return *this;
  }
  //    myarray &operator =(const QByteArray b){
  //        QByteArray::operator =(b);
  //        return *this;
  //    }
  myarray right(qsizetype index){
    return myarray(QByteArray::right(index));
  }
  myarray left(qsizetype index){
    return myarray(QByteArray::left(index));
  }
  myarray mid(qsizetype index,qsizetype len=-1LL){
    return myarray(QByteArray::mid(index,len));
  }
  QList<myarray> split(char sep){
    QByteArrayList list=QByteArray::split(sep);
    QList<myarray> myarrlist;
    foreach (QByteArray qb, list) {
      myarrlist.append(myarray(qb));
    };
    return myarrlist;
  }
};

class mystring : public QString
{
public:
  mystring() {}
  mystring(const char *data) : QString(data) {}
  mystring(myarray &data) : QString(data.data()) {}
  mystring(QByteArray &data) : QString(data.data()) {}
  mystring(QByteArray data) : QString(data.data()) {}
  mystring(QString &data) : QString(data) {}
  mystring(QString data) : QString(data) {}
  virtual ~mystring() {}
  const char *data()
  {
    localdata = QString::toLocal8Bit();
    return localdata.data();
  }
  mystring &operator=(const QString &b)
  {
    QString::operator=(b);
    return *this;
  }

protected:
  myarray localdata;
};

template <typename T>
QList<T> str_to_nums(mystring str, char c)
{
  QStringList snums = str.split(c);
  QList<T> nums;
  for (int i = 0; i < snums.size(); i++)
    nums.append(T(snums[i].toInt(nullptr, 10)));
  return nums;
}

myarray str_to_data(mystring str, char c);

#endif // BASE_H