rust-qt-binding-generator/demo/src/tmp.cpp

/* generated by rust_qt_binding_generator */
#include "tmp.h"
#include <QModelIndex>

namespace {
    struct qbytearray_t {
    private:
        const char* data;
        int len;
    public:
        qbytearray_t(const QByteArray& v):
            data(v.data()),
            len(v.size()) {
        }
        operator QByteArray() const {
            return QByteArray(data, len);
        }
    };
    struct qstring_t {
    private:
        const void* data;
        int len;
    public:
        qstring_t(const QString& v):
            data(static_cast<const void*>(v.utf16())),
            len(v.size()) {
        }
        operator QString() const {
            return QString::fromUtf8(static_cast<const char*>(data), len);
        }
    };
    struct qmodelindex_t {
        int row;
        int column;
        uint64_t id;
        qmodelindex_t(const QModelIndex& m):
           row(m.row()), column(m.column()), id(m.internalId()) {}
    };
    struct qvariant_t {
        unsigned int type;
        int value;
        const char* data;
    };
    QVariant variant(const qvariant_t& v) {
        switch (v.type) {
            case QVariant::String: return QString::fromUtf8(static_cast<const char*>(v.data), v.value);
            case QVariant::Bool: return QVariant((bool)v.value);
            case QVariant::Int: return QVariant(v.value);
            case QVariant::ByteArray: return QVariant(QByteArray(v.data, v.value));
            default:;
        }
        return QVariant();
    }
    void variant(const QByteArray& v, void* d, void (*set)(void*, qvariant_t)) {
        set(d, {
            .type = QVariant::ByteArray,
            .value = v.length(),
            .data = v.data()
        });
    }
    void variant(const QString& v, void* d, void (*set)(void*, qvariant_t)) {
        set(d, {
            .type = QVariant::String,
            .value = v.size(),
            .data = static_cast<const char*>(static_cast<const void*>(v.utf16()))
        });
    }
    void variant(const QVariant& v, void* d, void (*set)(void*, qvariant_t)) {
        switch (v.type()) {
            case QVariant::Bool:
                set(d, {
                    .type = QVariant::Bool,
                    .value = v.toBool(),
                    .data = 0
                });
                break;
            case QVariant::Int:
                set(d, {
                    .type = QVariant::Int,
                    .value = v.toInt(),
                    .data = 0
                });
                break;
            case QVariant::ByteArray:
                variant(v.toByteArray(), d, set);
                break;
            case QVariant::String:
                variant(v.toString(), d, set);
                break;
            default:
                set(d, {
                    .type = QVariant::Invalid,
                    .value = 0,
                    .data = 0
                });
        }
    }
}
typedef void (*qstring_set)(QString*, qstring_t*);
void set_qstring(QString* v, qstring_t* val) {
    *v = *val;
}
typedef void (*qbytearray_set)(QByteArray*, qbytearray_t*);
void set_qbytearray(QByteArray* v, qbytearray_t* val) {
    *v = *val;
}
typedef void (*qvariant_set)(QVariant*, qvariant_t*);
void set_qvariant(QVariant* v, qvariant_t* val) {
    *v = variant(*val);
}

extern "C" {
    PersonInterface* person_new(Person*, void (*)(Person*), void (*)(Person*), void (*)(Person*), void (*)(Person*), void (*)(Person*));
    void person_free(PersonInterface*);
    void person_user_name_get(PersonInterface*, QString*, qstring_set);
    void person_user_name_set(void*, qstring_t);
    int person_age_get(PersonInterface*);
    bool person_active_get(PersonInterface*);
    void person_active_set(void*, bool);
    void person_misc_get(PersonInterface*, QVariant*, qvariant_set);
    void person_misc_set(void*, qvariant_t);
    void person_icon_get(PersonInterface*, QByteArray*, qbytearray_set);
    void person_icon_set(void*, qbytearray_t);
    DirectoryInterface* directory_new(Directory*, void (*)(Directory*),
        void (*)(Directory*, int, int),
        void (*)(Directory*),
        void (*)(Directory*, int, int),
        void (*)(Directory*));
    void directory_free(DirectoryInterface*);
    void directory_path_get(DirectoryInterface*, QString*, qstring_set);
    void directory_path_set(void*, qstring_t);
};
Person::Person(QObject *parent):
    QObject(parent),
    d(person_new(this,
        [](Person* o) { emit o->userNameChanged(); },
        [](Person* o) { emit o->ageChanged(); },
        [](Person* o) { emit o->activeChanged(); },
        [](Person* o) { emit o->miscChanged(); },
        [](Person* o) { emit o->iconChanged(); })) {}

Person::~Person() {
    person_free(d);
}
QString Person::userName() const
{
    QString v;
    person_user_name_get(d, &v, set_qstring);
    return v;
}
void Person::setUserName(const QString& v) {
    person_user_name_set(d, v);
}
int Person::age() const
{
    return person_age_get(d);
}
bool Person::active() const
{
    return person_active_get(d);
}
void Person::setActive(bool v) {
    person_active_set(d, v);
}
QVariant Person::misc() const
{
    QVariant v;
    person_misc_get(d, &v, set_qvariant);
    return v;
}
void Person::setMisc(const QVariant& v) {
    variant(v, d, person_misc_set);
}
QByteArray Person::icon() const
{
    QByteArray v;
    person_icon_get(d, &v, set_qbytearray);
    return v;
}
void Person::setIcon(const QByteArray& v) {
    person_icon_set(d, v);
}
Directory::Directory(QObject *parent):
    QAbstractItemModel(parent),
    d(directory_new(this,
        [](Directory* o) { emit o->pathChanged(); },
        [](Directory* o, int first, int last) {
            emit o->beginInsertRows(QModelIndex(), first, last);
        },
        [](Directory* o) {
            emit o->endInsertRows();
        },
        [](Directory* o, int first, int last) {
            emit o->beginRemoveRows(QModelIndex(), first, last);
        },
        [](Directory* o) {
            emit o->endRemoveRows();
        }
)) {}

Directory::~Directory() {
    directory_free(d);
}
QString Directory::path() const
{
    QString v;
    directory_path_get(d, &v, set_qstring);
    return v;
}
void Directory::setPath(const QString& v) {
    directory_path_set(d, v);
}
enum DirectoryRole {
    DirectoryRoleFileIcon = Qt::DecorationRole,
    DirectoryRoleFilePath = Qt::UserRole + 1,
    DirectoryRoleFileName = Qt::UserRole + 2,
    DirectoryRoleFilePermissions = Qt::UserRole + 3,
};

extern "C" {
    void directory_data_file_icon(DirectoryInterface*, int, QVariant*, qvariant_set);
    void directory_data_file_path(DirectoryInterface*, int, QVariant*, qvariant_set);
    void directory_data_file_name(DirectoryInterface*, int, QVariant*, qvariant_set);
    void directory_data_file_permissions(DirectoryInterface*, int, QVariant*, qvariant_set);

    int directory_row_count(DirectoryInterface*);
    bool directory_can_fetch_more(DirectoryInterface*);
    void directory_fetch_more(DirectoryInterface*);
}
int Directory::columnCount(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : 1;
}

int Directory::rowCount(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : directory_row_count(d);
}

QModelIndex Directory::index(int row, int column, const QModelIndex &parent) const
{
    if (!parent.isValid() && column == 0) {
        return createIndex(row, 0, (quintptr)0);
    }
    return QModelIndex();
}

QModelIndex Directory::parent(const QModelIndex &) const
{
    return QModelIndex();
}

bool Directory::canFetchMore(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : directory_can_fetch_more(d);
}

void Directory::fetchMore(const QModelIndex &parent)
{
    if (!parent.isValid()) {
        directory_fetch_more(d);
    }
}

QVariant Directory::data(const QModelIndex &index, int role) const
{
    QVariant v;
    switch ((DirectoryRole)role) {
    case DirectoryRoleFileIcon:
        directory_data_file_icon(d, index.row(), &v, set_qvariant);
        break;
    case DirectoryRoleFilePath:
        directory_data_file_path(d, index.row(), &v, set_qvariant);
        break;
    case DirectoryRoleFileName:
        directory_data_file_name(d, index.row(), &v, set_qvariant);
        break;
    case DirectoryRoleFilePermissions:
        directory_data_file_permissions(d, index.row(), &v, set_qvariant);
        break;
    }
    return v;
}
QHash<int, QByteArray> Directory::roleNames() const {
    QHash<int, QByteArray> names;
    names.insert(Qt::DecorationRole, "FileIcon");
    names.insert(Qt::UserRole + 1, "FilePath");
    names.insert(Qt::UserRole + 2, "FileName");
    names.insert(Qt::UserRole + 3, "FilePermissions");
    return names;
}