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://github.com/matzke1/sawyer.




#ifndef Sawyer_Optional_H
#define Sawyer_Optional_H

#include <Sawyer/Sawyer.h>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/type_traits/type_with_alignment.hpp>

#include <stdexcept>

namespace Sawyer {

class Nothing {                                         // final
public:
    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_; }

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();
        
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;
    }
    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_;
    }
    // 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 &rhs) {
    lhs.this_type_does_not_support_comparisons();
    return false;
}

template<typename T, typename U>
bool operator!=(const Optional<T> &lhs, const U &rhs) {
    lhs.this_type_does_not_support_comparisons();
    return false;
}

} // namespace
#endif