10 #include "../../ubuntu/download_manager/download_interface.h" 
   11 #include <QtCore/qbytearray.h> 
   12 #include <QtCore/qmetatype.h> 
   13 #if !defined(Q_MOC_OUTPUT_REVISION) 
   14 #error "The header file 'download_interface.h' doesn't include <QObject>." 
   15 #elif Q_MOC_OUTPUT_REVISION != 67 
   16 #error "This file was generated using the moc from 5.15.2. It" 
   17 #error "cannot be used with the include files from this version of Qt." 
   18 #error "(The moc has changed too much.)" 
   21 QT_BEGIN_MOC_NAMESPACE
 
   23 QT_WARNING_DISABLE_DEPRECATED
 
   28 #define QT_MOC_LITERAL(idx, ofs, len) \ 
   29     Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ 
   30     qptrdiff(offsetof(qt_meta_stringdata_DownloadInterface_t, stringdata0) + ofs \ 
   31         - idx * sizeof(QByteArrayData)) \ 
   93     "DownloadInterface\0authError\0\0" 
   94     "AuthErrorStruct\0error\0canceled\0success\0" 
   95     "finished\0path\0hashError\0HashErrorStruct\0" 
   96     "httpError\0HttpErrorStruct\0networkError\0" 
   97     "NetworkErrorStruct\0paused\0processError\0" 
   98     "ProcessErrorStruct\0processing\0progress\0" 
   99     "received\0total\0resumed\0started\0" 
  100     "allowGSMDownload\0QDBusPendingReply<>\0" 
  101     "allowed\0cancel\0collected\0filePath\0" 
  102     "QDBusPendingReply<QString>\0headers\0" 
  103     "QDBusPendingReply<StringMap>\0" 
  104     "isGSMDownloadAllowed\0QDBusPendingReply<bool>\0" 
  105     "metadata\0QDBusPendingReply<QVariantMap>\0" 
  106     "pause\0QDBusPendingReply<qulonglong>\0" 
  107     "resume\0setDestinationDir\0setHeaders\0" 
  108     "StringMap\0setMetadata\0data\0setThrottle\0" 
  109     "speed\0start\0state\0QDBusPendingReply<int>\0" 
  110     "throttle\0totalSize\0ClickPackage\0" 
  111     "DestinationApp\0ShowInIndicator\0Title" 
  113 #undef QT_MOC_LITERAL 
  115 static const uint qt_meta_data_DownloadInterface[] = {
 
  134       11,    1,  184,    2, 0x06 ,
 
  135       13,    1,  187,    2, 0x06 ,
 
  136       15,    1,  190,    2, 0x06 ,
 
  137       16,    1,  193,    2, 0x06 ,
 
  138       18,    1,  196,    2, 0x06 ,
 
  139       19,    2,  199,    2, 0x06 ,
 
  140       22,    1,  204,    2, 0x06 ,
 
  141       23,    1,  207,    2, 0x06 ,
 
  144       24,    1,  210,    2, 0x0a ,
 
  145       27,    0,  213,    2, 0x0a ,
 
  146       28,    0,  214,    2, 0x0a ,
 
  147       29,    0,  215,    2, 0x0a ,
 
  148       31,    0,  216,    2, 0x0a ,
 
  149       33,    0,  217,    2, 0x0a ,
 
  150       35,    0,  218,    2, 0x0a ,
 
  151       37,    0,  219,    2, 0x0a ,
 
  152       19,    0,  220,    2, 0x0a ,
 
  153       39,    0,  221,    2, 0x0a ,
 
  154       40,    1,  222,    2, 0x0a ,
 
  155       41,    1,  225,    2, 0x0a ,
 
  156       43,    1,  228,    2, 0x0a ,
 
  157       45,    1,  231,    2, 0x0a ,
 
  158       47,    0,  234,    2, 0x0a ,
 
  159       48,    0,  235,    2, 0x0a ,
 
  160       50,    0,  236,    2, 0x0a ,
 
  161       51,    0,  237,    2, 0x0a ,
 
  164     QMetaType::Void, 0x80000000 | 3,    4,
 
  165     QMetaType::Void, QMetaType::Bool,    6,
 
  166     QMetaType::Void, QMetaType::QString,    4,
 
  167     QMetaType::Void, QMetaType::QString,    8,
 
  168     QMetaType::Void, 0x80000000 | 10,    4,
 
  169     QMetaType::Void, 0x80000000 | 12,    4,
 
  170     QMetaType::Void, 0x80000000 | 14,    4,
 
  171     QMetaType::Void, QMetaType::Bool,    6,
 
  172     QMetaType::Void, 0x80000000 | 17,    4,
 
  173     QMetaType::Void, QMetaType::QString,    8,
 
  174     QMetaType::Void, QMetaType::ULongLong, QMetaType::ULongLong,   20,   21,
 
  175     QMetaType::Void, QMetaType::Bool,    6,
 
  176     QMetaType::Void, QMetaType::Bool,    6,
 
  179     0x80000000 | 25, QMetaType::Bool,   26,
 
  189     0x80000000 | 25, QMetaType::QString,    8,
 
  190     0x80000000 | 25, 0x80000000 | 42,   31,
 
  191     0x80000000 | 25, QMetaType::QVariantMap,   44,
 
  192     0x80000000 | 25, QMetaType::ULongLong,   46,
 
  199       52, QMetaType::QString, 0x00095001,
 
  200       53, QMetaType::QString, 0x00095001,
 
  201       54, QMetaType::Bool, 0x00095001,
 
  202       55, QMetaType::QString, 0x00095001,
 
  207 void DownloadInterface::qt_static_metacall(
QObject *_o, QMetaObject::Call _c, 
int _id, 
void **_a)
 
  209     if (_c == QMetaObject::InvokeMetaMethod) {
 
  210         auto *_t = 
static_cast<DownloadInterface *
>(_o);
 
  213         case 0: _t->authError((*
reinterpret_cast< AuthErrorStruct(*)
>(_a[1]))); 
break;
 
  214         case 1: _t->canceled((*
reinterpret_cast< bool(*)
>(_a[1]))); 
break;
 
  215         case 2: _t->error((*
reinterpret_cast< const QString(*)
>(_a[1]))); 
break;
 
  216         case 3: _t->finished((*
reinterpret_cast< const QString(*)
>(_a[1]))); 
break;
 
  217         case 4: _t->hashError((*
reinterpret_cast< HashErrorStruct(*)
>(_a[1]))); 
break;
 
  218         case 5: _t->httpError((*
reinterpret_cast< HttpErrorStruct(*)
>(_a[1]))); 
break;
 
  219         case 6: _t->networkError((*
reinterpret_cast< NetworkErrorStruct(*)
>(_a[1]))); 
break;
 
  220         case 7: _t->paused((*
reinterpret_cast< bool(*)
>(_a[1]))); 
break;
 
  221         case 8: _t->processError((*
reinterpret_cast< ProcessErrorStruct(*)
>(_a[1]))); 
break;
 
  222         case 9: _t->processing((*
reinterpret_cast< const QString(*)
>(_a[1]))); 
break;
 
  223         case 10: _t->progress((*
reinterpret_cast< qulonglong(*)
>(_a[1])),(*
reinterpret_cast< qulonglong(*)
>(_a[2]))); 
break;
 
  224         case 11: _t->resumed((*
reinterpret_cast< bool(*)
>(_a[1]))); 
break;
 
  225         case 12: _t->started((*
reinterpret_cast< bool(*)
>(_a[1]))); 
break;
 
  226         case 13: { QDBusPendingReply<> _r = _t->allowGSMDownload((*
reinterpret_cast< bool(*)
>(_a[1])));
 
  227             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  228         case 14: { QDBusPendingReply<> _r = _t->cancel();
 
  229             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  230         case 15: { QDBusPendingReply<> _r = _t->collected();
 
  231             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  232         case 16: { QDBusPendingReply<QString> _r = _t->filePath();
 
  233             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<QString>*
>(_a[0]) = std::move(_r); }  
break;
 
  234         case 17: { QDBusPendingReply<StringMap> _r = _t->headers();
 
  235             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<StringMap>*
>(_a[0]) = std::move(_r); }  
break;
 
  236         case 18: { QDBusPendingReply<bool> _r = _t->isGSMDownloadAllowed();
 
  237             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<bool>*
>(_a[0]) = std::move(_r); }  
break;
 
  238         case 19: { QDBusPendingReply<QVariantMap> _r = _t->metadata();
 
  239             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<QVariantMap>*
>(_a[0]) = std::move(_r); }  
break;
 
  240         case 20: { QDBusPendingReply<> _r = _t->pause();
 
  241             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  242         case 21: { QDBusPendingReply<qulonglong> _r = _t->progress();
 
  243             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<qulonglong>*
>(_a[0]) = std::move(_r); }  
break;
 
  244         case 22: { QDBusPendingReply<> _r = _t->resume();
 
  245             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  246         case 23: { QDBusPendingReply<> _r = _t->setDestinationDir((*
reinterpret_cast< const QString(*)
>(_a[1])));
 
  247             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  248         case 24: { QDBusPendingReply<> _r = _t->setHeaders((*
reinterpret_cast< StringMap(*)
>(_a[1])));
 
  249             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  250         case 25: { QDBusPendingReply<> _r = _t->setMetadata((*
reinterpret_cast< const QVariantMap(*)
>(_a[1])));
 
  251             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  252         case 26: { QDBusPendingReply<> _r = _t->setThrottle((*
reinterpret_cast< qulonglong(*)
>(_a[1])));
 
  253             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  254         case 27: { QDBusPendingReply<> _r = _t->start();
 
  255             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<>*
>(_a[0]) = std::move(_r); }  
break;
 
  256         case 28: { QDBusPendingReply<int> _r = _t->state();
 
  257             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<int>*
>(_a[0]) = std::move(_r); }  
break;
 
  258         case 29: { QDBusPendingReply<qulonglong> _r = _t->throttle();
 
  259             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<qulonglong>*
>(_a[0]) = std::move(_r); }  
break;
 
  260         case 30: { QDBusPendingReply<qulonglong> _r = _t->totalSize();
 
  261             if (_a[0]) *
reinterpret_cast< QDBusPendingReply<qulonglong>*
>(_a[0]) = std::move(_r); }  
break;
 
  264     } 
else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
 
  266         default: *
reinterpret_cast<int*
>(_a[0]) = -1; 
break;
 
  268             switch (*
reinterpret_cast<int*
>(_a[1])) {
 
  269             default: *
reinterpret_cast<int*
>(_a[0]) = -1; 
break;
 
  271                 *
reinterpret_cast<int*
>(_a[0]) = qRegisterMetaType< AuthErrorStruct >(); 
break;
 
  275             switch (*
reinterpret_cast<int*
>(_a[1])) {
 
  276             default: *
reinterpret_cast<int*
>(_a[0]) = -1; 
break;
 
  278                 *
reinterpret_cast<int*
>(_a[0]) = qRegisterMetaType< HashErrorStruct >(); 
break;
 
  282             switch (*
reinterpret_cast<int*
>(_a[1])) {
 
  283             default: *
reinterpret_cast<int*
>(_a[0]) = -1; 
break;
 
  285                 *
reinterpret_cast<int*
>(_a[0]) = qRegisterMetaType< HttpErrorStruct >(); 
break;
 
  289             switch (*
reinterpret_cast<int*
>(_a[1])) {
 
  290             default: *
reinterpret_cast<int*
>(_a[0]) = -1; 
break;
 
  292                 *
reinterpret_cast<int*
>(_a[0]) = qRegisterMetaType< NetworkErrorStruct >(); 
break;
 
  296             switch (*
reinterpret_cast<int*
>(_a[1])) {
 
  297             default: *
reinterpret_cast<int*
>(_a[0]) = -1; 
break;
 
  299                 *
reinterpret_cast<int*
>(_a[0]) = qRegisterMetaType< ProcessErrorStruct >(); 
break;
 
  303             switch (*
reinterpret_cast<int*
>(_a[1])) {
 
  304             default: *
reinterpret_cast<int*
>(_a[0]) = -1; 
break;
 
  306                 *
reinterpret_cast<int*
>(_a[0]) = qRegisterMetaType< StringMap >(); 
break;
 
  310     } 
else if (_c == QMetaObject::IndexOfMethod) {
 
  311         int *result = 
reinterpret_cast<int *
>(_a[0]);
 
  313             using _t = void (DownloadInterface::*)(AuthErrorStruct );
 
  314             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::authError)) {
 
  320             using _t = void (DownloadInterface::*)(bool );
 
  321             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::canceled)) {
 
  327             using _t = void (DownloadInterface::*)(
const QString & );
 
  328             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::error)) {
 
  334             using _t = void (DownloadInterface::*)(
const QString & );
 
  335             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::finished)) {
 
  341             using _t = void (DownloadInterface::*)(HashErrorStruct );
 
  342             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::hashError)) {
 
  348             using _t = void (DownloadInterface::*)(HttpErrorStruct );
 
  349             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::httpError)) {
 
  355             using _t = void (DownloadInterface::*)(NetworkErrorStruct );
 
  356             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::networkError)) {
 
  362             using _t = void (DownloadInterface::*)(bool );
 
  363             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::paused)) {
 
  369             using _t = void (DownloadInterface::*)(ProcessErrorStruct );
 
  370             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::processError)) {
 
  376             using _t = void (DownloadInterface::*)(
const QString & );
 
  377             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::processing)) {
 
  383             using _t = void (DownloadInterface::*)(qulonglong , qulonglong );
 
  384             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::progress)) {
 
  390             using _t = void (DownloadInterface::*)(bool );
 
  391             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::resumed)) {
 
  397             using _t = void (DownloadInterface::*)(bool );
 
  398             if (*
reinterpret_cast<_t *
>(_a[1]) == 
static_cast<_t
>(&DownloadInterface::started)) {
 
  404 #ifndef QT_NO_PROPERTIES 
  405     else if (_c == QMetaObject::ReadProperty) {
 
  406         auto *_t = 
static_cast<DownloadInterface *
>(_o);
 
  410         case 0: *
reinterpret_cast< QString*
>(_v) = _t->clickPackage(); 
break;
 
  411         case 1: *
reinterpret_cast< QString*
>(_v) = _t->destinationApp(); 
break;
 
  412         case 2: *
reinterpret_cast< bool*
>(_v) = _t->showInIndicator(); 
break;
 
  413         case 3: *
reinterpret_cast< QString*
>(_v) = _t->title(); 
break;
 
  416     } 
else if (_c == QMetaObject::WriteProperty) {
 
  417     } 
else if (_c == QMetaObject::ResetProperty) {
 
  419 #endif // QT_NO_PROPERTIES 
  422 QT_INIT_METAOBJECT 
const QMetaObject DownloadInterface::staticMetaObject = { {
 
  423     QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
 
  424     qt_meta_stringdata_DownloadInterface.
data,
 
  425     qt_meta_data_DownloadInterface,
 
  432 const QMetaObject *DownloadInterface::metaObject()
 const 
  434     return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
 
  437 void *DownloadInterface::qt_metacast(
const char *_clname)
 
  439     if (!_clname) 
return nullptr;
 
  440     if (!strcmp(_clname, qt_meta_stringdata_DownloadInterface.
stringdata0))
 
  441         return static_cast<void*
>(
this);
 
  442     return QDBusAbstractInterface::qt_metacast(_clname);
 
  445 int DownloadInterface::qt_metacall(QMetaObject::Call _c, 
int _id, 
void **_a)
 
  447     _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
 
  450     if (_c == QMetaObject::InvokeMetaMethod) {
 
  452             qt_static_metacall(
this, _c, _id, _a);
 
  454     } 
else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
 
  456             qt_static_metacall(
this, _c, _id, _a);
 
  459 #ifndef QT_NO_PROPERTIES 
  460     else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
 
  461             || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
 
  462         qt_static_metacall(
this, _c, _id, _a);
 
  464     } 
else if (_c == QMetaObject::QueryPropertyDesignable) {
 
  466     } 
else if (_c == QMetaObject::QueryPropertyScriptable) {
 
  468     } 
else if (_c == QMetaObject::QueryPropertyStored) {
 
  470     } 
else if (_c == QMetaObject::QueryPropertyEditable) {
 
  472     } 
else if (_c == QMetaObject::QueryPropertyUser) {
 
  475 #endif // QT_NO_PROPERTIES 
  480 void DownloadInterface::authError(AuthErrorStruct _t1)
 
  482     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  483     QMetaObject::activate(
this, &staticMetaObject, 0, _a);
 
  487 void DownloadInterface::canceled(
bool _t1)
 
  489     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  490     QMetaObject::activate(
this, &staticMetaObject, 1, _a);
 
  494 void DownloadInterface::error(
const QString & _t1)
 
  496     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  497     QMetaObject::activate(
this, &staticMetaObject, 2, _a);
 
  501 void DownloadInterface::finished(
const QString & _t1)
 
  503     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  504     QMetaObject::activate(
this, &staticMetaObject, 3, _a);
 
  508 void DownloadInterface::hashError(HashErrorStruct _t1)
 
  510     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  511     QMetaObject::activate(
this, &staticMetaObject, 4, _a);
 
  515 void DownloadInterface::httpError(HttpErrorStruct _t1)
 
  517     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  518     QMetaObject::activate(
this, &staticMetaObject, 5, _a);
 
  522 void DownloadInterface::networkError(NetworkErrorStruct _t1)
 
  524     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  525     QMetaObject::activate(
this, &staticMetaObject, 6, _a);
 
  529 void DownloadInterface::paused(
bool _t1)
 
  531     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  532     QMetaObject::activate(
this, &staticMetaObject, 7, _a);
 
  536 void DownloadInterface::processError(ProcessErrorStruct _t1)
 
  538     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  539     QMetaObject::activate(
this, &staticMetaObject, 8, _a);
 
  543 void DownloadInterface::processing(
const QString & _t1)
 
  545     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  546     QMetaObject::activate(
this, &staticMetaObject, 9, _a);
 
  550 void DownloadInterface::progress(qulonglong _t1, qulonglong _t2)
 
  552     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))), 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t2))) };
 
  553     QMetaObject::activate(
this, &staticMetaObject, 10, _a);
 
  557 void DownloadInterface::resumed(
bool _t1)
 
  559     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  560     QMetaObject::activate(
this, &staticMetaObject, 11, _a);
 
  564 void DownloadInterface::started(
bool _t1)
 
  566     void *_a[] = { 
nullptr, 
const_cast<void*
>(
reinterpret_cast<const void*
>(std::addressof(_t1))) };
 
  567     QMetaObject::activate(
this, &staticMetaObject, 12, _a);