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

#include <memory>
#include "plugins/CopyEngine/Ultracopier-Spec/ListThread.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'ListThread.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.18. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_ListThread_t {
    QByteArrayData data[170];
    char stringdata0[2904];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ListThread_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ListThread_t qt_meta_stringdata_ListThread = {
    {
QT_MOC_LITERAL(0, 0, 10), // "ListThread"
QT_MOC_LITERAL(1, 11, 15), // "actionInProgess"
QT_MOC_LITERAL(2, 27, 0), // ""
QT_MOC_LITERAL(3, 28, 35), // "Ultracopier::EngineActionInPr..."
QT_MOC_LITERAL(4, 64, 15), // "newActionOnList"
QT_MOC_LITERAL(5, 80, 48), // "std::vector<Ultracopier::Retu..."
QT_MOC_LITERAL(6, 129, 9), // "syncReady"
QT_MOC_LITERAL(7, 139, 8), // "doneTime"
QT_MOC_LITERAL(8, 148, 42), // "std::vector<std::pair<uint64_..."
QT_MOC_LITERAL(9, 191, 19), // "pushFileProgression"
QT_MOC_LITERAL(10, 211, 41), // "std::vector<Ultracopier::Prog..."
QT_MOC_LITERAL(11, 253, 15), // "progressionList"
QT_MOC_LITERAL(12, 269, 22), // "pushGeneralProgression"
QT_MOC_LITERAL(13, 292, 8), // "uint64_t"
QT_MOC_LITERAL(14, 301, 16), // "newFolderListing"
QT_MOC_LITERAL(15, 318, 11), // "std::string"
QT_MOC_LITERAL(16, 330, 4), // "path"
QT_MOC_LITERAL(17, 335, 12), // "canBeDeleted"
QT_MOC_LITERAL(18, 348, 19), // "haveNeedPutAtBottom"
QT_MOC_LITERAL(19, 368, 15), // "needPutAtBottom"
QT_MOC_LITERAL(20, 384, 8), // "fileInfo"
QT_MOC_LITERAL(21, 393, 11), // "errorString"
QT_MOC_LITERAL(22, 405, 20), // "TransferThreadAsync*"
QT_MOC_LITERAL(23, 426, 6), // "thread"
QT_MOC_LITERAL(24, 433, 9), // "ErrorType"
QT_MOC_LITERAL(25, 443, 9), // "errorType"
QT_MOC_LITERAL(26, 453, 5), // "error"
QT_MOC_LITERAL(27, 459, 4), // "size"
QT_MOC_LITERAL(28, 464, 5), // "mtime"
QT_MOC_LITERAL(29, 470, 12), // "errorToRetry"
QT_MOC_LITERAL(30, 483, 6), // "source"
QT_MOC_LITERAL(31, 490, 11), // "destination"
QT_MOC_LITERAL(32, 502, 6), // "rmPath"
QT_MOC_LITERAL(33, 509, 6), // "mkPath"
QT_MOC_LITERAL(34, 516, 16), // "debugInformation"
QT_MOC_LITERAL(35, 533, 23), // "Ultracopier::DebugLevel"
QT_MOC_LITERAL(36, 557, 5), // "level"
QT_MOC_LITERAL(37, 563, 8), // "fonction"
QT_MOC_LITERAL(38, 572, 4), // "text"
QT_MOC_LITERAL(39, 577, 4), // "file"
QT_MOC_LITERAL(40, 582, 5), // "ligne"
QT_MOC_LITERAL(41, 588, 18), // "updateTheDebugInfo"
QT_MOC_LITERAL(42, 607, 24), // "std::vector<std::string>"
QT_MOC_LITERAL(43, 632, 22), // "send_fileAlreadyExists"
QT_MOC_LITERAL(44, 655, 6), // "isSame"
QT_MOC_LITERAL(45, 662, 16), // "send_errorOnFile"
QT_MOC_LITERAL(46, 679, 24), // "send_folderAlreadyExists"
QT_MOC_LITERAL(47, 704, 17), // "ScanFileOrFolder*"
QT_MOC_LITERAL(48, 722, 18), // "send_errorOnFolder"
QT_MOC_LITERAL(49, 741, 21), // "send_syncTransferList"
QT_MOC_LITERAL(50, 763, 19), // "mkPathErrorOnFolder"
QT_MOC_LITERAL(51, 783, 9), // "tryCancel"
QT_MOC_LITERAL(52, 793, 20), // "askNewTransferThread"
QT_MOC_LITERAL(53, 814, 19), // "warningTransferList"
QT_MOC_LITERAL(54, 834, 7), // "warning"
QT_MOC_LITERAL(55, 842, 17), // "errorTransferList"
QT_MOC_LITERAL(56, 860, 25), // "send_sendNewRenamingRules"
QT_MOC_LITERAL(57, 886, 17), // "firstRenamingRule"
QT_MOC_LITERAL(58, 904, 17), // "otherRenamingRule"
QT_MOC_LITERAL(59, 922, 24), // "send_realBytesTransfered"
QT_MOC_LITERAL(60, 947, 29), // "send_parallelizeIfSmallerThan"
QT_MOC_LITERAL(61, 977, 24), // "parallelizeIfSmallerThan"
QT_MOC_LITERAL(62, 1002, 16), // "send_updateMount"
QT_MOC_LITERAL(63, 1019, 16), // "missingDiskSpace"
QT_MOC_LITERAL(64, 1036, 22), // "std::vector<Diskspace>"
QT_MOC_LITERAL(65, 1059, 4), // "list"
QT_MOC_LITERAL(66, 1064, 9), // "isInPause"
QT_MOC_LITERAL(67, 1074, 22), // "exportTransferListSend"
QT_MOC_LITERAL(68, 1097, 8), // "fileName"
QT_MOC_LITERAL(69, 1106, 22), // "importTransferListSend"
QT_MOC_LITERAL(70, 1129, 5), // "pause"
QT_MOC_LITERAL(71, 1135, 6), // "resume"
QT_MOC_LITERAL(72, 1142, 4), // "skip"
QT_MOC_LITERAL(73, 1147, 2), // "id"
QT_MOC_LITERAL(74, 1150, 12), // "skipInternal"
QT_MOC_LITERAL(75, 1163, 6), // "cancel"
QT_MOC_LITERAL(76, 1170, 11), // "removeItems"
QT_MOC_LITERAL(77, 1182, 21), // "std::vector<uint64_t>"
QT_MOC_LITERAL(78, 1204, 3), // "ids"
QT_MOC_LITERAL(79, 1208, 14), // "moveItemsOnTop"
QT_MOC_LITERAL(80, 1223, 11), // "moveItemsUp"
QT_MOC_LITERAL(81, 1235, 13), // "moveItemsDown"
QT_MOC_LITERAL(82, 1249, 17), // "moveItemsOnBottom"
QT_MOC_LITERAL(83, 1267, 9), // "forceMode"
QT_MOC_LITERAL(84, 1277, 21), // "Ultracopier::CopyMode"
QT_MOC_LITERAL(85, 1299, 4), // "mode"
QT_MOC_LITERAL(86, 1304, 18), // "exportTransferList"
QT_MOC_LITERAL(87, 1323, 18), // "importTransferList"
QT_MOC_LITERAL(88, 1342, 18), // "setFolderCollision"
QT_MOC_LITERAL(89, 1361, 18), // "FolderExistsAction"
QT_MOC_LITERAL(90, 1380, 33), // "alwaysDoThisActionForFolderEx..."
QT_MOC_LITERAL(91, 1414, 18), // "setSpeedLimitation"
QT_MOC_LITERAL(92, 1433, 7), // "int64_t"
QT_MOC_LITERAL(93, 1441, 15), // "speedLimitation"
QT_MOC_LITERAL(94, 1457, 16), // "setRightTransfer"
QT_MOC_LITERAL(95, 1474, 15), // "doRightTransfer"
QT_MOC_LITERAL(96, 1490, 11), // "setKeepDate"
QT_MOC_LITERAL(97, 1502, 8), // "keepDate"
QT_MOC_LITERAL(98, 1511, 14), // "setOsSpecFlags"
QT_MOC_LITERAL(99, 1526, 13), // "os_spec_flags"
QT_MOC_LITERAL(100, 1540, 13), // "setNativeCopy"
QT_MOC_LITERAL(101, 1554, 11), // "native_copy"
QT_MOC_LITERAL(102, 1566, 31), // "setCheckDestinationFolderExists"
QT_MOC_LITERAL(103, 1598, 28), // "checkDestinationFolderExists"
QT_MOC_LITERAL(104, 1627, 25), // "setAlwaysFileExistsAction"
QT_MOC_LITERAL(105, 1653, 16), // "FileExistsAction"
QT_MOC_LITERAL(106, 1670, 31), // "alwaysDoThisActionForFileExists"
QT_MOC_LITERAL(107, 1702, 27), // "doNewActions_start_transfer"
QT_MOC_LITERAL(108, 1730, 31), // "doNewActions_inode_manipulation"
QT_MOC_LITERAL(109, 1762, 22), // "restartTransferIfItCan"
QT_MOC_LITERAL(110, 1785, 18), // "getNeedPutAtBottom"
QT_MOC_LITERAL(111, 1804, 15), // "newTransferStat"
QT_MOC_LITERAL(112, 1820, 12), // "TransferStat"
QT_MOC_LITERAL(113, 1833, 4), // "stat"
QT_MOC_LITERAL(114, 1838, 14), // "set_setFilters"
QT_MOC_LITERAL(115, 1853, 26), // "std::vector<Filters_rules>"
QT_MOC_LITERAL(116, 1880, 7), // "include"
QT_MOC_LITERAL(117, 1888, 7), // "exclude"
QT_MOC_LITERAL(118, 1896, 24), // "set_sendNewRenamingRules"
QT_MOC_LITERAL(119, 1921, 15), // "set_updateMount"
QT_MOC_LITERAL(120, 1937, 14), // "sendActionDone"
QT_MOC_LITERAL(121, 1952, 15), // "sendProgression"
QT_MOC_LITERAL(122, 1968, 21), // "setMoveTheWholeFolder"
QT_MOC_LITERAL(123, 1990, 18), // "moveTheWholeFolder"
QT_MOC_LITERAL(124, 2009, 23), // "setFollowTheStrictOrder"
QT_MOC_LITERAL(125, 2033, 20), // "followTheStrictOrder"
QT_MOC_LITERAL(126, 2054, 18), // "setignoreBlackList"
QT_MOC_LITERAL(127, 2073, 15), // "ignoreBlackList"
QT_MOC_LITERAL(128, 2089, 34), // "setDeletePartiallyTransferred..."
QT_MOC_LITERAL(129, 2124, 31), // "deletePartiallyTransferredFiles"
QT_MOC_LITERAL(130, 2156, 15), // "setInodeThreads"
QT_MOC_LITERAL(131, 2172, 12), // "inodeThreads"
QT_MOC_LITERAL(132, 2185, 31), // "setRenameTheOriginalDestination"
QT_MOC_LITERAL(133, 2217, 28), // "renameTheOriginalDestination"
QT_MOC_LITERAL(134, 2246, 17), // "setCheckDiskSpace"
QT_MOC_LITERAL(135, 2264, 14), // "checkDiskSpace"
QT_MOC_LITERAL(136, 2279, 9), // "setBuffer"
QT_MOC_LITERAL(137, 2289, 6), // "buffer"
QT_MOC_LITERAL(138, 2296, 27), // "exportErrorIntoTransferList"
QT_MOC_LITERAL(139, 2324, 26), // "exportTransferListInternal"
QT_MOC_LITERAL(140, 2351, 26), // "importTransferListInternal"
QT_MOC_LITERAL(141, 2378, 24), // "scanThreadHaveFinishSlot"
QT_MOC_LITERAL(142, 2403, 20), // "scanThreadHaveFinish"
QT_MOC_LITERAL(143, 2424, 15), // "skipFirstRemove"
QT_MOC_LITERAL(144, 2440, 22), // "autoStartAndCheckSpace"
QT_MOC_LITERAL(145, 2463, 15), // "updateTheStatus"
QT_MOC_LITERAL(146, 2479, 12), // "fileTransfer"
QT_MOC_LITERAL(147, 2492, 14), // "sourceFileInfo"
QT_MOC_LITERAL(148, 2507, 19), // "destinationFileInfo"
QT_MOC_LITERAL(149, 2527, 21), // "fileTransferWithInode"
QT_MOC_LITERAL(150, 2549, 25), // "TransferThread::dirent_uc"
QT_MOC_LITERAL(151, 2575, 5), // "inode"
QT_MOC_LITERAL(152, 2581, 23), // "mkPathFirstFolderFinish"
QT_MOC_LITERAL(153, 2605, 19), // "transferPutAtBottom"
QT_MOC_LITERAL(154, 2625, 21), // "transferInodeIsClosed"
QT_MOC_LITERAL(155, 2647, 22), // "timedUpdateDebugDialog"
QT_MOC_LITERAL(156, 2670, 17), // "fileAlreadyExists"
QT_MOC_LITERAL(157, 2688, 11), // "errorOnFile"
QT_MOC_LITERAL(158, 2700, 19), // "folderAlreadyExists"
QT_MOC_LITERAL(159, 2720, 13), // "errorOnFolder"
QT_MOC_LITERAL(160, 2734, 3), // "run"
QT_MOC_LITERAL(161, 2738, 20), // "createTransferThread"
QT_MOC_LITERAL(162, 2759, 20), // "deleteTransferThread"
QT_MOC_LITERAL(163, 2780, 11), // "addToMkPath"
QT_MOC_LITERAL(164, 2792, 13), // "addToMovePath"
QT_MOC_LITERAL(165, 2806, 13), // "inodeToRemove"
QT_MOC_LITERAL(166, 2820, 22), // "addToKeepAttributePath"
QT_MOC_LITERAL(167, 2843, 13), // "addToRealMove"
QT_MOC_LITERAL(168, 2857, 25), // "syncTransferList_internal"
QT_MOC_LITERAL(169, 2883, 20) // "checkIfReadyToCancel"

    },
    "ListThread\0actionInProgess\0\0"
    "Ultracopier::EngineActionInProgress\0"
    "newActionOnList\0"
    "std::vector<Ultracopier::ReturnActionOnCopyList>\0"
    "syncReady\0doneTime\0"
    "std::vector<std::pair<uint64_t,uint32_t> >\0"
    "pushFileProgression\0"
    "std::vector<Ultracopier::ProgressionItem>\0"
    "progressionList\0pushGeneralProgression\0"
    "uint64_t\0newFolderListing\0std::string\0"
    "path\0canBeDeleted\0haveNeedPutAtBottom\0"
    "needPutAtBottom\0fileInfo\0errorString\0"
    "TransferThreadAsync*\0thread\0ErrorType\0"
    "errorType\0error\0size\0mtime\0errorToRetry\0"
    "source\0destination\0rmPath\0mkPath\0"
    "debugInformation\0Ultracopier::DebugLevel\0"
    "level\0fonction\0text\0file\0ligne\0"
    "updateTheDebugInfo\0std::vector<std::string>\0"
    "send_fileAlreadyExists\0isSame\0"
    "send_errorOnFile\0send_folderAlreadyExists\0"
    "ScanFileOrFolder*\0send_errorOnFolder\0"
    "send_syncTransferList\0mkPathErrorOnFolder\0"
    "tryCancel\0askNewTransferThread\0"
    "warningTransferList\0warning\0"
    "errorTransferList\0send_sendNewRenamingRules\0"
    "firstRenamingRule\0otherRenamingRule\0"
    "send_realBytesTransfered\0"
    "send_parallelizeIfSmallerThan\0"
    "parallelizeIfSmallerThan\0send_updateMount\0"
    "missingDiskSpace\0std::vector<Diskspace>\0"
    "list\0isInPause\0exportTransferListSend\0"
    "fileName\0importTransferListSend\0pause\0"
    "resume\0skip\0id\0skipInternal\0cancel\0"
    "removeItems\0std::vector<uint64_t>\0ids\0"
    "moveItemsOnTop\0moveItemsUp\0moveItemsDown\0"
    "moveItemsOnBottom\0forceMode\0"
    "Ultracopier::CopyMode\0mode\0"
    "exportTransferList\0importTransferList\0"
    "setFolderCollision\0FolderExistsAction\0"
    "alwaysDoThisActionForFolderExists\0"
    "setSpeedLimitation\0int64_t\0speedLimitation\0"
    "setRightTransfer\0doRightTransfer\0"
    "setKeepDate\0keepDate\0setOsSpecFlags\0"
    "os_spec_flags\0setNativeCopy\0native_copy\0"
    "setCheckDestinationFolderExists\0"
    "checkDestinationFolderExists\0"
    "setAlwaysFileExistsAction\0FileExistsAction\0"
    "alwaysDoThisActionForFileExists\0"
    "doNewActions_start_transfer\0"
    "doNewActions_inode_manipulation\0"
    "restartTransferIfItCan\0getNeedPutAtBottom\0"
    "newTransferStat\0TransferStat\0stat\0"
    "set_setFilters\0std::vector<Filters_rules>\0"
    "include\0exclude\0set_sendNewRenamingRules\0"
    "set_updateMount\0sendActionDone\0"
    "sendProgression\0setMoveTheWholeFolder\0"
    "moveTheWholeFolder\0setFollowTheStrictOrder\0"
    "followTheStrictOrder\0setignoreBlackList\0"
    "ignoreBlackList\0setDeletePartiallyTransferredFiles\0"
    "deletePartiallyTransferredFiles\0"
    "setInodeThreads\0inodeThreads\0"
    "setRenameTheOriginalDestination\0"
    "renameTheOriginalDestination\0"
    "setCheckDiskSpace\0checkDiskSpace\0"
    "setBuffer\0buffer\0exportErrorIntoTransferList\0"
    "exportTransferListInternal\0"
    "importTransferListInternal\0"
    "scanThreadHaveFinishSlot\0scanThreadHaveFinish\0"
    "skipFirstRemove\0autoStartAndCheckSpace\0"
    "updateTheStatus\0fileTransfer\0"
    "sourceFileInfo\0destinationFileInfo\0"
    "fileTransferWithInode\0TransferThread::dirent_uc\0"
    "inode\0mkPathFirstFolderFinish\0"
    "transferPutAtBottom\0transferInodeIsClosed\0"
    "timedUpdateDebugDialog\0fileAlreadyExists\0"
    "errorOnFile\0folderAlreadyExists\0"
    "errorOnFolder\0run\0createTransferThread\0"
    "deleteTransferThread\0addToMkPath\0"
    "addToMovePath\0inodeToRemove\0"
    "addToKeepAttributePath\0addToRealMove\0"
    "syncTransferList_internal\0"
    "checkIfReadyToCancel"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ListThread[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
      99,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
      33,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,  509,    2, 0x06 /* Public */,
       4,    1,  512,    2, 0x06 /* Public */,
       6,    0,  515,    2, 0x06 /* Public */,
       7,    1,  516,    2, 0x06 /* Public */,
       9,    1,  519,    2, 0x06 /* Public */,
      12,    2,  522,    2, 0x06 /* Public */,
      14,    1,  527,    2, 0x06 /* Public */,
      17,    0,  530,    2, 0x06 /* Public */,
      18,    5,  531,    2, 0x06 /* Public */,
      26,    4,  542,    2, 0x06 /* Public */,
      29,    3,  551,    2, 0x06 /* Public */,
      32,    1,  558,    2, 0x06 /* Public */,
      33,    1,  561,    2, 0x06 /* Public */,
      34,    5,  564,    2, 0x06 /* Public */,
      41,    3,  575,    2, 0x06 /* Public */,
      43,    4,  582,    2, 0x06 /* Public */,
      45,    4,  591,    2, 0x06 /* Public */,
      46,    4,  600,    2, 0x06 /* Public */,
      48,    4,  609,    2, 0x06 /* Public */,
      49,    0,  618,    2, 0x06 /* Public */,
      50,    3,  619,    2, 0x06 /* Public */,
      51,    0,  626,    2, 0x06 /* Public */,
      52,    0,  627,    2, 0x06 /* Public */,
      53,    1,  628,    2, 0x06 /* Public */,
      55,    1,  631,    2, 0x06 /* Public */,
      56,    2,  634,    2, 0x06 /* Public */,
      59,    1,  639,    2, 0x06 /* Public */,
      60,    1,  642,    2, 0x06 /* Public */,
      62,    0,  645,    2, 0x06 /* Public */,
      63,    1,  646,    2, 0x06 /* Public */,
      66,    1,  649,    2, 0x06 /* Public */,
      67,    1,  652,    2, 0x06 /* Public */,
      69,    1,  655,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      70,    0,  658,    2, 0x0a /* Public */,
      71,    0,  659,    2, 0x0a /* Public */,
      72,    1,  660,    2, 0x0a /* Public */,
      74,    1,  663,    2, 0x0a /* Public */,
      75,    0,  666,    2, 0x0a /* Public */,
      76,    1,  667,    2, 0x0a /* Public */,
      79,    1,  670,    2, 0x0a /* Public */,
      80,    1,  673,    2, 0x0a /* Public */,
      81,    1,  676,    2, 0x0a /* Public */,
      82,    1,  679,    2, 0x0a /* Public */,
      83,    1,  682,    2, 0x0a /* Public */,
      86,    1,  685,    2, 0x0a /* Public */,
      87,    1,  688,    2, 0x0a /* Public */,
      88,    1,  691,    2, 0x0a /* Public */,
      91,    1,  694,    2, 0x0a /* Public */,
      94,    1,  697,    2, 0x0a /* Public */,
      96,    1,  700,    2, 0x0a /* Public */,
      98,    1,  703,    2, 0x0a /* Public */,
     100,    1,  706,    2, 0x0a /* Public */,
     102,    1,  709,    2, 0x0a /* Public */,
     104,    1,  712,    2, 0x0a /* Public */,
     107,    0,  715,    2, 0x0a /* Public */,
     108,    0,  716,    2, 0x0a /* Public */,
     109,    0,  717,    2, 0x0a /* Public */,
     110,    4,  718,    2, 0x0a /* Public */,
     111,    2,  727,    2, 0x0a /* Public */,
     114,    2,  732,    2, 0x0a /* Public */,
     118,    2,  737,    2, 0x0a /* Public */,
     119,    0,  742,    2, 0x0a /* Public */,
     120,    0,  743,    2, 0x0a /* Public */,
     121,    0,  744,    2, 0x0a /* Public */,
     122,    1,  745,    2, 0x0a /* Public */,
     124,    1,  748,    2, 0x0a /* Public */,
     126,    1,  751,    2, 0x0a /* Public */,
     128,    1,  754,    2, 0x0a /* Public */,
     130,    1,  757,    2, 0x0a /* Public */,
     132,    1,  760,    2, 0x0a /* Public */,
     134,    1,  763,    2, 0x0a /* Public */,
     136,    1,  766,    2, 0x0a /* Public */,
     138,    1,  769,    2, 0x0a /* Public */,
     139,    1,  772,    2, 0x08 /* Private */,
     140,    1,  775,    2, 0x08 /* Private */,
     141,    0,  778,    2, 0x08 /* Private */,
     142,    1,  779,    2, 0x08 /* Private */,
     142,    0,  782,    2, 0x28 /* Private | MethodCloned */,
     144,    0,  783,    2, 0x08 /* Private */,
     145,    0,  784,    2, 0x08 /* Private */,
     146,    3,  785,    2, 0x08 /* Private */,
     149,    4,  792,    2, 0x08 /* Private */,
     152,    0,  801,    2, 0x08 /* Private */,
     153,    0,  802,    2, 0x08 /* Private */,
     154,    0,  803,    2, 0x08 /* Private */,
     155,    0,  804,    2, 0x08 /* Private */,
     156,    3,  805,    2, 0x08 /* Private */,
     157,    3,  812,    2, 0x08 /* Private */,
     158,    3,  819,    2, 0x08 /* Private */,
     159,    3,  826,    2, 0x08 /* Private */,
     160,    0,  833,    2, 0x08 /* Private */,
     161,    0,  834,    2, 0x08 /* Private */,
     162,    0,  835,    2, 0x08 /* Private */,
     163,    3,  836,    2, 0x08 /* Private */,
     164,    3,  843,    2, 0x08 /* Private */,
     166,    3,  850,    2, 0x08 /* Private */,
     167,    2,  857,    2, 0x08 /* Private */,
     168,    0,  862,    2, 0x08 /* Private */,
     169,    0,  863,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3,    2,
    QMetaType::Void, 0x80000000 | 5,    2,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 8,    2,
    QMetaType::Void, 0x80000000 | 10,   11,
    QMetaType::Void, 0x80000000 | 13, 0x80000000 | 13,    2,    2,
    QMetaType::Void, 0x80000000 | 15,   16,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 22, 0x80000000 | 24,   19,   20,   21,   23,   25,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 13, 0x80000000 | 13, 0x80000000 | 15,   16,   27,   28,   26,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 15,   30,   31,   26,
    QMetaType::Void, 0x80000000 | 15,   16,
    QMetaType::Void, 0x80000000 | 15,   16,
    QMetaType::Void, 0x80000000 | 35, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 15, QMetaType::Int,   36,   37,   38,   39,   40,
    QMetaType::Void, 0x80000000 | 42, 0x80000000 | 42, QMetaType::Int,    2,    2,    2,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, QMetaType::Bool, 0x80000000 | 22,   30,   31,   44,   23,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 22, 0x80000000 | 24,   20,   21,   23,   25,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, QMetaType::Bool, 0x80000000 | 47,   30,   31,   44,   23,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 47, 0x80000000 | 24,   20,   21,   23,   25,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 24,   20,   21,   25,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 15,   54,
    QMetaType::Void, 0x80000000 | 15,   26,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15,   57,   58,
    QMetaType::Void, 0x80000000 | 13,    2,
    QMetaType::Void, QMetaType::Int,   61,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 64,   65,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void, 0x80000000 | 15,   68,
    QMetaType::Void, 0x80000000 | 15,   68,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 13,   73,
    QMetaType::Bool, 0x80000000 | 13,   73,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 77,   78,
    QMetaType::Void, 0x80000000 | 77,   78,
    QMetaType::Void, 0x80000000 | 77,   78,
    QMetaType::Void, 0x80000000 | 77,   78,
    QMetaType::Void, 0x80000000 | 77,   78,
    QMetaType::Void, 0x80000000 | 84,   85,
    QMetaType::Void, 0x80000000 | 15,   68,
    QMetaType::Void, 0x80000000 | 15,   68,
    QMetaType::Void, 0x80000000 | 89,   90,
    QMetaType::Bool, 0x80000000 | 92,   93,
    QMetaType::Void, QMetaType::Bool,   95,
    QMetaType::Void, QMetaType::Bool,   97,
    QMetaType::Void, QMetaType::Bool,   99,
    QMetaType::Void, QMetaType::Bool,  101,
    QMetaType::Void, QMetaType::Bool,  103,
    QMetaType::Void, 0x80000000 | 105,  106,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 22, 0x80000000 | 24,   20,   21,   23,   25,
    QMetaType::Void, 0x80000000 | 112, QMetaType::ULongLong,  113,   73,
    QMetaType::Void, 0x80000000 | 115, 0x80000000 | 115,  116,  117,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15,   57,   58,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,  123,
    QMetaType::Void, QMetaType::Bool,  125,
    QMetaType::Void, QMetaType::Bool,  127,
    QMetaType::Void, QMetaType::Bool,  129,
    QMetaType::Void, QMetaType::Int,  131,
    QMetaType::Void, QMetaType::Bool,  133,
    QMetaType::Void, QMetaType::Bool,  135,
    QMetaType::Void, QMetaType::Bool,  137,
    QMetaType::Void, 0x80000000 | 15,   68,
    QMetaType::Void, 0x80000000 | 15,   68,
    QMetaType::Void, 0x80000000 | 15,   68,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,  143,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 84,  147,  148,   85,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 84, 0x80000000 | 150,  147,  148,   85,  151,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, QMetaType::Bool,   30,   31,   44,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 24,   20,   21,   25,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, QMetaType::Bool,   30,   31,   44,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, 0x80000000 | 24,   20,   21,   25,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    0x80000000 | 13, 0x80000000 | 15, 0x80000000 | 15, QMetaType::Int,   30,   31,  151,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, QMetaType::Int,   30,   31,  165,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15, QMetaType::Int,   30,   31,  165,
    QMetaType::Void, 0x80000000 | 15, 0x80000000 | 15,   30,   31,
    QMetaType::Void,
    QMetaType::Void,

       0        // eod
};

void ListThread::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ListThread *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->actionInProgess((*reinterpret_cast< const Ultracopier::EngineActionInProgress(*)>(_a[1]))); break;
        case 1: _t->newActionOnList((*reinterpret_cast< const std::vector<Ultracopier::ReturnActionOnCopyList>(*)>(_a[1]))); break;
        case 2: _t->syncReady(); break;
        case 3: _t->doneTime((*reinterpret_cast< const std::vector<std::pair<uint64_t,uint32_t> >(*)>(_a[1]))); break;
        case 4: _t->pushFileProgression((*reinterpret_cast< const std::vector<Ultracopier::ProgressionItem>(*)>(_a[1]))); break;
        case 5: _t->pushGeneralProgression((*reinterpret_cast< const uint64_t(*)>(_a[1])),(*reinterpret_cast< const uint64_t(*)>(_a[2]))); break;
        case 6: _t->newFolderListing((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 7: _t->canBeDeleted(); break;
        case 8: _t->haveNeedPutAtBottom((*reinterpret_cast< bool(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const std::string(*)>(_a[3])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[4])),(*reinterpret_cast< const ErrorType(*)>(_a[5]))); break;
        case 9: _t->error((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const uint64_t(*)>(_a[2])),(*reinterpret_cast< const uint64_t(*)>(_a[3])),(*reinterpret_cast< const std::string(*)>(_a[4]))); break;
        case 10: _t->errorToRetry((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const std::string(*)>(_a[3]))); break;
        case 11: _t->rmPath((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 12: _t->mkPath((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 13: _t->debugInformation((*reinterpret_cast< const Ultracopier::DebugLevel(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const std::string(*)>(_a[3])),(*reinterpret_cast< const std::string(*)>(_a[4])),(*reinterpret_cast< const int(*)>(_a[5]))); break;
        case 14: _t->updateTheDebugInfo((*reinterpret_cast< const std::vector<std::string>(*)>(_a[1])),(*reinterpret_cast< const std::vector<std::string>(*)>(_a[2])),(*reinterpret_cast< const int(*)>(_a[3]))); break;
        case 15: _t->send_fileAlreadyExists((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const bool(*)>(_a[3])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[4]))); break;
        case 16: _t->send_errorOnFile((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[3])),(*reinterpret_cast< const ErrorType(*)>(_a[4]))); break;
        case 17: _t->send_folderAlreadyExists((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const bool(*)>(_a[3])),(*reinterpret_cast< ScanFileOrFolder*(*)>(_a[4]))); break;
        case 18: _t->send_errorOnFolder((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< ScanFileOrFolder*(*)>(_a[3])),(*reinterpret_cast< const ErrorType(*)>(_a[4]))); break;
        case 19: _t->send_syncTransferList(); break;
        case 20: _t->mkPathErrorOnFolder((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const ErrorType(*)>(_a[3]))); break;
        case 21: _t->tryCancel(); break;
        case 22: _t->askNewTransferThread(); break;
        case 23: _t->warningTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 24: _t->errorTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 25: _t->send_sendNewRenamingRules((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2]))); break;
        case 26: _t->send_realBytesTransfered((*reinterpret_cast< const uint64_t(*)>(_a[1]))); break;
        case 27: _t->send_parallelizeIfSmallerThan((*reinterpret_cast< const int(*)>(_a[1]))); break;
        case 28: _t->send_updateMount(); break;
        case 29: _t->missingDiskSpace((*reinterpret_cast< std::vector<Diskspace>(*)>(_a[1]))); break;
        case 30: _t->isInPause((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 31: _t->exportTransferListSend((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 32: _t->importTransferListSend((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 33: _t->pause(); break;
        case 34: _t->resume(); break;
        case 35: _t->skip((*reinterpret_cast< const uint64_t(*)>(_a[1]))); break;
        case 36: { bool _r = _t->skipInternal((*reinterpret_cast< const uint64_t(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 37: _t->cancel(); break;
        case 38: _t->removeItems((*reinterpret_cast< const std::vector<uint64_t>(*)>(_a[1]))); break;
        case 39: _t->moveItemsOnTop((*reinterpret_cast< std::vector<uint64_t>(*)>(_a[1]))); break;
        case 40: _t->moveItemsUp((*reinterpret_cast< std::vector<uint64_t>(*)>(_a[1]))); break;
        case 41: _t->moveItemsDown((*reinterpret_cast< std::vector<uint64_t>(*)>(_a[1]))); break;
        case 42: _t->moveItemsOnBottom((*reinterpret_cast< std::vector<uint64_t>(*)>(_a[1]))); break;
        case 43: _t->forceMode((*reinterpret_cast< const Ultracopier::CopyMode(*)>(_a[1]))); break;
        case 44: _t->exportTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 45: _t->importTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 46: _t->setFolderCollision((*reinterpret_cast< const FolderExistsAction(*)>(_a[1]))); break;
        case 47: { bool _r = _t->setSpeedLimitation((*reinterpret_cast< const int64_t(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 48: _t->setRightTransfer((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 49: _t->setKeepDate((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 50: _t->setOsSpecFlags((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 51: _t->setNativeCopy((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 52: _t->setCheckDestinationFolderExists((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 53: _t->setAlwaysFileExistsAction((*reinterpret_cast< const FileExistsAction(*)>(_a[1]))); break;
        case 54: _t->doNewActions_start_transfer(); break;
        case 55: _t->doNewActions_inode_manipulation(); break;
        case 56: _t->restartTransferIfItCan(); break;
        case 57: _t->getNeedPutAtBottom((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< TransferThreadAsync*(*)>(_a[3])),(*reinterpret_cast< const ErrorType(*)>(_a[4]))); break;
        case 58: _t->newTransferStat((*reinterpret_cast< const TransferStat(*)>(_a[1])),(*reinterpret_cast< const quint64(*)>(_a[2]))); break;
        case 59: _t->set_setFilters((*reinterpret_cast< const std::vector<Filters_rules>(*)>(_a[1])),(*reinterpret_cast< const std::vector<Filters_rules>(*)>(_a[2]))); break;
        case 60: _t->set_sendNewRenamingRules((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2]))); break;
        case 61: _t->set_updateMount(); break;
        case 62: _t->sendActionDone(); break;
        case 63: _t->sendProgression(); break;
        case 64: _t->setMoveTheWholeFolder((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 65: _t->setFollowTheStrictOrder((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 66: _t->setignoreBlackList((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 67: _t->setDeletePartiallyTransferredFiles((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 68: _t->setInodeThreads((*reinterpret_cast< const int(*)>(_a[1]))); break;
        case 69: _t->setRenameTheOriginalDestination((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 70: _t->setCheckDiskSpace((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 71: _t->setBuffer((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 72: _t->exportErrorIntoTransferList((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 73: _t->exportTransferListInternal((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 74: _t->importTransferListInternal((*reinterpret_cast< const std::string(*)>(_a[1]))); break;
        case 75: _t->scanThreadHaveFinishSlot(); break;
        case 76: _t->scanThreadHaveFinish((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 77: _t->scanThreadHaveFinish(); break;
        case 78: _t->autoStartAndCheckSpace(); break;
        case 79: _t->updateTheStatus(); break;
        case 80: _t->fileTransfer((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const Ultracopier::CopyMode(*)>(_a[3]))); break;
        case 81: _t->fileTransferWithInode((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const Ultracopier::CopyMode(*)>(_a[3])),(*reinterpret_cast< const TransferThread::dirent_uc(*)>(_a[4]))); break;
        case 82: _t->mkPathFirstFolderFinish(); break;
        case 83: _t->transferPutAtBottom(); break;
        case 84: _t->transferInodeIsClosed(); break;
        case 85: _t->timedUpdateDebugDialog(); break;
        case 86: _t->fileAlreadyExists((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const bool(*)>(_a[3]))); break;
        case 87: _t->errorOnFile((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const ErrorType(*)>(_a[3]))); break;
        case 88: _t->folderAlreadyExists((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const bool(*)>(_a[3]))); break;
        case 89: _t->errorOnFolder((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const ErrorType(*)>(_a[3]))); break;
        case 90: _t->run(); break;
        case 91: _t->createTransferThread(); break;
        case 92: _t->deleteTransferThread(); break;
        case 93: { uint64_t _r = _t->addToMkPath((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const int(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< uint64_t*>(_a[0]) = std::move(_r); }  break;
        case 94: _t->addToMovePath((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const int(*)>(_a[3]))); break;
        case 95: _t->addToKeepAttributePath((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2])),(*reinterpret_cast< const int(*)>(_a[3]))); break;
        case 96: _t->addToRealMove((*reinterpret_cast< const std::string(*)>(_a[1])),(*reinterpret_cast< const std::string(*)>(_a[2]))); break;
        case 97: _t->syncTransferList_internal(); break;
        case 98: _t->checkIfReadyToCancel(); break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 8:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        case 15:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        case 16:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        case 17:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 3:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ScanFileOrFolder* >(); break;
            }
            break;
        case 18:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ScanFileOrFolder* >(); break;
            }
            break;
        case 57:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 2:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< TransferThreadAsync* >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (ListThread::*)(const Ultracopier::EngineActionInProgress & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::actionInProgess)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::vector<Ultracopier::ReturnActionOnCopyList> & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::newActionOnList)) {
                *result = 1;
                return;
            }
        }
        {
            using _t = void (ListThread::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::syncReady)) {
                *result = 2;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::vector<std::pair<uint64_t,uint32_t> > & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::doneTime)) {
                *result = 3;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::vector<Ultracopier::ProgressionItem> & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::pushFileProgression)) {
                *result = 4;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const uint64_t & , const uint64_t & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::pushGeneralProgression)) {
                *result = 5;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::newFolderListing)) {
                *result = 6;
                return;
            }
        }
        {
            using _t = void (ListThread::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::canBeDeleted)) {
                *result = 7;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(bool , const std::string & , const std::string & , TransferThreadAsync * , const ErrorType & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::haveNeedPutAtBottom)) {
                *result = 8;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & , const uint64_t & , const uint64_t & , const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::error)) {
                *result = 9;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & , const std::string & , const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::errorToRetry)) {
                *result = 10;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::rmPath)) {
                *result = 11;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::mkPath)) {
                *result = 12;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const Ultracopier::DebugLevel & , const std::string & , const std::string & , const std::string & , const int & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::debugInformation)) {
                *result = 13;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::vector<std::string> & , const std::vector<std::string> & , const int & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::updateTheDebugInfo)) {
                *result = 14;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & , const std::string & , const bool & , TransferThreadAsync * ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_fileAlreadyExists)) {
                *result = 15;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & , const std::string & , TransferThreadAsync * , const ErrorType & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_errorOnFile)) {
                *result = 16;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & , const std::string & , const bool & , ScanFileOrFolder * ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_folderAlreadyExists)) {
                *result = 17;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & , const std::string & , ScanFileOrFolder * , const ErrorType & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_errorOnFolder)) {
                *result = 18;
                return;
            }
        }
        {
            using _t = void (ListThread::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_syncTransferList)) {
                *result = 19;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & , const std::string & , const ErrorType & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::mkPathErrorOnFolder)) {
                *result = 20;
                return;
            }
        }
        {
            using _t = void (ListThread::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::tryCancel)) {
                *result = 21;
                return;
            }
        }
        {
            using _t = void (ListThread::*)() const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::askNewTransferThread)) {
                *result = 22;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::warningTransferList)) {
                *result = 23;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::errorTransferList)) {
                *result = 24;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & , const std::string & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_sendNewRenamingRules)) {
                *result = 25;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const uint64_t & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_realBytesTransfered)) {
                *result = 26;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const int & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_parallelizeIfSmallerThan)) {
                *result = 27;
                return;
            }
        }
        {
            using _t = void (ListThread::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::send_updateMount)) {
                *result = 28;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(std::vector<Diskspace> ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::missingDiskSpace)) {
                *result = 29;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const bool & ) const;
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::isInPause)) {
                *result = 30;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::exportTransferListSend)) {
                *result = 31;
                return;
            }
        }
        {
            using _t = void (ListThread::*)(const std::string & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ListThread::importTransferListSend)) {
                *result = 32;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject ListThread::staticMetaObject = { {
    QMetaObject::SuperData::link<QThread::staticMetaObject>(),
    qt_meta_stringdata_ListThread.data,
    qt_meta_data_ListThread,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *ListThread::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_ListThread.stringdata0))
        return static_cast<void*>(this);
    return QThread::qt_metacast(_clname);
}

int ListThread::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QThread::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 99)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 99;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 99)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 99;
    }
    return _id;
}

// SIGNAL 0
void ListThread::actionInProgess(const Ultracopier::EngineActionInProgress & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 0, _a);
}

// SIGNAL 1
void ListThread::newActionOnList(const std::vector<Ultracopier::ReturnActionOnCopyList> & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 1, _a);
}

// SIGNAL 2
void ListThread::syncReady()const
{
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void ListThread::doneTime(const std::vector<std::pair<uint64_t,uint32_t> > & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 3, _a);
}

// SIGNAL 4
void ListThread::pushFileProgression(const std::vector<Ultracopier::ProgressionItem> & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 4, _a);
}

// SIGNAL 5
void ListThread::pushGeneralProgression(const uint64_t & _t1, const uint64_t & _t2)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 5, _a);
}

// SIGNAL 6
void ListThread::newFolderListing(const std::string & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 6, _a);
}

// SIGNAL 7
void ListThread::canBeDeleted()const
{
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void ListThread::haveNeedPutAtBottom(bool _t1, const std::string & _t2, const std::string & _t3, TransferThreadAsync * _t4, const ErrorType & _t5)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t5))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 8, _a);
}

// SIGNAL 9
void ListThread::error(const std::string & _t1, const uint64_t & _t2, const uint64_t & _t3, const std::string & _t4)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 9, _a);
}

// SIGNAL 10
void ListThread::errorToRetry(const std::string & _t1, const std::string & _t2, const std::string & _t3)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 10, _a);
}

// SIGNAL 11
void ListThread::rmPath(const std::string & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 11, _a);
}

// SIGNAL 12
void ListThread::mkPath(const std::string & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 12, _a);
}

// SIGNAL 13
void ListThread::debugInformation(const Ultracopier::DebugLevel & _t1, const std::string & _t2, const std::string & _t3, const std::string & _t4, const int & _t5)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t5))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 13, _a);
}

// SIGNAL 14
void ListThread::updateTheDebugInfo(const std::vector<std::string> & _t1, const std::vector<std::string> & _t2, const int & _t3)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 14, _a);
}

// SIGNAL 15
void ListThread::send_fileAlreadyExists(const std::string & _t1, const std::string & _t2, const bool & _t3, TransferThreadAsync * _t4)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 15, _a);
}

// SIGNAL 16
void ListThread::send_errorOnFile(const std::string & _t1, const std::string & _t2, TransferThreadAsync * _t3, const ErrorType & _t4)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 16, _a);
}

// SIGNAL 17
void ListThread::send_folderAlreadyExists(const std::string & _t1, const std::string & _t2, const bool & _t3, ScanFileOrFolder * _t4)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 17, _a);
}

// SIGNAL 18
void ListThread::send_errorOnFolder(const std::string & _t1, const std::string & _t2, ScanFileOrFolder * _t3, const ErrorType & _t4)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 18, _a);
}

// SIGNAL 19
void ListThread::send_syncTransferList()const
{
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void ListThread::mkPathErrorOnFolder(const std::string & _t1, const std::string & _t2, const ErrorType & _t3)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 20, _a);
}

// SIGNAL 21
void ListThread::tryCancel()const
{
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void ListThread::askNewTransferThread()const
{
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void ListThread::warningTransferList(const std::string & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 23, _a);
}

// SIGNAL 24
void ListThread::errorTransferList(const std::string & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 24, _a);
}

// SIGNAL 25
void ListThread::send_sendNewRenamingRules(const std::string & _t1, const std::string & _t2)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 25, _a);
}

// SIGNAL 26
void ListThread::send_realBytesTransfered(const uint64_t & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 26, _a);
}

// SIGNAL 27
void ListThread::send_parallelizeIfSmallerThan(const int & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 27, _a);
}

// SIGNAL 28
void ListThread::send_updateMount()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}

// SIGNAL 29
void ListThread::missingDiskSpace(std::vector<Diskspace> _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 29, _a);
}

// SIGNAL 30
void ListThread::isInPause(const bool & _t1)const
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(const_cast< ListThread *>(this), &staticMetaObject, 30, _a);
}

// SIGNAL 31
void ListThread::exportTransferListSend(const std::string & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 31, _a);
}

// SIGNAL 32
void ListThread::importTransferListSend(const std::string & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 32, _a);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
