1 files changed, 308 insertions, 0 deletions

diff --git a/framework/src/errors.h b/framework/src/errors.h
new file mode 100644
index 00000000..4249cf8d
--- /dev/null
+++ b/framework/src/errors.h
@@ -0,0 +1,308 @@
+/*
+    Copyright (c) 2018 Christian Mollekopf <mollekopf@kolabsys.com>
+
+    This library is free software; you can redistribute it and/or modify it
+    under the terms of the GNU Library General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    This library is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
+    License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to the
+    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+    02110-1301, USA.
+*/
+#pragma once
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include <QtGlobal>
+
+// A somewhat implementation of the expected monad, proposed here:
+// https://isocpp.org/files/papers/n4015.pdf
+
+// A class used to differentiate errors and values when they are of the same type.
+template <typename Error>
+class Unexpected
+{
+
+    static_assert(!std::is_same<Error, void>::value, "Cannot have an Unexpected void");
+
+public:
+    Unexpected() = delete;
+
+    constexpr explicit Unexpected(const Error &error) : mValue(error) {}
+    constexpr explicit Unexpected(Error &&error) : mValue(std::move(error)) {}
+
+    // For implicit conversions when doing makeUnexpected(other)
+    template <typename Other>
+    constexpr explicit Unexpected(const Unexpected<Other> &error) : mValue(error.value())
+    {
+    }
+    template <typename Other>
+    constexpr explicit Unexpected(Unexpected<Other> &&error) : mValue(std::move(error.value()))
+    {
+    }
+
+    constexpr const Error &value() const &
+    {
+        return mValue;
+    }
+    Error &value() &
+    {
+        return mValue;
+    }
+
+    constexpr const Error &&value() const &&
+    {
+        return std::move(mValue);
+    }
+    Error &&value() &&
+    {
+        return std::move(mValue);
+    }
+
+private:
+    Error mValue;
+};
+
+template <class Error>
+Unexpected<typename std::decay<Error>::type> makeUnexpected(Error &&e)
+{
+    return Unexpected<typename std::decay<Error>::type>(std::forward<Error>(e));
+}
+
+template <typename Error>
+bool operator==(const Unexpected<Error> &lhs, const Unexpected<Error> &rhs)
+{
+    return lhs.value() == rhs.value();
+}
+
+template <typename Error>
+bool operator!=(const Unexpected<Error> &lhs, const Unexpected<Error> &rhs)
+{
+    return lhs.value() != rhs.value();
+}
+
+namespace detail {
+
+namespace tags {
+struct Expected
+{};
+struct Unexpected
+{};
+} // namespace tags
+
+// Write functions here when storage related and when Type != void
+template <typename Error, typename Type>
+struct StorageBase
+{
+protected:
+    // Rule of 5 {{{
+
+    StorageBase(const StorageBase &other) : mIsValue(other.mIsValue)
+    {
+        // This is a constructor, you have to construct object, not assign them
+        // (hence the placement new)
+        //
+        // Here's the problem:
+        //
+        // Object that are part of a union are not initialized (which is
+        // normal). If we replaced the placement new by a line like this:
+        //
+        // ```
+        // mValue = other.mValue;
+        // ```
+        //
+        // If overloaded, this will call `mValue.operator=(other.mValue);`, but
+        // since we're in the constructor, mValue is not initialized. This can
+        // cause big issues if `Type` / `Error` is not trivially (move)
+        // assignable.
+        //
+        // And so, the placement new allows us to call the constructor of
+        // `Type` or `Error` instead of its assignment operator.
+        if (mIsValue) {
+            new (std::addressof(mValue)) Type(other.mValue);
+        } else {
+            new (std::addressof(mError)) Unexpected<Error>(other.mError);
+        }
+    }
+
+    StorageBase(StorageBase &&other) : mIsValue(other.mIsValue)
+    {
+        // If you're thinking WTF, see the comment in the copy constructor above.
+        if (mIsValue) {
+            new (std::addressof(mValue)) Type(std::move(other.mValue));
+        } else {
+            new (std::addressof(mError)) Unexpected<Error>(std::move(other.mError));
+        }
+    }
+
+    constexpr StorageBase &operator=(const StorageBase &other)
+    {
+        mIsValue = other.mIsValue;
+        if (mIsValue) {
+            mValue = other.mValue;
+        } else {
+            mError = other.mError;
+        }
+        return *this;
+    }
+
+    constexpr StorageBase &operator=(StorageBase &&other)
+    {
+        this->~StorageBase();
+        mIsValue = other.mIsValue;
+        if (mIsValue) {
+            mValue = std::move(other.mValue);
+        } else {
+            mError = std::move(other.mError);
+        }
+        return *this;
+    }
+
+    ~StorageBase()
+    {
+        if (mIsValue) {
+            mValue.~Type();
+        } else {
+            mError.~Unexpected<Error>();
+        }
+    }
+
+    // }}}
+
+    template <typename... Args>
+    constexpr StorageBase(tags::Expected, Args &&... args)
+        : mValue(std::forward<Args>(args)...), mIsValue(true)
+    {
+    }
+
+    template <typename... Args>
+    constexpr StorageBase(tags::Unexpected, Args &&... args)
+        : mError(std::forward<Args>(args)...), mIsValue(false)
+    {
+    }
+
+    union
+    {
+        Unexpected<Error> mError;
+        Type mValue;
+    };
+    bool mIsValue;
+};
+
+// Write functions here when storage related and when Type == void
+template <typename Error>
+struct StorageBase<Error, void>
+{
+protected:
+    constexpr StorageBase(tags::Expected) : mIsValue(true) {}
+
+    template <typename... Args>
+    constexpr StorageBase(tags::Unexpected, Args &&... args)
+        : mError(std::forward<Args>(args)...), mIsValue(false)
+    {
+    }
+
+    Unexpected<Error> mError;
+    bool mIsValue;
+};
+
+// Write functions here when storage related, whether Type is void or not
+template <typename Error, typename Type>
+struct Storage : StorageBase<Error, Type>
+{
+protected:
+    // Forward the construction to StorageBase
+    using StorageBase<Error, Type>::StorageBase;
+};
+
+// Write functions here when dev API related and when Type != void
+template <typename Error, typename Type>
+struct ExpectedBase : detail::Storage<Error, Type>
+{
+    constexpr ExpectedBase() : detail::Storage<Error, Type>(detail::tags::Expected{}) {}
+
+    template <typename OtherError>
+    constexpr ExpectedBase(const Unexpected<OtherError> &error)
+        : detail::Storage<Error, Type>(detail::tags::Unexpected{}, error)
+    {
+    }
+    template <typename OtherError>
+    constexpr ExpectedBase(Unexpected<OtherError> &&error)
+        : detail::Storage<Error, Type>(detail::tags::Unexpected{}, std::move(error))
+    {
+    }
+
+    constexpr ExpectedBase(const Type &value)
+        : detail::Storage<Error, Type>(detail::tags::Expected{}, value)
+    {
+    }
+    constexpr ExpectedBase(Type &&value)
+        : detail::Storage<Error, Type>(detail::tags::Expected{}, std::move(value))
+    {
+    }
+
+    // Warning: will crash if this is an error. You should always check this is
+    // an expected value before calling `.value()`
+    constexpr const Type &value() const &
+    {
+        Q_ASSERT(this->mIsValue);
+        return this->mValue;
+    }
+    Type &&value() &&
+    {
+        Q_ASSERT(this->mIsValue);
+        return std::move(this->mValue);
+    }
+};
+
+// Write functions here when dev API related and when Type == void
+template <typename Error>
+struct ExpectedBase<Error, void> : detail::Storage<Error, void>
+{
+    // Rewrite constructors for unexpected because Expected doesn't have direct access to it.
+    template <typename OtherError>
+    constexpr ExpectedBase(const Unexpected<OtherError> &error)
+        : detail::Storage<Error, void>(detail::tags::Unexpected{}, error)
+    {
+    }
+    template <typename OtherError>
+    constexpr ExpectedBase(Unexpected<OtherError> &&error)
+        : detail::Storage<Error, void>(detail::tags::Unexpected{}, std::move(error))
+    {
+    }
+};
+
+} // namespace detail
+
+// Write functions here when dev API related, whether Type is void or not
+template <typename Error, typename Type = void>
+class Expected : public detail::ExpectedBase<Error, Type>
+{
+    static_assert(!std::is_same<Error, void>::value, "Expected with void Error is not implemented");
+
+public:
+    using detail::ExpectedBase<Error, Type>::ExpectedBase;
+
+    constexpr const Error &error() const &
+    {
+        return this->mError.value();
+    }
+
+    constexpr bool isValue() const
+    {
+        return this->mIsValue;
+    }
+    constexpr explicit operator bool() const
+    {
+        return this->mIsValue;
+    }
+};