mn_optional.hpp

Go to the documentation of this file.

 
#ifndef __MINLIB_BASIC_OPTIONAL_H__
#define __MINLIB_BASIC_OPTIONAL_H__
 
#include "mn_config.hpp"
 
#include "mn_algorithm.hpp"
#include "mn_functional.hpp"
 
namespace mn {
 
    struct nullopt_t { };
 
    template< typename T>
    class basic_optional {
    public:
        using value_type = T;
        using const_value_type = const T;
        using reference = T&;
        using const_reference = const T&;
        using move_type = T&&;
        using const_move_type = const T&&;
 
        using pointer = T*;
        using const_pointer = const T*;
 
        using self_type = basic_optional<T>;
 
        constexpr basic_optional() noexcept
            : m_bHasValue( false), m_tValue() { }
 
        basic_optional(const self_type& other)
            : m_bHasValue( other.m_bHasValue), m_tValue(other.m_tValue) { }
 
        basic_optional(const self_type&& other) noexcept
            : m_bHasValue( mn::move(other.m_bHasValue)), m_tValue( mn::move(other.m_tValue)) { }
 
 
        template< typename... Args>
        constexpr explicit basic_optional(Args&&... args)
            : m_bHasValue( true), m_tValue( value_type( mn::forward<Args>(args)...))  {}
 
        template< typename U = value_type >
        constexpr explicit basic_optional( U && value)
            : m_bHasValue( true), m_tValue( mn::forward<U>( value)) { }
 
        ~basic_optional() { reset(); }
 
        void reset() noexcept {
            if ( has_value() & mn::is_class<T>::value)
                m_tValue->~T();
 
            m_bHasValue = false;
        }
        void clear() {
            m_bHasValue = false;
        }
 
        self_type& assign(const_value_type& value)
        {
            m_tValue = value;
            m_bHasValue = true;
            return *this;
        }
 
        self_type& assign(move_type value) {
            m_tValue = mn::move(value);
            m_bHasValue = true;
            return *this;
        }
 
        self_type& assign(const self_type& other) {
            self_type tmp(other);
            swap(tmp);
            return *this;
        }
        void swap( self_type& other) {
            mn::swap(m_bHasValue, other.m_bHasValue);
            mn::swap(m_tValue, other.m_tValue);
        }
 
        constexpr bool has_value() const noexcept {
            return m_bHasValue;
        }
        reference value() {
            assert( has_value());
            return m_tValue;
        }
        const_reference value() const {
            assert( has_value());
            return m_tValue;
        }
        constexpr value_type value_or(const value_type value) const {
            return has_value() ? m_tValue : static_cast<value_type>( value);
        }
        template< typename U >
        constexpr value_type value_or(const U& value) const {
            return has_value() ? m_tValue : static_cast<value_type>( value);
        }
 
        self_type& operator = (const self_type& other) noexcept {
            return assign(value);
        }
 
        self_type& operator = ( self_type&& other) noexcept {
            return assign(value);
        }
 
        constexpr const_pointer operator ->() const {
            return m_tValue;
        }
 
        pointer operator ->() {
            return m_tValue;
        }
 
        constexpr const_reference operator *() const  {
            return m_tValue;
        }
 
        reference operator *() {
            return m_tValue;
        }
 
        explicit operator bool() const noexcept {
            return m_bHasValue;
        }
    private:
        bool m_bHasValue;
        value_type m_tValue;
    };
 
    template <typename T>
    inline void swap(basic_optional<T>& a, basic_optional<T>& b) {
        a.swap(b);
    }
 
 
    template< typename T, typename U >
    inline constexpr bool operator == (const basic_optional<T>& x, const basic_optional<U>& y) {
        return bool(x) != bool(y) ? false : !bool( x) ? true : *x == *y;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator != (const basic_optional<T>& x, const basic_optional<U>& y) {
        return !(x.value() == y.value());
    }
 
    template< typename T, typename U >
    inline constexpr bool operator < (const basic_optional<T>& x, const basic_optional<U>& y) {
        return (!y) ? false : (!x) ? true : *x < *y;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator > (const basic_optional<T>& x, const basic_optional<U>& y) {
        return (y.value() < x.value());
    }
 
    template< typename T, typename U >
    inline constexpr bool operator <= (const basic_optional<T>& x, const basic_optional<U>& y) {
        return !(y.value() < x.value());
    }
 
    template< typename T, typename U >
    inline constexpr bool operator >= (const basic_optional<T>& x, const basic_optional<U>& y) {
        return !(x.value() < y.value());
    }
 
    // Comparison with nullopt
 
    template< typename T >
    inline constexpr bool operator == (const basic_optional<T>& x, nullopt_t) noexcept {
        return (!x);
    }
 
    template< typename T >
    inline constexpr bool operator == (nullopt_t, const basic_optional<T>& x) noexcept {
        return (!x);
    }
 
    template< typename T >
    inline constexpr bool operator != (const basic_optional<T>& x, nullopt_t) noexcept {
        return bool(x);
    }
 
    template< typename T >
    inline constexpr bool operator != (nullopt_t, const basic_optional<T>& x) noexcept {
        return bool(x);
    }
 
    template< typename T >
    inline constexpr bool operator < (const basic_optional<T>&, nullopt_t) noexcept {
        return false;
    }
 
    template< typename T >
    inline constexpr bool operator < (nullopt_t, const basic_optional<T>& x) noexcept {
        return bool(x);
    }
 
    template< typename T >
    inline constexpr bool operator <= (const basic_optional<T>& x, nullopt_t) noexcept {
        return (!x);
    }
 
    template< typename T >
    inline constexpr bool operator <= (nullopt_t, const basic_optional<T>&) noexcept {
        return true;
    }
 
    template< typename T >
    inline constexpr bool operator > (const basic_optional<T>& x, nullopt_t) noexcept {
        return bool(x);
    }
 
    template< typename T >
    inline constexpr bool operator > (nullopt_t, const basic_optional<T>&) noexcept
    {
        return false;
    }
 
    template< typename T >
    inline constexpr bool operator >= (const basic_optional<T>&, nullopt_t) noexcept {
        return true;
    }
 
    template< typename T >
    inline constexpr bool operator >= (nullopt_t, const basic_optional<T>& x) noexcept {
        return (!x);
    }
 
    template< typename T, typename U >
    inline constexpr bool operator == (const basic_optional<T>& x, const U& v) {
        return bool(x) ? *x == v : false;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator == (const U& v, const basic_optional<T>& x) {
        return bool(x) ? v == *x : false;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator != (const basic_optional<T>& x, const U& v) {
        return bool(x) ? *x != v : true;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator != (const U& v, const basic_optional<T>& x) {
        return bool(x) ? v != *x : true;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator < (const basic_optional<T>& x, const U& v) {
        return bool(x) ? *x < v : true;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator < (const U& v, const basic_optional<T>& x) {
        return bool(x) ? v < *x : false;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator <= (const basic_optional<T>& x, const U& v) {
        return bool(x) ? *x <= v : true;
    }
 
    template< typename T, typename U >
    inline constexpr bool operator<=(const U& v, const basic_optional<T>& x) {
        return bool(x) ? v <= *x : false;
    }
 
    template< typename T, typename U>
    inline constexpr bool operator>(const basic_optional<T>& x, const U& v) {
        return bool(x) ? *x > v : false;
    }
 
    template< typename T, typename U>
    inline constexpr bool operator>(const U& v, const basic_optional<T>& x) {
        return bool(x) ? v > *x : true;
    }
 
    template< typename T, typename U>
    inline constexpr bool operator>=(const basic_optional<T>& x, const U& v) {
        return bool(x) ? *x >= v : false;
    }
 
    template< typename T, typename U>
    inline constexpr bool operator >= (const U& v, const basic_optional<T>& x) {
        return bool(x) ? v >= *x : true;
    }
 
    template< typename T >
    constexpr basic_optional<typename mn::decay<T>::type> make_optional( T && value ) {
        return basic_optional<typename mn::decay<T>::type>( mn::forward<T>( value ) );
    }
 
    template< typename T, typename...Args >
    constexpr basic_optional<T> make_optional( Args&&... args ) {
        return basic_optional<T>(mn::forward<Args>(args)...);
    }
#if 0
    template< class T >
    struct hash<basic_optional<T>> {
        mn::size_t operator()( const basic_optional<T>& opt ) const noexcept {
            return bool(opt) ? hash<T>()(*opt) : 0;
        }
    };
#endif // 0
 
    template <typename T>
    using optional = basic_optional<T>;
}
 
#endif // __MINLIB_BASIC_OPTIONAL_H__