libxr_def.hpp

#pragma once
 
#include <cmath>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
#ifndef DEF2STR
#define XR_TO_STR(_arg) #_arg
#define DEF2STR(_arg) XR_TO_STR(_arg)
#endif
 
#ifndef UNUSED
#define UNUSED(_x) ((void)(_x))
#endif
 
#ifndef LIBXR_SINGLE_CORE
#define LIBXR_SINGLE_CORE 0
#endif
 
#if defined(_MSC_VER)
#define LIBXR_NOINLINE __declspec(noinline)
#define LIBXR_PACKED_BEGIN __pragma(pack(push, 1))
#define LIBXR_PACKED_END __pragma(pack(pop))
#define LIBXR_PACKED
#elif defined(__clang__) || defined(__GNUC__)
#define LIBXR_NOINLINE __attribute__((noinline))
#define LIBXR_PACKED_BEGIN _Pragma("pack(push, 1)")
#define LIBXR_PACKED_END _Pragma("pack(pop)")
#define LIBXR_PACKED __attribute__((packed))
#else
#warning "LibXR compiler compatibility macros fallback to no-op on unknown compiler"
#define LIBXR_NOINLINE
#define LIBXR_PACKED_BEGIN
#define LIBXR_PACKED_END
#define LIBXR_PACKED
#endif
 
namespace LibXR
{
inline constexpr double PI = 3.14159265358979323846;
 
inline constexpr double TWO_PI = 2.0 * PI;
 
inline constexpr double STANDARD_GRAVITY = 9.80665;
 
inline constexpr size_t HW_CACHE_LINE_SIZE = (sizeof(void*) == 8) ? 64 : 32;
 
#if LIBXR_SINGLE_CORE
inline constexpr size_t CONCURRENCY_ALIGNMENT = sizeof(size_t);
#else
inline constexpr size_t CONCURRENCY_ALIGNMENT = HW_CACHE_LINE_SIZE;
#endif
 
inline constexpr size_t CACHE_LINE_SIZE = HW_CACHE_LINE_SIZE;
 
inline constexpr size_t ALIGN_SIZE = sizeof(void*);
 
template <typename OwnerType, typename MemberType>
concept MemberObjectPointer = std::is_member_object_pointer_v<MemberType OwnerType::*>;
 
template <typename LeftType, typename RightType>
concept CommonOrdered = std::common_with<LeftType, RightType> &&
                        requires(const LeftType& left, const RightType& right) {
                          { left < right } -> std::convertible_to<bool>;
                          { left > right } -> std::convertible_to<bool>;
                        };
 
template <typename OwnerType, typename MemberType>
  requires MemberObjectPointer<OwnerType, MemberType>
[[nodiscard]] inline size_t OffsetOf(MemberType OwnerType::* member) noexcept
{
  return reinterpret_cast<size_t>(
      &(reinterpret_cast<const volatile OwnerType*>(0)->*member));
}
 
template <typename OwnerType, typename MemberType>
  requires MemberObjectPointer<OwnerType, MemberType>
[[nodiscard]] inline OwnerType* ContainerOf(MemberType* ptr,
                                            MemberType OwnerType::* member) noexcept
{
  return reinterpret_cast<OwnerType*>(reinterpret_cast<std::byte*>(ptr) -
                                      OffsetOf(member));
}
 
template <typename OwnerType, typename MemberType>
  requires MemberObjectPointer<OwnerType, MemberType>
[[nodiscard]] inline const OwnerType* ContainerOf(const MemberType* ptr,
                                                  MemberType OwnerType::* member) noexcept
{
  return reinterpret_cast<const OwnerType*>(reinterpret_cast<const std::byte*>(ptr) -
                                            OffsetOf(member));
}
 
enum class ErrorCode : int8_t
{
  PENDING = 1,        
  OK = 0,             
  FAILED = -1,        
  INIT_ERR = -2,      
  ARG_ERR = -3,       
  STATE_ERR = -4,     
  SIZE_ERR = -5,      
  CHECK_ERR = -6,     
  NOT_SUPPORT = -7,   
  NOT_FOUND = -8,     
  NO_RESPONSE = -9,   
  NO_MEM = -10,       
  NO_BUFF = -11,      
  TIMEOUT = -12,      
  EMPTY = -13,        
  FULL = -14,         
  BUSY = -15,         
  PTR_NULL = -16,     
  OUT_OF_RANGE = -17  
};
 
enum class SizeLimitMode : uint8_t
{
  EQUAL = 0,  
  LESS = 1,   
  MORE = 2,   
  NONE = 3    
};
 
[[nodiscard]] constexpr bool SizeLimitCheck(SizeLimitMode mode, size_t limit,
                                            size_t size) noexcept
{
  switch (mode)
  {
    case SizeLimitMode::EQUAL:
      return limit == size;
    case SizeLimitMode::LESS:
      return limit >= size;
    case SizeLimitMode::MORE:
      return limit <= size;
    case SizeLimitMode::NONE:
      return true;
  }
  return false;
}
}  // namespace LibXR
 
#ifdef DEV_ASSERT
#undef DEV_ASSERT
#endif
 
#ifdef DEV_ASSERT_FROM_CALLBACK
#undef DEV_ASSERT_FROM_CALLBACK
#endif
 
#ifdef REQUIRE
#undef REQUIRE
#endif
 
#ifdef REQUIRE_FROM_CALLBACK
#undef REQUIRE_FROM_CALLBACK
#endif
 
#ifdef ASSERT
#undef ASSERT
#endif
 
#ifdef ASSERT_FROM_CALLBACK
#undef ASSERT_FROM_CALLBACK
#endif
 
#ifdef LIBXR_DEBUG_BUILD
#define ASSERT(arg)                                 \
  do                                                \
  {                                                 \
    if (!(arg))                                     \
    {                                               \
      libxr_fatal_error(__FILE__, __LINE__, false); \
    }                                               \
  } while (0)
 
#define ASSERT_FROM_CALLBACK(arg, in_isr)              \
  do                                                   \
  {                                                    \
    if (!(arg))                                        \
    {                                                  \
      libxr_fatal_error(__FILE__, __LINE__, (in_isr)); \
    }                                                  \
  } while (0)
#else
#define ASSERT(arg) (void(arg), (void)0)
#define ASSERT_FROM_CALLBACK(arg, in_isr) \
  do                                      \
  {                                       \
    (void)(arg);                          \
    (void)(in_isr);                       \
  } while (0)
#endif
 
#ifdef LIBXR_DEV_ASSERT_BUILD
#define DEV_ASSERT(arg)                             \
  do                                                \
  {                                                 \
    if (!(arg))                                     \
    {                                               \
      libxr_fatal_error(__FILE__, __LINE__, false); \
    }                                               \
  } while (0)
 
#define DEV_ASSERT_FROM_CALLBACK(arg, in_isr)          \
  do                                                   \
  {                                                    \
    if (!(arg))                                        \
    {                                                  \
      libxr_fatal_error(__FILE__, __LINE__, (in_isr)); \
    }                                                  \
  } while (0)
#else
#define DEV_ASSERT(arg) (void(arg), (void)0)
#define DEV_ASSERT_FROM_CALLBACK(arg, in_isr) \
  do                                          \
  {                                           \
    (void)(arg);                              \
    (void)(in_isr);                           \
  } while (0)
#endif
 
#define REQUIRE(arg)                                \
  do                                                \
  {                                                 \
    if (!(arg))                                     \
    {                                               \
      libxr_fatal_error(__FILE__, __LINE__, false); \
    }                                               \
  } while (0)
 
#define REQUIRE_FROM_CALLBACK(arg, in_isr)             \
  do                                                   \
  {                                                    \
    if (!(arg))                                        \
    {                                                  \
      libxr_fatal_error(__FILE__, __LINE__, (in_isr)); \
    }                                                  \
  } while (0)
 
extern "C" void libxr_fatal_error(const char* file, uint32_t line, bool in_isr);
 
namespace LibXR
{
template <typename LeftType, typename RightType>
  requires CommonOrdered<LeftType, RightType>
constexpr auto max(LeftType a, RightType b) -> std::common_type_t<LeftType, RightType>
{
  return (a > b) ? a : b;
}
 
template <typename LeftType, typename RightType>
  requires CommonOrdered<LeftType, RightType>
constexpr auto min(LeftType a, RightType b) -> std::common_type_t<LeftType, RightType>
{
  return (a < b) ? a : b;
}
}  // namespace LibXR