optional.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_OPTIONAL_H
#define SWIFT_MISC_OPTIONAL_H
 
#include <utility>
 
#include <QtGlobal>
 
namespace swift::misc
{
 
    template <typename T>
    class Optional
    {
    public:
        Optional() noexcept = default;
 
        Optional(T value) noexcept(std::is_nothrow_move_constructible_v<T>)
        {
            new (m_data.bytes) T(std::move(value));
            m_isValid = true;
        }
 
        Optional(std::nullptr_t) noexcept {}
 
        Optional(const Optional &other) noexcept(std::is_nothrow_copy_constructible_v<T>)
        {
            if (other.m_isValid) { new (m_data.bytes) T(*other); }
            m_isValid = other.m_isValid;
        }
 
        Optional(Optional &&other) noexcept(std::is_nothrow_move_constructible_v<T>)
        {
            if (other.m_isValid) { new (m_data.bytes) T(std::move(*other)); }
            m_isValid = other.m_isValid;
        }
 
        Optional &operator=(std::nullptr_t) noexcept
        {
            reset();
            return *this;
        }
 
        Optional &operator=(const Optional &other) noexcept(std::is_nothrow_copy_constructible_v<T>)
        {
            reset();
            if (other.m_isValid) { new (m_data.bytes) T(*other); }
            m_isValid = other.m_isValid;
            return *this;
        }
 
        Optional &operator=(Optional &&other) noexcept(std::is_nothrow_move_constructible_v<T>)
        {
            reset();
            if (other.m_isValid) { new (m_data.bytes) T(std::move(*other)); }
            m_isValid = other.m_isValid;
            return *this;
        }
 
        ~Optional()
        {
            if (m_isValid) { (*this)->~T(); }
        }
 
        explicit operator bool() const noexcept { return m_isValid; }
 
        void reset() noexcept
        {
            if (m_isValid) { (*this)->~T(); }
            m_isValid = false;
        }
 
        T &operator*() { return dereference(); }
 
        const T &operator*() const { return dereference(); }
 
        T *operator->() { return &dereference(); }
 
        const T *operator->() const { return &dereference(); }
 
    private:
        bool m_isValid = false;
 
        T &dereference()
        {
            Q_ASSERT(m_isValid);
            return m_data.object;
        }
        const T &dereference() const
        {
            Q_ASSERT(m_isValid);
            return m_data.object;
        }
        union Data
        {
            Data() {}
            ~Data() {}
            char bytes[sizeof(T)];
            T object;
        };
        Data m_data;
    };
 
    template <typename T>
    void swap(Optional<T> &a, Optional<T> &b) noexcept(std::is_nothrow_swappable_v<T>)
    {
        if (a)
        {
            if (b)
            {
                using std::swap;
                swap(*a, *b);
            }
            else
            {
                b = std::move(a);
                a = nullptr;
            }
        }
        else if (b)
        {
            a = std::move(b);
            b = nullptr;
        }
    }
 
} // namespace swift::misc
 
#endif // SWIFT_MISC_OPTIONAL_H