carray.hpp

#pragma once
 
#include "qbigint.hpp"
#include <QByteArray>
#include <QCryptographicHash>
#include <QDataStream>
#include <QIODevice>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonValue>
#include <set>
 
#include <QtCore/QtGlobal>
 
#if defined(WINDOWS_QBLOCK)
#define QBLOCK_EXPORT Q_DECL_EXPORT
#else
#define QBLOCK_EXPORT Q_DECL_IMPORT
#endif
 
namespace qiota
{
namespace qblocks
{
class c_array : public QByteArray
{
  public:
    using QByteArray::QByteArray;
    c_array(const QByteArray &var) : QByteArray(var.constData(), var.size()){};
    c_array(const QJsonValue &val);
    QString toHexString(void) const;
    static c_array fromHexString(QString hash);
    friend QDataStream &operator<<(QDataStream &out, const c_array &obj);
    friend QDataStream &operator>>(QDataStream &in, c_array &obj);
    template <class obj_type> void append(const obj_type &obj)
    {
        auto buffer = QDataStream(this, QIODevice::WriteOnly | QIODevice::Append);
        buffer.setByteOrder(QDataStream::LittleEndian);
        buffer << obj;
    }
    template <QCryptographicHash::Algorithm hashty> c_array hash(void) const
    {
        return c_array(QCryptographicHash::hash(*this, hashty));
    }
    template <class obj_type> void from_object(const obj_type &obj)
    {
        auto buffer = QDataStream(this, QIODevice::WriteOnly | QIODevice::Append);
        buffer.setByteOrder(QDataStream::LittleEndian);
        obj.serialize(buffer);
    }
    template <class obj_type> obj_type to_object(void)
    {
        auto buffer = QDataStream(this, QIODevice::ReadOnly);
        buffer.setByteOrder(QDataStream::LittleEndian);
        return obj_type(buffer);
    }
};
 
template <typename max_lenght> class fl_array : public c_array
{
  public:
    using c_array::c_array;
    friend QDataStream &operator<<(QDataStream &out, const fl_array &obj)
    {
 
        out << static_cast<max_lenght>(obj.size());
        out << static_cast<c_array>(obj);
        return out;
    }
    friend QDataStream &operator>>(QDataStream &in, fl_array &obj)
    {
        max_lenght size;
        in >> size;
        obj.resize(size);
        auto var = static_cast<c_array *>(&obj);
        in >> (*var);
 
        return in;
    }
};
 
using Block_ID = c_array;
using Transaction_ID = c_array;
 
using public_key = c_array;
using signature = c_array;
 
using NFT_ID = c_array;
using Alias_ID = c_array;
using Output_ID = c_array;
using Token_ID = c_array;
 
using dataf = fl_array<quint16>;
 
using dataF = fl_array<quint32>;
 
using tagF = fl_array<quint8>;
 
template <class T> using pvector = std::vector<std::shared_ptr<T>>;
 
template <class T> struct ptrLess
{
    bool operator()(const std::shared_ptr<T> &a, const std::shared_ptr<T> &b) const
    {
        return *a < *b;
    }
};
 
template <class T> using pset = std::set<std::shared_ptr<T>, ptrLess<T>>;
 
template <class T> pset<const T> get_T(const QJsonArray &val)
{
    pset<const T> var;
    for (const auto &v : val)
        var.insert(T::from_(v));
    return var;
}
template <class T> pvector<const T> get_Tvec(const QJsonArray &val)
{
    pvector<const T> var;
    for (const auto &v : val)
        var.push_back(T::from_(v));
    return var;
}
template <class type_type> type_type get_type(const QJsonValue &val)
{
    return ((type_type)val.toObject()["type"].toInt());
}
template <class type_type> type_type get_type(QDataStream &val)
{
    type_type type_;
    val >> type_;
    return type_;
}
 
template <class size_type, class obj_type> void serializeList(QDataStream &out, const pset<const obj_type> &ptrSet)
{
    out << static_cast<size_type>(ptrSet.size());
    for (const auto &v : ptrSet)
        v->serialize(out);
}
template <class size_type, class obj_type> pset<const obj_type> deserializeList(QDataStream &in)
{
    pset<const obj_type> ptrSet;
    size_type length_;
    in >> length_;
    for (auto i = 0; i < length_; i++)
    {
        ptrSet.insert(obj_type::template from_<QDataStream>(in));
    }
    return ptrSet;
}
template <class obj_type> void orderList(pvector<obj_type> &ptrVector)
{
    std::sort(ptrVector.begin(), ptrVector.end(), [](auto a, auto b) { return *a < *b; });
}
 
}; // namespace qblocks
 
}; // namespace qiota