optional.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <optional>
#include <type_traits>
#include <utility>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T> class Optional {
        public:
                using ValueType = T;
 
                using DataType = std::optional<T>;
 
                Optional() = default;
 
                Optional(std::nullopt_t) noexcept {}
 
                Optional(const T &value) : d(value) {}
 
                Optional(T &&value) noexcept(std::is_nothrow_move_constructible_v<T>) : d(std::move(value)) {}
 
                Optional(const DataType &other) : d(other) {}
 
                Optional(DataType &&other) noexcept(std::is_nothrow_move_constructible_v<T>) : d(std::move(other)) {}
 
                Optional(const Optional &other) = default;
 
                Optional(Optional &&other) noexcept(std::is_nothrow_move_constructible_v<T>) = default;
 
                ~Optional() = default;
 
                Optional &operator=(const Optional &other) = default;
 
                Optional &operator=(Optional &&other) noexcept(std::is_nothrow_move_assignable_v<T>) = default;
 
                Optional &operator=(std::nullopt_t) noexcept {
                        d.reset();
                        return *this;
                }
 
                template <typename U,
                          typename = std::enable_if_t<!std::is_same_v<std::decay_t<U>, Optional> &&
                                                      !std::is_same_v<std::decay_t<U>, std::nullopt_t> &&
                                                      std::is_constructible_v<T, U &&>>>
                Optional &operator=(U &&value) {
                        d = std::forward<U>(value);
                        return *this;
                }
 
                bool hasValue() const noexcept { return d.has_value(); }
 
                explicit operator bool() const noexcept { return d.has_value(); }
 
                const T &value() const & { return d.value(); }
 
                T &value() & { return d.value(); }
 
                T &&value() && { return std::move(d).value(); }
 
                template <typename U> T valueOr(U &&fallback) const & {
                        return d.value_or(std::forward<U>(fallback));
                }
 
                template <typename U> T valueOr(U &&fallback) && {
                        return std::move(d).value_or(std::forward<U>(fallback));
                }
 
                const T &operator*() const & noexcept { return *d; }
 
                T &operator*() & noexcept { return *d; }
 
                T &&operator*() && noexcept { return std::move(*d); }
 
                const T *operator->() const noexcept { return d.operator->(); }
 
                T *operator->() noexcept { return d.operator->(); }
 
                void reset() noexcept { d.reset(); }
 
                template <typename... ArgsT> T &emplace(ArgsT &&...args) {
                        return d.emplace(std::forward<ArgsT>(args)...);
                }
 
                void swap(Optional &other) noexcept(std::is_nothrow_swappable_v<T> &&
                                                    std::is_nothrow_move_constructible_v<T>) {
                        d.swap(other.d);
                }
 
                const DataType &toStdOptional() const noexcept { return d; }
 
                DataType &toStdOptional() noexcept { return d; }
 
                friend bool operator==(const Optional &lhs, const Optional &rhs) { return lhs.d == rhs.d; }
 
                friend bool operator!=(const Optional &lhs, const Optional &rhs) { return lhs.d != rhs.d; }
 
                friend bool operator==(const Optional &lhs, std::nullopt_t) noexcept { return !lhs.d.has_value(); }
 
                friend bool operator==(std::nullopt_t, const Optional &rhs) noexcept { return !rhs.d.has_value(); }
 
                friend bool operator!=(const Optional &lhs, std::nullopt_t) noexcept { return lhs.d.has_value(); }
 
                friend bool operator!=(std::nullopt_t, const Optional &rhs) noexcept { return rhs.d.has_value(); }
 
        private:
                DataType d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE