libxr_def.hpp

#pragma once
 
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
#ifndef M_2PI
#define M_2PI (2.0 * M_PI)
#endif
 
#ifndef M_1G
constexpr double M_1G = 9.80665;
#endif
 
#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 OFFSET_OF
#define OFFSET_OF(type, member) ((size_t)&((type*)0)->member)
#endif
 
#ifndef MEMBER_SIZE_OF
#define MEMBER_SIZE_OF(type, member) (sizeof(decltype(((type*)0)->member)))
#endif
 
#ifndef CONTAINER_OF
#define CONTAINER_OF(ptr, type, member) \
  ((type*)((char*)(ptr) - OFFSET_OF(type, member)))  // NOLINT
#endif
 
static constexpr size_t LIBXR_CACHE_LINE_SIZE = (sizeof(void*) == 8) ? 64 : 32;
static constexpr size_t LIBXR_ALIGN_SIZE = (sizeof(void*));
 
namespace LibXR
{
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    
};
}  // namespace LibXR
 
#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
 
extern "C" void libxr_fatal_error(const char* file, uint32_t line, bool in_isr);
 
namespace LibXR
{
template <typename T1, typename T2>
constexpr auto max(T1 a, T2 b) -> typename std::common_type<T1, T2>::type
{
  return (a > b) ? a : b;
}
 
template <typename T1, typename T2>
constexpr auto min(T1 a, T2 b) -> typename std::common_type<T1, T2>::type
{
  return (a < b) ? a : b;
}
}  // namespace LibXR