JUCE/modules/juce_core/containers/juce_Optional.h

/*
  ==============================================================================

   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited

   JUCE is an open source library subject to commercial or open-source
   licensing.

   The code included in this file is provided under the terms of the ISC license
   http://www.isc.org/downloads/software-support-policy/isc-license. Permission
   To use, copy, modify, and/or distribute this software for any purpose with or
   without fee is hereby granted provided that the above copyright notice and
   this permission notice appear in all copies.

   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.

  ==============================================================================
*/

#pragma once

#include <utility>

namespace juce
{

namespace detail
{
namespace adlSwap
{
using std::swap;

template <typename T>
constexpr auto isNothrowSwappable = noexcept (swap (std::declval<T&>(), std::declval<T&>()));
} // namespace adlSwap
} // namespace detail

struct Nullopt {};

constexpr Nullopt nullopt;

// Without this, our tests can emit "unreachable code" warnings during
// link time code generation.
JUCE_BEGIN_IGNORE_WARNINGS_MSVC (4702)

/*  For internal use only!

    A simple optional type.

    Has similar (not necessarily identical!) semantics to std::optional.

    This isn't really intended to be used by JUCE clients. Instead, it's to be
    used internally in JUCE code, with an API close-enough to std::optional
    that the types can be swapped with fairly minor disruption at some point in
    the future, but *without breaking any public APIs*.
*/
template <typename Value>
class Optional
{
    template <typename T, typename U>
    struct NotConstructibleFromSimilarType
    {
        static constexpr auto value = ! std::is_constructible<T, Optional<U>&>::value
                                   && ! std::is_constructible<T, const Optional<U>&>::value
                                   && ! std::is_constructible<T, Optional<U>&&>::value
                                   && ! std::is_constructible<T, const Optional<U>&&>::value
                                   && ! std::is_convertible<Optional<U>&, T>::value
                                   && ! std::is_convertible<const Optional<U>&, T>::value
                                   && ! std::is_convertible<Optional<U>&&, T>::value
                                   && ! std::is_convertible<const Optional<U>&&, T>::value;
    };

    template <typename T, typename U>
    using OptionalCopyConstructorEnabled = std::enable_if_t<std::is_constructible<T, const U&>::value && NotConstructibleFromSimilarType<T, U>::value>;

    template <typename T, typename U>
    using OptionalMoveConstructorEnabled = std::enable_if_t<std::is_constructible<T, U&&>::value && NotConstructibleFromSimilarType<T, U>::value>;

    template <typename T, typename U>
    static auto notAssignableFromSimilarType = NotConstructibleFromSimilarType<T, U>::value
                                               && ! std::is_assignable<T&, Optional<U>&>::value
                                               && ! std::is_assignable<T&, const Optional<U>&>::value
                                               && ! std::is_assignable<T&, Optional<U>&&>::value
                                               && ! std::is_assignable<T&, const Optional<U>&&>::value;

    template <typename T, typename U>
    using OptionalCopyAssignmentEnabled = std::enable_if_t<std::is_constructible<T, const U&>::value
                                                           && std::is_assignable<T&, const U&>::value
                                                           && NotConstructibleFromSimilarType<T, U>::value>;

    template <typename T, typename U>
    using OptionalMoveAssignmentEnabled = std::enable_if_t<std::is_constructible<T, U>::value
                                                           && std::is_nothrow_assignable<T&, U>::value
                                                           && NotConstructibleFromSimilarType<T, U>::value>;

public:
    Optional() = default;

    Optional (Nullopt) noexcept {}

    template <typename U = Value,
              typename = std::enable_if_t<std::is_constructible<Value, U&&>::value
                                          && ! std::is_same<std::decay_t<U>, Optional>::value>>
    Optional (U&& value) noexcept (noexcept (Value (std::forward<U> (value))))
        : valid (true)
    {
        new (&storage) Value (std::forward<U> (value));
    }

    Optional (Optional&& other) noexcept (noexcept (std::declval<Optional>().constructFrom (other)))
    {
        constructFrom (other);
    }

    Optional (const Optional& other)
        : valid (other.valid)
    {
        if (valid)
            new (&storage) Value (*other);
    }

    template <typename Other, typename = OptionalMoveConstructorEnabled<Value, Other>>
    Optional (Optional<Other>&& other) noexcept (noexcept (std::declval<Optional>().constructFrom (other)))
    {
        constructFrom (other);
    }

    template <typename Other, typename = OptionalCopyConstructorEnabled<Value, Other>>
    Optional (const Optional<Other>& other)
        : valid (other.hasValue())
    {
        if (valid)
            new (&storage) Value (*other);
    }

    Optional& operator= (Nullopt) noexcept
    {
        reset();
        return *this;
    }

    template <typename U = Value,
              typename = std::enable_if_t<std::is_nothrow_move_constructible<U>::value
                                          && std::is_nothrow_move_assignable<U>::value>>
    Optional& operator= (Optional&& other) noexcept (noexcept (std::declval<Optional>().assign (std::declval<Optional&>())))
    {
        assign (other);
        return *this;
    }

    template <typename U = Value,
              typename = std::enable_if_t<! std::is_same<std::decay_t<U>, Optional>::value
                                          && std::is_constructible<Value, U>::value
                                          && std::is_assignable<Value&, U>::value
                                          && (! std::is_scalar<Value>::value || ! std::is_same<std::decay_t<U>, Value>::value)>>
    Optional& operator= (U&& value)
    {
        if (valid)
            **this = std::forward<U> (value);
        else
            new (&storage) Value (std::forward<U> (value));

        valid = true;
        return *this;
    }

    /*  Maintains the strong exception safety guarantee. */
    Optional& operator= (const Optional& other)
    {
        auto copy = other;
        assign (copy);
        return *this;
    }

    template <typename Other, typename = OptionalMoveAssignmentEnabled<Value, Other>>
    Optional& operator= (Optional<Other>&& other) noexcept (noexcept (std::declval<Optional>().assign (other)))
    {
        assign (other);
        return *this;
    }

    /*  Maintains the strong exception safety guarantee. */
    template <typename Other, typename = OptionalCopyAssignmentEnabled<Value, Other>>
    Optional& operator= (const Optional<Other>& other)
    {
        auto copy = other;
        assign (copy);
        return *this;
    }

    ~Optional() noexcept
    {
        reset();
    }

          Value* operator->()       noexcept { return reinterpret_cast<      Value*> (&storage); }
    const Value* operator->() const noexcept { return reinterpret_cast<const Value*> (&storage); }

          Value& operator*()       noexcept { return *operator->(); }
    const Value& operator*() const noexcept { return *operator->(); }

    explicit operator bool() const noexcept { return valid; }
    bool hasValue() const noexcept { return valid; }

    void reset()
    {
        if (std::exchange (valid, false))
            operator*().~Value();
    }

    /*  Like std::optional::value_or */
    template <typename U>
    Value orFallback (U&& fallback) const { return *this ? **this : std::forward<U> (fallback); }

    template <typename... Args>
    Value& emplace (Args&&... args)
    {
        reset();
        new (&storage) Value (std::forward<Args> (args)...);
        valid = true;
        return **this;
    }

    void swap (Optional& other) noexcept (std::is_nothrow_move_constructible<Value>::value
                                          && detail::adlSwap::isNothrowSwappable<Value>)
    {
        if (hasValue() && other.hasValue())
        {
            using std::swap;
            swap (**this, *other);
        }
        else if (hasValue() || other.hasValue())
        {
            (hasValue() ? other : *this).constructFrom (hasValue() ? *this : other);
        }
    }

private:
    template <typename Other>
    void constructFrom (Optional<Other>& other) noexcept (noexcept (Value (std::move (*other))))
    {
        if (! other.hasValue())
            return;

        new (&storage) Value (std::move (*other));
        valid = true;
        other.reset();
    }

    template <typename Other>
    void assign (Optional<Other>& other) noexcept (noexcept (std::declval<Value&>() = std::move (*other)) && noexcept (std::declval<Optional>().constructFrom (other)))
    {
        if (valid)
        {
            if (other.hasValue())
            {
                **this = std::move (*other);
                other.reset();
            }
            else
            {
                reset();
            }
        }
        else
        {
            constructFrom (other);
        }
    }

    std::aligned_storage_t<sizeof (Value), alignof (Value)> storage;
    bool valid = false;
};

JUCE_END_IGNORE_WARNINGS_MSVC

template <class T, class U>
bool operator== (const Optional<T>& lhs, const Optional<U>& rhs)
{
    if (lhs.hasValue() != rhs.hasValue()) return false;
    if (! lhs.hasValue()) return true;
    return *lhs == *rhs;
}

template <class T, class U>
bool operator!= (const Optional<T>& lhs, const Optional<U>& rhs)
{
    if (lhs.hasValue() != rhs.hasValue()) return true;
    if (! lhs.hasValue()) return false;
    return *lhs != *rhs;
}

template <class T, class U>
bool operator< (const Optional<T>& lhs, const Optional<U>& rhs)
{
    if (! rhs.hasValue()) return false;
    if (! lhs.hasValue()) return true;
    return *lhs < *rhs;
}

template <class T, class U>
bool operator<= (const Optional<T>& lhs, const Optional<U>& rhs)
{
    if (! lhs.hasValue()) return true;
    if (! rhs.hasValue()) return false;
    return *lhs <= *rhs;
}

template <class T, class U>
bool operator> (const Optional<T>& lhs, const Optional<U>& rhs)
{
    if (! lhs.hasValue()) return false;
    if (! rhs.hasValue()) return true;
    return *lhs > *rhs;
}

template <class T, class U>
bool operator>= (const Optional<T>& lhs, const Optional<U>& rhs)
{
    if (! rhs.hasValue()) return true;
    if (! lhs.hasValue()) return false;
    return *lhs >= *rhs;
}

template <class T>
bool operator== (const Optional<T>& opt, Nullopt) noexcept { return ! opt.hasValue(); }
template <class T>
bool operator== (Nullopt, const Optional<T>& opt) noexcept { return ! opt.hasValue(); }
template <class T>
bool operator!= (const Optional<T>& opt, Nullopt) noexcept { return opt.hasValue(); }
template <class T>
bool operator!= (Nullopt, const Optional<T>& opt) noexcept { return opt.hasValue(); }
template <class T>
bool operator< (const Optional<T>&, Nullopt) noexcept { return false; }
template <class T>
bool operator< (Nullopt, const Optional<T>& opt) noexcept { return opt.hasValue(); }
template <class T>
bool operator<= (const Optional<T>& opt, Nullopt) noexcept { return ! opt.hasValue(); }
template <class T>
bool operator<= (Nullopt, const Optional<T>&) noexcept { return true; }
template <class T>
bool operator> (const Optional<T>& opt, Nullopt) noexcept { return opt.hasValue(); }
template <class T>
bool operator> (Nullopt, const Optional<T>&) noexcept { return false; }
template <class T>
bool operator>= (const Optional<T>&, Nullopt) noexcept { return true; }
template <class T>
bool operator>= (Nullopt, const Optional<T>& opt) noexcept { return ! opt.hasValue(); }

template <class T, class U>
bool operator== (const Optional<T>& opt, const U& value) { return opt.hasValue() ? *opt == value : false; }
template <class T, class U>
bool operator== (const T& value, const Optional<U>& opt) { return opt.hasValue() ? value == *opt : false; }
template <class T, class U>
bool operator!= (const Optional<T>& opt, const U& value) { return opt.hasValue() ? *opt != value : true; }
template <class T, class U>
bool operator!= (const T& value, const Optional<U>& opt) { return opt.hasValue() ? value != *opt : true; }
template <class T, class U>
bool operator< (const Optional<T>& opt, const U& value) { return opt.hasValue() ? *opt < value : true; }
template <class T, class U>
bool operator< (const T& value, const Optional<U>& opt) { return opt.hasValue() ? value < *opt : false; }
template <class T, class U>
bool operator<= (const Optional<T>& opt, const U& value) { return opt.hasValue() ? *opt <= value : true; }
template <class T, class U>
bool operator<= (const T& value, const Optional<U>& opt) { return opt.hasValue() ? value <= *opt : false; }
template <class T, class U>
bool operator> (const Optional<T>& opt, const U& value) { return opt.hasValue() ? *opt > value : false; }
template <class T, class U>
bool operator> (const T& value, const Optional<U>& opt) { return opt.hasValue() ? value > *opt : true; }
template <class T, class U>
bool operator>= (const Optional<T>& opt, const U& value) { return opt.hasValue() ? *opt >= value : false; }
template <class T, class U>
bool operator>= (const T& value, const Optional<U>& opt) { return opt.hasValue() ? value >= *opt : true; }

} // namespace juce