DeferredFormatCodec.h

#pragma once

#include "quill/core/Attributes.h"
#include "quill/core/Codec.h"
#include "quill/core/DynamicFormatArgStore.h"
#include "quill/core/InlinedVector.h"

#include <cstddef>
#include <cstdint>
#include <cstring>
#include <new>
#include <type_traits>
#include <utility>

QUILL_BEGIN_NAMESPACE

#if defined(_WIN32) && defined(_MSC_VER)
  // silence msvc warning C4702: unreachable code
  #pragma warning(push)
  #pragma warning(disable : 4702)
#endif

QUILL_BEGIN_EXPORT

template <typename T>
struct DeferredFormatCodec
{
  static constexpr bool use_memcpy =
    std::conjunction_v<std::is_trivially_copyable<T>, std::is_default_constructible<T>>;

  static size_t compute_encoded_size(detail::SizeCacheVector&, T const&) noexcept
  {
    if constexpr (use_memcpy)
    {
      return sizeof(T);
    }
    else
    {
      // If it’s misaligned, the worst-case scenario is when the pointer is off by one byte from an alignment boundary
      return sizeof(T) + alignof(T) - 1;
    }
  }

  template <typename Arg>
  static void encode(std::byte*& buffer, detail::SizeCacheVector const&, uint32_t&, Arg&& arg)
  {
    if constexpr (use_memcpy)
    {
      std::memcpy(buffer, &arg, sizeof(arg));
      buffer += sizeof(arg);
    }
    else
    {
      auto aligned_ptr = align_pointer(buffer, alignof(T));

      if constexpr (std::is_rvalue_reference_v<Arg&&> && is_move_constructible<T>::value)
      {
        new (static_cast<void*>(aligned_ptr)) T(std::move(arg));
      }
      else
      {
        static_assert(is_copy_constructible<T>::value, "T is not copy-constructible!");
        new (static_cast<void*>(aligned_ptr)) T(arg);
      }

      buffer += sizeof(T) + alignof(T) - 1;
    }
  }

  static T decode_arg(std::byte*& buffer)
  {
    if constexpr (use_memcpy)
    {
      T arg;

      // Cast to void* to silence compiler warning about private members
      std::memcpy(static_cast<void*>(&arg), buffer, sizeof(arg));

      buffer += sizeof(arg);
      return arg;
    }
    else
    {
      static_assert(std::is_move_constructible_v<T> || std::is_copy_constructible_v<T>,
                    "T must be move or copy constructible");

      auto* aligned_ptr = align_pointer(buffer, alignof(T));
      auto* tmp = std::launder(reinterpret_cast<T*>(aligned_ptr));
      buffer += sizeof(T) + alignof(T) - 1;

      // Guarantee *tmp is destroyed even if the move/copy below throws. The original object
      // was placement-new'd into the queue buffer during encode().
      struct DestroyGuard
      {
        T* ptr;
        ~DestroyGuard()
        {
          if constexpr (!std::is_trivially_destructible_v<T>)
          {
            ptr->~T();
          }
        }
      } destroy_guard{tmp};

      if constexpr (std::is_move_constructible_v<T>)
      {
        // Move into the backend value; DestroyGuard still owns the queue-buffer object.
        return T{std::move(*tmp)};
      }
      else
      {
        // Keep the return as an explicit copy. `return T{*tmp};` is preferred over `return *tmp;`
        // since the latter can still prefer a deleted move constructor for copy-only types.
        return T{*tmp};
      }
    }
  }

  static void decode_and_store_arg(std::byte*& buffer, DynamicFormatArgStore* args_store)
  {
    QUILL_TRY { args_store->push_back(decode_arg(buffer)); }
#if !defined(QUILL_NO_EXCEPTIONS)
    QUILL_CATCH_ALL()
    {
      // Fall back to a placeholder so the surrounding log line is still produced. Without this,
      // a throwing decode would propagate up and discard the whole transit event.
      static constexpr char fallback[] = "[Quill deferred decode failed]";
      args_store->push_back(fmtquill::string_view{fallback, sizeof(fallback) - 1u});
    }
#endif
  }

private:
  // These trait implementations will take the friend declaration into account

  // Default constructible check
  template <typename U, typename = void>
  struct is_default_constructible : std::false_type
  {
  };

  template <typename U>
  struct is_default_constructible<U, std::void_t<decltype(U())>> : std::true_type
  {
  };

  // Copy constructible check: tests if we can call U(const U&)
  template <typename U, typename = void>
  struct is_copy_constructible : std::false_type
  {
  };

  template <typename U>
  struct is_copy_constructible<U, std::void_t<decltype(U(std::declval<U const&>()))>> : std::true_type
  {
  };

  // Move constructible check: tests if we can call U(U&&)
  template <typename U, typename = void>
  struct is_move_constructible : std::false_type
  {
  };

  template <typename U>
  struct is_move_constructible<U, std::void_t<decltype(U(std::declval<U&&>()))>> : std::true_type
  {
  };

  static std::byte* align_pointer(void* pointer, size_t alignment) noexcept
  {
    return reinterpret_cast<std::byte*>((reinterpret_cast<uintptr_t>(pointer) + (alignment - 1ul)) &
                                        ~(alignment - 1ul));
  }
};

QUILL_END_EXPORT

#if defined(_WIN32) && defined(_MSC_VER)
  #pragma warning(pop)
#endif

QUILL_END_NAMESPACE