posix_call.hpp

Go to the documentation of this file.

// Copyright (c) 2021 - 2022 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_POSIX_DESIGN_POSIX_CALL_HPP
#define IOX2_BB_POSIX_DESIGN_POSIX_CALL_HPP
 
#include "iox2/legacy/detail/platform_correction.hpp"
 
#include "iox2/bb/detail/attributes.hpp"
#include "iox2/legacy/expected.hpp"
 
#include <cstdint>
 
namespace iox2 {
namespace legacy {
static constexpr uint32_t POSIX_CALL_ERROR_STRING_SIZE = 128U;
static constexpr uint64_t POSIX_CALL_EINTR_REPETITIONS = 5U;
static constexpr int32_t POSIX_CALL_INVALID_ERRNO = -1;
 
template <typename ReturnType, typename... FunctionArguments>
class PosixCallBuilder;
 
template <typename T>
struct PosixCallResult {
    PosixCallResult() noexcept = default;
 
    T value {};
 
    int32_t errnum = POSIX_CALL_INVALID_ERRNO;
};
 
namespace detail {
template <typename ReturnType, typename... FunctionArguments>
PosixCallBuilder<ReturnType, FunctionArguments...>
createPosixCallBuilder(ReturnType (*IOX2_POSIX_CALL)(FunctionArguments...),
                       const char* posixFunctionName,
                       const char* file,
                       const int32_t line,
                       const char* callingFunction) noexcept;
 
template <typename ReturnType>
struct PosixCallDetails {
    PosixCallDetails(const char* posixFunctionName, const char* file, int line, const char* callingFunction) noexcept;
    const char* posixFunctionName = nullptr;
    const char* file = nullptr;
    const char* callingFunction = nullptr;
    int32_t line = 0;
    bool hasSuccess = true;
    bool hasIgnoredErrno = false;
    bool hasSilentErrno = false;
 
    PosixCallResult<ReturnType> result;
};
} // namespace detail
 
template <typename ReturnType>
class IOX2_NO_DISCARD PosixCallEvaluator {
  public:
    template <typename... IgnoredErrnos>
    PosixCallEvaluator<ReturnType> ignoreErrnos(const IgnoredErrnos... ignoredErrnos) const&& noexcept;
 
    template <typename... SilentErrnos>
    PosixCallEvaluator<ReturnType> suppressErrorMessagesForErrnos(const SilentErrnos... silentErrnos) const&& noexcept;
 
    expected<PosixCallResult<ReturnType>, PosixCallResult<ReturnType>> evaluate() const&& noexcept;
 
  private:
    template <typename>
    friend class PosixCallVerificator;
 
    explicit PosixCallEvaluator(detail::PosixCallDetails<ReturnType>& details) noexcept;
 
  private:
    // NOLINTJUSTIFICATION refences are intentionally used since the class does not need to be assignable
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
    detail::PosixCallDetails<ReturnType>& m_details;
};
 
template <typename ReturnType>
class IOX2_NO_DISCARD PosixCallVerificator {
  public:
    template <typename... SuccessReturnValues>
    PosixCallEvaluator<ReturnType> successReturnValue(const SuccessReturnValues... successReturnValues) && noexcept;
 
    template <typename... FailureReturnValues>
    PosixCallEvaluator<ReturnType> failureReturnValue(const FailureReturnValues... failureReturnValues) && noexcept;
 
    PosixCallEvaluator<ReturnType> returnValueMatchesErrno() && noexcept;
 
  private:
    template <typename, typename...>
    friend class PosixCallBuilder;
 
    explicit PosixCallVerificator(detail::PosixCallDetails<ReturnType>& details) noexcept;
 
  private:
    // NOLINTJUSTIFICATION refences are intentionally used since the class does not need to be assignable
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
    detail::PosixCallDetails<ReturnType>& m_details;
};
 
template <typename ReturnType, typename... FunctionArguments>
class IOX2_NO_DISCARD PosixCallBuilder {
  public:
    using FunctionType_t = ReturnType (*)(FunctionArguments...);
 
    PosixCallVerificator<ReturnType> operator()(FunctionArguments... arguments) && noexcept;
 
  private:
    template <typename ReturnTypeFriend, typename... FunctionArgumentsFriend>
    friend PosixCallBuilder<ReturnTypeFriend, FunctionArgumentsFriend...>
    detail::createPosixCallBuilder(ReturnTypeFriend (*IOX2_POSIX_CALL)(FunctionArgumentsFriend...),
                                   const char* posixFunctionName,
                                   const char* file,
                                   const int32_t line,
                                   const char* callingFunction) noexcept;
 
    PosixCallBuilder(FunctionType_t IOX2_POSIX_CALL,
                     const char* posixFunctionName,
                     const char* file,
                     const int32_t line,
                     const char* callingFunction) noexcept;
 
  private:
    FunctionType_t m_IOX2_POSIX_CALL = nullptr;
    detail::PosixCallDetails<ReturnType> m_details;
};
} // namespace legacy
} // namespace iox2
 
#include "iox2/legacy/detail/posix_call.inl"
 
// NOLINTJUSTIFICATION a template or constexpr function does not have access to source code origin file, line, function
//                     name
// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
#define IOX2_POSIX_CALL(f)                                                                                             \
    iox2::legacy::detail::createPosixCallBuilder(                                                                      \
        &(f),                                                                                                          \
        (#f),                                                                                                          \
        __FILE__,                                                                                                      \
        __LINE__,                                                                                                      \
        __PRETTY_FUNCTION__) // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay)
// needed for source code location, safely wrapped in macro
 
#endif // IOX2_BB_POSIX_DESIGN_POSIX_CALL_HPP