Global.h

#pragma once
 
#include <type_traits>
#include <QList>
#include <QSharedPointer>
#include <QString>
 
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
#define KNOWCORE_QT_SKIP_EMPTY_PART Qt::SkipEmptyParts
#else
#define KNOWCORE_QT_SKIP_EMPTY_PART QString::SkipEmptyParts
#endif
 
#ifdef __GNU_LIBRARY__
#ifndef __clang__
#define KNOWCORE_GLIBC_CONSTEXPR constexpr
#endif
#endif
 
//BEGIN knowCore Macros
 
#ifndef KNOWCORE_GLIBC_CONSTEXPR
#define KNOWCORE_GLIBC_CONSTEXPR
#endif
 
#if defined __has_builtin
#define __KNOWCORE_HAS_BUILTIN(_X_) __has_builtin(_X_)
#else
#define __KNOWCORE_HAS_BUILTIN(_X_) 0
#endif
 
#define __KNOWCORE_STR_2(_X_) # _X_
#define __KNOWCORE_STR(_X_) __KNOWCORE_STR_2(_X_)
 
#define __KNOWCORE_CAT(a, b) __KNOWCORE_CAT_I(a, b)
#define __KNOWCORE_CAT_I(a, b) __KNOWCORE_CAT_II(~, a ## b)
#define __KNOWCORE_CAT_II(p, res) res
 
#ifdef __COUNTER__
#define __KNOWCORE_UNIQUE_STATIC_NAME(_X_) __KNOWCORE_CAT(_X_, __COUNTER__)
#else
#define __KNOWCORE_UNIQUE_STATIC_NAME(_X_) __KNOWCORE_CAT(_X_, __LINE__)
#endif
 
#define __KNOWCORE_GET_2ND_ARG(s, arg1, arg2, ...) arg2
 
#define KNOWCORE_UNPACK(...) __VA_ARGS__
#define KNOWCORE_COMMA ,
 
//BEGIN knowCore Foreach
 
// The following macros are for internal use by knowCore, no warranty of behavior is guaranteed
 
#define __KNOWCORE_INC(I) __KNOWCORE_INC_## I
#define __KNOWCORE_INC_0 1
#define __KNOWCORE_INC_1 2
#define __KNOWCORE_INC_2 3
#define __KNOWCORE_INC_3 4
#define __KNOWCORE_INC_4 5
#define __KNOWCORE_INC_5 6
#define __KNOWCORE_INC_6 7
#define __KNOWCORE_INC_7 8
#define __KNOWCORE_INC_8 9
#define __KNOWCORE_INC_9 10
#define __KNOWCORE_INC_10 11
#define __KNOWCORE_INC_11 12
#define __KNOWCORE_INC_12 13
#define __KNOWCORE_INC_13 14
#define __KNOWCORE_INC_14 15
#define __KNOWCORE_INC_15 16
#define __KNOWCORE_INC_16 17
#define __KNOWCORE_INC_17 18
#define __KNOWCORE_INC_18 19
#define __KNOWCORE_INC_19 20
#define __KNOWCORE_INC_20 21
 
#define __KNOWCORE_FOREACH__0(WHAT, SEP, I, ...)
#define __KNOWCORE_FOREACH__1(WHAT, SEP, I, X, ...) WHAT(X, I)
#define __KNOWCORE_FOREACH__2(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__1(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__3(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__2(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__4(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__3(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__5(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__4(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__6(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__5(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__7(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__6(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__8(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__7(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__9(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__8(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__10(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__9(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__11(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__10(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__12(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__11(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__13(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__12(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__14(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__13(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__15(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__14(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__16(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__15(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__17(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__16(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__18(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__17(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__19(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__18(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__20(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__19(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__21(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__20(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__22(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__21(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__23(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__22(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__24(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__23(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__25(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__24(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__26(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__25(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__27(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__26(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__28(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__27(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__29(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__28(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
#define __KNOWCORE_FOREACH__30(WHAT, SEP, I, X, ...) WHAT(X, I) KNOWCORE_UNPACK SEP __KNOWCORE_FOREACH__29(WHAT, SEP, __KNOWCORE_INC(I), __VA_ARGS__)
 
#define __KNOWCORE_GET_MACRO(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, NAME, ...) NAME
 
#define KNOWCORE_FOREACH_SEP(action, sep, ...) \
  __KNOWCORE_GET_MACRO(void, __VA_ARGS__ __VA_OPT__(,) \
  __KNOWCORE_FOREACH__29, __KNOWCORE_FOREACH__28, __KNOWCORE_FOREACH__27, __KNOWCORE_FOREACH__26, __KNOWCORE_FOREACH__25, __KNOWCORE_FOREACH__24, __KNOWCORE_FOREACH__23, __KNOWCORE_FOREACH__22, __KNOWCORE_FOREACH__21, __KNOWCORE_FOREACH__20, \
  __KNOWCORE_FOREACH__19, __KNOWCORE_FOREACH__18, __KNOWCORE_FOREACH__17, __KNOWCORE_FOREACH__16, __KNOWCORE_FOREACH__15, __KNOWCORE_FOREACH__14, __KNOWCORE_FOREACH__13, __KNOWCORE_FOREACH__12, __KNOWCORE_FOREACH__11, __KNOWCORE_FOREACH__10, \
  __KNOWCORE_FOREACH__9, __KNOWCORE_FOREACH__8, __KNOWCORE_FOREACH__7, __KNOWCORE_FOREACH__6, __KNOWCORE_FOREACH__5, __KNOWCORE_FOREACH__4, __KNOWCORE_FOREACH__3, __KNOWCORE_FOREACH__2, __KNOWCORE_FOREACH__1, __KNOWCORE_FOREACH__0)(action, (sep), 0, __VA_ARGS__)
 
#define KNOWCORE_FOREACH(action, ...) KNOWCORE_FOREACH_SEP(action, , __VA_ARGS__)
 
//END knowCore Foreach
 
#define __KNOWCORE_UNLIST_ACTION(__X__, __I__) __X__
 
#define KNOWCORE_UNLIST(...) KNOWCORE_FOREACH(__KNOWCORE_UNLIST_ACTION, __VA_ARGS__)
  
//BEGIN knowCore List
 
#define __KNOWCORE_LIST_ACTION(__X__, __I__) , __X__
 
#define KNOWCORE_LIST(__A__, ...) __A__ KNOWCORE_FOREACH(__KNOWCORE_LIST_ACTION, __VA_ARGS__)
 
//END knowCore List
  
//END Macros
 
//BEGIN knowCore Literal Operators
 
#if __cplusplus > 201703L
inline QString operator "" _kCs(const char8_t* _text, std::size_t _size)
{
  return QString::fromUtf8((const char*)_text, _size);
}
#endif
 
inline QString operator "" _kCs(const char* _text, std::size_t _size)
{
  return QString::fromUtf8((const char*)_text, _size);
}
 
namespace knowCore::details
{
  // From https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1423r3.html
  template<std::size_t N>
  struct char8_t_string_literal {
    static constexpr inline std::size_t size = N;
    template<std::size_t... I>
    constexpr char8_t_string_literal(
      const char8_t (&r)[N],
      std::index_sequence<I...>)
    :
      s{r[I]...}
    {}
    constexpr char8_t_string_literal(
      const char8_t (&r)[N])
    :
      char8_t_string_literal(r, std::make_index_sequence<N>())
    {}
    auto operator <=>(const char8_t_string_literal&) const = default;
    char8_t s[N];
  };
 
  template<char8_t_string_literal L, std::size_t... I>
  constexpr inline const char as_char_buffer[sizeof...(I)] =
    { static_cast<char>(L.s[I])... };
 
  template<char8_t_string_literal L, std::size_t... I>
  constexpr auto& make_as_char_buffer(std::index_sequence<I...>) {
    return as_char_buffer<L, I...>;
  }
}
 
constexpr char operator ""_kC_as_char(char8_t c) {
  return c;
}
 
template<knowCore::details::char8_t_string_literal L>
constexpr auto& operator""_kC_as_char() {
  return knowCore::details::make_as_char_buffer<L>(std::make_index_sequence<decltype(L)::size>());
}
 
//END knowCore Literal Operators
 
//BEGIN knowCore Utils and C++ extensions
 
namespace knowCore
{
  //BEGIN demangle and prettyTypename
  namespace details
  {
    QString demangle(const char* _mangled_symbol);
  }
  template<typename _T_>
  QString prettyTypename()
  {
    return details::demangle(typeid(_T_).name());
  }
//END demangle and prettyTypename
  
  namespace details {
    
    template<typename _T_>
    struct DeleteAll {
      DeleteAll(const QList<_T_>&) {}
    };
    template<typename _T_>
    struct DeleteAll<_T_*> {
      DeleteAll(const QList<_T_*>& _list) {
        qDeleteAll(_list);
      }
    };
  }
  template<typename _T_>
  void deleteAll(const QList<_T_>& _list)
  {
    (void)details::DeleteAll<_T_>(_list);
  }
  
  
  namespace details
  {
    template<typename _T_>
    inline constexpr bool exists_v = std::true_type::value;
    template<typename _T_, typename _T2_>
    using enable_if_exists_t = std::enable_if_t<details::exists_v<_T_>, _T2_>;
    
    template<typename T, typename... Ts>
    struct contains : std::disjunction<std::is_same<T, Ts>...>
    {};
    template<typename T, typename... Ts>
    inline constexpr bool contains_v = contains<T, Ts...>::value;
    
    template <typename...> struct all_int;
 
    template <> struct all_int<> : std::true_type { };
 
    template <typename T, typename ...Rest> struct all_int<T, Rest...>
    : std::integral_constant<bool,
          std::is_convertible<T, int>::value && all_int<Rest...>::value>
    { };
    
    template <typename... T>
    inline constexpr bool all_int_v = all_int<T...>::value;
    
    template<typename _T_>
    struct declare_type
    {
      typedef _T_ type;
    };
    
    //
    // The following template can be used to detect if a class is fully implemented
    //
    template <typename T, class = void>
    struct is_complete : std::false_type {};
 
    template <typename T> 
    struct is_complete<T,decltype(void(sizeof(T)))> : std::true_type {};
 
    template <typename... T>
    inline constexpr bool is_complete_v = is_complete<T...>::value;
    
    //
    // The following template can be used to detect if a class is an instance of atempolate
    //
    namespace
    {
      template <typename, template <typename...> typename>
      struct is_instance_impl : public std::false_type {};
      
      template <template <typename...> typename U, typename...Ts>
      struct is_instance_impl<U<Ts...>, U> : public std::true_type {};
    }
    
    template <typename T, template <typename ...> typename U>
    using is_instance = is_instance_impl<std::decay_t<T>, U>;
    template <typename T, template <typename ...> typename U>
    inline constexpr bool is_instance_v = is_instance<T, U>::value;
 
    template < template <typename...> class Template, typename T >
    struct is_specialisation_of : std::false_type {};
 
    template < template <typename...> class Template, typename... Args >
    struct is_specialisation_of< Template, Template<Args...> > : std::true_type {};
    
    template< template <typename...> class Template, typename... Args >
    inline constexpr bool is_specialisation_of_v = is_specialisation_of<Template, Args...>::value;
  }
  template<class... Ts>
  struct Overloaded : Ts... { using Ts::operator()...; };
}
 
//END knowCore Utils and C++ extensions
 
//BEGIN knowCore D-Pointer Utilities
 
namespace knowCore::Private
{
  template<typename _TD_, typename _TS_, class Enable = void>
  struct CastD
  {
    typedef _TD_* ReturnT;
    static ReturnT get(_TS_ _t)
    {
      return static_cast<_TD_*>(_t);
    }
  };
  template<typename _TD_, typename _TS_>
  struct CastD<_TD_, const _TS_, std::enable_if_t<not std::is_const_v<_TD_>>>
  {
    typedef _TD_* ReturnT;
    static ReturnT get(_TS_ _t)
    {
      return const_cast<_TD_*>(static_cast<const _TD_*>(_t));
    }
  };
  template<typename _TD_, typename _TS_>
  struct CastD<_TD_, QSharedPointer<_TS_>>
  {
    typedef std::remove_const_t<_TD_> TD;
    typedef QSharedPointer<TD> ReturnT;
    static ReturnT get(const QSharedPointer<_TS_> _t)
    {
      return _t.template staticCast<TD>();
    }
  };
  template<typename _TD_, typename _TS_>
  struct CastD<_TD_, QExplicitlySharedDataPointer<_TS_>>
  {
    typedef std::remove_const_t<_TD_> TD;
    typedef QExplicitlySharedDataPointer<TD> ReturnT;
    static ReturnT get(const QExplicitlySharedDataPointer<_TS_> _t)
    {
      return ReturnT(const_cast<TD*>(static_cast<_TD_*>(_t.data())));
    }
  };
  template<typename _TD_, typename _TS_>
  typename CastD<_TD_, _TS_>::ReturnT castD(const _TS_& _t)
  {
    return CastD<_TD_, _TS_>::get(_t);
  };
}
 
#define __KNOWCORE_D_FUNC_DECL()                                             \
    inline decltype(knowCore::Private::castD<Private>(d)) D();               \
    inline decltype(knowCore::Private::castD<const Private>(d)) CD();        \
    inline decltype(knowCore::Private::castD<Private>(d)) NCD() const;       \
    inline decltype(knowCore::Private::castD<const Private>(d)) D() const
 
#define KNOWCORE_D_DECL()                \
  struct Private;                   \
  __KNOWCORE_D_FUNC_DECL()
 
#define KNOWCORE_D_FUNC_DEF(_KLASS_)                                                                                         \
  decltype(knowCore::Private::castD<_KLASS_::Private>(static_cast<_KLASS_*>(nullptr)->d)) _KLASS_::D()                       \
  { return knowCore::Private::castD<Private>(d); }                                                                           \
  decltype(knowCore::Private::castD<const _KLASS_::Private>(static_cast<_KLASS_*>(nullptr)->d)) _KLASS_::CD()                \
  { return knowCore::Private::castD<const Private>(d); }                                                                     \
  decltype(knowCore::Private::castD<_KLASS_::Private>(static_cast<_KLASS_*>(nullptr)->d)) _KLASS_::NCD() const               \
  { return knowCore::Private::castD<Private>(d); }                                                                           \
  decltype(knowCore::Private::castD<const _KLASS_::Private>(static_cast<_KLASS_*>(nullptr)->d)) _KLASS_::D() const           \
  { return knowCore::Private::castD<const Private>(d); }
 
//END knowCore D-Pointer Utilities
 
//BEGIN function forward
 
#define KNOWCORE_FORWARD_INTERFACE_DEFAULT interface()
 
#define KNOWCORE_FORWARD_INTERFACE KNOWCORE_FORWARD_INTERFACE_DEFAULT
 
#define __KNOWCORE_FORWARD_CONST_FUNCTION_ACTION(__NAME__, __I__)                                        \
    auto __NAME__() const                                                                                \
                  -> decltype(this->KNOWCORE_FORWARD_INTERFACE->__NAME__()) override                     \
    {                                                                                                    \
      return this->KNOWCORE_FORWARD_INTERFACE->__NAME__();                                               \
    }
 
#define __KNOWCORE_FORWARD_FUNCTION_ACTION(__NAME__, __I__)                                                       \
    auto __NAME__() -> decltype(this->KNOWCORE_FORWARD_INTERFACE->__NAME__()) override                            \
    {                                                                                                             \
      return this->KNOWCORE_FORWARD_INTERFACE->__NAME__();                                                        \
    }
 
#define __KNOWCORE_FORWARD_FUNCTION_ARGUMENTS_ACTION(__TYPE__, __I__)                                             \
    __TYPE__ _arg ## __I__
 
#define __KNOWCORE_FORWARD_FUNCTION_ARGUMENTS(...)                                                                \
    KNOWCORE_FOREACH_SEP(__KNOWCORE_FORWARD_FUNCTION_ARGUMENTS_ACTION, KNOWCORE_COMMA, __VA_ARGS__)
 
#define __KNOWCORE_FORWARD_FUNCTION_ARGUMENTS_NAMES_ACTION(__TYPE__, __I__)                                       \
    _arg ## __I__
 
#define __KNOWCORE_FORWARD_FUNCTION_ARGUMENTS_NAMES(...)                                                          \
    KNOWCORE_FOREACH_SEP(__KNOWCORE_FORWARD_FUNCTION_ARGUMENTS_NAMES_ACTION, KNOWCORE_COMMA, __VA_ARGS__)
 
#define ___KNOWCORE_FORWARD_FUNCTION_IMPLEMENTATION(__NAME__, __MODIFIER__, ...)                                                        \
    auto __NAME__(__KNOWCORE_FORWARD_FUNCTION_ARGUMENTS(__VA_ARGS__)) __MODIFIER__                                                      \
            -> decltype(this->KNOWCORE_FORWARD_INTERFACE->__NAME__(__KNOWCORE_FORWARD_FUNCTION_ARGUMENTS_NAMES(__VA_ARGS__))) override  \
    {                                                                                                                                   \
      return this->KNOWCORE_FORWARD_INTERFACE->__NAME__(__KNOWCORE_FORWARD_FUNCTION_ARGUMENTS_NAMES(__VA_ARGS__));                      \
    }
 
#define KNOWCORE_FORWARD_FUNCTION(__NAME__, ...)                                 \
  ___KNOWCORE_FORWARD_FUNCTION_IMPLEMENTATION(__NAME__,, __VA_ARGS__)
 
#define KNOWCORE_FORWARD_CONST_FUNCTION(__NAME__, ...)                           \
  ___KNOWCORE_FORWARD_FUNCTION_IMPLEMENTATION(__NAME__, const, __VA_ARGS__)
 
 
#define KNOWCORE_FORWARD_FUNCTIONS(...)                               \
  public:                                                             \
    KNOWCORE_FOREACH(__KNOWCORE_FORWARD_FUNCTION_ACTION, __VA_ARGS__)
 
#define KNOWCORE_FORWARD_CONST_FUNCTIONS(...)                               \
  public:                                                                   \
    KNOWCORE_FOREACH(__KNOWCORE_FORWARD_CONST_FUNCTION_ACTION, __VA_ARGS__)
 
//END function forward
 
//BEGIN concepts
 
namespace knowCore::details
{
  template<class Base, class Derived>
  concept base_of = std::is_base_of_v<Base, Derived>;
}
 
//END concepts