expected.hpp

Go to the documentation of this file.

// Copyright (c) 2019 - 2020 by Robert Bosch GmbH. All rights reserved.
// Copyright (c) 2020 - 2023 by Apex.AI Inc. All rights reserved.
// Copyright (c) 2025 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
 
#ifndef IOX2_BB_VOCABULARY_EXPECTED_HPP
#define IOX2_BB_VOCABULARY_EXPECTED_HPP
 
#include "iox2/bb/detail/attributes.hpp"
#include "iox2/bb/detail/source_location.hpp"
#include "iox2/legacy/detail/expected_helper.hpp"
#include "iox2/legacy/logging.hpp"
 
#include <type_traits>
#include <typeinfo>
 
namespace iox2 {
namespace legacy {
template <typename T = void>
using success = detail::ok<T>;
 
template <typename T>
using error = detail::err<T>;
 
template <typename T = void, typename = enable_if_void_t<T>>
detail::ok<void> ok();
 
template <typename T, typename = enable_if_non_void_t<T>>
detail::ok<T> ok(const T& value);
 
template <typename T, typename = enable_if_non_void_t<T>, typename = enable_if_not_lvalue_referece_t<T>>
detail::ok<T> ok(T&& value);
 
template <typename T, typename... Targs, typename = enable_if_non_void_t<T>>
detail::ok<T> ok(Targs&&... args);
 
template <typename T>
detail::err<T> err(const T& error);
 
template <typename T, typename = enable_if_not_lvalue_referece_t<T>>
detail::err<T> err(T&& error);
 
template <typename T, typename... Targs>
detail::err<T> err(Targs&&... args);
 
template <typename ValueType, typename ErrorType>
class expected;
 
template <typename ValueType, typename ErrorType>
constexpr bool operator==(const expected<ValueType, ErrorType>& lhs,
                          const expected<ValueType, ErrorType>& rhs) noexcept;
 
template <typename ValueType, typename ErrorType>
constexpr bool operator!=(const expected<ValueType, ErrorType>& lhs,
                          const expected<ValueType, ErrorType>& rhs) noexcept;
 
template <typename ValueType, typename ErrorType>
class IOX2_NO_DISCARD expected final {
  public:
    expected() = delete;
 
    expected(const expected&) noexcept = default;
 
    expected(expected&& rhs) noexcept;
 
    template <typename... Targs>
    explicit expected(in_place_t, Targs&&... args) noexcept;
 
    template <typename... Targs>
    explicit expected(unexpect_t, Targs&&... args) noexcept;
 
    ~expected() noexcept = default;
 
    expected& operator=(const expected&) noexcept;
 
    expected& operator=(expected&& rhs) noexcept;
 
    //
    // we would like to use 'return ok(myValue)' with an implicit
    // conversion to return an expected easily
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    expected(const detail::ok<ValueType>& successValue) noexcept;
 
    //
    // we would like to use 'return ok(myValue)' with an implicit
    // conversion to return an expected easily
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    expected(detail::ok<ValueType>&& successValue) noexcept;
 
    // we would like to use 'return err(myErrorValue)' with an implicit
    // conversion to return an expected easily
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    expected(const detail::err<ErrorType>& errorValue) noexcept;
 
    // we would like to use 'return err(myErrorValue)' with an implicit
    // conversion to return an expected easily
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    expected(detail::err<ErrorType>&& errorValue) noexcept;
 
    // AXIVION Next Construct AutosarC++19_03-A13.5.3: Implementation is inspired from std::expected
    explicit operator bool() const noexcept;
 
    bool has_value() const noexcept;
 
    bool has_error() const noexcept;
 
    ErrorType& error(bb::detail::SourceLocation location = bb::detail::SourceLocation::current()) & noexcept;
 
    const ErrorType& error(bb::detail::SourceLocation location = bb::detail::SourceLocation::current()) const& noexcept;
 
    ErrorType&& error(bb::detail::SourceLocation location = bb::detail::SourceLocation::current()) && noexcept;
 
    const ErrorType&&
    error(bb::detail::SourceLocation location = bb::detail::SourceLocation::current()) const&& noexcept;
 
    template <typename U = ValueType>
    enable_if_non_void_t<U>&
    value(bb::detail::SourceLocation location = bb::detail::SourceLocation::current()) & noexcept;
 
    template <typename U = ValueType>
    const enable_if_non_void_t<U>&
    value(bb::detail::SourceLocation location = bb::detail::SourceLocation::current()) const& noexcept;
 
    template <typename U = ValueType>
    enable_if_non_void_t<U>&&
    value(bb::detail::SourceLocation location = bb::detail::SourceLocation::current()) && noexcept;
 
    template <typename U = ValueType>
    const enable_if_non_void_t<U>&&
    value(bb::detail::SourceLocation location = bb::detail::SourceLocation::current()) const&& noexcept;
 
    template <typename U = ValueType>
    enable_if_non_void_t<U>& operator*() noexcept;
 
    template <typename U = ValueType>
    const enable_if_non_void_t<U>& operator*() const noexcept;
 
    template <typename U = ValueType>
    enable_if_non_void_t<U>* operator->() noexcept;
 
    template <typename U = ValueType>
    const enable_if_non_void_t<U>* operator->() const noexcept;
 
    //
    // AXIVION Next Construct AutosarC++19_03-A13.5.2 , AutosarC++19_03-A13.5.3: see doxygen brief section
    // template <typename E>
    // NOLINTNEXTLINE(hicpp-explicit-conversions)
    operator expected<void, ErrorType>() const noexcept;
 
    template <typename T, typename E>
    friend constexpr bool ::iox2::legacy::operator==(const expected<T, E>&, const expected<T, E>&) noexcept;
 
  private:
    template <typename U = ValueType>
    enable_if_non_void_t<U>& value_checked(bb::detail::SourceLocation location) & noexcept;
    template <typename U = ValueType>
    const enable_if_non_void_t<U>& value_checked(bb::detail::SourceLocation location) const& noexcept;
 
    ErrorType& error_checked(bb::detail::SourceLocation location) & noexcept;
    const ErrorType& error_checked(bb::detail::SourceLocation location) const& noexcept;
 
    template <typename E = ErrorType>
    std::enable_if_t<!(std::is_integral<E>::value || std::is_enum<E>::value), void>
    log_error_unchecked() const noexcept;
 
    template <typename E = ErrorType>
    std::enable_if_t<std::is_integral<E>::value, void> log_error_unchecked() const noexcept;
 
    template <typename E = ErrorType>
    std::enable_if_t<std::is_enum<E>::value, void> log_error_unchecked() const noexcept;
 
  private:
    detail::expected_storage<ValueType, ErrorType> m_store;
};
 
} // namespace legacy
} // namespace iox2
 
#include "iox2/legacy/detail/expected.inl"
 
#endif // IOX2_BB_VOCABULARY_EXPECTED_HPP