Optional.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
 
#ifndef IMT_BASE_CORE_UTIL_OPTIONAL_H
#define IMT_BASE_CORE_UTIL_OPTIONAL_H
 
#include <Imt.Base.Core.Diagnostics/Diagnostics.h>
#include <Imt.Base.Core.Platform/Platform.h>
 
namespace imt {
namespace base {
namespace core {
namespace util {
 
// AXIVION Next Construct AutosarC++19_03-M2.10.1: Name given by STL.
template<typename ElementType>
class Optional final {
 
public:
 
    // AXIVION Next Construct AutosarC++19_03-A12.1.5: No constructor to delegate to.
    constexpr Optional() noexcept :
        m_hasValue {false},
        m_value {} {
    }
 
    // AXIVION Next Construct AutosarC++19_03-A12.1.4: Implicit conversion on purpose (same as STL implementation).
    constexpr Optional(ElementType const value) noexcept :
        m_hasValue {true},
        m_value {value} {
    }
 
    inline bool hasValue() const noexcept {
        return m_hasValue;
    }
 
    inline ElementType value() const {
        // STL would throw std::bad_optional_access here. Because Imt.Base do not use exceptions, an assert is used instead.
        const bool hasVal {hasValue()};
        ASSERT_DEBUG1(hasVal, "No value available");
        return m_value;
    }
 
    inline ElementType valueOr(ElementType const fallbackValue) const noexcept {
        if (!hasValue()) {
            return fallbackValue;
        }
        return m_value;
    }
 
    inline ElementType operator*() const {
        return value();
    }
 
    inline ElementType operator->() const {
        return value();
    }
 
    // AXIVION Next Codeline AutosarC++19_03-A13.5.2: Implitcit bool conversion is intended (same as STL implementation).
    // AXIVION Next Codeline AutosarC++19_03-A13.5.3: Overload of operator intended (same as STL implementation).
    operator bool() const noexcept {
        return m_hasValue;
    }
 
private:
 
    bool m_hasValue;
    ElementType m_value;
};
 
template<typename ElementType>
bool operator==(Optional<ElementType> const left, Optional<ElementType> const right) noexcept {
    if (!left.hasValue() && !right.hasValue()) {
        return true;
    }
    if (!left.hasValue() || !right.hasValue()) {
        return false;
    }
    return left.value() == right.value();
}
 
template<typename ElementType>
bool operator!=(Optional<ElementType> const left, Optional<ElementType> const right) noexcept {
    return !(left == right);
}
 
template<typename ElementType>
bool operator>(Optional<ElementType> const left, Optional<ElementType> const right) noexcept {
    if (!left.hasValue()) {
        return false;
    }
    if (!right.hasValue()) {
        return false;
    }
    return left.value() > right.value();
}
 
template<typename ElementType>
bool operator<(Optional<ElementType> const left, Optional<ElementType> const right) noexcept {
    if (!left.hasValue()) {
        return false;
    }
    if (!right.hasValue()) {
        return false;
    }
    return left.value() < right.value();
}
 
template<typename ElementType>
bool operator<=(Optional<ElementType> const left, Optional<ElementType> const right) noexcept {
    if (left == right) {
        return true;
    }
    return left < right;
}
 
template<typename ElementType>
bool operator>=(Optional<ElementType> const left, Optional<ElementType> const right) noexcept {
    if (left == right) {
        return true;
    }
    return left > right;
}
 
} // namespace util
} // namespace core
} // namespace base
} // namespace imt
 
#endif // IMT_BASE_CORE_UTIL_OPTIONAL_H