Common.h

#pragma once
 
// On MSVC 2008 in 64 Bit <cmath> generates a lot of warnings (actually it is math.h, which is included by cmath)
PL_WARNING_PUSH()
PL_WARNING_DISABLE_MSVC(4985)
 
// include std header
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cwchar>
#include <cwctype>
#include <new>
 
PL_WARNING_POP()
 
// redefine NULL to nullptr
#undef NULL
#define NULL nullptr
 
// include c++11 specific header
#include <type_traits>
#include <utility>
 
#define PL_DISALLOW_COPY_AND_ASSIGN(type) \
  type(const type&) = delete;             \
  void operator=(const type&) = delete
 
#if PL_ENABLED(PL_COMPILE_FOR_DEVELOPMENT)
#  define PL_CHECK_ALIGNMENT(ptr, alignment) PL_ASSERT_DEV(((size_t)ptr & ((alignment) - 1)) == 0, "Wrong alignment.")
#else
#  define PL_CHECK_ALIGNMENT(ptr, alignment)
#endif
 
#define PL_WINCHECK_1 1          // PL_INCLUDED_WINDOWS_H defined to 1, _WINDOWS_ defined (stringyfied to nothing)
#define PL_WINCHECK_1_WINDOWS_ 1 // PL_INCLUDED_WINDOWS_H defined to 1, _WINDOWS_ undefined (stringyfied to "_WINDOWS_")
#define PL_WINCHECK_PL_INCLUDED_WINDOWS_H \
  0                              // PL_INCLUDED_WINDOWS_H undefined (stringyfied to "PL_INCLUDED_WINDOWS_H", _WINDOWS_ defined (stringyfied to nothing)
#define PL_WINCHECK_PL_INCLUDED_WINDOWS_H_WINDOWS_ \
  1                              // PL_INCLUDED_WINDOWS_H undefined (stringyfied to "PL_INCLUDED_WINDOWS_H", _WINDOWS_ undefined (stringyfied to "_WINDOWS_")
 
#define PL_CHECK_WINDOWS_INCLUDE(PL_WINH_INCLUDED, WINH_INCLUDED)                               \
  static_assert(PL_PP_CONCAT(PL_WINCHECK_, PL_PP_CONCAT(PL_WINH_INCLUDED, WINH_INCLUDED)) == 1, \
    "Windows.h has been included but not through pl. #include <Foundation/Basics/Platform/Win/IncludeWindows.h> instead of Windows.h");
 
#if PL_ENABLED(PL_COMPILE_ENGINE_AS_DLL)
 
#  define PL_STATICLINK_FILE(LibraryName, UniqueName) PL_CHECK_WINDOWS_INCLUDE(PL_INCLUDED_WINDOWS_H, _WINDOWS_)
 
#  define PL_STATICLINK_REFERENCE(UniqueName)
 
#  define PL_STATICLINK_LIBRARY(LibraryName) void plReferenceFunction_##LibraryName(bool bReturn = true)
 
#else
 
struct plStaticLinkHelper
{
  using Func = void (*)(bool);
  plStaticLinkHelper(Func f) { f(true); }
};
 
struct PL_FOUNDATION_DLL plPluginRegister
{
  plPluginRegister(const char* szName);
};
 
#  define PL_STATICLINK_FILE(LibraryName, UniqueName)        \
    extern "C"                                               \
    {                                                        \
      void plReferenceFunction_##UniqueName(bool bReturn) {} \
      void plReferenceFunction_##LibraryName(bool bReturn);  \
    }                                                        \
    static plStaticLinkHelper StaticLinkHelper_##UniqueName(plReferenceFunction_##LibraryName);
 
#  define PL_STATICLINK_REFERENCE(UniqueName)                   \
    void plReferenceFunction_##UniqueName(bool bReturn = true); \
    plReferenceFunction_##UniqueName()
 
#  define PL_STATICLINK_LIBRARY(LibraryName)                                                         \
    plPluginRegister plPluginRegister_##LibraryName(PL_PP_STRINGIFY(PL_PP_CONCAT(pl, LibraryName))); \
    extern "C" void plReferenceFunction_##LibraryName(bool bReturn = true)
 
#endif
 
namespace plInternal
{
  template <typename T, size_t N>
  char (*ArraySizeHelper(T (&)[N]))[N];
}
 
#define PL_ARRAY_SIZE(a) (sizeof(*plInternal::ArraySizeHelper(a)) + 0)
 
template <class T>
void PL_IGNORE_UNUSED(const T&)
{
}
 
#if (__cplusplus >= 202002L || _MSVC_LANG >= 202002L)
#  undef PL_USE_CPP20_OPERATORS
#  define PL_USE_CPP20_OPERATORS PL_ON
#endif
 
#if PL_ENABLED(PL_USE_CPP20_OPERATORS)
// in C++ 20 we don't need to declare an operator!=, it is automatically generated from operator==
#  define PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(...) /*empty*/
#else
#  define PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(...)                                   \
    PL_ALWAYS_INLINE bool operator!=(PL_EXPAND_ARGS_COMMA(__VA_ARGS__) rhs) const \
    {                                                                             \
      return !(*this == rhs);                                                     \
    }
#endif