expression-formatter-inlines.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2021-2026 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can be
 * obtained from https://opensource.org/licenses/mit.
 *
 * Major parts of the code are inspired from v1.1.8 of the Boost UT project,
 * released under the terms of the Boost Version 1.0 Software License,
 * which can be obtained from https://www.boost.org/LICENSE_1_0.txt.
 */
 
// ----------------------------------------------------------------------------

 
#ifndef MICRO_TEST_PLUS_EXPRESSION_FORMATTER_INLINES_H_
#define MICRO_TEST_PLUS_EXPRESSION_FORMATTER_INLINES_H_
 
// ----------------------------------------------------------------------------
 
#ifdef __cplusplus
 
// ----------------------------------------------------------------------------
 
#include <cstdio>
 
#include "micro-os-plus/micro-test-plus/reflection.h"
 
// ----------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waggregate-return"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#endif
#endif
 
// ============================================================================
 
namespace micro_os_plus::micro_test_plus::detail
{
  // --------------------------------------------------------------------------

  inline expression_formatter::expression_formatter (colours& colours) noexcept
      : colours_ (colours)
  {
  }
 
  // --------------------------------------------------------------------------

  inline auto
  expression_formatter::colour_ (const bool cond) const
  {
    return cond ? colours_.pass : colours_.fail;
  }
 
  // --------------------------------------------------------------------------

  inline const std::string&
  expression_formatter::str () const noexcept
  {
    return buffer_;
  }

  inline const char*
  expression_formatter::c_str () const noexcept
  {
    return buffer_.c_str ();
  }

  inline void
  expression_formatter::clear () noexcept
  {
    buffer_.clear ();
  }

  inline bool
  expression_formatter::empty () const noexcept
  {
    return buffer_.empty ();
  }

  inline void
  expression_formatter::append (size_t count, char ch)
  {
    buffer_.append (count, ch);
  }

  inline void
  expression_formatter::reserve (size_t capacity)
  {
    buffer_.reserve (capacity);
  }
 
  // --------------------------------------------------------------------------
 
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
 
  // --------------------------------------------------------------------------

  template <typename T>
  expression_formatter&
  expression_formatter::operator<< (T* v)
  {
    if (v == nullptr)
      {
        buffer_.append ("0x0");
        return *this;
      }
#if defined(__GNUC__)
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage-in-libc-call"
#endif
#endif
    char buff[20];
    snprintf (buff, sizeof (buff), "%p", reinterpret_cast<void*> (v));
    buffer_.append (buff);
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
    return *this;
  }

  template <class T>
    requires type_traits::is_op<T>
  expression_formatter&
  expression_formatter::operator<< (const T& t)
  {
    *this << detail::get (t);
    return *this;
  }

  template <class T>
  expression_formatter&
  expression_formatter::operator<< (
      const type_traits::genuine_integral_value<T>& v)
  {
    detail::append_number_ (buffer_, static_cast<long long> (v.get ()));
    return *this;
  }

  template <class T>
    requires (type_traits::container_like<T> and not type_traits::has_npos<T>)
  expression_formatter&
  expression_formatter::operator<< (const T& t)
  {
    *this << '{';
    auto first = true;
    for (const auto& arg : t)
      {
        *this << (first ? "" : ", ") << arg;
        first = false;
      }
    *this << '}';
    return *this;
  }
 
  // --------------------------------------------------------------------------
  // Compound expression operators (without colour codes).

  template <class Lhs_T, class Rhs_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::eq_<Lhs_T, Rhs_T>& op)
  {
    return (*this << colour_ (op) << op.lhs () << " == " << op.rhs ()
                  << colours_.none);
  }

  template <class Lhs_T, class Rhs_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::ne_<Lhs_T, Rhs_T>& op)
  {
    return (*this << colour_ (op) << op.lhs () << " != " << op.rhs ()
                  << colours_.none);
  }

  template <class Lhs_T, class Rhs_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::gt_<Lhs_T, Rhs_T>& op)
  {
    return (*this << colour_ (op) << op.lhs () << " > " << op.rhs ()
                  << colours_.none);
  }

  template <class Lhs_T, class Rhs_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::ge_<Lhs_T, Rhs_T>& op)
  {
    return (*this << colour_ (op) << op.lhs () << " >= " << op.rhs ()
                  << colours_.none);
  }

  template <class Lhs_T, class Rhs_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::lt_<Rhs_T, Lhs_T>& op)
  {
    return (*this << colour_ (op) << op.lhs () << " < " << op.rhs ()
                  << colours_.none);
  }

  template <class Lhs_T, class Rhs_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::le_<Rhs_T, Lhs_T>& op)
  {
    return (*this << colour_ (op) << op.lhs () << " <= " << op.rhs ()
                  << colours_.none);
  }

  template <class Lhs_T, class Rhs_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::and_<Lhs_T, Rhs_T>& op)
  {
    return (*this << '(' << op.lhs () << colour_ (op) << " and "
                  << colours_.none << op.rhs () << ')');
  }

  template <class Lhs_T, class Rhs_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::or_<Lhs_T, Rhs_T>& op)
  {
    return (*this << '(' << op.lhs () << colour_ (op) << " or "
                  << colours_.none << op.rhs () << ')');
  }

  template <class T>
  expression_formatter&
  expression_formatter::operator<< (const detail::not_<T>& op)
  {
    return (*this << colour_ (op) << "not " << op.operand () << colours_.none);
  }
 
#if defined(__cpp_exceptions)
  template <class Callable_T, class Exception_T>
  expression_formatter&
  expression_formatter::operator<< (
      const detail::throws_<Callable_T, Exception_T>& op)
  {
    return (*this << colour_ (op) << "throws<"
                  << reflection::type_name<Exception_T> () << ">"
                  << colours_.none);
  }

  template <class Callable_T>
  expression_formatter&
  expression_formatter::operator<< (
      const detail::throws_<Callable_T, void>& op)
  {
    return (*this << colour_ (op) << "throws" << colours_.none);
  }

  template <class Callable_T>
  expression_formatter&
  expression_formatter::operator<< (const detail::nothrow_<Callable_T>& op)
  {
    return (*this << colour_ (op) << "nothrow" << colours_.none);
  }
#endif
 
  // --------------------------------------------------------------------------
} // namespace micro_os_plus::micro_test_plus::detail
 
#if defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
// ----------------------------------------------------------------------------
 
#endif // __cplusplus
 
// ----------------------------------------------------------------------------
 
#endif // MICRO_TEST_PLUS_EXPRESSION_FORMATTER_INLINES_H_
 
// ----------------------------------------------------------------------------