Remove appbase as an external dependency.

lib/appbase/common/Aliases.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <QHash>
+#include <QString>
+#include <functional>
+
+#define QStringAlias(name)                                 \
+    namespace chatterino {                                 \
+    struct name {                                          \
+        QString string;                                    \
+        bool operator==(const name &other) const           \
+        {                                                  \
+            return this->string == other.string;           \
+        }                                                  \
+        bool operator!=(const name &other) const           \
+        {                                                  \
+            return this->string != other.string;           \
+        }                                                  \
+    };                                                     \
+    } /* namespace chatterino */                           \
+    namespace std {                                        \
+    template <>                                            \
+    struct hash<chatterino::name> {                        \
+        size_t operator()(const chatterino::name &s) const \
+        {                                                  \
+            return qHash(s.string);                        \
+        }                                                  \
+    };                                                     \
+    } /* namespace std */
+
+QStringAlias(UserName);
+QStringAlias(UserId);
+QStringAlias(Url);
+QStringAlias(Tooltip);
+QStringAlias(EmoteId);
+QStringAlias(EmoteName);

lib/appbase/common/ChatterinoSetting.cpp

@@ -0,0 +1,12 @@
+#include "common/ChatterinoSetting.hpp"
+
+#include "BaseSettings.hpp"
+
+namespace AB_NAMESPACE {
+
+void _registerSetting(std::weak_ptr<pajlada::Settings::SettingData> setting)
+{
+    _actuallyRegisterSetting(setting);
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/common/ChatterinoSetting.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <QString>
+#include <pajlada/settings.hpp>
+
+namespace AB_NAMESPACE {
+
+void _registerSetting(std::weak_ptr<pajlada::Settings::SettingData> setting);
+
+template <typename Type>
+class ChatterinoSetting : public pajlada::Settings::Setting<Type>
+{
+public:
+    ChatterinoSetting(const std::string &path)
+        : pajlada::Settings::Setting<Type>(path)
+    {
+        _registerSetting(this->getData());
+    }
+
+    ChatterinoSetting(const std::string &path, const Type &defaultValue)
+        : pajlada::Settings::Setting<Type>(path, defaultValue)
+    {
+        _registerSetting(this->getData());
+    }
+
+    template <typename T2>
+    ChatterinoSetting &operator=(const T2 &newValue)
+    {
+        this->setValue(newValue);
+
+        return *this;
+    }
+
+    ChatterinoSetting &operator=(Type &&newValue) noexcept
+    {
+        pajlada::Settings::Setting<Type>::operator=(newValue);
+
+        return *this;
+    }
+
+    using pajlada::Settings::Setting<Type>::operator==;
+    using pajlada::Settings::Setting<Type>::operator!=;
+
+    using pajlada::Settings::Setting<Type>::operator Type;
+};
+
+using BoolSetting = ChatterinoSetting<bool>;
+using FloatSetting = ChatterinoSetting<float>;
+using DoubleSetting = ChatterinoSetting<double>;
+using IntSetting = ChatterinoSetting<int>;
+using StringSetting = ChatterinoSetting<std::string>;
+using QStringSetting = ChatterinoSetting<QString>;
+
+}  // namespace AB_NAMESPACE

lib/appbase/common/FlagsEnum.hpp

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <type_traits>
+
+namespace chatterino {
+
+template <typename T, typename Q = typename std::underlying_type<T>::type>
+class FlagsEnum
+{
+public:
+    FlagsEnum()
+        : value_(static_cast<T>(0))
+    {
+    }
+
+    FlagsEnum(T value)
+        : value_(value)
+    {
+    }
+
+    FlagsEnum(std::initializer_list<T> flags)
+    {
+        for (auto flag : flags)
+        {
+            this->set(flag);
+        }
+    }
+
+    bool operator==(const FlagsEnum<T> &other)
+    {
+        return this->value_ == other.value_;
+    }
+
+    bool operator!=(const FlagsEnum &other)
+    {
+        return this->value_ != other.value_;
+    }
+
+    void set(T flag)
+    {
+        reinterpret_cast<Q &>(this->value_) |= static_cast<Q>(flag);
+    }
+
+    void unset(T flag)
+    {
+        reinterpret_cast<Q &>(this->value_) &= ~static_cast<Q>(flag);
+    }
+
+    void set(T flag, bool value)
+    {
+        if (value)
+            this->set(flag);
+        else
+            this->unset(flag);
+    }
+
+    bool has(T flag) const
+    {
+        return static_cast<Q>(this->value_) & static_cast<Q>(flag);
+    }
+
+    bool hasAny(FlagsEnum flags) const
+    {
+        return static_cast<Q>(this->value_) & static_cast<Q>(flags.value_);
+    }
+
+    bool hasAll(FlagsEnum<T> flags) const
+    {
+        return (static_cast<Q>(this->value_) & static_cast<Q>(flags.value_)) &&
+               static_cast<Q>(flags->value);
+    }
+
+    bool hasNone(std::initializer_list<T> flags) const
+    {
+        return !this->hasAny(flags);
+    }
+
+private:
+    T value_{};
+};
+
+}  // namespace chatterino

lib/appbase/common/Outcome.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+namespace chatterino {
+
+struct SuccessTag {
+};
+
+struct FailureTag {
+};
+
+const SuccessTag Success{};
+const FailureTag Failure{};
+
+class Outcome
+{
+public:
+    Outcome(SuccessTag)
+        : success_(true)
+    {
+    }
+
+    Outcome(FailureTag)
+        : success_(false)
+    {
+    }
+
+    explicit operator bool() const
+    {
+        return this->success_;
+    }
+
+    bool operator!() const
+    {
+        return !this->success_;
+    }
+
+    bool operator==(const Outcome &other) const
+    {
+        return this->success_ == other.success_;
+    }
+
+    bool operator!=(const Outcome &other) const
+    {
+        return !this->operator==(other);
+    }
+
+private:
+    bool success_;
+};
+
+}  // namespace chatterino

lib/appbase/common/Singleton.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <boost/noncopyable.hpp>
+
+namespace AB_NAMESPACE {
+
+class Settings;
+class Paths;
+
+class Singleton : boost::noncopyable
+{
+public:
+    virtual ~Singleton() = default;
+
+    virtual void initialize(Settings &settings, Paths &paths)
+    {
+        (void)(settings);
+        (void)(paths);
+    }
+
+    virtual void save()
+    {
+    }
+};
+
+}  // namespace AB_NAMESPACE