istringlist.h

#pragma once
 
#include <QtCore/qcontainerfwd.h>
 
#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); }