2024-08-25 04:08:24 +00:00
|
|
|
#include <QCborArray>
|
2024-08-29 07:01:51 +00:00
|
|
|
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__ConstIterator
|
|
|
|
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__Iterator
|
2024-08-25 04:08:24 +00:00
|
|
|
#include <QCborValue>
|
|
|
|
#include <QCborValueRef>
|
|
|
|
#include <QJsonArray>
|
|
|
|
#include <QList>
|
|
|
|
#include <QString>
|
2024-08-29 07:01:51 +00:00
|
|
|
#include <QByteArray>
|
|
|
|
#include <cstring>
|
|
|
|
#include "qcborarray.h"
|
|
|
|
#include "gen_qcborarray.h"
|
2024-09-14 22:29:05 +00:00
|
|
|
#include "_cgo_export.h"
|
2024-08-25 04:08:24 +00:00
|
|
|
|
|
|
|
QCborArray* QCborArray_new() {
|
|
|
|
return new QCborArray();
|
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray* QCborArray_new2(QCborArray* other) {
|
|
|
|
return new QCborArray(*other);
|
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_OperatorAssign(QCborArray* self, QCborArray* other) {
|
|
|
|
self->operator=(*other);
|
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_Swap(QCborArray* self, QCborArray* other) {
|
|
|
|
self->swap(*other);
|
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValue* QCborArray_ToCborValue(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->toCborValue());
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
size_t QCborArray_Size(const QCborArray* self) {
|
|
|
|
return self->size();
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray_IsEmpty(const QCborArray* self) {
|
|
|
|
return self->isEmpty();
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_Clear(QCborArray* self) {
|
|
|
|
self->clear();
|
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValue* QCborArray_At(const QCborArray* self, size_t i) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->at(static_cast<qsizetype>(i)));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValue* QCborArray_First(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->first());
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValue* QCborArray_Last(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->last());
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, size_t i) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->operator[](static_cast<qsizetype>(i)));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborValueRef* QCborArray_First2(QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValueRef(self->first());
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborValueRef* QCborArray_Last2(QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValueRef(self->last());
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, size_t i) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValueRef(self->operator[](static_cast<qsizetype>(i)));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_Insert(QCborArray* self, size_t i, QCborValue* value) {
|
|
|
|
self->insert(static_cast<qsizetype>(i), *value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_Prepend(QCborArray* self, QCborValue* value) {
|
|
|
|
self->prepend(*value);
|
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_Append(QCborArray* self, QCborValue* value) {
|
|
|
|
self->append(*value);
|
|
|
|
}
|
|
|
|
|
2024-08-29 07:01:51 +00:00
|
|
|
QCborValue* QCborArray_Extract(QCborArray* self, QCborArray__ConstIterator* it) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->extract(*it));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborValue* QCborArray_ExtractWithIt(QCborArray* self, QCborArray__Iterator* it) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->extract(*it));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-08-25 04:08:24 +00:00
|
|
|
void QCborArray_RemoveAt(QCborArray* self, size_t i) {
|
|
|
|
self->removeAt(static_cast<qsizetype>(i));
|
|
|
|
}
|
|
|
|
|
|
|
|
QCborValue* QCborArray_TakeAt(QCborArray* self, size_t i) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->takeAt(static_cast<qsizetype>(i)));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_RemoveFirst(QCborArray* self) {
|
|
|
|
self->removeFirst();
|
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_RemoveLast(QCborArray* self) {
|
|
|
|
self->removeLast();
|
|
|
|
}
|
|
|
|
|
|
|
|
QCborValue* QCborArray_TakeFirst(QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->takeFirst());
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborValue* QCborArray_TakeLast(QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValue(self->takeLast());
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray_Contains(const QCborArray* self, QCborValue* value) {
|
|
|
|
return self->contains(*value);
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
int QCborArray_Compare(const QCborArray* self, QCborArray* other) {
|
|
|
|
return self->compare(*other);
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray_OperatorEqual(const QCborArray* self, QCborArray* other) {
|
|
|
|
return self->operator==(*other);
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray_OperatorNotEqual(const QCborArray* self, QCborArray* other) {
|
|
|
|
return self->operator!=(*other);
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray_OperatorLesser(const QCborArray* self, QCborArray* other) {
|
|
|
|
return self->operator<(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray_Begin(QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->begin());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__ConstIterator* QCborArray_ConstBegin(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->constBegin());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__ConstIterator* QCborArray_Begin2(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->begin());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__ConstIterator* QCborArray_Cbegin(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->cbegin());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray_End(QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->end());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__ConstIterator* QCborArray_ConstEnd(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->constEnd());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__ConstIterator* QCborArray_End2(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->end());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__ConstIterator* QCborArray_Cend(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->cend());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray_Insert2(QCborArray* self, QCborArray__Iterator* before, QCborValue* value) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->insert(*before, *value));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray_Insert3(QCborArray* self, QCborArray__ConstIterator* before, QCborValue* value) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->insert(*before, *value));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray_Erase(QCborArray* self, QCborArray__Iterator* it) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->erase(*it));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray_EraseWithIt(QCborArray* self, QCborArray__ConstIterator* it) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->erase(*it));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_PushBack(QCborArray* self, QCborValue* t) {
|
|
|
|
self->push_back(*t);
|
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_PushFront(QCborArray* self, QCborValue* t) {
|
|
|
|
self->push_front(*t);
|
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_PopFront(QCborArray* self) {
|
|
|
|
self->pop_front();
|
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_PopBack(QCborArray* self) {
|
|
|
|
self->pop_back();
|
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray_Empty(const QCborArray* self) {
|
|
|
|
return self->empty();
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray* QCborArray_OperatorPlus(const QCborArray* self, QCborValue* v) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray(self->operator+(*v));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray* QCborArray_OperatorPlusAssign(QCborArray* self, QCborValue* v) {
|
2024-09-14 22:29:05 +00:00
|
|
|
QCborArray& _ret = self->operator+=(*v);
|
2024-08-25 04:08:24 +00:00
|
|
|
// Cast returned reference into pointer
|
2024-09-14 22:29:05 +00:00
|
|
|
return &_ret;
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray* QCborArray_OperatorShiftLeft(QCborArray* self, QCborValue* v) {
|
2024-09-14 22:29:05 +00:00
|
|
|
QCborArray& _ret = self->operator<<(*v);
|
2024-08-25 04:08:24 +00:00
|
|
|
// Cast returned reference into pointer
|
2024-09-14 22:29:05 +00:00
|
|
|
return &_ret;
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-16 07:33:40 +00:00
|
|
|
QCborArray* QCborArray_FromStringList(struct miqt_array* /* of struct miqt_string* */ list) {
|
2024-08-25 04:08:24 +00:00
|
|
|
QList<QString> list_QList;
|
2024-09-14 22:29:05 +00:00
|
|
|
list_QList.reserve(list->len);
|
|
|
|
miqt_string** list_arr = static_cast<miqt_string**>(list->data);
|
|
|
|
for(size_t i = 0; i < list->len; ++i) {
|
|
|
|
list_QList.push_back(QString::fromUtf8(& list_arr[i]->data, list_arr[i]->len));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray(QCborArray::fromStringList(list_QList));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray* QCborArray_FromJsonArray(QJsonArray* array) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray(QCborArray::fromJsonArray(*array));
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QJsonArray* QCborArray_ToJsonArray(const QCborArray* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QJsonArray(self->toJsonArray());
|
2024-08-25 04:08:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray_Delete(QCborArray* self) {
|
|
|
|
delete self;
|
|
|
|
}
|
|
|
|
|
2024-08-29 07:01:51 +00:00
|
|
|
QCborArray__Iterator* QCborArray__Iterator_new() {
|
|
|
|
return new QCborArray::Iterator();
|
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray__Iterator_new2(QCborArray__Iterator* param1) {
|
|
|
|
return new QCborArray::Iterator(*param1);
|
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValueRef(self->operator*());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Iterator* self) {
|
|
|
|
return self->operator->();
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, size_t j) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValueRef(self->operator[](static_cast<qsizetype>(j)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o) {
|
|
|
|
return self->operator==(*o);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorNotEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o) {
|
|
|
|
return self->operator!=(*o);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorLesser(const QCborArray__Iterator* self, QCborArray__Iterator* other) {
|
|
|
|
return self->operator<(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorLesserOrEqual(const QCborArray__Iterator* self, QCborArray__Iterator* other) {
|
|
|
|
return self->operator<=(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorGreater(const QCborArray__Iterator* self, QCborArray__Iterator* other) {
|
|
|
|
return self->operator>(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorGreaterOrEqual(const QCborArray__Iterator* self, QCborArray__Iterator* other) {
|
|
|
|
return self->operator>=(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorEqualWithQCborArrayConstIterator(const QCborArray__Iterator* self, QCborArray__ConstIterator* o) {
|
|
|
|
return self->operator==(*o);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorNotEqualWithQCborArrayConstIterator(const QCborArray__Iterator* self, QCborArray__ConstIterator* o) {
|
|
|
|
return self->operator!=(*o);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorLesserWithOther(const QCborArray__Iterator* self, QCborArray__ConstIterator* other) {
|
|
|
|
return self->operator<(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorLesserOrEqualWithOther(const QCborArray__Iterator* self, QCborArray__ConstIterator* other) {
|
|
|
|
return self->operator<=(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorGreaterWithOther(const QCborArray__Iterator* self, QCborArray__ConstIterator* other) {
|
|
|
|
return self->operator>(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__Iterator_OperatorGreaterOrEqualWithOther(const QCborArray__Iterator* self, QCborArray__ConstIterator* other) {
|
|
|
|
return self->operator>=(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray__Iterator_OperatorPlusPlus(QCborArray__Iterator* self, int param1) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->operator++(static_cast<int>(param1)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__Iterator* QCborArray__Iterator_OperatorMinusMinus(QCborArray__Iterator* self, int param1) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->operator--(static_cast<int>(param1)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, size_t j) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->operator+(static_cast<qsizetype>(j)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, size_t j) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::Iterator(self->operator-(static_cast<qsizetype>(j)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
size_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j) {
|
|
|
|
return self->operator-(*j);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray__Iterator_Delete(QCborArray__Iterator* self) {
|
|
|
|
delete self;
|
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__ConstIterator* QCborArray__ConstIterator_new() {
|
|
|
|
return new QCborArray::ConstIterator();
|
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__ConstIterator* QCborArray__ConstIterator_new2(QCborArray__ConstIterator* param1) {
|
|
|
|
return new QCborArray::ConstIterator(*param1);
|
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValueRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValueRef(self->operator*());
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self) {
|
|
|
|
return (QCborValueRef*) self->operator->();
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, size_t j) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborValueRef(self->operator[](static_cast<qsizetype>(j)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o) {
|
|
|
|
return self->operator==(*o);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorNotEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o) {
|
|
|
|
return self->operator!=(*o);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorLesser(const QCborArray__ConstIterator* self, QCborArray__Iterator* other) {
|
|
|
|
return self->operator<(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorLesserOrEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* other) {
|
|
|
|
return self->operator<=(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorGreater(const QCborArray__ConstIterator* self, QCborArray__Iterator* other) {
|
|
|
|
return self->operator>(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorGreaterOrEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* other) {
|
|
|
|
return self->operator>=(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorEqualWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* o) {
|
|
|
|
return self->operator==(*o);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorNotEqualWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* o) {
|
|
|
|
return self->operator!=(*o);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorLesserWithOther(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* other) {
|
|
|
|
return self->operator<(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorLesserOrEqualWithOther(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* other) {
|
|
|
|
return self->operator<=(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorGreaterWithOther(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* other) {
|
|
|
|
return self->operator>(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
bool QCborArray__ConstIterator_OperatorGreaterOrEqualWithOther(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* other) {
|
|
|
|
return self->operator>=(*other);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusPlus(QCborArray__ConstIterator* self, int param1) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->operator++(static_cast<int>(param1)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusMinus(QCborArray__ConstIterator* self, int param1) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->operator--(static_cast<int>(param1)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, size_t j) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->operator+(static_cast<qsizetype>(j)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, size_t j) {
|
2024-09-17 06:29:11 +00:00
|
|
|
return new QCborArray::ConstIterator(self->operator-(static_cast<qsizetype>(j)));
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
2024-09-11 05:41:09 +00:00
|
|
|
size_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j) {
|
|
|
|
return self->operator-(*j);
|
2024-08-29 07:01:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void QCborArray__ConstIterator_Delete(QCborArray__ConstIterator* self) {
|
|
|
|
delete self;
|
|
|
|
}
|
|
|
|
|