/* generated by rust_qt_binding_generator */
#include "Bindings.h"

namespace {

    struct option_quint64 {
    public:
        quint64 value;
        bool some;
        operator QVariant() const {
            if (some) {
                return QVariant::fromValue(value);
            }
            return QVariant();
        }
    };
    static_assert(std::is_pod<option_quint64>::value, "option_quint64 must be a POD type.");

    struct option_quintptr {
    public:
        quintptr value;
        bool some;
        operator QVariant() const {
            if (some) {
                return QVariant::fromValue(value);
            }
            return QVariant();
        }
    };
    static_assert(std::is_pod<option_quintptr>::value, "option_quintptr must be a POD type.");

    typedef void (*qstring_set)(QString* val, const char* utf8, int nbytes);
    void set_qstring(QString* val, const char* utf8, int nbytes) {
        *val = QString::fromUtf8(utf8, nbytes);
    }

    typedef void (*qbytearray_set)(QByteArray* val, const char* bytes, int nbytes);
    void set_qbytearray(QByteArray* v, const char* bytes, int nbytes) {
        if (v->isNull() && nbytes == 0) {
            *v = QByteArray(bytes, nbytes);
        } else {
            v->truncate(0);
            v->append(bytes, nbytes);
        }
    }

    struct qmodelindex_t {
        int row;
        quintptr id;
    };
    inline QVariant cleanNullQVariant(const QVariant& v) {
        return (v.isNull()) ?QVariant() :v;
    }
    inline void fibonacciInputChanged(Fibonacci* o)
    {
        Q_EMIT o->inputChanged();
    }
    inline void fibonacciResultChanged(Fibonacci* o)
    {
        Q_EMIT o->resultChanged();
    }
    inline void fileSystemTreePathChanged(FileSystemTree* o)
    {
        Q_EMIT o->pathChanged();
    }
    inline void processesActiveChanged(Processes* o)
    {
        Q_EMIT o->activeChanged();
    }
}
extern "C" {
    Demo::Private* demo_new(Demo*, Fibonacci*, void (*)(Fibonacci*), void (*)(Fibonacci*), FibonacciList*,
        void (*)(const FibonacciList*),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*, quintptr, quintptr),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*, int, int),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*, int, int, int),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*, int, int),
        void (*)(FibonacciList*), FileSystemTree*, void (*)(FileSystemTree*),
        void (*)(const FileSystemTree*, option_quintptr),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*, quintptr, quintptr),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*, option_quintptr, int, int),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*, option_quintptr, int, int, option_quintptr, int),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*, option_quintptr, int, int),
        void (*)(FileSystemTree*), Processes*, void (*)(Processes*),
        void (*)(const Processes*, option_quintptr),
        void (*)(Processes*),
        void (*)(Processes*),
        void (*)(Processes*, quintptr, quintptr),
        void (*)(Processes*),
        void (*)(Processes*),
        void (*)(Processes*, option_quintptr, int, int),
        void (*)(Processes*),
        void (*)(Processes*, option_quintptr, int, int, option_quintptr, int),
        void (*)(Processes*),
        void (*)(Processes*, option_quintptr, int, int),
        void (*)(Processes*), TimeSeries*,
        void (*)(const TimeSeries*),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*, quintptr, quintptr),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*, int, int),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*, int, int, int),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*, int, int),
        void (*)(TimeSeries*));
    void demo_free(Demo::Private*);
    Fibonacci::Private* demo_fibonacci_get(const Demo::Private*);
    FibonacciList::Private* demo_fibonacci_list_get(const Demo::Private*);
    FileSystemTree::Private* demo_file_system_tree_get(const Demo::Private*);
    Processes::Private* demo_processes_get(const Demo::Private*);
    TimeSeries::Private* demo_time_series_get(const Demo::Private*);
};

extern "C" {
    Fibonacci::Private* fibonacci_new(Fibonacci*, void (*)(Fibonacci*), void (*)(Fibonacci*));
    void fibonacci_free(Fibonacci::Private*);
    quint32 fibonacci_input_get(const Fibonacci::Private*);
    void fibonacci_input_set(Fibonacci::Private*, quint32);
    quint64 fibonacci_result_get(const Fibonacci::Private*);
};

extern "C" {
    quint64 fibonacci_list_data_fibonacci_number(const FibonacciList::Private*, int);
    quint64 fibonacci_list_data_row(const FibonacciList::Private*, int);
    void fibonacci_list_sort(FibonacciList::Private*, unsigned char column, Qt::SortOrder order = Qt::AscendingOrder);

    int fibonacci_list_row_count(const FibonacciList::Private*);
    bool fibonacci_list_insert_rows(FibonacciList::Private*, int, int);
    bool fibonacci_list_remove_rows(FibonacciList::Private*, int, int);
    bool fibonacci_list_can_fetch_more(const FibonacciList::Private*);
    void fibonacci_list_fetch_more(FibonacciList::Private*);
}
int FibonacciList::columnCount(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : 2;
}

bool FibonacciList::hasChildren(const QModelIndex &parent) const
{
    return rowCount(parent) > 0;
}

int FibonacciList::rowCount(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : fibonacci_list_row_count(m_d);
}

bool FibonacciList::insertRows(int row, int count, const QModelIndex &)
{
    return fibonacci_list_insert_rows(m_d, row, count);
}

bool FibonacciList::removeRows(int row, int count, const QModelIndex &)
{
    return fibonacci_list_remove_rows(m_d, row, count);
}

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

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

bool FibonacciList::canFetchMore(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : fibonacci_list_can_fetch_more(m_d);
}

void FibonacciList::fetchMore(const QModelIndex &parent)
{
    if (!parent.isValid()) {
        fibonacci_list_fetch_more(m_d);
    }
}
void FibonacciList::updatePersistentIndexes() {}

void FibonacciList::sort(int column, Qt::SortOrder order)
{
    fibonacci_list_sort(m_d, column, order);
}
Qt::ItemFlags FibonacciList::flags(const QModelIndex &i) const
{
    auto flags = QAbstractItemModel::flags(i);
    return flags;
}

quint64 FibonacciList::fibonacciNumber(int row) const
{
    return fibonacci_list_data_fibonacci_number(m_d, row);
}

quint64 FibonacciList::row(int row) const
{
    return fibonacci_list_data_row(m_d, row);
}

QVariant FibonacciList::data(const QModelIndex &index, int role) const
{
    Q_ASSERT(rowCount(index.parent()) > index.row());
    switch (index.column()) {
    case 0:
        switch (role) {
        case Qt::UserRole + 0:
            return QVariant::fromValue(fibonacciNumber(index.row()));
        case Qt::DisplayRole:
        case Qt::UserRole + 1:
            return QVariant::fromValue(row(index.row()));
        }
        break;
    case 1:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::UserRole + 0:
            return QVariant::fromValue(fibonacciNumber(index.row()));
        }
        break;
    }
    return QVariant();
}

int FibonacciList::role(const char* name) const {
    auto names = roleNames();
    auto i = names.constBegin();
    while (i != names.constEnd()) {
        if (i.value() == name) {
            return i.key();
        }
        ++i;
    }
    return -1;
}
QHash<int, QByteArray> FibonacciList::roleNames() const {
    QHash<int, QByteArray> names = QAbstractItemModel::roleNames();
    names.insert(Qt::UserRole + 0, "fibonacciNumber");
    names.insert(Qt::UserRole + 1, "row");
    return names;
}
QVariant FibonacciList::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation != Qt::Horizontal) {
        return QVariant();
    }
    return m_headerData.value(qMakePair(section, (Qt::ItemDataRole)role), role == Qt::DisplayRole ?QString::number(section + 1) :QVariant());
}

bool FibonacciList::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
{
    if (orientation != Qt::Horizontal) {
        return false;
    }
    m_headerData.insert(qMakePair(section, (Qt::ItemDataRole)role), value);
    return true;
}

extern "C" {
    FibonacciList::Private* fibonacci_list_new(FibonacciList*,
        void (*)(const FibonacciList*),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*, quintptr, quintptr),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*, int, int),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*, int, int, int),
        void (*)(FibonacciList*),
        void (*)(FibonacciList*, int, int),
        void (*)(FibonacciList*));
    void fibonacci_list_free(FibonacciList::Private*);
};

extern "C" {
    void file_system_tree_data_file_icon(const FileSystemTree::Private*, quintptr, QByteArray*, qbytearray_set);
    void file_system_tree_data_file_name(const FileSystemTree::Private*, quintptr, QString*, qstring_set);
    void file_system_tree_data_file_path(const FileSystemTree::Private*, quintptr, QString*, qstring_set);
    qint32 file_system_tree_data_file_permissions(const FileSystemTree::Private*, quintptr);
    option_quint64 file_system_tree_data_file_size(const FileSystemTree::Private*, quintptr);
    qint32 file_system_tree_data_file_type(const FileSystemTree::Private*, quintptr);
    void file_system_tree_sort(FileSystemTree::Private*, unsigned char column, Qt::SortOrder order = Qt::AscendingOrder);

    int file_system_tree_row_count(const FileSystemTree::Private*, option_quintptr);
    bool file_system_tree_can_fetch_more(const FileSystemTree::Private*, option_quintptr);
    void file_system_tree_fetch_more(FileSystemTree::Private*, option_quintptr);
    quintptr file_system_tree_index(const FileSystemTree::Private*, option_quintptr, int);
    qmodelindex_t file_system_tree_parent(const FileSystemTree::Private*, quintptr);
    int file_system_tree_row(const FileSystemTree::Private*, quintptr);
    option_quintptr file_system_tree_check_row(const FileSystemTree::Private*, quintptr, int);
}
int FileSystemTree::columnCount(const QModelIndex &) const
{
    return 5;
}

bool FileSystemTree::hasChildren(const QModelIndex &parent) const
{
    return rowCount(parent) > 0;
}

int FileSystemTree::rowCount(const QModelIndex &parent) const
{
    if (parent.isValid() && parent.column() != 0) {
        return 0;
    }
    const option_quintptr rust_parent = {
        parent.internalId(),
        parent.isValid()
    };
    return file_system_tree_row_count(m_d, rust_parent);
}

bool FileSystemTree::insertRows(int, int, const QModelIndex &)
{
    return false; // not supported yet
}

bool FileSystemTree::removeRows(int, int, const QModelIndex &)
{
    return false; // not supported yet
}

QModelIndex FileSystemTree::index(int row, int column, const QModelIndex &parent) const
{
    if (row < 0 || column < 0 || column >= 5) {
        return QModelIndex();
    }
    if (parent.isValid() && parent.column() != 0) {
        return QModelIndex();
    }
    if (row >= rowCount(parent)) {
        return QModelIndex();
    }
    const option_quintptr rust_parent = {
        parent.internalId(),
        parent.isValid()
    };
    const quintptr id = file_system_tree_index(m_d, rust_parent, row);
    return createIndex(row, column, id);
}

QModelIndex FileSystemTree::parent(const QModelIndex &index) const
{
    if (!index.isValid()) {
        return QModelIndex();
    }
    const qmodelindex_t parent = file_system_tree_parent(m_d, index.internalId());
    return parent.row >= 0 ?createIndex(parent.row, 0, parent.id) :QModelIndex();
}

bool FileSystemTree::canFetchMore(const QModelIndex &parent) const
{
    if (parent.isValid() && parent.column() != 0) {
        return false;
    }
    const option_quintptr rust_parent = {
        parent.internalId(),
        parent.isValid()
    };
    return file_system_tree_can_fetch_more(m_d, rust_parent);
}

void FileSystemTree::fetchMore(const QModelIndex &parent)
{
    const option_quintptr rust_parent = {
        parent.internalId(),
        parent.isValid()
    };
    file_system_tree_fetch_more(m_d, rust_parent);
}
void FileSystemTree::updatePersistentIndexes() {
    const auto from = persistentIndexList();
    auto to = from;
    auto len = to.size();
    for (int i = 0; i < len; ++i) {
        auto index = to.at(i);
        auto row = file_system_tree_check_row(m_d, index.internalId(), index.row());
        if (row.some) {
            to[i] = createIndex(row.value, index.column(), index.internalId());
        } else {
            to[i] = QModelIndex();
        }
    }
    changePersistentIndexList(from, to);
}

void FileSystemTree::sort(int column, Qt::SortOrder order)
{
    file_system_tree_sort(m_d, column, order);
}
Qt::ItemFlags FileSystemTree::flags(const QModelIndex &i) const
{
    auto flags = QAbstractItemModel::flags(i);
    return flags;
}

QByteArray FileSystemTree::fileIcon(const QModelIndex& index) const
{
    QByteArray b;
    file_system_tree_data_file_icon(m_d, index.internalId(), &b, set_qbytearray);
    return b;
}

QString FileSystemTree::fileName(const QModelIndex& index) const
{
    QString s;
    file_system_tree_data_file_name(m_d, index.internalId(), &s, set_qstring);
    return s;
}

QString FileSystemTree::filePath(const QModelIndex& index) const
{
    QString s;
    file_system_tree_data_file_path(m_d, index.internalId(), &s, set_qstring);
    return s;
}

qint32 FileSystemTree::filePermissions(const QModelIndex& index) const
{
    return file_system_tree_data_file_permissions(m_d, index.internalId());
}

QVariant FileSystemTree::fileSize(const QModelIndex& index) const
{
    QVariant v;
    v = file_system_tree_data_file_size(m_d, index.internalId());
    return v;
}

qint32 FileSystemTree::fileType(const QModelIndex& index) const
{
    return file_system_tree_data_file_type(m_d, index.internalId());
}

QVariant FileSystemTree::data(const QModelIndex &index, int role) const
{
    Q_ASSERT(rowCount(index.parent()) > index.row());
    switch (index.column()) {
    case 0:
        switch (role) {
        case Qt::DecorationRole:
        case Qt::UserRole + 0:
            return QVariant::fromValue(fileIcon(index));
        case Qt::DisplayRole:
        case Qt::UserRole + 1:
            return QVariant::fromValue(fileName(index));
        case Qt::UserRole + 2:
            return cleanNullQVariant(QVariant::fromValue(filePath(index)));
        case Qt::UserRole + 3:
            return QVariant::fromValue(filePermissions(index));
        case Qt::UserRole + 4:
            return fileSize(index);
        case Qt::UserRole + 5:
            return QVariant::fromValue(fileType(index));
        }
        break;
    case 1:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::UserRole + 4:
            return fileSize(index);
        }
        break;
    case 2:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::UserRole + 2:
            return cleanNullQVariant(QVariant::fromValue(filePath(index)));
        }
        break;
    case 3:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::UserRole + 3:
            return QVariant::fromValue(filePermissions(index));
        }
        break;
    case 4:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::UserRole + 5:
            return QVariant::fromValue(fileType(index));
        }
        break;
    }
    return QVariant();
}

int FileSystemTree::role(const char* name) const {
    auto names = roleNames();
    auto i = names.constBegin();
    while (i != names.constEnd()) {
        if (i.value() == name) {
            return i.key();
        }
        ++i;
    }
    return -1;
}
QHash<int, QByteArray> FileSystemTree::roleNames() const {
    QHash<int, QByteArray> names = QAbstractItemModel::roleNames();
    names.insert(Qt::UserRole + 0, "fileIcon");
    names.insert(Qt::UserRole + 1, "fileName");
    names.insert(Qt::UserRole + 2, "filePath");
    names.insert(Qt::UserRole + 3, "filePermissions");
    names.insert(Qt::UserRole + 4, "fileSize");
    names.insert(Qt::UserRole + 5, "fileType");
    return names;
}
QVariant FileSystemTree::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation != Qt::Horizontal) {
        return QVariant();
    }
    return m_headerData.value(qMakePair(section, (Qt::ItemDataRole)role), role == Qt::DisplayRole ?QString::number(section + 1) :QVariant());
}

bool FileSystemTree::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
{
    if (orientation != Qt::Horizontal) {
        return false;
    }
    m_headerData.insert(qMakePair(section, (Qt::ItemDataRole)role), value);
    return true;
}

extern "C" {
    FileSystemTree::Private* file_system_tree_new(FileSystemTree*, void (*)(FileSystemTree*),
        void (*)(const FileSystemTree*, option_quintptr),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*, quintptr, quintptr),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*, option_quintptr, int, int),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*, option_quintptr, int, int, option_quintptr, int),
        void (*)(FileSystemTree*),
        void (*)(FileSystemTree*, option_quintptr, int, int),
        void (*)(FileSystemTree*));
    void file_system_tree_free(FileSystemTree::Private*);
    void file_system_tree_path_get(const FileSystemTree::Private*, QString*, qstring_set);
    void file_system_tree_path_set(FileSystemTree::Private*, const ushort *str, int len);
    void file_system_tree_path_set_none(FileSystemTree::Private*);
};

extern "C" {
    void processes_data_cmd(const Processes::Private*, quintptr, QString*, qstring_set);
    quint8 processes_data_cpu_percentage(const Processes::Private*, quintptr);
    float processes_data_cpu_usage(const Processes::Private*, quintptr);
    quint64 processes_data_memory(const Processes::Private*, quintptr);
    void processes_data_name(const Processes::Private*, quintptr, QString*, qstring_set);
    quint32 processes_data_pid(const Processes::Private*, quintptr);
    quint32 processes_data_uid(const Processes::Private*, quintptr);
    void processes_sort(Processes::Private*, unsigned char column, Qt::SortOrder order = Qt::AscendingOrder);

    int processes_row_count(const Processes::Private*, option_quintptr);
    bool processes_can_fetch_more(const Processes::Private*, option_quintptr);
    void processes_fetch_more(Processes::Private*, option_quintptr);
    quintptr processes_index(const Processes::Private*, option_quintptr, int);
    qmodelindex_t processes_parent(const Processes::Private*, quintptr);
    int processes_row(const Processes::Private*, quintptr);
    option_quintptr processes_check_row(const Processes::Private*, quintptr, int);
}
int Processes::columnCount(const QModelIndex &) const
{
    return 3;
}

bool Processes::hasChildren(const QModelIndex &parent) const
{
    return rowCount(parent) > 0;
}

int Processes::rowCount(const QModelIndex &parent) const
{
    if (parent.isValid() && parent.column() != 0) {
        return 0;
    }
    const option_quintptr rust_parent = {
        parent.internalId(),
        parent.isValid()
    };
    return processes_row_count(m_d, rust_parent);
}

bool Processes::insertRows(int, int, const QModelIndex &)
{
    return false; // not supported yet
}

bool Processes::removeRows(int, int, const QModelIndex &)
{
    return false; // not supported yet
}

QModelIndex Processes::index(int row, int column, const QModelIndex &parent) const
{
    if (row < 0 || column < 0 || column >= 3) {
        return QModelIndex();
    }
    if (parent.isValid() && parent.column() != 0) {
        return QModelIndex();
    }
    if (row >= rowCount(parent)) {
        return QModelIndex();
    }
    const option_quintptr rust_parent = {
        parent.internalId(),
        parent.isValid()
    };
    const quintptr id = processes_index(m_d, rust_parent, row);
    return createIndex(row, column, id);
}

QModelIndex Processes::parent(const QModelIndex &index) const
{
    if (!index.isValid()) {
        return QModelIndex();
    }
    const qmodelindex_t parent = processes_parent(m_d, index.internalId());
    return parent.row >= 0 ?createIndex(parent.row, 0, parent.id) :QModelIndex();
}

bool Processes::canFetchMore(const QModelIndex &parent) const
{
    if (parent.isValid() && parent.column() != 0) {
        return false;
    }
    const option_quintptr rust_parent = {
        parent.internalId(),
        parent.isValid()
    };
    return processes_can_fetch_more(m_d, rust_parent);
}

void Processes::fetchMore(const QModelIndex &parent)
{
    const option_quintptr rust_parent = {
        parent.internalId(),
        parent.isValid()
    };
    processes_fetch_more(m_d, rust_parent);
}
void Processes::updatePersistentIndexes() {
    const auto from = persistentIndexList();
    auto to = from;
    auto len = to.size();
    for (int i = 0; i < len; ++i) {
        auto index = to.at(i);
        auto row = processes_check_row(m_d, index.internalId(), index.row());
        if (row.some) {
            to[i] = createIndex(row.value, index.column(), index.internalId());
        } else {
            to[i] = QModelIndex();
        }
    }
    changePersistentIndexList(from, to);
}

void Processes::sort(int column, Qt::SortOrder order)
{
    processes_sort(m_d, column, order);
}
Qt::ItemFlags Processes::flags(const QModelIndex &i) const
{
    auto flags = QAbstractItemModel::flags(i);
    return flags;
}

QString Processes::cmd(const QModelIndex& index) const
{
    QString s;
    processes_data_cmd(m_d, index.internalId(), &s, set_qstring);
    return s;
}

quint8 Processes::cpuPercentage(const QModelIndex& index) const
{
    return processes_data_cpu_percentage(m_d, index.internalId());
}

float Processes::cpuUsage(const QModelIndex& index) const
{
    return processes_data_cpu_usage(m_d, index.internalId());
}

quint64 Processes::memory(const QModelIndex& index) const
{
    return processes_data_memory(m_d, index.internalId());
}

QString Processes::name(const QModelIndex& index) const
{
    QString s;
    processes_data_name(m_d, index.internalId(), &s, set_qstring);
    return s;
}

quint32 Processes::pid(const QModelIndex& index) const
{
    return processes_data_pid(m_d, index.internalId());
}

quint32 Processes::uid(const QModelIndex& index) const
{
    return processes_data_uid(m_d, index.internalId());
}

QVariant Processes::data(const QModelIndex &index, int role) const
{
    Q_ASSERT(rowCount(index.parent()) > index.row());
    switch (index.column()) {
    case 0:
        switch (role) {
        case Qt::UserRole + 0:
            return QVariant::fromValue(cmd(index));
        case Qt::UserRole + 1:
            return QVariant::fromValue(cpuPercentage(index));
        case Qt::UserRole + 2:
            return QVariant::fromValue(cpuUsage(index));
        case Qt::UserRole + 3:
            return QVariant::fromValue(memory(index));
        case Qt::DisplayRole:
        case Qt::UserRole + 4:
            return QVariant::fromValue(name(index));
        case Qt::ToolTipRole:
        case Qt::UserRole + 5:
            return QVariant::fromValue(pid(index));
        case Qt::UserRole + 6:
            return QVariant::fromValue(uid(index));
        }
        break;
    case 1:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::UserRole + 2:
            return QVariant::fromValue(cpuUsage(index));
        }
        break;
    case 2:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::UserRole + 3:
            return QVariant::fromValue(memory(index));
        }
        break;
    }
    return QVariant();
}

int Processes::role(const char* name) const {
    auto names = roleNames();
    auto i = names.constBegin();
    while (i != names.constEnd()) {
        if (i.value() == name) {
            return i.key();
        }
        ++i;
    }
    return -1;
}
QHash<int, QByteArray> Processes::roleNames() const {
    QHash<int, QByteArray> names = QAbstractItemModel::roleNames();
    names.insert(Qt::UserRole + 0, "cmd");
    names.insert(Qt::UserRole + 1, "cpuPercentage");
    names.insert(Qt::UserRole + 2, "cpuUsage");
    names.insert(Qt::UserRole + 3, "memory");
    names.insert(Qt::UserRole + 4, "name");
    names.insert(Qt::UserRole + 5, "pid");
    names.insert(Qt::UserRole + 6, "uid");
    return names;
}
QVariant Processes::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation != Qt::Horizontal) {
        return QVariant();
    }
    return m_headerData.value(qMakePair(section, (Qt::ItemDataRole)role), role == Qt::DisplayRole ?QString::number(section + 1) :QVariant());
}

bool Processes::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
{
    if (orientation != Qt::Horizontal) {
        return false;
    }
    m_headerData.insert(qMakePair(section, (Qt::ItemDataRole)role), value);
    return true;
}

extern "C" {
    Processes::Private* processes_new(Processes*, void (*)(Processes*),
        void (*)(const Processes*, option_quintptr),
        void (*)(Processes*),
        void (*)(Processes*),
        void (*)(Processes*, quintptr, quintptr),
        void (*)(Processes*),
        void (*)(Processes*),
        void (*)(Processes*, option_quintptr, int, int),
        void (*)(Processes*),
        void (*)(Processes*, option_quintptr, int, int, option_quintptr, int),
        void (*)(Processes*),
        void (*)(Processes*, option_quintptr, int, int),
        void (*)(Processes*));
    void processes_free(Processes::Private*);
    bool processes_active_get(const Processes::Private*);
    void processes_active_set(Processes::Private*, bool);
};

extern "C" {
    float time_series_data_cos(const TimeSeries::Private*, int);
    bool time_series_set_data_cos(TimeSeries::Private*, int, float);
    float time_series_data_sin(const TimeSeries::Private*, int);
    bool time_series_set_data_sin(TimeSeries::Private*, int, float);
    float time_series_data_time(const TimeSeries::Private*, int);
    bool time_series_set_data_time(TimeSeries::Private*, int, float);
    void time_series_sort(TimeSeries::Private*, unsigned char column, Qt::SortOrder order = Qt::AscendingOrder);

    int time_series_row_count(const TimeSeries::Private*);
    bool time_series_insert_rows(TimeSeries::Private*, int, int);
    bool time_series_remove_rows(TimeSeries::Private*, int, int);
    bool time_series_can_fetch_more(const TimeSeries::Private*);
    void time_series_fetch_more(TimeSeries::Private*);
}
int TimeSeries::columnCount(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : 3;
}

bool TimeSeries::hasChildren(const QModelIndex &parent) const
{
    return rowCount(parent) > 0;
}

int TimeSeries::rowCount(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : time_series_row_count(m_d);
}

bool TimeSeries::insertRows(int row, int count, const QModelIndex &)
{
    return time_series_insert_rows(m_d, row, count);
}

bool TimeSeries::removeRows(int row, int count, const QModelIndex &)
{
    return time_series_remove_rows(m_d, row, count);
}

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

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

bool TimeSeries::canFetchMore(const QModelIndex &parent) const
{
    return (parent.isValid()) ? 0 : time_series_can_fetch_more(m_d);
}

void TimeSeries::fetchMore(const QModelIndex &parent)
{
    if (!parent.isValid()) {
        time_series_fetch_more(m_d);
    }
}
void TimeSeries::updatePersistentIndexes() {}

void TimeSeries::sort(int column, Qt::SortOrder order)
{
    time_series_sort(m_d, column, order);
}
Qt::ItemFlags TimeSeries::flags(const QModelIndex &i) const
{
    auto flags = QAbstractItemModel::flags(i);
    if (i.column() == 0) {
        flags |= Qt::ItemIsEditable;
    }
    if (i.column() == 1) {
        flags |= Qt::ItemIsEditable;
    }
    if (i.column() == 2) {
        flags |= Qt::ItemIsEditable;
    }
    return flags;
}

float TimeSeries::cos(int row) const
{
    return time_series_data_cos(m_d, row);
}

bool TimeSeries::setCos(int row, float value)
{
    bool set = false;
    set = time_series_set_data_cos(m_d, row, value);
    if (set) {
        QModelIndex index = createIndex(row, 0, row);
        Q_EMIT dataChanged(index, index);
    }
    return set;
}

float TimeSeries::sin(int row) const
{
    return time_series_data_sin(m_d, row);
}

bool TimeSeries::setSin(int row, float value)
{
    bool set = false;
    set = time_series_set_data_sin(m_d, row, value);
    if (set) {
        QModelIndex index = createIndex(row, 0, row);
        Q_EMIT dataChanged(index, index);
    }
    return set;
}

float TimeSeries::time(int row) const
{
    return time_series_data_time(m_d, row);
}

bool TimeSeries::setTime(int row, float value)
{
    bool set = false;
    set = time_series_set_data_time(m_d, row, value);
    if (set) {
        QModelIndex index = createIndex(row, 0, row);
        Q_EMIT dataChanged(index, index);
    }
    return set;
}

QVariant TimeSeries::data(const QModelIndex &index, int role) const
{
    Q_ASSERT(rowCount(index.parent()) > index.row());
    switch (index.column()) {
    case 0:
        switch (role) {
        case Qt::UserRole + 0:
            return QVariant::fromValue(cos(index.row()));
        case Qt::UserRole + 1:
            return QVariant::fromValue(sin(index.row()));
        case Qt::DisplayRole:
        case Qt::EditRole:
        case Qt::UserRole + 2:
            return QVariant::fromValue(time(index.row()));
        }
        break;
    case 1:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::EditRole:
        case Qt::UserRole + 1:
            return QVariant::fromValue(sin(index.row()));
        }
        break;
    case 2:
        switch (role) {
        case Qt::DisplayRole:
        case Qt::EditRole:
        case Qt::UserRole + 0:
            return QVariant::fromValue(cos(index.row()));
        }
        break;
    }
    return QVariant();
}

int TimeSeries::role(const char* name) const {
    auto names = roleNames();
    auto i = names.constBegin();
    while (i != names.constEnd()) {
        if (i.value() == name) {
            return i.key();
        }
        ++i;
    }
    return -1;
}
QHash<int, QByteArray> TimeSeries::roleNames() const {
    QHash<int, QByteArray> names = QAbstractItemModel::roleNames();
    names.insert(Qt::UserRole + 0, "cos");
    names.insert(Qt::UserRole + 1, "sin");
    names.insert(Qt::UserRole + 2, "time");
    return names;
}
QVariant TimeSeries::headerData(int section, Qt::Orientation orientation, int role) const
{
    if (orientation != Qt::Horizontal) {
        return QVariant();
    }
    return m_headerData.value(qMakePair(section, (Qt::ItemDataRole)role), role == Qt::DisplayRole ?QString::number(section + 1) :QVariant());
}

bool TimeSeries::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)
{
    if (orientation != Qt::Horizontal) {
        return false;
    }
    m_headerData.insert(qMakePair(section, (Qt::ItemDataRole)role), value);
    return true;
}

bool TimeSeries::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (index.column() == 0) {
        if (role == Qt::UserRole + 0) {
            if (value.canConvert(qMetaTypeId<float>())) {
                return setCos(index.row(), value.value<float>());
            }
        }
        if (role == Qt::UserRole + 1) {
            if (value.canConvert(qMetaTypeId<float>())) {
                return setSin(index.row(), value.value<float>());
            }
        }
        if (role == Qt::DisplayRole || role == Qt::EditRole || role == Qt::UserRole + 2) {
            if (value.canConvert(qMetaTypeId<float>())) {
                return setTime(index.row(), value.value<float>());
            }
        }
    }
    if (index.column() == 1) {
        if (role == Qt::DisplayRole || role == Qt::EditRole || role == Qt::UserRole + 1) {
            if (value.canConvert(qMetaTypeId<float>())) {
                return setSin(index.row(), value.value<float>());
            }
        }
    }
    if (index.column() == 2) {
        if (role == Qt::DisplayRole || role == Qt::EditRole || role == Qt::UserRole + 0) {
            if (value.canConvert(qMetaTypeId<float>())) {
                return setCos(index.row(), value.value<float>());
            }
        }
    }
    return false;
}

extern "C" {
    TimeSeries::Private* time_series_new(TimeSeries*,
        void (*)(const TimeSeries*),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*, quintptr, quintptr),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*, int, int),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*, int, int, int),
        void (*)(TimeSeries*),
        void (*)(TimeSeries*, int, int),
        void (*)(TimeSeries*));
    void time_series_free(TimeSeries::Private*);
};

Demo::Demo(bool /*owned*/, QObject *parent):
    QObject(parent),
    m_fibonacci(new Fibonacci(false, this)),
    m_fibonacciList(new FibonacciList(false, this)),
    m_fileSystemTree(new FileSystemTree(false, this)),
    m_processes(new Processes(false, this)),
    m_timeSeries(new TimeSeries(false, this)),
    m_d(nullptr),
    m_ownsPrivate(false)
{
}

Demo::Demo(QObject *parent):
    QObject(parent),
    m_fibonacci(new Fibonacci(false, this)),
    m_fibonacciList(new FibonacciList(false, this)),
    m_fileSystemTree(new FileSystemTree(false, this)),
    m_processes(new Processes(false, this)),
    m_timeSeries(new TimeSeries(false, this)),
    m_d(demo_new(this, m_fibonacci,
        fibonacciInputChanged,
        fibonacciResultChanged, m_fibonacciList,
        [](const FibonacciList* o) {
            Q_EMIT o->newDataReady(QModelIndex());
        },
        [](FibonacciList* o) {
            Q_EMIT o->layoutAboutToBeChanged();
        },
        [](FibonacciList* o) {
            o->updatePersistentIndexes();
            Q_EMIT o->layoutChanged();
        },
        [](FibonacciList* o, quintptr first, quintptr last) {
            o->dataChanged(o->createIndex(first, 0, first),
                       o->createIndex(last, 1, last));
        },
        [](FibonacciList* o) {
            o->beginResetModel();
        },
        [](FibonacciList* o) {
            o->endResetModel();
        },
        [](FibonacciList* o, int first, int last) {
            o->beginInsertRows(QModelIndex(), first, last);
        },
        [](FibonacciList* o) {
            o->endInsertRows();
        },
        [](FibonacciList* o, int first, int last, int destination) {
            o->beginMoveRows(QModelIndex(), first, last, QModelIndex(), destination);
        },
        [](FibonacciList* o) {
            o->endMoveRows();
        },
        [](FibonacciList* o, int first, int last) {
            o->beginRemoveRows(QModelIndex(), first, last);
        },
        [](FibonacciList* o) {
            o->endRemoveRows();
        }
, m_fileSystemTree,
        fileSystemTreePathChanged,
        [](const FileSystemTree* o, option_quintptr id) {
            if (id.some) {
                int row = file_system_tree_row(o->m_d, id.value);
                Q_EMIT o->newDataReady(o->createIndex(row, 0, id.value));
            } else {
                Q_EMIT o->newDataReady(QModelIndex());
            }
        },
        [](FileSystemTree* o) {
            Q_EMIT o->layoutAboutToBeChanged();
        },
        [](FileSystemTree* o) {
            o->updatePersistentIndexes();
            Q_EMIT o->layoutChanged();
        },
        [](FileSystemTree* o, quintptr first, quintptr last) {
            quintptr frow = file_system_tree_row(o->m_d, first);
            quintptr lrow = file_system_tree_row(o->m_d, first);
            o->dataChanged(o->createIndex(frow, 0, first),
                       o->createIndex(lrow, 4, last));
        },
        [](FileSystemTree* o) {
            o->beginResetModel();
        },
        [](FileSystemTree* o) {
            o->endResetModel();
        },
        [](FileSystemTree* o, option_quintptr id, int first, int last) {
            if (id.some) {
                int row = file_system_tree_row(o->m_d, id.value);
                o->beginInsertRows(o->createIndex(row, 0, id.value), first, last);
            } else {
                o->beginInsertRows(QModelIndex(), first, last);
            }
        },
        [](FileSystemTree* o) {
            o->endInsertRows();
        },
        [](FileSystemTree* o, option_quintptr sourceParent, int first, int last, option_quintptr destinationParent, int destination) {
            QModelIndex s;
            if (sourceParent.some) {
                int row = file_system_tree_row(o->m_d, sourceParent.value);
                s = o->createIndex(row, 0, sourceParent.value);
            }
            QModelIndex d;
            if (destinationParent.some) {
                int row = file_system_tree_row(o->m_d, destinationParent.value);
                d = o->createIndex(row, 0, destinationParent.value);
            }
            o->beginMoveRows(s, first, last, d, destination);
        },
        [](FileSystemTree* o) {
            o->endMoveRows();
        },
        [](FileSystemTree* o, option_quintptr id, int first, int last) {
            if (id.some) {
                int row = file_system_tree_row(o->m_d, id.value);
                o->beginRemoveRows(o->createIndex(row, 0, id.value), first, last);
            } else {
                o->beginRemoveRows(QModelIndex(), first, last);
            }
        },
        [](FileSystemTree* o) {
            o->endRemoveRows();
        }
, m_processes,
        processesActiveChanged,
        [](const Processes* o, option_quintptr id) {
            if (id.some) {
                int row = processes_row(o->m_d, id.value);
                Q_EMIT o->newDataReady(o->createIndex(row, 0, id.value));
            } else {
                Q_EMIT o->newDataReady(QModelIndex());
            }
        },
        [](Processes* o) {
            Q_EMIT o->layoutAboutToBeChanged();
        },
        [](Processes* o) {
            o->updatePersistentIndexes();
            Q_EMIT o->layoutChanged();
        },
        [](Processes* o, quintptr first, quintptr last) {
            quintptr frow = processes_row(o->m_d, first);
            quintptr lrow = processes_row(o->m_d, first);
            o->dataChanged(o->createIndex(frow, 0, first),
                       o->createIndex(lrow, 2, last));
        },
        [](Processes* o) {
            o->beginResetModel();
        },
        [](Processes* o) {
            o->endResetModel();
        },
        [](Processes* o, option_quintptr id, int first, int last) {
            if (id.some) {
                int row = processes_row(o->m_d, id.value);
                o->beginInsertRows(o->createIndex(row, 0, id.value), first, last);
            } else {
                o->beginInsertRows(QModelIndex(), first, last);
            }
        },
        [](Processes* o) {
            o->endInsertRows();
        },
        [](Processes* o, option_quintptr sourceParent, int first, int last, option_quintptr destinationParent, int destination) {
            QModelIndex s;
            if (sourceParent.some) {
                int row = processes_row(o->m_d, sourceParent.value);
                s = o->createIndex(row, 0, sourceParent.value);
            }
            QModelIndex d;
            if (destinationParent.some) {
                int row = processes_row(o->m_d, destinationParent.value);
                d = o->createIndex(row, 0, destinationParent.value);
            }
            o->beginMoveRows(s, first, last, d, destination);
        },
        [](Processes* o) {
            o->endMoveRows();
        },
        [](Processes* o, option_quintptr id, int first, int last) {
            if (id.some) {
                int row = processes_row(o->m_d, id.value);
                o->beginRemoveRows(o->createIndex(row, 0, id.value), first, last);
            } else {
                o->beginRemoveRows(QModelIndex(), first, last);
            }
        },
        [](Processes* o) {
            o->endRemoveRows();
        }
, m_timeSeries,
        [](const TimeSeries* o) {
            Q_EMIT o->newDataReady(QModelIndex());
        },
        [](TimeSeries* o) {
            Q_EMIT o->layoutAboutToBeChanged();
        },
        [](TimeSeries* o) {
            o->updatePersistentIndexes();
            Q_EMIT o->layoutChanged();
        },
        [](TimeSeries* o, quintptr first, quintptr last) {
            o->dataChanged(o->createIndex(first, 0, first),
                       o->createIndex(last, 2, last));
        },
        [](TimeSeries* o) {
            o->beginResetModel();
        },
        [](TimeSeries* o) {
            o->endResetModel();
        },
        [](TimeSeries* o, int first, int last) {
            o->beginInsertRows(QModelIndex(), first, last);
        },
        [](TimeSeries* o) {
            o->endInsertRows();
        },
        [](TimeSeries* o, int first, int last, int destination) {
            o->beginMoveRows(QModelIndex(), first, last, QModelIndex(), destination);
        },
        [](TimeSeries* o) {
            o->endMoveRows();
        },
        [](TimeSeries* o, int first, int last) {
            o->beginRemoveRows(QModelIndex(), first, last);
        },
        [](TimeSeries* o) {
            o->endRemoveRows();
        }
)),
    m_ownsPrivate(true)
{
    m_fibonacci->m_d = demo_fibonacci_get(m_d);
    m_fibonacciList->m_d = demo_fibonacci_list_get(m_d);
    m_fileSystemTree->m_d = demo_file_system_tree_get(m_d);
    m_processes->m_d = demo_processes_get(m_d);
    m_timeSeries->m_d = demo_time_series_get(m_d);
    connect(this->m_fibonacciList, &FibonacciList::newDataReady, this->m_fibonacciList, [this](const QModelIndex& i) {
        this->m_fibonacciList->fetchMore(i);
    }, Qt::QueuedConnection);
    connect(this->m_fileSystemTree, &FileSystemTree::newDataReady, this->m_fileSystemTree, [this](const QModelIndex& i) {
        this->m_fileSystemTree->fetchMore(i);
    }, Qt::QueuedConnection);
    connect(this->m_processes, &Processes::newDataReady, this->m_processes, [this](const QModelIndex& i) {
        this->m_processes->fetchMore(i);
    }, Qt::QueuedConnection);
    connect(this->m_timeSeries, &TimeSeries::newDataReady, this->m_timeSeries, [this](const QModelIndex& i) {
        this->m_timeSeries->fetchMore(i);
    }, Qt::QueuedConnection);
}

Demo::~Demo() {
    if (m_ownsPrivate) {
        demo_free(m_d);
    }
}
const Fibonacci* Demo::fibonacci() const
{
    return m_fibonacci;
}
Fibonacci* Demo::fibonacci()
{
    return m_fibonacci;
}
const FibonacciList* Demo::fibonacciList() const
{
    return m_fibonacciList;
}
FibonacciList* Demo::fibonacciList()
{
    return m_fibonacciList;
}
const FileSystemTree* Demo::fileSystemTree() const
{
    return m_fileSystemTree;
}
FileSystemTree* Demo::fileSystemTree()
{
    return m_fileSystemTree;
}
const Processes* Demo::processes() const
{
    return m_processes;
}
Processes* Demo::processes()
{
    return m_processes;
}
const TimeSeries* Demo::timeSeries() const
{
    return m_timeSeries;
}
TimeSeries* Demo::timeSeries()
{
    return m_timeSeries;
}
Fibonacci::Fibonacci(bool /*owned*/, QObject *parent):
    QObject(parent),
    m_d(nullptr),
    m_ownsPrivate(false)
{
}

Fibonacci::Fibonacci(QObject *parent):
    QObject(parent),
    m_d(fibonacci_new(this,
        fibonacciInputChanged,
        fibonacciResultChanged)),
    m_ownsPrivate(true)
{
}

Fibonacci::~Fibonacci() {
    if (m_ownsPrivate) {
        fibonacci_free(m_d);
    }
}
quint32 Fibonacci::input() const
{
    return fibonacci_input_get(m_d);
}
void Fibonacci::setInput(quint32 v) {
    fibonacci_input_set(m_d, v);
}
quint64 Fibonacci::result() const
{
    return fibonacci_result_get(m_d);
}
FibonacciList::FibonacciList(bool /*owned*/, QObject *parent):
    QAbstractItemModel(parent),
    m_d(nullptr),
    m_ownsPrivate(false)
{
    initHeaderData();
}

FibonacciList::FibonacciList(QObject *parent):
    QAbstractItemModel(parent),
    m_d(fibonacci_list_new(this,
        [](const FibonacciList* o) {
            Q_EMIT o->newDataReady(QModelIndex());
        },
        [](FibonacciList* o) {
            Q_EMIT o->layoutAboutToBeChanged();
        },
        [](FibonacciList* o) {
            o->updatePersistentIndexes();
            Q_EMIT o->layoutChanged();
        },
        [](FibonacciList* o, quintptr first, quintptr last) {
            o->dataChanged(o->createIndex(first, 0, first),
                       o->createIndex(last, 1, last));
        },
        [](FibonacciList* o) {
            o->beginResetModel();
        },
        [](FibonacciList* o) {
            o->endResetModel();
        },
        [](FibonacciList* o, int first, int last) {
            o->beginInsertRows(QModelIndex(), first, last);
        },
        [](FibonacciList* o) {
            o->endInsertRows();
        },
        [](FibonacciList* o, int first, int last, int destination) {
            o->beginMoveRows(QModelIndex(), first, last, QModelIndex(), destination);
        },
        [](FibonacciList* o) {
            o->endMoveRows();
        },
        [](FibonacciList* o, int first, int last) {
            o->beginRemoveRows(QModelIndex(), first, last);
        },
        [](FibonacciList* o) {
            o->endRemoveRows();
        }
)),
    m_ownsPrivate(true)
{
    connect(this, &FibonacciList::newDataReady, this, [this](const QModelIndex& i) {
        this->fetchMore(i);
    }, Qt::QueuedConnection);
    initHeaderData();
}

FibonacciList::~FibonacciList() {
    if (m_ownsPrivate) {
        fibonacci_list_free(m_d);
    }
}
void FibonacciList::initHeaderData() {
    m_headerData.insert(qMakePair(0, Qt::DisplayRole), QVariant("row"));
    m_headerData.insert(qMakePair(1, Qt::DisplayRole), QVariant("fibonacciNumber"));
}
FileSystemTree::FileSystemTree(bool /*owned*/, QObject *parent):
    QAbstractItemModel(parent),
    m_d(nullptr),
    m_ownsPrivate(false)
{
    initHeaderData();
}

FileSystemTree::FileSystemTree(QObject *parent):
    QAbstractItemModel(parent),
    m_d(file_system_tree_new(this,
        fileSystemTreePathChanged,
        [](const FileSystemTree* o, option_quintptr id) {
            if (id.some) {
                int row = file_system_tree_row(o->m_d, id.value);
                Q_EMIT o->newDataReady(o->createIndex(row, 0, id.value));
            } else {
                Q_EMIT o->newDataReady(QModelIndex());
            }
        },
        [](FileSystemTree* o) {
            Q_EMIT o->layoutAboutToBeChanged();
        },
        [](FileSystemTree* o) {
            o->updatePersistentIndexes();
            Q_EMIT o->layoutChanged();
        },
        [](FileSystemTree* o, quintptr first, quintptr last) {
            quintptr frow = file_system_tree_row(o->m_d, first);
            quintptr lrow = file_system_tree_row(o->m_d, first);
            o->dataChanged(o->createIndex(frow, 0, first),
                       o->createIndex(lrow, 4, last));
        },
        [](FileSystemTree* o) {
            o->beginResetModel();
        },
        [](FileSystemTree* o) {
            o->endResetModel();
        },
        [](FileSystemTree* o, option_quintptr id, int first, int last) {
            if (id.some) {
                int row = file_system_tree_row(o->m_d, id.value);
                o->beginInsertRows(o->createIndex(row, 0, id.value), first, last);
            } else {
                o->beginInsertRows(QModelIndex(), first, last);
            }
        },
        [](FileSystemTree* o) {
            o->endInsertRows();
        },
        [](FileSystemTree* o, option_quintptr sourceParent, int first, int last, option_quintptr destinationParent, int destination) {
            QModelIndex s;
            if (sourceParent.some) {
                int row = file_system_tree_row(o->m_d, sourceParent.value);
                s = o->createIndex(row, 0, sourceParent.value);
            }
            QModelIndex d;
            if (destinationParent.some) {
                int row = file_system_tree_row(o->m_d, destinationParent.value);
                d = o->createIndex(row, 0, destinationParent.value);
            }
            o->beginMoveRows(s, first, last, d, destination);
        },
        [](FileSystemTree* o) {
            o->endMoveRows();
        },
        [](FileSystemTree* o, option_quintptr id, int first, int last) {
            if (id.some) {
                int row = file_system_tree_row(o->m_d, id.value);
                o->beginRemoveRows(o->createIndex(row, 0, id.value), first, last);
            } else {
                o->beginRemoveRows(QModelIndex(), first, last);
            }
        },
        [](FileSystemTree* o) {
            o->endRemoveRows();
        }
)),
    m_ownsPrivate(true)
{
    connect(this, &FileSystemTree::newDataReady, this, [this](const QModelIndex& i) {
        this->fetchMore(i);
    }, Qt::QueuedConnection);
    initHeaderData();
}

FileSystemTree::~FileSystemTree() {
    if (m_ownsPrivate) {
        file_system_tree_free(m_d);
    }
}
void FileSystemTree::initHeaderData() {
    m_headerData.insert(qMakePair(0, Qt::DisplayRole), QVariant("fileName"));
    m_headerData.insert(qMakePair(1, Qt::DisplayRole), QVariant("fileSize"));
    m_headerData.insert(qMakePair(2, Qt::DisplayRole), QVariant("filePath"));
    m_headerData.insert(qMakePair(3, Qt::DisplayRole), QVariant("filePermissions"));
    m_headerData.insert(qMakePair(4, Qt::DisplayRole), QVariant("fileType"));
}
QString FileSystemTree::path() const
{
    QString v;
    file_system_tree_path_get(m_d, &v, set_qstring);
    return v;
}
void FileSystemTree::setPath(const QString& v) {
    if (v.isNull()) {
        file_system_tree_path_set_none(m_d);
    } else {
    file_system_tree_path_set(m_d, reinterpret_cast<const ushort*>(v.data()), v.size());
    }
}
Processes::Processes(bool /*owned*/, QObject *parent):
    QAbstractItemModel(parent),
    m_d(nullptr),
    m_ownsPrivate(false)
{
    initHeaderData();
}

Processes::Processes(QObject *parent):
    QAbstractItemModel(parent),
    m_d(processes_new(this,
        processesActiveChanged,
        [](const Processes* o, option_quintptr id) {
            if (id.some) {
                int row = processes_row(o->m_d, id.value);
                Q_EMIT o->newDataReady(o->createIndex(row, 0, id.value));
            } else {
                Q_EMIT o->newDataReady(QModelIndex());
            }
        },
        [](Processes* o) {
            Q_EMIT o->layoutAboutToBeChanged();
        },
        [](Processes* o) {
            o->updatePersistentIndexes();
            Q_EMIT o->layoutChanged();
        },
        [](Processes* o, quintptr first, quintptr last) {
            quintptr frow = processes_row(o->m_d, first);
            quintptr lrow = processes_row(o->m_d, first);
            o->dataChanged(o->createIndex(frow, 0, first),
                       o->createIndex(lrow, 2, last));
        },
        [](Processes* o) {
            o->beginResetModel();
        },
        [](Processes* o) {
            o->endResetModel();
        },
        [](Processes* o, option_quintptr id, int first, int last) {
            if (id.some) {
                int row = processes_row(o->m_d, id.value);
                o->beginInsertRows(o->createIndex(row, 0, id.value), first, last);
            } else {
                o->beginInsertRows(QModelIndex(), first, last);
            }
        },
        [](Processes* o) {
            o->endInsertRows();
        },
        [](Processes* o, option_quintptr sourceParent, int first, int last, option_quintptr destinationParent, int destination) {
            QModelIndex s;
            if (sourceParent.some) {
                int row = processes_row(o->m_d, sourceParent.value);
                s = o->createIndex(row, 0, sourceParent.value);
            }
            QModelIndex d;
            if (destinationParent.some) {
                int row = processes_row(o->m_d, destinationParent.value);
                d = o->createIndex(row, 0, destinationParent.value);
            }
            o->beginMoveRows(s, first, last, d, destination);
        },
        [](Processes* o) {
            o->endMoveRows();
        },
        [](Processes* o, option_quintptr id, int first, int last) {
            if (id.some) {
                int row = processes_row(o->m_d, id.value);
                o->beginRemoveRows(o->createIndex(row, 0, id.value), first, last);
            } else {
                o->beginRemoveRows(QModelIndex(), first, last);
            }
        },
        [](Processes* o) {
            o->endRemoveRows();
        }
)),
    m_ownsPrivate(true)
{
    connect(this, &Processes::newDataReady, this, [this](const QModelIndex& i) {
        this->fetchMore(i);
    }, Qt::QueuedConnection);
    initHeaderData();
}

Processes::~Processes() {
    if (m_ownsPrivate) {
        processes_free(m_d);
    }
}
void Processes::initHeaderData() {
    m_headerData.insert(qMakePair(0, Qt::DisplayRole), QVariant("name"));
    m_headerData.insert(qMakePair(1, Qt::DisplayRole), QVariant("cpuUsage"));
    m_headerData.insert(qMakePair(2, Qt::DisplayRole), QVariant("memory"));
}
bool Processes::active() const
{
    return processes_active_get(m_d);
}
void Processes::setActive(bool v) {
    processes_active_set(m_d, v);
}
TimeSeries::TimeSeries(bool /*owned*/, QObject *parent):
    QAbstractItemModel(parent),
    m_d(nullptr),
    m_ownsPrivate(false)
{
    initHeaderData();
}

TimeSeries::TimeSeries(QObject *parent):
    QAbstractItemModel(parent),
    m_d(time_series_new(this,
        [](const TimeSeries* o) {
            Q_EMIT o->newDataReady(QModelIndex());
        },
        [](TimeSeries* o) {
            Q_EMIT o->layoutAboutToBeChanged();
        },
        [](TimeSeries* o) {
            o->updatePersistentIndexes();
            Q_EMIT o->layoutChanged();
        },
        [](TimeSeries* o, quintptr first, quintptr last) {
            o->dataChanged(o->createIndex(first, 0, first),
                       o->createIndex(last, 2, last));
        },
        [](TimeSeries* o) {
            o->beginResetModel();
        },
        [](TimeSeries* o) {
            o->endResetModel();
        },
        [](TimeSeries* o, int first, int last) {
            o->beginInsertRows(QModelIndex(), first, last);
        },
        [](TimeSeries* o) {
            o->endInsertRows();
        },
        [](TimeSeries* o, int first, int last, int destination) {
            o->beginMoveRows(QModelIndex(), first, last, QModelIndex(), destination);
        },
        [](TimeSeries* o) {
            o->endMoveRows();
        },
        [](TimeSeries* o, int first, int last) {
            o->beginRemoveRows(QModelIndex(), first, last);
        },
        [](TimeSeries* o) {
            o->endRemoveRows();
        }
)),
    m_ownsPrivate(true)
{
    connect(this, &TimeSeries::newDataReady, this, [this](const QModelIndex& i) {
        this->fetchMore(i);
    }, Qt::QueuedConnection);
    initHeaderData();
}

TimeSeries::~TimeSeries() {
    if (m_ownsPrivate) {
        time_series_free(m_d);
    }
}
void TimeSeries::initHeaderData() {
    m_headerData.insert(qMakePair(0, Qt::DisplayRole), QVariant("time"));
    m_headerData.insert(qMakePair(1, Qt::DisplayRole), QVariant("sin"));
    m_headerData.insert(qMakePair(2, Qt::DisplayRole), QVariant("cos"));
}