Optional.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://gitlab.com/charger7534/sawyer.git.
 
 
 
 
#ifndef Sawyer_Optional_H
#define Sawyer_Optional_H
 
#include <Sawyer/Sawyer.h>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/type_traits/type_with_alignment.hpp>
 
#include <stdexcept>
 
namespace Sawyer {
 
class Nothing {                                         // final
public:
    Nothing() {}
    template<class T> explicit Nothing(T) {}
    template<class T> Nothing& operator=(T) { return *this; }
    bool operator==(const Nothing&) const { return true; }
    bool operator!=(const Nothing&) const { return false; }
    bool operator>(const Nothing&) const { return false; }
    bool operator>=(const Nothing&) const { return true; }
    bool operator<(const Nothing&) const { return false; }
    bool operator<=(const Nothing&) const { return true; }
};
 
template<typename T>
class Optional {
 
    // Done as a union to avoid aliasing warnings from GCC
    union SAWYER_MAY_ALIAS MayAlias {
        unsigned char data_[sizeof(T)];
        BOOST_DEDUCED_TYPENAME boost::type_with_alignment<boost::alignment_of<T>::value >::type aligner_;
    } mayAlias_;
 
    bool isEmpty_;
 
    void *address() { return &mayAlias_; }
    const void*address() const { return &mayAlias_; }
 
#ifdef SAWYER_HAVE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void save(S &s, const unsigned /*version*/) const {
        s <<BOOST_SERIALIZATION_NVP(isEmpty_);
        if (!isEmpty_)
            s <<boost::serialization::make_nvp("value", get());
    }
 
    template<class S>
    void load(S &s, const unsigned /*version*/) {
        *this = Nothing();
        bool skip = false;
        s >>boost::serialization::make_nvp("isEmpty_", skip);
        if (!skip) {
            *this = T();
            s >>boost::serialization::make_nvp("value", get());
        }
    }
 
    BOOST_SERIALIZATION_SPLIT_MEMBER();
#endif
 
#ifdef SAWYER_HAVE_CEREAL
private:
    friend class cereal::access;
 
    template<class Archive>
    void CEREAL_SAVE_FUNCTION_NAME(Archive &archive) const {
        archive(cereal::make_nvp("isEmpty", isEmpty_));
        if (!isEmpty_)
            archive(cereal::make_nvp("value", get()));
    }
 
    template<class Archive>
    void CEREAL_LOAD_FUNCTION_NAME(Archive &archive) {
        *this = Nothing();
        bool isEmpty = false;
        archive(CEREAL_NVP(isEmpty));
        if (!isEmpty) {
            *this = T{};
            archive(cereal::make_nvp("value", get()));
        }
    }
#endif
 
public:
    typedef T Value;
 
    Optional(): isEmpty_(true) {}
 
    Optional(const Value &v): isEmpty_(false) {         // implicit
        new (address()) Value(v);                    // copy constructed in place
    }
 
    Optional(const Nothing&): isEmpty_(true) {}
 
    Optional(const Optional &other) {
        isEmpty_ = other.isEmpty_;
        if (!isEmpty_) {
            const Value &otherValue = *other;
            new (address()) Value(otherValue);
       }
    }
 
    ~Optional() {
        if (!isEmpty_) {
            Value &thisValue = **this;
            thisValue.~Value();
        }
    }
 
    Optional& operator=(const Value &value) {
        if (isEmpty_) {
            new (address()) Value(value);
        } else {
            Value &thisValue = **this;
            thisValue = value;
        }
        isEmpty_ = false;
        return *this;
    }
 
    Optional& operator=(const Nothing&) {
        if (!isEmpty_) {
            Value &thisValue = **this;
            thisValue.~Value();
        }
        isEmpty_ = true;
        return *this;
    }
    
    Optional& operator=(const Optional &other) {
        if (isEmpty_ && !other.isEmpty_) {
            const Value &otherValue = *other;
            new (address()) Value(otherValue);
        } else if (!isEmpty_) {
            if (other.isEmpty_) {
                Value &thisValue = **this;
                thisValue.~Value();
            } else {
                Value &thisValue = **this;
                const Value &otherValue = *other;
                thisValue = otherValue;
            }
        }
        isEmpty_ = other.isEmpty_;
        return *this;
    }
 
    void reset() {
        *this = Nothing();
    }
 
    const Value& operator*() const {
        return get();
    }
    Value& operator*() {
        return get();
    }
    const Value& get() const {
        if (isEmpty_)
            throw std::domain_error("dereferenced nothing");
        return *reinterpret_cast<const Value*>(address());
    }
    Value& get() {
        if (isEmpty_)
            throw std::domain_error("dereferenced nothing");
        return *reinterpret_cast<Value*>(address());
    }
    const Value* operator->() const {
        return &get();
    }
    Value* operator->() {
        return &get();
    }
    const Value& orElse(const Value &dflt) const {
        return isEmpty_ ? dflt : **this;
    }
    const Value& orElse(Value &dflt) {
        return isEmpty_ ? dflt : **this;
    }
    const Optional orElse(const Optional &other) const {
        return isEmpty_ ? other : *this;
    }
    Optional andThen(const Value &value) const {
        return isEmpty_ ? *this : Optional(value);
    }
    Optional andTHen(Value &value) const {
        return isEmpty_ ? *this : Optional(value);
    }
    const Optional& andThen(const Optional &other) const {
        return isEmpty_ ? *this : other;
    }
    Value orDefault() const {
        return isEmpty_ ? Value() : **this;
    }
 
    template<class U>
    bool assignTo(U &out) const {
        if (isEmpty_) {
            return false;
        } else {
            out = **this;
            return true;
        }
    }
 
    bool isEqual(const Optional &other) const {
        return (isEmpty_ && other.isEmpty_) || (!isEmpty_ && !other.isEmpty_ && get()==other.get());
    }
    bool isEqual(const Value &other) const {
        return !isEmpty_ && get()==other;
    }
    bool isEqual(const Nothing&) const {
        return isEmpty_;
    }
    template <typename F>
    auto
    fmap(F&& f) -> Optional<decltype(f(get()))> {
        if (isEmpty_)
            return Optional<decltype(f(get()))>();
        return Optional<decltype(f(get()))>(f(get()));
    }
 
    
    // The following trickery is to allow things like "if (x)" to work but without having an implicit
    // conversion to bool which would cause no end of other problems. This is fixed in C++11.
private:
    typedef void(Optional::*unspecified_bool)() const;
    void this_type_does_not_support_comparisons() const {}
public:
    operator unspecified_bool() const {
        return isEmpty_ ? 0 : &Optional::this_type_does_not_support_comparisons;
    }
};
 
 
// These functions intentionally do not compile. They are to prevent comparisons and thus save users from making
// mistakes like this:
//    Optional<int> x = 0;
//    int y = 1;
//    if (x == y)       // won't compile
//    if (x && *x == y) // what they really meant
//    if (x.isEqual(y)) // another valid way to write it
template<typename T, typename U>
bool operator==(const Optional<T> &lhs, const U&) {
    lhs.this_type_does_not_support_comparisons();
    return false;
}
 
template<typename T, typename U>
bool operator!=(const Optional<T> &lhs, const U&) {
    lhs.this_type_does_not_support_comparisons();
    return false;
}
 
} // namespace
#endif