OptionalRef.hpp

Go to the documentation of this file.

 
 
// --- Core Includes ---
#include "includes/kratos_export_api.h" // KRATOS_API
#include "includes/exception.h" // KRATOS_ERROR
 
// --- STL Includes ---
#include <type_traits> // alignment_of
#include <bitset> // bitset
#include <cstdint> // uintptr_t
 
 
namespace Kratos::WRApp {
 
 
template <class TElement>
class OptionalRef
{
private:
    using PointerInteger = std::uintptr_t;
 
public:
    using value_type = TElement&;
 
    OptionalRef() noexcept
    {
        // First of all, make sure that the pointer doesn't use the least significant bit
        static_assert(1 < std::alignment_of<TElement>(),
                      "OptionalReference cannot be used with types of size 1");
 
        // Assume that the size of PointerInteger is equal to the system's pointer size
        static_assert(sizeof(PointerInteger) == sizeof(TElement*));
 
        // Verify that the alignment is identical to a pointer
        static_assert(std::alignment_of<OptionalRef>() == std::alignment_of<TElement*>());
 
        mpElement.pointer = 0;
    }
 
    explicit OptionalRef(TElement& rElement) noexcept
    {
        PointerInteger p = reinterpret_cast<PointerInteger>(&rElement);
        mpElement.integer = p | static_cast<PointerInteger>(1);
    }
 
    OptionalRef(OptionalRef&& rRhs) noexcept = default;
 
    OptionalRef(const OptionalRef& rRhs) noexcept = default;
 
    OptionalRef& operator=(OptionalRef&& rRhs) noexcept = default;
 
    OptionalRef& operator=(const OptionalRef& rRhs) noexcept = default;
 
    OptionalRef& operator=(TElement& rElement) noexcept
    {
        PointerInteger p = reinterpret_cast<PointerInteger>(&rElement);
        mpElement.integer = p | static_cast<PointerInteger>(1);
    }
 
    bool has_value() const noexcept
    {
        return mpElement.integer & static_cast<PointerInteger>(1);
    }
 
    explicit operator bool () const noexcept
    {
        return this->has_value();
    }
 
    TElement& value() const
    {
        if (!this->has_value()){
            KRATOS_ERROR << "bad optional access";
        } else {
            PointerInteger p = mpElement.integer & ~static_cast<PointerInteger>(1);
            return *reinterpret_cast<TElement*>(p);
        }
    }
 
    TElement& operator*() const noexcept
    {
        return this->value();
    }
 
    void reset() noexcept
    {
        mpElement.integer = 0;
    }
 
private:
    union {
        TElement* pointer;
        PointerInteger integer;
    } mpElement;
}; // class OptionalRef
 
 
} // namespace Kratos::WRAp