qaglobalutils.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018-2026 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);
 

template <class QHashType>
QHashType &subtract(QHashType &left, const QHashType& right) {
    if (left.isSharedWith(right)) {
        left.clear();
    } else {
        for (auto&& it =  right.begin(); it != right.end(); ++it)
            left.remove(it.key());
    }
    return left;
}

template <class QHashType>
QHashType &unite(QHashType &left, const QHashType& right) {
    if (!left.isSharedWith(right)) {
        for (auto&& it =  right.begin(); it != right.end(); ++it)
            left.insert(it.key(), it.value());
    }
    return left;
}

template <class QHashType>
QHashType &match(QHashType &left, const QHashType& right) {
    if (!left.isSharedWith(right)) {
        for (auto&& it =  left.begin(); it != left.end(); ) {
            if (!right.contains(it.key())) {
                it = left.erase(it);
            } else {
                ++it;
            }
        }
 
        return left;
    }
 
    left.clear();
    return left;
}
 
 
#endif // GLOBAL_H