maybe.h

// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
#pragma once
 
#include <bond/core/config.h>
 
#include "detail/alloc.h"
#include "traits.h"
 
#include <boost/none.hpp>
#include <boost/optional/optional.hpp>
#include <boost/utility/enable_if.hpp>
 
#include <memory>
#include <type_traits>
#include <utility>
 
namespace bond
{
 
 
[[noreturn]] void NothingException();
 
namespace detail
{
 
template <typename T>
class maybe_common
{
public:
    using value_type = T;
 
    maybe_common() = default;
 
    maybe_common(const maybe_common&) = default;
 
    template <typename... Args>
    explicit maybe_common(const T& value, Args&&... args)
    {
        _value.emplace(value, std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    explicit maybe_common(T&& value, Args&&... args)
    {
        _value.emplace(std::move(value), std::forward<Args>(args)...);
    }
 
    maybe_common(maybe_common&& that) BOND_NOEXCEPT_IF(std::is_nothrow_move_constructible<boost::optional<T>>::value)
        : _value(std::move(that._value))
    {
        // unlike std::optional/boost::optional, moved-from bond::maybe
        // instances are guaranteed to be nothing.
        //
        // asigning boost::none is noexcept, but assigning { } is not
        that._value = boost::none;
    }
 
    bool is_nothing() const BOND_NOEXCEPT
    {
        return !static_cast<bool>(_value);
    }
 
    explicit operator bool() const BOND_NOEXCEPT
    {
        return !is_nothing();
    }
 
    void set_nothing() BOND_NOEXCEPT
    {
        // asigning boost::none is noexcept, but assigning { } is not
        _value = boost::none;
    }
 
    template<typename... Args>
    T& emplace(Args&&... args)
    {
        _value.emplace(std::forward<Args>(args)...);
        return *_value;
    }
 
    T& value()
    {
        if (is_nothing())
        {
            NothingException();
        }
 
        return *_value;
    }
 
    const T& value() const
    {
        if (is_nothing())
        {
            NothingException();
        }
 
        return *_value;
    }
 
    T& value(const std::nothrow_t&) BOND_NOEXCEPT
    {
        BOOST_ASSERT(!is_nothing());
        return *_value;
    }
 
    const T& value(const std::nothrow_t&) const BOND_NOEXCEPT
    {
        BOOST_ASSERT(!is_nothing());
        return *_value;
    }
 
    maybe_common& operator=(const maybe_common&) = default;
    maybe_common& operator=(maybe_common&&) = default;
 
    friend bool operator==(const maybe_common& lhs, const T& rhs)
    {
        return lhs._value == rhs;
    }
 
    friend bool operator!=(const maybe_common& lhs, const T& rhs)
    {
        return !(lhs == rhs);
    }
 
    friend bool operator==(const T& lhs, const maybe_common& rhs)
    {
        return lhs == rhs._value;
    }
 
    friend bool operator!=(const T& lhs, const maybe_common& rhs)
    {
        return !(lhs == rhs);
    }
 
protected:
    boost::optional<T> _value;
};
 
 
template <typename T, typename Enable = void> struct
has_allocator
    : std::false_type {};
 
template <typename T> struct
has_allocator<T, typename boost::enable_if<std::is_class<typename T::allocator_type> >::type>
    : std::true_type {};
 
} // namespace detail
 
 
template <typename T, typename Enabled = void>
class maybe;
 
template <typename T>
class maybe<T, typename boost::disable_if<detail::has_allocator<T> >::type>
    : public detail::maybe_common<T>
{
public:
    maybe() = default;
 
    maybe(const maybe&) = default;
    maybe(maybe&&) = default;
 
    explicit
    maybe(const T& value)
        : detail::maybe_common<T>(value)
    { }
 
    explicit
    maybe(T&& value)
        : detail::maybe_common<T>(std::move(value))
    { }
 
    maybe& operator=(const maybe&) = default;
    maybe& operator=(maybe&&) = default;
 
    maybe& operator=(const T& value)
    {
        this->emplace(value);
        return *this;
    }
 
    maybe& operator=(T&& value)
    {
        this->emplace(std::move(value));
        return *this;
    }
 
    friend bool operator==(const maybe& lhs, const maybe& rhs)
    {
        return lhs._value == rhs._value;
    }
 
    friend bool operator!=(const maybe& lhs, const maybe& rhs)
    {
        return lhs._value != rhs._value;
    }
 
    T& set_value()
    {
        if (this->is_nothing())
        {
            this->emplace();
        }
 
        return *this->_value;
    }
 
    void swap(maybe& that)
    {
        using std::swap;
        swap(this->_value, that._value);
    }
};
 
template <typename T>
class maybe<T, typename boost::enable_if<detail::has_allocator<T> >::type>
    : public detail::maybe_common<T>,
      private detail::allocator_holder<typename T::allocator_type>
{
    using alloc_holder = detail::allocator_holder<typename T::allocator_type>;
 
public:
    // allocator_holder may inherit from an allocator that has its own
    // value_type. Add an using to explicitly "export" the one from
    // maybe_common
    using typename detail::maybe_common<T>::value_type;
 
    using allocator_type = typename T::allocator_type;
 
    maybe() = default;
    maybe(const maybe&) = default;
    maybe(maybe&&) = default;
 
    maybe(const maybe& that, const allocator_type& alloc)
        : detail::maybe_common<T>(),
          alloc_holder(alloc)
    {
        if (!that.is_nothing())
        {
            this->emplace(*that._value, alloc);
        }
    }
 
    maybe(maybe&& that, const allocator_type& alloc)
        : detail::maybe_common<T>(),
          alloc_holder(alloc)
    {
        if (!that.is_nothing())
        {
            this->emplace(std::move(*that._value), alloc);
 
            // asigning boost::none is noexcept, but assigning { } is not
            that._value = boost::none;
        }
    }
 
    explicit maybe(const allocator_type& alloc)
        : detail::maybe_common<T>(),
          alloc_holder(alloc)
    { }
 
    explicit maybe(const T& value)
        : detail::maybe_common<T>(value),
          alloc_holder()
    { }
 
    maybe(T&& value)
        : detail::maybe_common<T>(std::move(value)),
          alloc_holder()
    { }
 
    maybe& operator=(const maybe&) = default;
    maybe& operator=(maybe&&) = default;
 
    maybe& operator=(const T& value)
    {
        this->emplace(value);
        return *this;
    }
 
    maybe& operator=(T&& value)
    {
        this->emplace(std::move(value));
        return *this;
    }
 
    // We need to get rid of any operator== that may come from the
    // allocator_holder so the friend free functions from maybe_common don't
    // have any competition.
    bool operator==(const alloc_holder&) = delete;
 
    friend bool operator==(const maybe& lhs, const maybe& rhs)
    {
        return lhs._value == rhs._value;
    }
 
    friend bool operator!=(const maybe& lhs, const maybe& rhs)
    {
        return lhs._value != rhs._value;
    }
 
    T& set_value()
    {
        if (this->is_nothing())
        {
            this->emplace(base_alloc_holder().get());
        }
 
        return *this->_value;
    }
 
    void swap(maybe& that)
    {
        using std::swap;
        swap(this->_value, that._value);
        swap(base_alloc_holder(), that.base_alloc_holder());
    }
 
    allocator_type get_allocator() const BOND_NOEXCEPT
    {
        return base_alloc_holder().get();
    }
 
private:
    detail::maybe_common<T>& base_common() BOND_NOEXCEPT { return *this; }
    const detail::maybe_common<T>& base_common() const BOND_NOEXCEPT { return *this; }
    alloc_holder& base_alloc_holder() BOND_NOEXCEPT { return *this; }
    const alloc_holder& base_alloc_holder() const BOND_NOEXCEPT { return *this; }
};
 
template<typename T>
inline void swap(maybe<T>& x, maybe<T>& y)
{
    x.swap(y);
}
 
} // namespace bond