OptionalRef.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <type_traits>
 
#include "storm/utility/macros.h"
 
namespace storm {

 
namespace optionalref_detail {
template<class T>
constexpr T& FUN(T& t) noexcept {
    return t;
}
template<class T>
void FUN(T&&) = delete;
}  // namespace optionalref_detail

struct NullRefType {
    constexpr explicit NullRefType(int) {}
};
inline constexpr NullRefType NullRef{0};

template<class T>
class OptionalRef {
    static_assert(!std::is_reference_v<T>, "Type of OptionalRef should not be a reference type itself.");
 
   public:
    using type = T;

    OptionalRef() : ptr(nullptr) {}

    OptionalRef(NullRefType /*NullRef*/) : ptr(nullptr) {}

    template<class U, class = decltype(optionalref_detail::FUN<T>(std::declval<U>()),
                                       std::enable_if_t<!std::is_same_v<OptionalRef, std::remove_cv_t<std::remove_reference_t<U>>>>())>
    constexpr OptionalRef(U&& u) noexcept(noexcept(optionalref_detail::FUN<T>(std::forward<U>(u))))
        : ptr(std::addressof(optionalref_detail::FUN<T>(std::forward<U>(u)))) {}

    OptionalRef(OptionalRef<T> const& other) = default;

    OptionalRef(OptionalRef<T>&& other) = default;

    OptionalRef& operator=(OptionalRef const& other) = delete;

    operator bool() const {
        return ptr != nullptr;
    }

    bool has_value() const {
        return ptr != nullptr;
    }

    T& operator*() {
        STORM_LOG_ASSERT(has_value(), "OptionalRef operator* called but no object is referenced by this.");
        return *ptr;
    }

    T const& operator*() const {
        STORM_LOG_ASSERT(has_value(), "OptionalRef operator* called but no object is referenced by this.");
        return *ptr;
    }

    T& value() {
        STORM_LOG_ASSERT(has_value(), "OptionalRef value() called but no object is referenced by this.");
        return *ptr;
    }

    T const& value() const {
        STORM_LOG_ASSERT(has_value(), "OptionalRef value called but no object is referenced by this.");
        return *ptr;
    }

    T& value_or(T& defaultValue) {
        return has_value() ? value() : defaultValue;
    }

    T const& value_or(T const& defaultValue) const {
        return has_value() ? value() : defaultValue;
    }

    T* operator->() {
        STORM_LOG_ASSERT(has_value(), "OptionalRef operator-> called but no object is referenced by this.");
        return ptr;
    }

    T const* operator->() const {
        STORM_LOG_ASSERT(has_value(), "OptionalRef operator-> called but no object is referenced by this.");
        return ptr;
    }

    void reset() {
        ptr = nullptr;
    }

    void reset(NullRefType const&) {
        ptr = nullptr;
    }

    void reset(T& t) {
        ptr = std::addressof(t);
    }
 
   private:
    T* ptr;  
};

template<class T>
OptionalRef(T&) -> OptionalRef<T>;
 
}  // namespace storm