types.hpp

Go to the documentation of this file.

 
/*
    SPDX-FileCopyrightText: 2026 Igor Mironchik <igor.mironchik@gmail.com>
    SPDX-License-Identifier: MIT
*/
 
#ifndef ARGS__TYPES_HPP__INCLUDED
#define ARGS__TYPES_HPP__INCLUDED
 
#ifdef ARGS_WSTRING_BUILD
// C++ include.
#include <iostream>
#include <string>
 
#ifdef ARGS_LIST
#include <list>
#elif defined(ARGS_DEQUE)
#include <deque>
#else
#include <vector>
#endif
 
#elif defined(ARGS_QSTRING_BUILD)
// Qt include.
#include <QString>
#include <QTextStream>
 
#ifdef ARGS_LIST
#include <QLinkedList>
#elif defined(ARGS_DEQUE)
#include <QList>
#else
#include <QVector>
#endif
 
#else
// C++ include.
#include <iostream>
#include <string>
 
#ifdef ARGS_LIST
#include <list>
#elif defined(ARGS_DEQUE)
#include <deque>
#else
#include <vector>
#endif
 
#endif
 
namespace Args
{
 
#ifdef ARGS_WSTRING_BUILD

using String = std::wstring;

using Char = String::value_type;

using OutStreamType = std::wostream;

static OutStreamType &outStream()
{
    return std::wcout;
}
 
#define SL(str) L##str

#ifdef ARGS_LIST
using StringList = std::list<String>;
#elif defined(ARGS_DEQUE)
using StringList = std::deque<String>;
#else
using StringList = std::vector<String>;
#endif
 
#elif defined(ARGS_QSTRING_BUILD)

using Char = QChar;

using OutStreamType = QTextStream;
 
class String
{
public:
    using size_type = int;
 
    String()
    {
    }
 
    String(size_type size,
           Char ch)
        : m_str(size,
                ch)
    {
    }
 
    String(const char *str)
        : m_str(str)
    {
    }
 
    String(const QString &other)
        : m_str(other)
    {
    }
 
    String(const Char *unicode,
           size_type size = -1)
        : m_str(unicode,
                size)
    {
    }
 
    String(Char ch)
        : m_str(ch)
    {
    }
 
    String(QLatin1String str)
        : m_str(str)
    {
    }
 
    String(const QByteArray &ba)
        : m_str(ba)
    {
    }
 
    operator QString()
    {
        return m_str;
    }
 
    operator QString() const
    {
        return m_str;
    }
 
    inline bool empty() const
    {
        return m_str.isEmpty();
    }
 
    static const int npos = -1;
 
    inline int find(Char ch) const
    {
        return m_str.indexOf(ch);
    }
 
    inline int find(const String &str) const
    {
        return m_str.indexOf(str.m_str);
    }
 
    QString::iterator begin()
    {
        return m_str.begin();
    }
 
    QString::iterator end()
    {
        return m_str.end();
    }
 
    QString::const_iterator begin() const
    {
        return m_str.begin();
    }
 
    QString::const_iterator end() const
    {
        return m_str.end();
    }
 
    QString::const_iterator cbegin() const
    {
        return m_str.begin();
    }
 
    QString::const_iterator cend() const
    {
        return m_str.end();
    }
 
    size_type length() const
    {
        return m_str.length();
    }
 
    String substr(size_type pos,
                  size_type count = npos) const
    {
        return m_str.mid(pos, count);
    }
 
    friend bool operator==(const String &s1,
                           const String &s2)
    {
        return (s1.m_str == s2.m_str);
    }
 
    friend bool operator!=(const String &s1,
                           const String &s2)
    {
        return (s1.m_str != s2.m_str);
    }
 
    friend String operator+(const String &s1,
                            const String &s2)
    {
        return String(s1.m_str + s2.m_str);
    }
 
    friend String operator+(const String &s1,
                            const char *s2)
    {
        return String(s1.m_str + s2);
    }
 
    friend String operator+(const char *s1,
                            const String &s2)
    {
        return String(s1 + s2.m_str);
    }
 
    friend String operator+(const String &s1,
                            const char ch)
    {
        return String(s1.m_str + ch);
    }
 
    friend String operator+(const char ch,
                            const String &s2)
    {
        return String(ch + s2.m_str);
    }
 
    friend bool operator<(const String &s1,
                          const String &s2)
    {
        return s1.m_str < s2.m_str;
    }
 
    friend OutStreamType &operator<<(OutStreamType &to,
                                     const String &what)
    {
        to << what.m_str;
 
        return to;
    }
 
    const Char operator[](size_type pos) const
    {
        return m_str[pos];
    }
 
    String &append(const String &other)
    {
        m_str.append(other.m_str);
 
        return *this;
    }
 
    String &append(size_type count,
                   Char ch)
    {
        m_str.append(QString(count, ch));
 
        return *this;
    }
 
    void clear()
    {
        m_str.clear();
    }
 
private:
    QString m_str;
}; // class String

static OutStreamType &outStream()
{
    static QTextStream stream(stdout);
 
    return stream;
}
 
#define SL(str) str

#ifdef ARGS_LIST
using StringList = QLinkedList<String>;
#elif defined(ARGS_DEQUE)
using StringList = QList<String>;
#else
using StringList = QVector<String>;
#endif
 
#else

using String = std::string;

using Char = String::value_type;

using OutStreamType = std::ostream;

static OutStreamType &outStream()
{
    return std::cout;
}
 
#define SL(str) str

#ifdef ARGS_LIST
using StringList = std::list<String>;
#elif defined(ARGS_DEQUE)
using StringList = std::deque<String>;
#else
using StringList = std::vector<String>;
#endif
 
#endif
 
namespace details
{
 
//
// Deleter
//

template<typename T>
class Deleter
{
public:
    explicit Deleter(bool shouldIDelete)
        : m_delete(shouldIDelete)
    {
    }
 
    void operator()(T *obj) noexcept
    {
        if (m_delete) {
            delete obj;
        }
    }
 
private:
    bool m_delete;
}; // class Deleter
 
} /* namespace details */
 
} /* namespace Args */
 
#endif // ARGS__TYPES_HPP__INCLUDED