logstream.hpp

Go to the documentation of this file.

// Copyright (c) 2019 - 2021 by Robert Bosch GmbH. All rights reserved.
// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
// Copyright (c) 2023 by ekxide IO GmbH. 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_REPORTING_LOG_LOGSTREAM_HPP
#define IOX2_BB_REPORTING_LOG_LOGSTREAM_HPP
 
#include "iox2/bb/detail/source_location.hpp"
 
#include "iox2/legacy/log/logger.hpp"
#include "iox2/legacy/type_traits.hpp"
 
#include <cstdint>
#include <string>
 
namespace iox2 {
namespace legacy {
namespace log {
class LogStream;
 
template <typename T>
class LogHex {
  public:
    friend class LogStream;
 
    template <typename TT, typename>
    friend constexpr LogHex<TT> hex(const TT) noexcept;
    friend constexpr LogHex<const void* const> hex(const void* const) noexcept;
 
    ~LogHex() = default;
 
    LogHex(const LogHex&) = delete;
    LogHex& operator=(const LogHex&) = delete;
    LogHex& operator=(LogHex&&) noexcept = delete;
 
  private:
    template <typename = std::enable_if_t<std::is_arithmetic<T>::value || std::is_pointer<T>::value>>
    explicit constexpr LogHex(const T value) noexcept;
 
    LogHex(LogHex&&) noexcept = default;
 
    // NOLINTJUSTIFICATION intentionally used since the class does not need to be assignable and the data is not supposed to be changed
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
    T m_value;
};
 
// AXIVION Next Construct AutosarC++19_03-M17.0.3 : The function is in the iox2::legacy::log namespace which prevents easy misuse
template <typename T, typename = std::enable_if_t<std::is_arithmetic<T>::value && !std::is_same<T, bool>::value>>
constexpr LogHex<T> hex(const T value) noexcept;
 
// AXIVION Next Construct AutosarC++19_03-M17.0.3 : The function is in the iox2::legacy::log namespace which prevents easy misuse
constexpr LogHex<const void* const> hex(const void* const ptr) noexcept;
 
template <typename T>
class LogOct {
  public:
    friend class LogStream;
 
    template <typename TT, typename>
    friend constexpr LogOct<TT> oct(const TT) noexcept;
 
    ~LogOct() = default;
 
    LogOct(const LogOct&) = delete;
    LogOct& operator=(const LogOct&) = delete;
    LogOct& operator=(LogOct&&) noexcept = delete;
 
  private:
    template <typename = std::enable_if_t<std::is_integral<T>::value>>
    explicit constexpr LogOct(const T value) noexcept;
 
    LogOct(LogOct&&) noexcept = default;
 
    T m_value;
};
 
// AXIVION Next Construct AutosarC++19_03-M17.0.3 : The function is in the iox2::legacy::log namespace which prevents easy misuse
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value && !std::is_same<T, bool>::value>>
constexpr LogOct<T> oct(const T value) noexcept;
 
template <typename T>
class LogBin {
  public:
    friend class LogStream;
 
    template <typename TT, typename>
    friend constexpr LogBin<TT> bin(const TT) noexcept;
 
    ~LogBin() = default;
 
    LogBin(const LogBin&) = delete;
    LogBin& operator=(const LogBin&) = delete;
    LogBin& operator=(LogBin&&) noexcept = delete;
 
  private:
    template <typename = std::enable_if_t<std::is_integral<T>::value>>
    explicit constexpr LogBin(const T value) noexcept;
 
    LogBin(LogBin&&) noexcept = default;
 
    T m_value;
};
 
// AXIVION Next Construct AutosarC++19_03-M17.0.3 : The function is in the iox2::legacy::log namespace which prevents easy misuse
template <typename T, typename = std::enable_if_t<std::is_integral<T>::value && !std::is_same<T, bool>::value>>
constexpr LogBin<T> bin(const T value) noexcept;
 
class LogRaw {
  public:
    friend class LogStream;
 
    // for some reasons the default template argument SFINEA results in the error
    // 'redeclaration of friend ... may not have default template arguments' on GCC but return type SFINEA seams to work
    template <typename T>
    friend constexpr typename std::enable_if<!std::is_pointer<T>::value, LogRaw>::type raw(const T&) noexcept;
    friend constexpr LogRaw raw(const void* const, const uint64_t) noexcept;
 
    ~LogRaw() = default;
 
    LogRaw(const LogRaw&) = delete;
    LogRaw& operator=(const LogRaw&) = delete;
    LogRaw& operator=(LogRaw&&) noexcept = delete;
 
  private:
    explicit constexpr LogRaw(const void* const data, uint64_t size) noexcept;
 
    LogRaw(LogRaw&&) noexcept = default;
 
    // NOLINTJUSTIFICATION intentionally used since the class does not need to be assignable and the data is not supposed to be changed
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
    const void* const m_data;
    uint64_t m_size;
};
 
// AXIVION Next Construct AutosarC++19_03-M17.0.3 : The function is in the iox2::legacy::log namespace which prevents easy misuse
template <typename T>
constexpr typename std::enable_if<!std::is_pointer<T>::value, LogRaw>::type raw(const T& object) noexcept;
 
// AXIVION Next Construct AutosarC++19_03-M17.0.3 : The function is in the iox2::legacy::log namespace which prevents easy misuse
constexpr LogRaw raw(const void* const data, const uint64_t size) noexcept;
 
class LogStream {
  public:
    LogStream(Logger& logger, const bb::detail::SourceLocation location, const LogLevel logLevel) noexcept;
 
    LogStream(const bb::detail::SourceLocation location, const LogLevel logLevel) noexcept;
 
    virtual ~LogStream() noexcept;
 
    LogStream(const LogStream&) = delete;
    LogStream(LogStream&&) = delete;
 
    LogStream& operator=(const LogStream&) = delete;
    LogStream& operator=(LogStream&&) = delete;
 
    LogStream& self() noexcept;
 
    // AXIVION Next Construct AutosarC++19_03-A3.9.1 : Logging support for C-style strings
    LogStream& operator<<(const char* cstr) noexcept;
 
    LogStream& operator<<(const std::string& str) noexcept;
 
    LogStream& operator<<(const bool val) noexcept;
 
    // AXIVION DISABLE STYLE AutosarC++19_03-A3.9.1 : Basic numeric types are used in order to cover als basic numeric types, independent of the type alias
 
    LogStream& operator<<(const char val) noexcept;
 
    LogStream& operator<<(const signed char val) noexcept;
 
    LogStream& operator<<(const unsigned char val) noexcept;
 
    LogStream& operator<<(const short val) noexcept;
 
    LogStream& operator<<(const unsigned short val) noexcept;
 
    LogStream& operator<<(const int val) noexcept;
 
    LogStream& operator<<(const unsigned int val) noexcept;
 
    LogStream& operator<<(const long val) noexcept;
 
    LogStream& operator<<(const unsigned long val) noexcept;
 
    LogStream& operator<<(const long long val) noexcept;
 
    LogStream& operator<<(const unsigned long long val) noexcept;
 
    LogStream& operator<<(const float val) noexcept;
 
    LogStream& operator<<(const double val) noexcept;
 
    LogStream& operator<<(const long double val) noexcept;
 
    // AXIVION ENABLE STYLE AutosarC++19_03-A3.9.1
 
    template <typename T, typename std::enable_if_t<std::is_integral<T>::value, bool> = 0>
    LogStream& operator<<(const LogHex<T>&& val) noexcept;
 
    template <typename T, typename std::enable_if_t<std::is_floating_point<T>::value, bool> = 0>
    LogStream& operator<<(const LogHex<T>&& val) noexcept;
 
    LogStream& operator<<(const LogHex<const void* const>&& val) noexcept;
 
    template <typename T, typename std::enable_if_t<std::is_integral<T>::value, bool> = 0>
    LogStream& operator<<(const LogOct<T>&& val) noexcept;
 
    template <typename T, typename std::enable_if_t<std::is_integral<T>::value, bool> = 0>
    LogStream& operator<<(const LogBin<T>&& val) noexcept;
 
    LogStream& operator<<(const LogRaw&& val) noexcept;
 
    template <typename Callable, typename = std::enable_if_t<is_invocable_r<LogStream&, Callable, LogStream&>::value>>
    LogStream& operator<<(const Callable& c) noexcept;
 
    LogStream& operator<<(const LogLevel value) noexcept;
 
  private:
    void flush() noexcept;
 
    // JUSTIFICATION it is fine to use a reference since the LogStream object is intentionally not movable
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
    Logger& m_logger;
    bool m_isFlushed { false };
 
    bool m_doFlush { true };
};
 
} // namespace log
} // namespace legacy
} // namespace iox2
 
#include "iox2/legacy/detail/log/logstream.inl"
 
#endif // IOX2_BB_REPORTING_LOG_LOGSTREAM_HPP