maybe.hpp

Go to the documentation of this file.

//===- include/pstore/support/maybe.hpp -------------------*- mode: C++ -*-===//
//*                        _           *
//*  _ __ ___   __ _ _   _| |__   ___  *
//* | '_ ` _ \ / _` | | | | '_ \ / _ \ *
//* | | | | | | (_| | |_| | |_) |  __/ *
//* |_| |_| |_|\__,_|\__, |_.__/ \___| *
//*                  |___/             *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef PSTORE_SUPPORT_MAYBE_HPP
#define PSTORE_SUPPORT_MAYBE_HPP

#include <new>
#include <stdexcept>

#include "pstore/adt/utility.hpp"
#include "pstore/support/assert.hpp"
#include "pstore/support/inherit_const.hpp"


namespace pstore {

    namespace details {

        template <typename T>
        struct remove_cvref {
            using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
        };
        template <typename T>
        using remove_cvref_t = typename remove_cvref<T>::type;

    } // end namespace details

    template <typename T, typename = typename std::enable_if<!std::is_reference<T>::value>::type>
    class maybe {
    public:
        using value_type = T;

        static_assert (std::is_object<value_type>::value,
                       "Instantiation of maybe<> with a non-object type is undefined behavior.");
        static_assert (std::is_nothrow_destructible<value_type>::value,
                       "Instantiation of maybe<> with an object type that is not noexcept "
                       "destructible is undefined behavior.");

        constexpr maybe () noexcept = default;

        template <typename U,
                  typename = typename std::enable_if<
                      std::is_constructible<T, U &&>::value &&
                      !std::is_same<typename details::remove_cvref_t<U>, maybe<T>>::value>::type>
        explicit maybe (U && value) noexcept (std::is_nothrow_move_constructible<T>::value &&
                                                  std::is_nothrow_copy_constructible<T>::value &&
                                              !std::is_convertible<U &&, T>::value)
                : valid_{true} {

            new (&storage_) T (std::forward<U> (value));
        }

        template <typename... Args>
        explicit maybe (in_place_t const inp, Args &&... args)
                : valid_{true} {
            (void) inp;
            new (&storage_) T (std::forward<Args> (args)...);
        }

        maybe (maybe const & other) noexcept (std::is_nothrow_copy_constructible<T>::value) {
            if (other.valid_) {
                new (&storage_) T (*other);
                valid_ = true;
            }
        }

        maybe (maybe && other) noexcept (std::is_nothrow_move_constructible<T>::value) {
            if (other.valid_) {
                new (&storage_) T (std::move (*other));
                valid_ = true;
            }
        }

        ~maybe () noexcept { this->reset (); }

        void reset () noexcept {
            if (valid_) {
                // Set valid_ to false before calling the dtor.
                valid_ = false;
                reinterpret_cast<T const *> (&storage_)->~T ();
            }
        }

        maybe & operator= (maybe const & other) noexcept (
            std::is_nothrow_copy_assignable<T>::value &&
                std::is_nothrow_copy_constructible<T>::value) {
            if (&other != this) {
                if (!other.has_value ()) {
                    this->reset ();
                } else {
                    this->operator= (other.value ());
                }
            }
            return *this;
        }

        maybe &
        operator= (maybe && other) noexcept (std::is_nothrow_move_assignable<T>::value &&
                                                 std::is_nothrow_move_constructible<T>::value) {

            if (&other != this) {
                if (!other.has_value ()) {
                    this->reset ();
                } else {
                    this->operator= (std::forward<T> (other.value ()));
                }
            }
            return *this;
        }


        template <typename U,
                  typename = typename std::enable_if<
                      std::is_constructible<T, U &&>::value &&
                      !std::is_same<typename details::remove_cvref_t<U>, maybe<T>>::value>::type>
        maybe & operator= (U && other) noexcept (
            std::is_nothrow_copy_assignable<T>::value && std::is_nothrow_copy_constructible<
                T>::value && std::is_nothrow_move_assignable<T>::value &&
                std::is_nothrow_move_constructible<T>::value) {

            if (valid_) {
                T temp = std::forward<U> (other);
                std::swap (this->value (), temp);
            } else {
                new (&storage_) T (std::forward<U> (other));
                valid_ = true;
            }
            return *this;
        }

        template <typename... Args>
        T & emplace (Args &&... args) {
            if (valid_) {
                T temp (std::forward<Args> (args)...);
                std::swap (this->value (), temp);
            } else {
                new (&storage_) T (std::forward<Args> (args)...);
                valid_ = true;
            }
            return this->value ();
        }

        bool operator== (maybe const & other) const {
            return this->has_value () == other.has_value () &&
                   (!this->has_value () || this->value () == other.value ());
        }
        bool operator!= (maybe const & other) const { return !operator== (other); }

        T const & operator* () const noexcept { return *(operator-> ()); }
        T & operator* () noexcept { return *(operator-> ()); }
        T const * operator-> () const noexcept {
            PSTORE_ASSERT (valid_);
            return reinterpret_cast<T const *> (&storage_);
        }
        T * operator-> () noexcept {
            PSTORE_ASSERT (valid_);
            return reinterpret_cast<T *> (&storage_);
        }

        constexpr explicit operator bool () const noexcept { return valid_; }
        constexpr bool has_value () const noexcept { return valid_; }

        T const & value () const noexcept { return value_impl (*this); }
        T & value () noexcept { return value_impl (*this); }

        template <typename U>
        constexpr T value_or (U && default_value) const {
            return this->has_value () ? this->value () : default_value;
        }

    private:
        template <typename Maybe, typename ResultType = typename inherit_const<Maybe, T>::type>
        static ResultType & value_impl (Maybe && m) noexcept {
            PSTORE_ASSERT (m.has_value ());
            return *m;
        }

        bool valid_ = false;
        typename std::aligned_storage<sizeof (T), alignof (T)>::type storage_;
    };


    // just
    // ~~~~
    template <typename T>
    constexpr decltype (auto) just (T && value) {
        return maybe<typename details::remove_cvref_t<T>>{std::forward<T> (value)};
    }

    template <typename T, typename... Args>
    constexpr decltype (auto) just (in_place_t const inp, Args &&... args) {
        (void) inp;
        return maybe<typename details::remove_cvref_t<T>>{in_place, std::forward<Args> (args)...};
    }

    // nothing
    // ~~~~~~~
    template <typename T>
    constexpr decltype (auto) nothing () noexcept {
        return maybe<typename details::remove_cvref_t<T>>{};
    }

    template <typename T, typename Function>
    auto operator>>= (maybe<T> && t, Function f) -> decltype (f (*t)) {
        if (t) {
            return f (*t);
        }
        return maybe<typename decltype (f (*t))::value_type>{};
    }

} // namespace pstore

#endif // PSTORE_SUPPORT_MAYBE_HPP