Either.h

Go to the documentation of this file.

#pragma once

#include <utility>
#include <scl/macros.h>
#include <scl/exceptions/InvalidEitherAccess.h>
#include <scl/tools/meta/enable_if.h>
#include <scl/tools/meta/type_check.h>
#include <scl/tools/meta/void_t.h>
#include <scl/tools/meta/is_same.h>
#include <scl/utils/Optional.h>

namespace scl{
    namespace utils{
        template <class Lhs, class Rhs>
        class Either{
            public:
                using left_type = Lhs;

                using right_type = Rhs;

            protected:
                static constexpr bool is_copyable(){
                    return META::is_copyable<Lhs>()
                    && META::is_copyable<Rhs>();
                }

                static constexpr bool is_movable(){
                    return META::is_movable<Lhs>()
                    && META::is_movable<Rhs>();
                }

                struct payload_t final{
                    Optional<Lhs> left = {};

                    Optional<Rhs> right = {};

                    payload_t() = default;
                    ~payload_t() = default;

                    template <class = META::enable_if_t<
                        Either::is_movable()
                    >>
                    explicit payload_t(payload_t&& p) : left{std::move(p.left)}, right{std::move(p.right)} {
                    }

                    template <class = META::enable_if_t<
                        Either::is_copyable()
                    >>
                    explicit payload_t(const payload_t& p) : left{p.left}, right{p.right} {
                    }

                    template <class = META::void_t<
                        META::enable_if_t<
                            Either::is_copyable()
                        >
                    >>
                    payload_t& operator=(const payload_t& p){
                        this->left = p.left;
                        this->right = p.right;
                        return *this;
                    };

                    template <class = META::void_t<
                        META::enable_if_t<
                            Either::is_movable()
                        >
                    >>
                    payload_t& operator=(payload_t&& p){
                        this->left = std::move(p.left);
                        this->right = std::move(p.right);
                        return *this;
                    }
                };

                struct lhs_tag final{};

                struct rhs_tag final{};

                bool lhs = false;

                payload_t payload = {};


            protected:
                 template <class = META::enable_if_t<
                     META::is_movable<Lhs>()
                 >>
                Either(lhs_tag, Lhs&& lhs) : lhs{true} {
                    this->payload.left = std::move(lhs);
                }

                 template <class = META::enable_if_t<
                     META::is_copyable<Lhs>()
                 >>
                Either(lhs_tag, const Lhs& lhs) : lhs{true} {
                    this->payload.left = lhs;
                }

                template <class = META::void_t<META::enable_if_t<
                    META::is_movable<Rhs>()
                >>>
                Either(rhs_tag, Rhs&& rhs) : lhs{false} {
                    this->payload.right = std::move(rhs);
                }

                template <class = META::void_t<META::enable_if_t<
                    META::is_copyable<Rhs>()
                >>>
                Either(rhs_tag, const Rhs& rhs) : lhs{false} {
                    this->payload.right = rhs;
                }

                static void leftVoidVisitor(const Lhs& lhs){}

                static void rightVoidVisitor(const Rhs& rhs){}

            public:
                Either() = delete;

                template <class = META::void_t<
                    META::enable_if_t<is_copyable()>
                >>
                Either(const Either& other) : payload{}, lhs{other.lhs} {
                    if(lhs)
                        this->payload.left = other.getLeft();
                    else
                        this->payload.right = other.getRight();
                }

                template <class = META::void_t<
                    META::enable_if_t<is_copyable()>
                >>
                Either& operator=(const Either& other){
                    this->lhs = other.lhs;
                    if(lhs)
                        this->payload.left = other.getLeft();
                    else
                        this->payload.right = other.getRight();

                    return *this;
                }

                template <class = META::void_t<
                    META::enable_if_t<is_movable()>
                >>
                Either(Either&& other) noexcept :  payload{}, lhs{other.lhs} {
                    if(lhs)
                        this->payload.left = std::move(other.payload.left);
                    else
                        this->payload.right = std::move(other.payload.right);
                }

                template <class = META::void_t<
                    META::enable_if_t<is_movable()>
                >>
                Either& operator=(Either&& other) noexcept{
                    this->lhs = other.lhs;
                    if(lhs)
                        this->payload.left = std::move(other.payload.left);
                    else
                        this->payload.right = std::move(other.payload.right);

                    return *this;
                };

                 template <class L>
                static Either left(L&& lhs){
                    return Either(lhs_tag{}, std::forward<L>(lhs));
                }

                 template <class L>
                static Either Left(L&& lhs){
                    return left(std::forward<L>(lhs));
                }

                template <class... Args>
                static Either emplaceLeft(Args&&... args){
                    return left(Lhs{std::forward<Args>(args)...});
                }

                template <class... Args>
                static Either emplaceRight(Args&&... args){
                    return right(Rhs{std::forward<Args>(args)...});
                }

                 template <class R>
                static Either right(R&& rhs){
                    return Either(rhs_tag{}, std::forward<R>(rhs));
                }

                 template <class R>
                static Either Right(R&& rhs){
                    return right(std::forward<R>(rhs));
                }

                bool hasLeft() const{ return this->lhs; }

                bool hasRight() const{ return !this->hasLeft(); }

                const Lhs& getLeft() const{
                    if(!this->hasLeft())
                        throw exceptions::InvalidEitherAccess::leftWhenRight();

                    return this->payload.left.get();
                }

                const Rhs& getRight() const{
                    if(!this->hasRight())
                        throw exceptions::InvalidEitherAccess::rightWhenLeft();

                    return this->payload.right.get();
                }

                template <class LeftVisitor, class RightVisitor>
                const Either& visit(LeftVisitor visitLeft, RightVisitor visitRight) const{
                    if(this->hasLeft()) {
                        const Lhs& left = this->getLeft();
                        visitLeft(left);
                    }else {
                        const Rhs& right = this->getRight();
                        visitRight(right);
                    }

                    return *this;
                }

                template <class LeftVisitor>
                const Either& doIfLeft(LeftVisitor visitLeft) const{
                    return this->visit(visitLeft, Either::rightVoidVisitor);
                }

                template <class RightVisitor>
                const Either& doIfRight(RightVisitor visitRight) const{
                    return this->visit(Either::leftVoidVisitor, visitRight);
                }

                template <class NewLhs, class Mapper>
                Either<NewLhs, Rhs> mapLeftTo(Mapper mapper) const{
                    if(this->hasLeft()){
                        const Lhs& left = this->getLeft();
                        return Either<NewLhs, Rhs>::Left(mapper(left));
                    }

                    return Either<NewLhs, Rhs>::Right(this->getRight());
                }

                template <class NewRhs, class Mapper>
                Either<Lhs, NewRhs> mapRightTo(Mapper mapper) const{
                    if(this->hasRight()){
                        const Rhs& right = this->getRight();
                        return Either<Lhs, NewRhs>::Right(mapper(right));
                    }

                    return Either<Lhs, NewRhs>::Left(this->getLeft());
                }

                template <class NewLhs, class NewRhs, class MapperLeft, class MapperRight>
                Either<NewLhs, NewRhs> mapTo(MapperLeft mapLeft, MapperRight mapRight) const{
                    if(this->hasLeft()){
                        const Lhs& left = this->getLeft();
                        return Either<NewLhs, NewRhs>::Left(mapLeft(left));
                    }else{
                        //this->hasRight()
                        const Rhs& right = this->getRight();
                        return Either<NewLhs, NewRhs>::Right(mapRight(right));
                    }
                }

                Lhs leftOr(const Lhs& defaultValue) const{
                    return this->payload.left.orElse(defaultValue);
                }

                Rhs rightOr(const Rhs& defaultValue) const{
                    return this->payload.right.orElse(defaultValue);
                }
        };
    }
}