Optional.h

Go to the documentation of this file.

#pragma once

#include <scl/macros.h>
#include <scl/exceptions/EmptyOptionalAccess.h>
#include <scl/tools/meta/enable_if.h>
#include <scl/tools/meta/void_t.h>
#include <scl/tools/meta/is_same.h>
#include <scl/tools/meta/is_instance.h>
#include <scl/tools/meta/exists.h>
#include <scl/tools/meta/type_check.h>
#include <scl/tools/meta/type_query.h>
#include <scl/utils/toString.h>
#include <scl/utils/RawStorage.h>
#include <scl/tools/meta/defines_scl_to_string.h>
#include <iostream>

#include <scl/tools/iostream/nl.h>
#include <scl/tools/meta/conditional.h>

#include <scl/concepts/require.h>
#include <scl/concepts/Movable.h>

namespace scl{
    namespace utils{
        struct None final{
            constexpr bool operator==(None) const{ return true; }
            constexpr bool operator!=(None) const{ return false; }
            constexpr bool operator<(None) const{ return false; }
            constexpr bool operator<=(None) const{ return true; }
            constexpr bool operator>(None) const{ return false; }
            constexpr bool operator>=(None) const{ return true; }
        };

        constexpr None none = None{};

        template <>
        struct ToString<None>{
            constexpr stringLiteral operator()(const None&) const{
                return "[none ; scl::utils::None]";
            }
        };

        template <class T>
        class Optional{
            protected:
                RawStorage<T> payload;

            public:
                using value_type = META::remove_cv_ref_t<T>;

            public:
                constexpr static Optional fromPointer(const T* ptr){
                    return !ptr ? Optional{none} : Optional{*ptr};
                }

                constexpr static Optional fromPointer(std::nullptr_t){
                    return none;
                }

                template <class... Args>
                static Optional inplace(Args&&... args){
                    Optional ret = none;
                    value_type value{std::forward<Args>(args)...};
                    ret = std::move(value);
                    return std::move(ret);
                }

                static Optional ref(const value_type& ref){
                    Optional ret = none;
                    ret.payload.construct(ref);
                    return ret;
                }

                Optional() : payload{} {
                }

                bool hasValue() const{
                    return this->payload.hasValue();
                }

                const value_type& get() const{
                    if(!this->hasValue())
                        throw exceptions::EmptyOptionalAccess{};

                    return this->payload.get();
                }

                Optional(const value_type& value){
                    this->payload.construct(value);
                }

                Optional& operator=(const value_type& value){
                    this->payload.construct(value);
                    return *this;
                }

                Optional(const Optional& o){
                    if(o.hasValue())
                        this->payload.construct(o.get());
                };

                Optional& operator=(const Optional& rhs){
                    if(rhs.hasValue())
                        this->payload.construct(rhs.get());

                    return *this;
                };

                operator const value_type&() const{ return this->get(); }

                Optional(Optional&& rhs){
                    if(rhs.hasValue())
                        this->payload = std::move(rhs.payload);
                };

                Optional& operator=(Optional&& rhs) noexcept{
                    if(rhs.hasValue())
                        this->payload = std::move(rhs.payload);
                    return *this;
                };


            public:
                Optional(None _) : Optional(){
                }

                Optional& operator=(None _){
                    this->payload.reset();
                    return *this;
                }

#define TPL template <class U, class = META::enable_if_t<\
    !META::is_same<META::decay_t<U>, META::decay_t<T>>()\
    && !META::is_same<META::decay_t<U>, None>()\
    && !META::is_same<META::decay_t<U>, Optional>()\
>>

                TPL
                Optional(const U& value){
                    this->payload.construct(value);
                }

                TPL
                Optional& operator=(const U& value){
                    this->payload.construct(value);
                    return *this;
                }

                TPL
                Optional(U&& value){
                    this->payload.construct(std::forward<U&&>(value));
                }

                TPL
                Optional& operator=(U&& value){
                    this->payload.construct(std::forward<U&&>(value));
                    return *this;
                }

#undef TPL

                const value_type& value() const{ return this->get(); }

                realConst(value_type*) ptr() const{ return &(this->get()); }

                operator bool() const{ return this->hasValue(); }

                const value_type& operator*() const{ return this->get(); }

                realConst(value_type*) operator->() const{ return this->ptr(); }

                const value_type& orElse(const value_type& defaultValue) const{
                    return this->hasValue() ? this->get() : defaultValue;
                }

                template <class F>
                const Optional& doIfPresent(F&& f) const{
                    if(this->hasValue())
                        f(this->get());

                    return *this;
                }

                template <class F>
                const Optional& ifSome(F&& f) const{
                    return this->doIfPresent(std::forward<F>(f));
                }

                template <class F>
                const Optional& doIfEmpty(F&& f) const{
                    if(!this->hasValue())
                        f();

                    return *this;
                }

                template <class F>
                const Optional& ifNone(F&& f) const{
                    return this->doIfEmpty(std::forward<F>(f));
                }

                template <class E>
                const value_type& orThrow(const E& e) const{
                    if(this->hasValue())
                        return this->get();

                    throw e;
                }

                template <class U, class F>
                Optional<U> map(F&& mapper) const{
                    if(this->hasValue()){
                        const value_type& _ = this->get();
                        return mapper(_);
                    }

                    return none;
                }

                template <class U, class F>
                Optional<U> mapTo(F&& mapper) const{ return this->map<U>(mapper); }

                template <class F>
                Optional<T> filter(F predicate) const{
                    if(this->hasValue()){
                        const value_type& _ = this->get();
                        return predicate(_) ? Optional<T>{_} : Optional<T>{};
                    }

                    return none;
                }

                template <class U, class F>
                Optional<U> flatMap(F&& mapper) const{
                    return this->hasValue() ? mapper(this->get()) : none;
                }

                template <class U, class F>
                Optional<U> flatMapTo(F&& mapper) const{
                    return this->flatMap<U>(std::forward<F>(mapper));
                }

            public:
                bool operator==(None) const{ return !this->hasValue(); }
                friend bool operator==(None, const Optional& o){ return o == none; }

                bool operator<(None) const{ return false; }
                friend bool operator<(None, const Optional&){ return true; }

                bool operator<=(None) const{ return (*this) == none; }
                friend bool operator<=(None, const Optional&){ return true; }

                bool operator>(None) const{ return true; }
                friend bool operator>(None, const Optional&){ return false; }

                bool operator>=(None) const{ return true; }
                friend bool operator>=(None, const Optional& o){ return o <= none; }

                bool operator!=(None) const{ return !((*this) == none); }
                friend bool operator!=(None, const Optional& o){ return o != none; }

#define SCL_TPL template <class U, class = META::enable_if_t<\
    !META::is_same<U, None>()\
    && !META::is_same<U, Optional>()\
    && !META::is_instance<scl::utils::Optional, U>()\
>>
                SCL_TPL
                bool operator==(const U& t) const{ return this->hasValue() && this->value() == t; }
                SCL_TPL
                bool operator!=(const U& t) const{ return !((*this) == t); }
                SCL_TPL
                bool operator<(const U& t) const{ return !this->hasValue() || this->value() < t; }
                SCL_TPL
                bool operator<=(const U& t) const{ return (*this) == t || (*this) < t; }
                SCL_TPL
                bool operator>(const U& t) const{ return !((*this) <= t); }
                SCL_TPL
                bool operator>=(const U& t) const{ return !((*this) < t); }

                SCL_TPL
                friend bool operator==(const U& t, const Optional& o){ return o == t; }
                SCL_TPL
                friend bool operator!=(const U& t, const Optional& o){ return o != t; }
                SCL_TPL
                friend bool operator<(const U& t, const Optional& o){ return o > t; }
                SCL_TPL
                friend bool operator<=(const U& t, const Optional& o){ return o >= t; }
                SCL_TPL
                friend bool operator>(const U& t, const Optional& o){ return o < t; }
                SCL_TPL
                friend bool operator>=(const U& t, const Optional& o){ return o <= t; }
#undef SCL_TPL

#define SCL_TPL template<class U/*, class = META::enable_if_t<!META::is_same<U,T>()>*/>
                SCL_TPL
                bool operator==(const Optional<U>& o) const{
                    if(!this->hasValue())
                        return !o.hasValue();

                    return o.hasValue() && this->value() == o.value();
                }

                SCL_TPL
                bool operator!=(const Optional<U>& o) const{ return !((*this) == o); }

                SCL_TPL
                bool operator<(const Optional<U>& o) const{
                    if(!this->hasValue())
                        return o.hasValue();

                    return o.hasValue() && this->value() < o.value();
                }

                SCL_TPL
                bool operator<=(const Optional<U>& o) const{ return (*this) == o || (*this) < o; }

                SCL_TPL
                bool operator>(const Optional<U>& o) const{ return o < (*this); }

                SCL_TPL
                bool operator>=(const Optional<U>& o) const{ return o <= (*this); }
#undef SCL_TPL
        };

        template <class T>
        struct ToString<Optional<T>, META::enable_if_t<
            META::defines_scl_to_string<T>()
        >>{
            std::string operator()(const Optional<T>& opt){
                return opt.hasValue() ? asString(*opt) : asString(none);
            }
        };
    }
}