optional.hpp

// Copyright (c) 2016-2022 Thomas Fussell
// Copyright (c) 2024-2025 xlnt-community
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE
//
// @license: http://www.opensource.org/licenses/mit-license.php
// @author: see AUTHORS file

#pragma once

#include "xlnt/utils/exceptions.hpp"
#include "xlnt/utils/numeric.hpp"
#include <type_traits>
#include <cstring>

namespace xlnt {

template <typename T>
class optional
{
#if ((defined(_MSC_VER) && _MSC_VER <= 1900) || (defined(__GNUC__) && __GNUC__ < 5))
// Disable enhanced type checking on Visual Studio <= 2015 and GCC <5
#define XLNT_NOEXCEPT_VALUE_COMPAT(...) (false)
#else
#define XLNT_NOEXCEPT_VALUE_COMPAT(...) (__VA_ARGS__)
    using ctor_copy_T_noexcept = typename std::conditional<std::is_nothrow_copy_constructible<T>{}, std::true_type, std::false_type>::type;
    using ctor_move_T_noexcept = typename std::conditional<std::is_nothrow_move_constructible<T>{}, std::true_type, std::false_type>::type;
    using copy_ctor_noexcept = ctor_copy_T_noexcept;
    using move_ctor_noexcept = ctor_move_T_noexcept;
    using set_copy_noexcept_t = typename std::conditional<std::is_nothrow_copy_constructible<T>{} && std::is_nothrow_assignable<T, T>{}, std::true_type, std::false_type>::type;
    using set_move_noexcept_t = typename std::conditional<std::is_nothrow_move_constructible<T>{} && std::is_nothrow_move_assignable<T>{}, std::true_type, std::false_type>::type;
    using clear_noexcept_t = typename std::conditional<std::is_nothrow_destructible<T>{}, std::true_type, std::false_type>::type;
#endif
    template <typename U = T, typename std::enable_if<!std::is_floating_point<U>::value>::type * = nullptr>
    constexpr bool compare_equal(const U &lhs, const U &rhs) const
    {
        return lhs == rhs;
    }

    template <typename U = T, typename std::enable_if<std::is_floating_point<U>::value>::type * = nullptr>
    constexpr bool compare_equal(const U &lhs, const U &rhs) const
    {
        return detail::float_equals(lhs, rhs);
    }

public:
    optional() noexcept
        : has_value_(false),
        storage_{}
    {
    }

    optional(const T &value) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(ctor_copy_T_noexcept{}))
        : has_value_(true)
    {
        new (&storage_) T(value);
    }

    optional(T &&value) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(ctor_move_T_noexcept{}))
        : has_value_(true)
    {
        new (&storage_) T(std::move(value));
    }

    optional(const optional &other) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(copy_ctor_noexcept{}))
        : has_value_(other.has_value_)
    {
        if (has_value_)
        {
            new (&storage_) T(other.value_ref());
        }
        else
        {
            std::memset(storage_, 0, sizeof(T));
        }
    }

    optional(optional &&other) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(move_ctor_noexcept{}))
        : has_value_(other.has_value_)
    {
        if (has_value_)
        {
            new (&storage_) T(std::move(other.value_ref()));
            other.clear();
        }
        else
        {
            std::memset(storage_, 0, sizeof(T));
        }
    }

    optional &operator=(const optional &other) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(set_copy_noexcept_t{} && clear_noexcept_t{}))
    {
        if (other.has_value_)
        {
            set(other.value_ref());
        }
        else
        {
            clear();
        }
        return *this;
    }

    optional &operator=(optional &&other) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(set_move_noexcept_t{} && clear_noexcept_t{}))
    {
        if (other.has_value_)
        {
            set(std::move(other.value_ref()));
            other.clear();
        }
        else
        {
            clear();
        }
        return *this;
    }

    ~optional() noexcept // note:: unconditional because msvc freaks out otherwise
    {
        clear();
    }

    bool is_set() const noexcept
    {
        return has_value_;
    }

    void set(const T &value) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(set_copy_noexcept_t{}))
    {
        if (has_value_)
        {
            value_ref() = value;
        }
        else
        {
            new (&storage_) T(value);
            has_value_ = true;
        }
    }

    void set(T &&value) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(set_move_noexcept_t{}))
    {
        // note seperate overload for two reasons (as opposed to perfect forwarding)
        // 1. have to deal with implicit conversions internally with perfect forwarding
        // 2. have to deal with the noexcept specfiers for all the different variations
        // overload is just far and away the simpler solution
        if (has_value_)
        {
            value_ref() = std::move(value);
        }
        else
        {
            new (&storage_) T(std::move(value));
            has_value_ = true;
        }
    }

    optional &operator=(const T &rhs) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(set_copy_noexcept_t{}))
    {
        set(rhs);
        return *this;
    }

    optional &operator=(T &&rhs) noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(set_move_noexcept_t{}))
    {
        set(std::move(rhs));
        return *this;
    }

    void clear() noexcept(XLNT_NOEXCEPT_VALUE_COMPAT(clear_noexcept_t{}))
    {
        if (has_value_)
        {
            reinterpret_cast<T *>(&storage_)->~T();
        }
        has_value_ = false;
    }

    T &get()
    {
        if (!has_value_)
        {
            throw invalid_attribute();
        }

        return value_ref();
    }

    const T &get() const
    {
        if (!has_value_)
        {
            throw invalid_attribute();
        }

        return value_ref();
    }

    bool operator==(const optional<T> &other) const noexcept
    {
        if (has_value_ != other.has_value_)
        {
            return false;
        }
        if (!has_value_)
        {
            return true;
        }
        // equality is overloaded to provide fuzzy equality when T is a fp number
        return compare_equal(value_ref(), other.value_ref());
    }

    bool operator!=(const optional<T> &other) const noexcept
    {
        return !operator==(other);
    }

private:
    // helpers for getting a T out of storage
    T &value_ref() noexcept
    {
        return *reinterpret_cast<T *>(&storage_);
    }

    const T &value_ref() const noexcept
    {
        return *reinterpret_cast<const T *>(&storage_);
    }

    bool has_value_;
    alignas(T) unsigned char storage_[sizeof(T)];
};

#ifdef XLNT_NOEXCEPT_VALUE_COMPAT
#undef XLNT_NOEXCEPT_VALUE_COMPAT
#endif

} // namespace xlnt