qaglobalutils.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018-2025 QuasarApp.
 * Distributed under the lgplv3 software license, see the accompanying
 * Everyone is permitted to copy and distribute verbatim copies
 * of this license document, but changing it is not allowed.
*/
 
#ifndef QU_GLOBAL_UTILS_H
#define QU_GLOBAL_UTILS_H
 
#include <type_traits>
#include <typeinfo>
#include <QByteArray>
#include "QtGlobal"
#include "quasarapp_global.h"
 
template <typename T>
constexpr inline T operator | (T lhs, T rhs)
{
 
    static_assert(std::is_enum<T>::value,
                  "template parameter is not an enum type");
 
    return static_cast<T>(static_cast<int>(lhs) | static_cast<int>(rhs));
}
 
template <typename T>
constexpr inline T operator & (T lhs, T rhs)
{
 
    static_assert(std::is_enum<T>::value,
                  "template parameter is not an enum type");
 
    return static_cast<T>(static_cast<int>(lhs) & static_cast<int>(rhs));
}
 
template <typename T>
constexpr inline T operator >> (T lhs, T rhs)
{
 
    static_assert(std::is_enum<T>::value,
                  "template parameter is not an enum type");
 
    return static_cast<T>(static_cast<int>(lhs) >> static_cast<int>(rhs));
}
 
template <typename T>
constexpr inline T operator << (T lhs, T rhs)
{
 
    static_assert(std::is_enum<T>::value,
                  "template parameter is not an enum type");
 
    return static_cast<T>(static_cast<int>(lhs) << static_cast<int>(rhs));
}
 
template <typename T>
constexpr inline T operator ~ (T lhs)
{
 
    static_assert(std::is_enum<T>::value,
                  "template parameter is not an enum type");
 
    return static_cast<T>(~static_cast<int>(lhs));
}
 
template <typename T>
constexpr inline T operator ^ (T lhs, T rhs)
{
 
    static_assert(std::is_enum<T>::value,
                  "template parameter is not an enum type");
 
    return static_cast<T>(static_cast<int>(lhs) ^ static_cast<int>(rhs));
}
 
template<class T>
uint32_t static_type_hash_32() noexcept {
    return typeid (T).hash_code();
};
 
template<class T>
uint16_t static_type_hash_16() noexcept {
    return typeid (T).hash_code() % 0xFFFF;
};
 
template<class T>
uint8_t static_type_hash_8() noexcept {
    return typeid (T).hash_code() % 0xFF;
};
 
template<class T>
uint32_t static_type_hash_32(T& object) noexcept {
    return typeid (object).hash_code();
};
 
template<class T>
uint16_t static_type_hash_16(T& object) noexcept {
    return typeid (object).hash_code() % 0xFFFF;
};
 
template<class T>
uint8_t static_type_hash_8(T& object) noexcept {
    return typeid (object).hash_code() % 0xFF;
};
 
#define H_8 static_type_hash_8
 
#define H_16 static_type_hash_16
 
#define H_32 static_type_hash_32
 
 
#define debug_assert(C, M) Q_ASSERT(C && M)
 
void QUASARAPPSHARED_EXPORT randomArray(int size, QByteArray &result);
 
#endif // GLOBAL_H