migrate(Lts/Common): apply clang-tidy modernization fixes\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
torsten committed
1 parent
6822817a63
commit
acee7b8766
8 files changed
+1216
-1568
No files matched your search
Executable → Regular
+99
-126
@@ -1,126 +1,99 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <QObject>
|
||||
#include <QMetaObject>
|
||||
#include <QPointer>
|
||||
#include <QtGlobal>
|
||||
#include <type_traits>
|
||||
|
||||
|
||||
namespace LtsUtils
|
||||
{
|
||||
|
||||
|
||||
|
||||
class IConnection
|
||||
{
|
||||
public:
|
||||
virtual ~IConnection() = default;
|
||||
virtual void connect(Qt::ConnectionType = Qt::AutoConnection) = 0;
|
||||
virtual void disconnect() = 0;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
class DummyConnection : public IConnection
|
||||
{
|
||||
public:
|
||||
void connect(Qt::ConnectionType = Qt::AutoConnection) override {}
|
||||
void disconnect() override {}
|
||||
};
|
||||
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
|
||||
|
||||
template<class T>
|
||||
struct ExtractClass;
|
||||
|
||||
|
||||
|
||||
template<class T, class Member>
|
||||
struct ExtractClass<Member T::*>
|
||||
{
|
||||
using type = T;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
template<class Signal, class Slot>
|
||||
class Connection : public IConnection
|
||||
{
|
||||
static_assert(std::is_member_function_pointer<Signal>::value, "Must be a pointer to method");
|
||||
static_assert(std::is_member_function_pointer<Slot>::value, "Must be a pointer to method");
|
||||
|
||||
using Emitter = typename detail::ExtractClass<Signal>::type;
|
||||
using Target = typename detail::ExtractClass<Slot>::type;
|
||||
|
||||
static_assert(std::is_base_of<QObject, Emitter>::value, "Must be derived from QObject");
|
||||
static_assert(std::is_base_of<QObject, Target>::value, "Must be derived from QObject");
|
||||
|
||||
public:
|
||||
Connection(Emitter *emitter, Signal signal, Target *target, Slot slot):
|
||||
m_emitter(emitter),
|
||||
m_signal(signal),
|
||||
m_target(target),
|
||||
m_slot(slot)
|
||||
{
|
||||
Q_ASSERT(emitter);
|
||||
Q_ASSERT(signal);
|
||||
Q_ASSERT(target);
|
||||
Q_ASSERT(slot);
|
||||
}
|
||||
|
||||
void connect(Qt::ConnectionType connectionType = Qt::AutoConnection) override
|
||||
{
|
||||
Q_ASSERT(!m_connected);
|
||||
|
||||
m_connected = true;
|
||||
|
||||
|
||||
|
||||
if (!m_emitter || !m_target)
|
||||
return;
|
||||
|
||||
m_conn = QObject::connect(m_emitter.data(), m_signal, m_target.data(), m_slot, connectionType);
|
||||
Q_ASSERT(m_conn);
|
||||
}
|
||||
|
||||
void disconnect() override
|
||||
{
|
||||
Q_ASSERT(m_connected);
|
||||
|
||||
if (m_conn)
|
||||
QObject::disconnect(m_conn);
|
||||
|
||||
m_connected = false;
|
||||
}
|
||||
|
||||
private:
|
||||
bool m_connected{false};
|
||||
QPointer<Emitter> m_emitter;
|
||||
Signal m_signal;
|
||||
QPointer<Target> m_target;
|
||||
Slot m_slot;
|
||||
QMetaObject::Connection m_conn;
|
||||
};
|
||||
|
||||
|
||||
|
||||
template<class Signal, class Slot>
|
||||
Connection<Signal, Slot>* createConnection(typename detail::ExtractClass<Signal>::type *emitter, Signal signal,
|
||||
typename detail::ExtractClass<Slot>::type *target, Slot slot)
|
||||
{
|
||||
return new Connection<Signal, Slot>(emitter, signal, target, slot);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <QMetaObject>
|
||||
#include <QObject>
|
||||
#include <QPointer>
|
||||
#include <QtGlobal>
|
||||
#include <type_traits>
|
||||
|
||||
namespace LtsUtils {
|
||||
|
||||
class IConnection {
|
||||
public:
|
||||
virtual ~IConnection() = default;
|
||||
virtual void connect(Qt::ConnectionType = Qt::AutoConnection) = 0;
|
||||
virtual void disconnect() = 0;
|
||||
};
|
||||
|
||||
class DummyConnection : public IConnection {
|
||||
public:
|
||||
void connect(Qt::ConnectionType = Qt::AutoConnection) override {}
|
||||
void disconnect() override {}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
template <class T> struct ExtractClass;
|
||||
|
||||
template <class T, class Member> struct ExtractClass<Member T::*> {
|
||||
using type = T;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <class Signal, class Slot> class Connection : public IConnection {
|
||||
static_assert(std::is_member_function_pointer_v<Signal>,
|
||||
"Must be a pointer to method");
|
||||
static_assert(std::is_member_function_pointer_v<Slot>,
|
||||
"Must be a pointer to method");
|
||||
|
||||
using Emitter = typename detail::ExtractClass<Signal>::type;
|
||||
using Target = typename detail::ExtractClass<Slot>::type;
|
||||
|
||||
static_assert(std::is_base_of_v<QObject, Emitter>,
|
||||
"Must be derived from QObject");
|
||||
static_assert(std::is_base_of_v<QObject, Target>,
|
||||
"Must be derived from QObject");
|
||||
|
||||
public:
|
||||
Connection(Emitter *emitter, Signal signal, Target *target, Slot slot)
|
||||
: m_emitter(emitter), m_signal(signal), m_target(target), m_slot(slot) {
|
||||
Q_ASSERT(emitter);
|
||||
Q_ASSERT(signal);
|
||||
Q_ASSERT(target);
|
||||
Q_ASSERT(slot);
|
||||
}
|
||||
|
||||
void
|
||||
connect(Qt::ConnectionType connectionType = Qt::AutoConnection) override {
|
||||
Q_ASSERT(!m_connected);
|
||||
|
||||
m_connected = true;
|
||||
|
||||
if (!m_emitter || !m_target)
|
||||
return;
|
||||
|
||||
m_conn = QObject::connect(m_emitter.data(), m_signal, m_target.data(),
|
||||
m_slot, connectionType);
|
||||
Q_ASSERT(m_conn);
|
||||
}
|
||||
|
||||
void disconnect() override {
|
||||
Q_ASSERT(m_connected);
|
||||
|
||||
if (m_conn)
|
||||
QObject::disconnect(m_conn);
|
||||
|
||||
m_connected = false;
|
||||
}
|
||||
|
||||
private:
|
||||
bool m_connected{false};
|
||||
QPointer<Emitter> m_emitter;
|
||||
Signal m_signal;
|
||||
QPointer<Target> m_target;
|
||||
Slot m_slot;
|
||||
QMetaObject::Connection m_conn;
|
||||
};
|
||||
|
||||
template <class Signal, class Slot>
|
||||
Connection<Signal, Slot> *
|
||||
createConnection(typename detail::ExtractClass<Signal>::type *emitter,
|
||||
Signal signal,
|
||||
typename detail::ExtractClass<Slot>::type *target, Slot slot) {
|
||||
return new Connection<Signal, Slot>(emitter, signal, target, slot);
|
||||
}
|
||||
|
||||
} // namespace LtsUtils
|
||||
Executable → Regular
+35
-43
@@ -1,43 +1,35 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <QByteArray>
|
||||
#include <QString>
|
||||
|
||||
namespace LtsUtils
|
||||
{
|
||||
|
||||
template <typename T, typename S>
|
||||
inline void convert(const S &in, T &out)
|
||||
{
|
||||
static_assert(!std::is_same<S, T>::value, "Try to convert a type to the same type - is useless");
|
||||
out.reserve(static_cast<int>(in.size()));
|
||||
std::copy(in.begin(), in.end(), std::back_inserter(out));
|
||||
}
|
||||
|
||||
template <typename T, typename S>
|
||||
inline T convert(const S &in)
|
||||
{
|
||||
static_assert(!std::is_same<S, T>::value, "Try to convert a type to the same type - is useless");
|
||||
T out;
|
||||
convert(in, out);
|
||||
return out;
|
||||
}
|
||||
|
||||
|
||||
template <typename T>
|
||||
inline QByteArray toQByteArray(const T &in)
|
||||
{
|
||||
return convert<QByteArray>(in);
|
||||
}
|
||||
|
||||
template <typename T, typename V = typename T::value_type>
|
||||
bool isInVector(const T &vec, const V &valueToSearch)
|
||||
{
|
||||
const auto end = vec.end();
|
||||
return std::find(vec.begin(), end, valueToSearch) != end;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <QByteArray>
|
||||
#include <QString>
|
||||
|
||||
namespace LtsUtils {
|
||||
|
||||
template <typename T, typename S> inline void convert(const S &in, T &out) {
|
||||
static_assert(!std::is_same_v<S, T>,
|
||||
"Try to convert a type to the same type - is useless");
|
||||
out.reserve(static_cast<int>(in.size()));
|
||||
std::copy(in.begin(), in.end(), std::back_inserter(out));
|
||||
}
|
||||
|
||||
template <typename T, typename S> inline T convert(const S &in) {
|
||||
static_assert(!std::is_same_v<S, T>,
|
||||
"Try to convert a type to the same type - is useless");
|
||||
T out;
|
||||
convert(in, out);
|
||||
return out;
|
||||
}
|
||||
|
||||
template <typename T> inline QByteArray toQByteArray(const T &in) {
|
||||
return convert<QByteArray>(in);
|
||||
}
|
||||
|
||||
template <typename T, typename V = typename T::value_type>
|
||||
bool isInVector(const T &vec, const V &valueToSearch) {
|
||||
const auto end = vec.end();
|
||||
return std::find(vec.begin(), end, valueToSearch) != end;
|
||||
}
|
||||
|
||||
} // namespace LtsUtils
|
||||
Executable → Regular
+519
-696
File diff suppressed because it is too large.
Load diff
Executable → Regular
+34
-45
@@ -1,45 +1,34 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
#include <QString>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <cstdint>
|
||||
|
||||
namespace LtsUtils
|
||||
{
|
||||
|
||||
template<typename T, typename C>
|
||||
class PgArray
|
||||
{
|
||||
public:
|
||||
using Type = T;
|
||||
using ContainerType = C;
|
||||
|
||||
PgArray() = default;
|
||||
Q_DECL_CONSTEXPR explicit PgArray(const C &data)
|
||||
: m_data(data)
|
||||
{}
|
||||
|
||||
Q_DECL_CONSTEXPR C operator()()const
|
||||
{
|
||||
return m_data;
|
||||
}
|
||||
|
||||
QString toPgString() const;
|
||||
static PgArray fromPgString(const QString &str);
|
||||
private:
|
||||
C m_data;
|
||||
};
|
||||
|
||||
|
||||
|
||||
using IntArray = PgArray<int, std::vector<int>>;
|
||||
using BigintArray = PgArray<int64_t, std::vector<int64_t>>;
|
||||
|
||||
|
||||
using IntArray2D = PgArray<int, std::map<int, int>>;
|
||||
using BigintArray2D = PgArray<int64_t, std::map<int64_t, int64_t>>;
|
||||
|
||||
}
|
||||
|
||||
|
||||
#pragma once
|
||||
#include <QString>
|
||||
#include <cstdint>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
namespace LtsUtils {
|
||||
|
||||
template <typename T, typename C> class PgArray {
|
||||
public:
|
||||
using Type = T;
|
||||
using ContainerType = C;
|
||||
|
||||
PgArray() = default;
|
||||
Q_DECL_CONSTEXPR explicit PgArray(const C &data) : m_data(data) {}
|
||||
|
||||
Q_DECL_CONSTEXPR C operator()() const { return m_data; }
|
||||
|
||||
[[nodiscard]] QString toPgString() const;
|
||||
static PgArray fromPgString(const QString &str);
|
||||
|
||||
private:
|
||||
C m_data;
|
||||
};
|
||||
|
||||
using IntArray = PgArray<int, std::vector<int>>;
|
||||
using BigintArray = PgArray<int64_t, std::vector<int64_t>>;
|
||||
|
||||
using IntArray2D = PgArray<int, std::map<int, int>>;
|
||||
using BigintArray2D = PgArray<int64_t, std::map<int64_t, int64_t>>;
|
||||
|
||||
} // namespace LtsUtils
|
||||
Executable → Regular
+54
-70
@@ -1,70 +1,54 @@
|
||||
#pragma once
|
||||
|
||||
|
||||
#include <QObject>
|
||||
|
||||
|
||||
namespace LtsUtils
|
||||
{
|
||||
|
||||
|
||||
class PromiseExample1_Class : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
using QObject::QObject;
|
||||
|
||||
void doSomethingAsync1();
|
||||
void doSomethingAsync2();
|
||||
|
||||
signals:
|
||||
void signalDone1(bool didThisWork);
|
||||
void signalDone2(bool didThisWork, int someNumberThatReturns);
|
||||
};
|
||||
|
||||
|
||||
class PromiseExample1 : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit PromiseExample1(QObject *parent = nullptr);
|
||||
|
||||
bool isSuccess() const { return m_success; }
|
||||
|
||||
private:
|
||||
bool m_success;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
class PromiseExample2 : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit PromiseExample2(QObject *parent = nullptr);
|
||||
|
||||
bool isSuccess() const { return m_success; }
|
||||
|
||||
private:
|
||||
bool m_success;
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
class PromiseExample3 : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit PromiseExample3(QObject *parent = nullptr);
|
||||
|
||||
bool isSuccess() const { return m_success; }
|
||||
|
||||
private:
|
||||
bool m_success;
|
||||
bool m_alreadyRejected;
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
#pragma once
|
||||
|
||||
#include <QObject>
|
||||
|
||||
namespace LtsUtils {
|
||||
|
||||
class PromiseExample1_Class : public QObject {
|
||||
Q_OBJECT
|
||||
public:
|
||||
using QObject::QObject;
|
||||
|
||||
void doSomethingAsync1();
|
||||
void doSomethingAsync2();
|
||||
|
||||
signals:
|
||||
void signalDone1(bool didThisWork);
|
||||
void signalDone2(bool didThisWork, int someNumberThatReturns);
|
||||
};
|
||||
|
||||
class PromiseExample1 : public QObject {
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit PromiseExample1(QObject *parent = nullptr);
|
||||
|
||||
[[nodiscard]] bool isSuccess() const { return m_success; }
|
||||
|
||||
private:
|
||||
bool m_success;
|
||||
};
|
||||
|
||||
class PromiseExample2 : public QObject {
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit PromiseExample2(QObject *parent = nullptr);
|
||||
|
||||
[[nodiscard]] bool isSuccess() const { return m_success; }
|
||||
|
||||
private:
|
||||
bool m_success;
|
||||
};
|
||||
|
||||
class PromiseExample3 : public QObject {
|
||||
Q_OBJECT
|
||||
public:
|
||||
explicit PromiseExample3(QObject *parent = nullptr);
|
||||
|
||||
[[nodiscard]] bool isSuccess() const { return m_success; }
|
||||
|
||||
private:
|
||||
bool m_success;
|
||||
bool m_alreadyRejected;
|
||||
};
|
||||
|
||||
} // namespace LtsUtils
|
||||
Executable → Regular
+241
-282
@@ -1,282 +1,241 @@
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <QtCore/QByteArray>
|
||||
#include <limits>
|
||||
|
||||
namespace LtsUtils
|
||||
{
|
||||
|
||||
|
||||
|
||||
template<typename T>
|
||||
void inline set8Byte(const T in, QByteArray& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
out += (in & 0xFF00000000000000UL) >> 56;
|
||||
out += (in & 0x00FF000000000000UL) >> 48;
|
||||
out += (in & 0x0000FF0000000000UL) >> 40;
|
||||
out += (in & 0x000000FF00000000UL) >> 32;
|
||||
out += (in & 0x00000000FF000000UL) >> 24;
|
||||
out += (in & 0x0000000000FF0000UL) >> 16;
|
||||
out += (in & 0x000000000000FF00UL) >> 8;
|
||||
out += (in & 0x00000000000000FFUL);
|
||||
}
|
||||
|
||||
template<>
|
||||
void inline set8Byte(const double in, QByteArray &out)
|
||||
{
|
||||
union hack
|
||||
{
|
||||
double d;
|
||||
int64_t i;
|
||||
} h;
|
||||
h.d = in;
|
||||
set8Byte(h.i, out);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get8Byte(const QByteArray& baData,
|
||||
size_t &pos,
|
||||
T& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
static_assert(sizeof(T) >= 8, "sizeof(out) is smaller than 8 bytes - will not fit");
|
||||
out = T();
|
||||
|
||||
if(size_t(baData.size()) < pos + 8)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if(std::numeric_limits<T>::is_signed)
|
||||
out |= static_cast<signed long long>(data[0]) << 56;
|
||||
else
|
||||
out |= (data[0] & 0xFFULL) << 56;
|
||||
out |= (data[1] & 0xFFULL) << 48;
|
||||
out |= (data[2] & 0xFFULL) << 40;
|
||||
out |= (data[3] & 0xFFULL) << 32;
|
||||
out |= (data[4] & 0xFFULL) << 24;
|
||||
out |= (data[5] & 0xFFULL) << 16;
|
||||
out |= (data[6] & 0xFFULL) << 8;
|
||||
out |= (data[7] & 0xFFULL);
|
||||
|
||||
pos += 8;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<>
|
||||
bool inline get8Byte(const QByteArray& baData,
|
||||
size_t &pos,
|
||||
double& out)
|
||||
{
|
||||
out = 0.;
|
||||
union hack
|
||||
{
|
||||
double d;
|
||||
int64_t i;
|
||||
} h;
|
||||
if (!get8Byte(baData, pos, h.i))
|
||||
return false;
|
||||
out = h.d;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get8Byte(const QByteArray& data, T& out)
|
||||
{
|
||||
size_t pos = 0;
|
||||
return get8Byte(data, pos, out);
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
void inline set4Byte(const T in, QByteArray& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
out += (in & 0xFF000000) >> 24;
|
||||
out += (in & 0x00FF0000) >> 16;
|
||||
out += (in & 0x0000FF00) >> 8;
|
||||
out += (in & 0x000000FF);
|
||||
}
|
||||
|
||||
template<>
|
||||
void inline set4Byte(const double in, QByteArray& out)
|
||||
{
|
||||
int tmp = qRound(in);
|
||||
return set4Byte(tmp, out);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get4Byte(const QByteArray& baData,
|
||||
size_t &pos,
|
||||
T& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
static_assert(sizeof(T) >= 4, "sizeof(out) is smaller than 4 bytes - will not fit");
|
||||
out = T();
|
||||
|
||||
if(size_t(baData.size()) < pos + 4)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if(std::numeric_limits<T>::is_signed)
|
||||
out |= data[0] << 24;
|
||||
else
|
||||
out |= (data[0] & 0xFFU) << 24;
|
||||
out |= (data[1] & 0xFFU) << 16;
|
||||
out |= (data[2] & 0xFFU) << 8;
|
||||
out |= (data[3] & 0xFFU);
|
||||
|
||||
pos += 4;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<>
|
||||
bool inline get4Byte(const QByteArray& baData,
|
||||
size_t &pos,
|
||||
double& out)
|
||||
{
|
||||
out = 0.;
|
||||
int tmp;
|
||||
if(!get4Byte(baData, pos, tmp))
|
||||
return false;
|
||||
out = tmp;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get4Byte(const QByteArray& data, T& out)
|
||||
{
|
||||
size_t pos = 0;
|
||||
return get4Byte(data, pos, out);
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
void inline set3Byte(const T in, QByteArray& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
out += (in & 0x00FF0000) >> 16;
|
||||
out += (in & 0x0000FF00) >> 8;
|
||||
out += (in & 0x000000FF);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get3Byte(const QByteArray& baData,
|
||||
size_t &pos,
|
||||
T& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
static_assert(sizeof(T) >= 3, "sizeof(out) is smaller than 3 bytes - will not fit");
|
||||
out = T();
|
||||
|
||||
if(size_t(baData.size()) < pos + 3)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if(std::numeric_limits<T>::is_signed)
|
||||
out |= data[0] << 16;
|
||||
else
|
||||
out |= (data[0] & 0xFFU) << 16;
|
||||
out |= (data[1] & 0xFFU) << 8;
|
||||
out |= (data[2] & 0xFFU);
|
||||
|
||||
pos += 3;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get3Byte(const QByteArray& data, T& out)
|
||||
{
|
||||
size_t pos = 0;
|
||||
return get3Byte(data, pos, out);
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
void inline set2Byte(const T in, QByteArray& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
out += (in & 0x0000FF00) >> 8;
|
||||
out += (in & 0x000000FF);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get2Byte(const QByteArray& baData,
|
||||
size_t &pos,
|
||||
T& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
static_assert(sizeof(T) >= 2, "sizeof(out) is smaller than 2 bytes - will not fit");
|
||||
out = T();
|
||||
|
||||
if(size_t(baData.size()) < pos + 2)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if(std::numeric_limits<T>::is_signed)
|
||||
out |= data[0] << 8;
|
||||
else
|
||||
out |= (data[0] & 0xFFU) << 8;
|
||||
out |= data[1] & 0xFFU;
|
||||
|
||||
pos += 2;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get2Byte(const QByteArray& data, T& out)
|
||||
{
|
||||
size_t pos = 0;
|
||||
return get2Byte(data, pos, out);
|
||||
}
|
||||
|
||||
|
||||
template<typename T>
|
||||
void inline set1Byte(const T in, QByteArray& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
unsigned char c = in;
|
||||
out += c;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get1Byte(const QByteArray& baData,
|
||||
size_t &pos,
|
||||
T& out)
|
||||
{
|
||||
static_assert(std::is_integral<T>::value || std::is_enum<T>::value, "Only integrals allowed for raw byte accessd");
|
||||
out = T();
|
||||
|
||||
if(size_t(baData.size()) < pos + 1)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if(std::numeric_limits<T>::is_signed)
|
||||
out = (T)(data[0]);
|
||||
else
|
||||
out = (T)(data[0] & 0xFF);
|
||||
|
||||
pos += 1;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool inline get1Byte(const QByteArray& data, T& out)
|
||||
{
|
||||
size_t pos = 0;
|
||||
return get1Byte(data, pos, out);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <QtCore/QByteArray>
|
||||
#include <limits>
|
||||
|
||||
namespace LtsUtils {
|
||||
|
||||
template <typename T> void inline set8Byte(const T in, QByteArray &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
out += (in & 0xFF00000000000000UL) >> 56;
|
||||
out += (in & 0x00FF000000000000UL) >> 48;
|
||||
out += (in & 0x0000FF0000000000UL) >> 40;
|
||||
out += (in & 0x000000FF00000000UL) >> 32;
|
||||
out += (in & 0x00000000FF000000UL) >> 24;
|
||||
out += (in & 0x0000000000FF0000UL) >> 16;
|
||||
out += (in & 0x000000000000FF00UL) >> 8;
|
||||
out += (in & 0x00000000000000FFUL);
|
||||
}
|
||||
|
||||
template <> void inline set8Byte(const double in, QByteArray &out) {
|
||||
union hack {
|
||||
double d;
|
||||
int64_t i;
|
||||
} h;
|
||||
h.d = in;
|
||||
set8Byte(h.i, out);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool inline get8Byte(const QByteArray &baData, size_t &pos, T &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
static_assert(sizeof(T) >= 8,
|
||||
"sizeof(out) is smaller than 8 bytes - will not fit");
|
||||
out = T();
|
||||
|
||||
if (size_t(baData.size()) < pos + 8)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if (std::numeric_limits<T>::is_signed)
|
||||
out |= static_cast<signed long long>(data[0]) << 56;
|
||||
else
|
||||
out |= (data[0] & 0xFFULL) << 56;
|
||||
out |= (data[1] & 0xFFULL) << 48;
|
||||
out |= (data[2] & 0xFFULL) << 40;
|
||||
out |= (data[3] & 0xFFULL) << 32;
|
||||
out |= (data[4] & 0xFFULL) << 24;
|
||||
out |= (data[5] & 0xFFULL) << 16;
|
||||
out |= (data[6] & 0xFFULL) << 8;
|
||||
out |= (data[7] & 0xFFULL);
|
||||
|
||||
pos += 8;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <>
|
||||
bool inline get8Byte(const QByteArray &baData, size_t &pos, double &out) {
|
||||
out = 0.;
|
||||
union hack {
|
||||
double d;
|
||||
int64_t i;
|
||||
} h;
|
||||
if (!get8Byte(baData, pos, h.i))
|
||||
return false;
|
||||
out = h.d;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T> bool inline get8Byte(const QByteArray &data, T &out) {
|
||||
size_t pos = 0;
|
||||
return get8Byte(data, pos, out);
|
||||
}
|
||||
|
||||
template <typename T> void inline set4Byte(const T in, QByteArray &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
out += (in & 0xFF000000) >> 24;
|
||||
out += (in & 0x00FF0000) >> 16;
|
||||
out += (in & 0x0000FF00) >> 8;
|
||||
out += (in & 0x000000FF);
|
||||
}
|
||||
|
||||
template <> void inline set4Byte(const double in, QByteArray &out) {
|
||||
int tmp = qRound(in);
|
||||
return set4Byte(tmp, out);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool inline get4Byte(const QByteArray &baData, size_t &pos, T &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
static_assert(sizeof(T) >= 4,
|
||||
"sizeof(out) is smaller than 4 bytes - will not fit");
|
||||
out = T();
|
||||
|
||||
if (size_t(baData.size()) < pos + 4)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if (std::numeric_limits<T>::is_signed)
|
||||
out |= data[0] << 24;
|
||||
else
|
||||
out |= (data[0] & 0xFFU) << 24;
|
||||
out |= (data[1] & 0xFFU) << 16;
|
||||
out |= (data[2] & 0xFFU) << 8;
|
||||
out |= (data[3] & 0xFFU);
|
||||
|
||||
pos += 4;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <>
|
||||
bool inline get4Byte(const QByteArray &baData, size_t &pos, double &out) {
|
||||
out = 0.;
|
||||
int tmp;
|
||||
if (!get4Byte(baData, pos, tmp))
|
||||
return false;
|
||||
out = tmp;
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T> bool inline get4Byte(const QByteArray &data, T &out) {
|
||||
size_t pos = 0;
|
||||
return get4Byte(data, pos, out);
|
||||
}
|
||||
|
||||
template <typename T> void inline set3Byte(const T in, QByteArray &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
out += (in & 0x00FF0000) >> 16;
|
||||
out += (in & 0x0000FF00) >> 8;
|
||||
out += (in & 0x000000FF);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool inline get3Byte(const QByteArray &baData, size_t &pos, T &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
static_assert(sizeof(T) >= 3,
|
||||
"sizeof(out) is smaller than 3 bytes - will not fit");
|
||||
out = T();
|
||||
|
||||
if (size_t(baData.size()) < pos + 3)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if (std::numeric_limits<T>::is_signed)
|
||||
out |= data[0] << 16;
|
||||
else
|
||||
out |= (data[0] & 0xFFU) << 16;
|
||||
out |= (data[1] & 0xFFU) << 8;
|
||||
out |= (data[2] & 0xFFU);
|
||||
|
||||
pos += 3;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T> bool inline get3Byte(const QByteArray &data, T &out) {
|
||||
size_t pos = 0;
|
||||
return get3Byte(data, pos, out);
|
||||
}
|
||||
|
||||
template <typename T> void inline set2Byte(const T in, QByteArray &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
out += (in & 0x0000FF00) >> 8;
|
||||
out += (in & 0x000000FF);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool inline get2Byte(const QByteArray &baData, size_t &pos, T &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
static_assert(sizeof(T) >= 2,
|
||||
"sizeof(out) is smaller than 2 bytes - will not fit");
|
||||
out = T();
|
||||
|
||||
if (size_t(baData.size()) < pos + 2)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if (std::numeric_limits<T>::is_signed)
|
||||
out |= data[0] << 8;
|
||||
else
|
||||
out |= (data[0] & 0xFFU) << 8;
|
||||
out |= data[1] & 0xFFU;
|
||||
|
||||
pos += 2;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T> bool inline get2Byte(const QByteArray &data, T &out) {
|
||||
size_t pos = 0;
|
||||
return get2Byte(data, pos, out);
|
||||
}
|
||||
|
||||
template <typename T> void inline set1Byte(const T in, QByteArray &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
unsigned char c = in;
|
||||
out += c;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
bool inline get1Byte(const QByteArray &baData, size_t &pos, T &out) {
|
||||
static_assert(std::is_integral_v<T> || std::is_enum_v<T>,
|
||||
"Only integrals allowed for raw byte accessd");
|
||||
out = T();
|
||||
|
||||
if (size_t(baData.size()) < pos + 1)
|
||||
return false;
|
||||
|
||||
const char *data = baData.data() + pos;
|
||||
|
||||
if (std::numeric_limits<T>::is_signed)
|
||||
out = (T)(data[0]);
|
||||
else
|
||||
out = (T)(data[0] & 0xFF);
|
||||
|
||||
pos += 1;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T> bool inline get1Byte(const QByteArray &data, T &out) {
|
||||
size_t pos = 0;
|
||||
return get1Byte(data, pos, out);
|
||||
}
|
||||
} // namespace LtsUtils
|
||||
Reference in new issue
Block a user