istringlist.h

#pragma once
#include "istring.h"
#include "idef.h"
 
class QStringList;
template <typename T> class QList;
class IStringList : public IList<IString> {
public:
    using IList<IString>::IList;
    IStringList(const IList<IString> &in) : IList<IString>(in) { }
    IStringList(std::vector<string> &&in) { reserve(in.size());  for (auto &&v : in) emplace_back(v); in.clear(); }
    IStringList(const std::vector<string> &in) { reserve(in.size());  for (auto &v : in) emplace_back(v);  }
    IStringList(const StringList &in) { reserve(in.size());  for (auto &v : in) emplace_back(v); }
    explicit IStringList(const IString &s) : IList<IString>({s}) { }
    BASE_EXPORT operator StringList() const;
 
    // Temporary Conversion
    BASE_EXPORT IStringList(const QStringList &sl);
    BASE_EXPORT IStringList(const QList<IString> &q);
    BASE_EXPORT operator QList<IString>() const;
    BASE_EXPORT operator QStringList() const;
 
    void operator+=(const string &s) { push_back(s); }
    void operator+=(const QString &s) { push_back(s); }
    void operator+=(const char *str) { push_back(string(str)); }
    BASE_EXPORT void operator+=(const StringList &s);
    BASE_EXPORT void operator+=(const QStringList &s);
    BASE_EXPORT void operator+=(const IStringList &s);
    BASE_EXPORT void operator+=(const std::vector<string> &s);
    BASE_EXPORT IStringList operator+(const IStringList &in) { IStringList out(*this);  out += in;  return out; }
 
    IStringList &operator<<(const string &s) { push_back(s); return *this; }
    BASE_EXPORT IStringList &operator<<(const std::vector<string> &s);
    BASE_EXPORT IStringList &operator<<(const QStringList &s);
 
    BASE_EXPORT void insert(int index,const IString &s);
    void append(const IString &s) { push_back(s); }
    BASE_EXPORT void append(const IStringList &);
    BASE_EXPORT int removeDuplicates();
    BASE_EXPORT void sort();
    BASE_EXPORT IString takeFirst();
 
    int length() const { return size(); }
    int size() const { return to<int>(std::vector<IString>::size()); }
    int count() const { return size(); }
    IString value(int index,const IString &def={}) const { if (index<0 or index>=to<int>(size())) return def;  return at(index); }
    IString join(const IString &sep) const { return ::join(*this,sep); }
    BASE_EXPORT bool contains(const IString &sep,IString::Case c=IString::Case::Sensitive) const;
    BASE_EXPORT int indexOf(const IString &val) const;
};
 
inline StringList toStringList(const IStringList &sl) { return sl; }
inline IStringList toIStringList(const StringList &sl) { return IStringList(sl); }