/****************************************************************************
** Meta object code from reading C++ file 'bupvfs.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../kup-0.10.0/kioworker/bupvfs.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'bupvfs.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN4NodeE_t {};
} // unnamed namespace

template <> constexpr inline auto Node::qt_create_metaobjectdata<qt_meta_tag_ZN4NodeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Node"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Node, qt_meta_tag_ZN4NodeE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Node::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4NodeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4NodeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4NodeE_t>.metaTypes,
    nullptr
} };

void Node::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Node *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *Node::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Node::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4NodeE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Metadata"))
        return static_cast< Metadata*>(this);
    return QObject::qt_metacast(_clname);
}

int Node::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN9DirectoryE_t {};
} // unnamed namespace

template <> constexpr inline auto Directory::qt_create_metaobjectdata<qt_meta_tag_ZN9DirectoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Directory"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Directory, qt_meta_tag_ZN9DirectoryE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Directory::staticMetaObject = { {
    QMetaObject::SuperData::link<Node::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9DirectoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9DirectoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9DirectoryE_t>.metaTypes,
    nullptr
} };

void Directory::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Directory *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *Directory::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Directory::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9DirectoryE_t>.strings))
        return static_cast<void*>(this);
    return Node::qt_metacast(_clname);
}

int Directory::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Node::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN4FileE_t {};
} // unnamed namespace

template <> constexpr inline auto File::qt_create_metaobjectdata<qt_meta_tag_ZN4FileE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "File"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<File, qt_meta_tag_ZN4FileE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject File::staticMetaObject = { {
    QMetaObject::SuperData::link<Node::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4FileE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4FileE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4FileE_t>.metaTypes,
    nullptr
} };

void File::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<File *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *File::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *File::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4FileE_t>.strings))
        return static_cast<void*>(this);
    return Node::qt_metacast(_clname);
}

int File::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Node::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN8BlobFileE_t {};
} // unnamed namespace

template <> constexpr inline auto BlobFile::qt_create_metaobjectdata<qt_meta_tag_ZN8BlobFileE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "BlobFile"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<BlobFile, qt_meta_tag_ZN8BlobFileE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject BlobFile::staticMetaObject = { {
    QMetaObject::SuperData::link<File::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8BlobFileE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8BlobFileE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8BlobFileE_t>.metaTypes,
    nullptr
} };

void BlobFile::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<BlobFile *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *BlobFile::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *BlobFile::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8BlobFileE_t>.strings))
        return static_cast<void*>(this);
    return File::qt_metacast(_clname);
}

int BlobFile::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = File::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN7SymlinkE_t {};
} // unnamed namespace

template <> constexpr inline auto Symlink::qt_create_metaobjectdata<qt_meta_tag_ZN7SymlinkE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Symlink"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Symlink, qt_meta_tag_ZN7SymlinkE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Symlink::staticMetaObject = { {
    QMetaObject::SuperData::link<BlobFile::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7SymlinkE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7SymlinkE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7SymlinkE_t>.metaTypes,
    nullptr
} };

void Symlink::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Symlink *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *Symlink::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Symlink::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7SymlinkE_t>.strings))
        return static_cast<void*>(this);
    return BlobFile::qt_metacast(_clname);
}

int Symlink::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BlobFile::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN9ChunkFileE_t {};
} // unnamed namespace

template <> constexpr inline auto ChunkFile::qt_create_metaobjectdata<qt_meta_tag_ZN9ChunkFileE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ChunkFile"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ChunkFile, qt_meta_tag_ZN9ChunkFileE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ChunkFile::staticMetaObject = { {
    QMetaObject::SuperData::link<File::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9ChunkFileE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9ChunkFileE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9ChunkFileE_t>.metaTypes,
    nullptr
} };

void ChunkFile::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ChunkFile *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *ChunkFile::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *ChunkFile::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9ChunkFileE_t>.strings))
        return static_cast<void*>(this);
    return File::qt_metacast(_clname);
}

int ChunkFile::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = File::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17ArchivedDirectoryE_t {};
} // unnamed namespace

template <> constexpr inline auto ArchivedDirectory::qt_create_metaobjectdata<qt_meta_tag_ZN17ArchivedDirectoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ArchivedDirectory"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ArchivedDirectory, qt_meta_tag_ZN17ArchivedDirectoryE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ArchivedDirectory::staticMetaObject = { {
    QMetaObject::SuperData::link<Directory::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17ArchivedDirectoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17ArchivedDirectoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17ArchivedDirectoryE_t>.metaTypes,
    nullptr
} };

void ArchivedDirectory::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ArchivedDirectory *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *ArchivedDirectory::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *ArchivedDirectory::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17ArchivedDirectoryE_t>.strings))
        return static_cast<void*>(this);
    return Directory::qt_metacast(_clname);
}

int ArchivedDirectory::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Directory::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN6BranchE_t {};
} // unnamed namespace

template <> constexpr inline auto Branch::qt_create_metaobjectdata<qt_meta_tag_ZN6BranchE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Branch"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Branch, qt_meta_tag_ZN6BranchE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Branch::staticMetaObject = { {
    QMetaObject::SuperData::link<Directory::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6BranchE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6BranchE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6BranchE_t>.metaTypes,
    nullptr
} };

void Branch::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Branch *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *Branch::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Branch::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6BranchE_t>.strings))
        return static_cast<void*>(this);
    return Directory::qt_metacast(_clname);
}

int Branch::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Directory::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN10RepositoryE_t {};
} // unnamed namespace

template <> constexpr inline auto Repository::qt_create_metaobjectdata<qt_meta_tag_ZN10RepositoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Repository"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Repository, qt_meta_tag_ZN10RepositoryE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Repository::staticMetaObject = { {
    QMetaObject::SuperData::link<Directory::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10RepositoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10RepositoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10RepositoryE_t>.metaTypes,
    nullptr
} };

void Repository::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Repository *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

const QMetaObject *Repository::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *Repository::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10RepositoryE_t>.strings))
        return static_cast<void*>(this);
    return Directory::qt_metacast(_clname);
}

int Repository::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Directory::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
