/****************************************************************************
** Meta object code from reading C++ file 'playlist.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 "../../../strawberry/src/playlist/playlist.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'playlist.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_ZN8PlaylistE_t {};
} // unnamed namespace

template <> constexpr inline auto Playlist::qt_create_metaobjectdata<qt_meta_tag_ZN8PlaylistE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Playlist",
        "RestoreFinished",
        "",
        "PlaylistLoaded",
        "CurrentSongChanged",
        "Song",
        "metadata",
        "CurrentSongMetadataChanged",
        "EditingFinished",
        "playlist_id",
        "QModelIndex",
        "idx",
        "PlayRequested",
        "Playlist::AutoScroll",
        "autoscroll",
        "MaybeAutoscroll",
        "PlaylistChanged",
        "DynamicModeChanged",
        "dynamic",
        "Error",
        "message",
        "QueueChanged",
        "PlaylistItemsAdded",
        "QList<QUuid>",
        "track_ids",
        "QUuid",
        "after_track_id",
        "PlaylistItemsRemoved",
        "PlaylistItemMetadataChanged",
        "track_id",
        "Rename",
        "id",
        "name",
        "set_current_row",
        "i",
        "is_stopping",
        "force_inform",
        "Paused",
        "Playing",
        "Stopped",
        "IgnoreSorting",
        "value",
        "ClearStreamMetadata",
        "UpdateItems",
        "SongList",
        "songs",
        "Clear",
        "RemoveDuplicateSongs",
        "RemoveUnavailableSongs",
        "Shuffle",
        "ShuffleModeChanged",
        "PlaylistSequence::ShuffleMode",
        "shuffle_mode",
        "SetColumnAlignment",
        "ColumnAlignmentMap",
        "alignment",
        "InsertUrls",
        "QList<QUrl>",
        "urls",
        "pos",
        "play_now",
        "enqueue",
        "enqueue_next",
        "signal",
        "RemoveItemsWithoutUndo",
        "QList<int>",
        "indicesIn",
        "ExpandDynamicPlaylist",
        "RepopulateDynamicPlaylist",
        "TurnOffDynamicPlaylist",
        "AlbumCoverLoaded",
        "song",
        "AlbumCoverLoaderResult",
        "result",
        "TracksAboutToBeDequeued",
        "begin",
        "end",
        "TracksDequeued",
        "TracksEnqueued",
        "parent_idx",
        "QueueLayoutChanged",
        "SongSaveComplete",
        "TagReaderReplyPtr",
        "reply",
        "QPersistentModelIndex",
        "ItemReloadComplete",
        "new_metadata",
        "metadata_edit",
        "ItemsLoaded",
        "ScheduleSave",
        "ForceScheduleSave",
        "Save"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'RestoreFinished'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'PlaylistLoaded'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'CurrentSongChanged'
        QtMocHelpers::SignalData<void(const Song &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'CurrentSongMetadataChanged'
        QtMocHelpers::SignalData<void(const Song &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'EditingFinished'
        QtMocHelpers::SignalData<void(const int, const QModelIndex)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 }, { 0x80000000 | 10, 11 },
        }}),
        // Signal 'PlayRequested'
        QtMocHelpers::SignalData<void(const QModelIndex, const Playlist::AutoScroll)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 11 }, { 0x80000000 | 13, 14 },
        }}),
        // Signal 'MaybeAutoscroll'
        QtMocHelpers::SignalData<void(const Playlist::AutoScroll)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 14 },
        }}),
        // Signal 'PlaylistChanged'
        QtMocHelpers::SignalData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'DynamicModeChanged'
        QtMocHelpers::SignalData<void(bool)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 18 },
        }}),
        // Signal 'Error'
        QtMocHelpers::SignalData<void(QString)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 },
        }}),
        // Signal 'QueueChanged'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'PlaylistItemsAdded'
        QtMocHelpers::SignalData<void(const int, const QList<QUuid> &, const QUuid)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 }, { 0x80000000 | 23, 24 }, { 0x80000000 | 25, 26 },
        }}),
        // Signal 'PlaylistItemsRemoved'
        QtMocHelpers::SignalData<void(const int, const QList<QUuid> &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 }, { 0x80000000 | 23, 24 },
        }}),
        // Signal 'PlaylistItemMetadataChanged'
        QtMocHelpers::SignalData<void(const int, const QUuid)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 }, { 0x80000000 | 25, 29 },
        }}),
        // Signal 'Rename'
        QtMocHelpers::SignalData<void(const int, const QString &)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 }, { QMetaType::QString, 32 },
        }}),
        // Slot 'set_current_row'
        QtMocHelpers::SlotData<void(const int, const Playlist::AutoScroll, const bool, const bool)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 34 }, { 0x80000000 | 13, 14 }, { QMetaType::Bool, 35 }, { QMetaType::Bool, 36 },
        }}),
        // Slot 'set_current_row'
        QtMocHelpers::SlotData<void(const int, const Playlist::AutoScroll, const bool)>(33, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 34 }, { 0x80000000 | 13, 14 }, { QMetaType::Bool, 35 },
        }}),
        // Slot 'set_current_row'
        QtMocHelpers::SlotData<void(const int, const Playlist::AutoScroll)>(33, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 34 }, { 0x80000000 | 13, 14 },
        }}),
        // Slot 'set_current_row'
        QtMocHelpers::SlotData<void(const int)>(33, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 34 },
        }}),
        // Slot 'Paused'
        QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'Playing'
        QtMocHelpers::SlotData<void()>(38, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'Stopped'
        QtMocHelpers::SlotData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'IgnoreSorting'
        QtMocHelpers::SlotData<void(const bool)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 41 },
        }}),
        // Slot 'ClearStreamMetadata'
        QtMocHelpers::SlotData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'UpdateItems'
        QtMocHelpers::SlotData<void(SongList)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 44, 45 },
        }}),
        // Slot 'Clear'
        QtMocHelpers::SlotData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'RemoveDuplicateSongs'
        QtMocHelpers::SlotData<void()>(47, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'RemoveUnavailableSongs'
        QtMocHelpers::SlotData<void()>(48, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'Shuffle'
        QtMocHelpers::SlotData<void()>(49, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'ShuffleModeChanged'
        QtMocHelpers::SlotData<void(const PlaylistSequence::ShuffleMode)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 51, 52 },
        }}),
        // Slot 'SetColumnAlignment'
        QtMocHelpers::SlotData<void(const ColumnAlignmentMap &)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 54, 55 },
        }}),
        // Slot 'InsertUrls'
        QtMocHelpers::SlotData<void(const QList<QUrl> &, const int, const bool, const bool, const bool, const bool)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 }, { QMetaType::Int, 59 }, { QMetaType::Bool, 60 }, { QMetaType::Bool, 61 },
            { QMetaType::Bool, 62 }, { QMetaType::Bool, 63 },
        }}),
        // Slot 'InsertUrls'
        QtMocHelpers::SlotData<void(const QList<QUrl> &, const int, const bool, const bool, const bool)>(56, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 57, 58 }, { QMetaType::Int, 59 }, { QMetaType::Bool, 60 }, { QMetaType::Bool, 61 },
            { QMetaType::Bool, 62 },
        }}),
        // Slot 'InsertUrls'
        QtMocHelpers::SlotData<void(const QList<QUrl> &, const int, const bool, const bool)>(56, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 57, 58 }, { QMetaType::Int, 59 }, { QMetaType::Bool, 60 }, { QMetaType::Bool, 61 },
        }}),
        // Slot 'InsertUrls'
        QtMocHelpers::SlotData<void(const QList<QUrl> &, const int, const bool)>(56, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 57, 58 }, { QMetaType::Int, 59 }, { QMetaType::Bool, 60 },
        }}),
        // Slot 'InsertUrls'
        QtMocHelpers::SlotData<void(const QList<QUrl> &, const int)>(56, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 57, 58 }, { QMetaType::Int, 59 },
        }}),
        // Slot 'InsertUrls'
        QtMocHelpers::SlotData<void(const QList<QUrl> &)>(56, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'RemoveItemsWithoutUndo'
        QtMocHelpers::SlotData<void(const QList<int> &)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 65, 66 },
        }}),
        // Slot 'ExpandDynamicPlaylist'
        QtMocHelpers::SlotData<void()>(67, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'RepopulateDynamicPlaylist'
        QtMocHelpers::SlotData<void()>(68, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'TurnOffDynamicPlaylist'
        QtMocHelpers::SlotData<void()>(69, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'AlbumCoverLoaded'
        QtMocHelpers::SlotData<void(const Song &, const AlbumCoverLoaderResult &)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 71 }, { 0x80000000 | 72, 73 },
        }}),
        // Slot 'TracksAboutToBeDequeued'
        QtMocHelpers::SlotData<void(const QModelIndex &, const int, const int)>(74, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 10, 2 }, { QMetaType::Int, 75 }, { QMetaType::Int, 76 },
        }}),
        // Slot 'TracksDequeued'
        QtMocHelpers::SlotData<void()>(77, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'TracksEnqueued'
        QtMocHelpers::SlotData<void(const QModelIndex &, const int, const int)>(78, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 10, 79 }, { QMetaType::Int, 75 }, { QMetaType::Int, 76 },
        }}),
        // Slot 'QueueLayoutChanged'
        QtMocHelpers::SlotData<void()>(80, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'SongSaveComplete'
        QtMocHelpers::SlotData<void(TagReaderReplyPtr, const QPersistentModelIndex &)>(81, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 82, 83 }, { 0x80000000 | 84, 11 },
        }}),
        // Slot 'ItemReloadComplete'
        QtMocHelpers::SlotData<void(const QPersistentModelIndex &, const Song &, const bool)>(85, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 84, 11 }, { 0x80000000 | 5, 86 }, { QMetaType::Bool, 87 },
        }}),
        // Slot 'ItemsLoaded'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'ScheduleSave'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'ForceScheduleSave'
        QtMocHelpers::SlotData<void()>(90, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'Save'
        QtMocHelpers::SlotData<void()>(91, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Playlist, qt_meta_tag_ZN8PlaylistE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Playlist::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8PlaylistE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8PlaylistE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8PlaylistE_t>.metaTypes,
    nullptr
} };

void Playlist::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Playlist *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->RestoreFinished(); break;
        case 1: _t->PlaylistLoaded(); break;
        case 2: _t->CurrentSongChanged((*reinterpret_cast<std::add_pointer_t<Song>>(_a[1]))); break;
        case 3: _t->CurrentSongMetadataChanged((*reinterpret_cast<std::add_pointer_t<Song>>(_a[1]))); break;
        case 4: _t->EditingFinished((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[2]))); break;
        case 5: _t->PlayRequested((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Playlist::AutoScroll>>(_a[2]))); break;
        case 6: _t->MaybeAutoscroll((*reinterpret_cast<std::add_pointer_t<Playlist::AutoScroll>>(_a[1]))); break;
        case 7: _t->PlaylistChanged(); break;
        case 8: _t->DynamicModeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->Error((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 10: _t->QueueChanged(); break;
        case 11: _t->PlaylistItemsAdded((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QUuid>>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QUuid>>(_a[3]))); break;
        case 12: _t->PlaylistItemsRemoved((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QUuid>>>(_a[2]))); break;
        case 13: _t->PlaylistItemMetadataChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QUuid>>(_a[2]))); break;
        case 14: _t->Rename((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 15: _t->set_current_row((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Playlist::AutoScroll>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 16: _t->set_current_row((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Playlist::AutoScroll>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 17: _t->set_current_row((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Playlist::AutoScroll>>(_a[2]))); break;
        case 18: _t->set_current_row((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 19: _t->Paused(); break;
        case 20: _t->Playing(); break;
        case 21: _t->Stopped(); break;
        case 22: _t->IgnoreSorting((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 23: _t->ClearStreamMetadata(); break;
        case 24: _t->UpdateItems((*reinterpret_cast<std::add_pointer_t<SongList>>(_a[1]))); break;
        case 25: _t->Clear(); break;
        case 26: _t->RemoveDuplicateSongs(); break;
        case 27: _t->RemoveUnavailableSongs(); break;
        case 28: _t->Shuffle(); break;
        case 29: _t->ShuffleModeChanged((*reinterpret_cast<std::add_pointer_t<PlaylistSequence::ShuffleMode>>(_a[1]))); break;
        case 30: _t->SetColumnAlignment((*reinterpret_cast<std::add_pointer_t<ColumnAlignmentMap>>(_a[1]))); break;
        case 31: _t->InsertUrls((*reinterpret_cast<std::add_pointer_t<QList<QUrl>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[6]))); break;
        case 32: _t->InsertUrls((*reinterpret_cast<std::add_pointer_t<QList<QUrl>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5]))); break;
        case 33: _t->InsertUrls((*reinterpret_cast<std::add_pointer_t<QList<QUrl>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 34: _t->InsertUrls((*reinterpret_cast<std::add_pointer_t<QList<QUrl>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 35: _t->InsertUrls((*reinterpret_cast<std::add_pointer_t<QList<QUrl>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 36: _t->InsertUrls((*reinterpret_cast<std::add_pointer_t<QList<QUrl>>>(_a[1]))); break;
        case 37: _t->RemoveItemsWithoutUndo((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1]))); break;
        case 38: _t->ExpandDynamicPlaylist(); break;
        case 39: _t->RepopulateDynamicPlaylist(); break;
        case 40: _t->TurnOffDynamicPlaylist(); break;
        case 41: _t->AlbumCoverLoaded((*reinterpret_cast<std::add_pointer_t<Song>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<AlbumCoverLoaderResult>>(_a[2]))); break;
        case 42: _t->TracksAboutToBeDequeued((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 43: _t->TracksDequeued(); break;
        case 44: _t->TracksEnqueued((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 45: _t->QueueLayoutChanged(); break;
        case 46: _t->SongSaveComplete((*reinterpret_cast<std::add_pointer_t<TagReaderReplyPtr>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPersistentModelIndex>>(_a[2]))); break;
        case 47: _t->ItemReloadComplete((*reinterpret_cast<std::add_pointer_t<QPersistentModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Song>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 48: _t->ItemsLoaded(); break;
        case 49: _t->ScheduleSave(); break;
        case 50: _t->ForceScheduleSave(); break;
        case 51: _t->Save(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 30:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ColumnAlignmentMap >(); break;
            }
            break;
        case 37:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)()>(_a, &Playlist::RestoreFinished, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)()>(_a, &Playlist::PlaylistLoaded, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const Song & )>(_a, &Playlist::CurrentSongChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const Song & )>(_a, &Playlist::CurrentSongMetadataChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const int , const QModelIndex )>(_a, &Playlist::EditingFinished, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const QModelIndex , const Playlist::AutoScroll )>(_a, &Playlist::PlayRequested, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const Playlist::AutoScroll )>(_a, &Playlist::MaybeAutoscroll, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)()>(_a, &Playlist::PlaylistChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(bool )>(_a, &Playlist::DynamicModeChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(QString )>(_a, &Playlist::Error, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)()>(_a, &Playlist::QueueChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const int , const QList<QUuid> & , const QUuid )>(_a, &Playlist::PlaylistItemsAdded, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const int , const QList<QUuid> & )>(_a, &Playlist::PlaylistItemsRemoved, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const int , const QUuid )>(_a, &Playlist::PlaylistItemMetadataChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Playlist::*)(const int , const QString & )>(_a, &Playlist::Rename, 14))
            return;
    }
}

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

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

int Playlist::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 52)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 52;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 52)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 52;
    }
    return _id;
}

// SIGNAL 0
void Playlist::RestoreFinished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void Playlist::PlaylistLoaded()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void Playlist::CurrentSongChanged(const Song & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void Playlist::CurrentSongMetadataChanged(const Song & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void Playlist::EditingFinished(const int _t1, const QModelIndex _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1, _t2);
}

// SIGNAL 5
void Playlist::PlayRequested(const QModelIndex _t1, const Playlist::AutoScroll _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1, _t2);
}

// SIGNAL 6
void Playlist::MaybeAutoscroll(const Playlist::AutoScroll _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void Playlist::PlaylistChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void Playlist::DynamicModeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void Playlist::Error(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Playlist::QueueChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void Playlist::PlaylistItemsAdded(const int _t1, const QList<QUuid> & _t2, const QUuid _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2, _t3);
}

// SIGNAL 12
void Playlist::PlaylistItemsRemoved(const int _t1, const QList<QUuid> & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2);
}

// SIGNAL 13
void Playlist::PlaylistItemMetadataChanged(const int _t1, const QUuid _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1, _t2);
}

// SIGNAL 14
void Playlist::Rename(const int _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1, _t2);
}
QT_WARNING_POP
