From 2c40f8dc73317992a184ff51a4f515fc1fb644da Mon Sep 17 00:00:00 2001 From: mappu Date: Mon, 16 Sep 2024 19:04:28 +1200 Subject: [PATCH] qt: rebuild for new enum underlying types --- qt/gen_qcborcommon.go | 6 +- qt/gen_qcborstreamreader.cpp | 16 +++++ qt/gen_qcborstreamreader.go | 19 +++++- qt/gen_qcborstreamreader.h | 4 ++ qt/gen_qcborstreamwriter.cpp | 16 +++++ qt/gen_qcborstreamwriter.go | 16 +++++ qt/gen_qcborstreamwriter.h | 4 ++ qt/gen_qcborvalue.cpp | 72 +++++++++++++++++++---- qt/gen_qcborvalue.go | 110 +++++++++++++++++++++++++++-------- qt/gen_qcborvalue.h | 33 +++++++---- qt/gen_qdatetime.go | 2 +- qt/gen_qglobal.go | 2 + 12 files changed, 254 insertions(+), 46 deletions(-) diff --git a/qt/gen_qcborcommon.go b/qt/gen_qcborcommon.go index e99a362..19df3b8 100644 --- a/qt/gen_qcborcommon.go +++ b/qt/gen_qcborcommon.go @@ -13,7 +13,7 @@ import ( "unsafe" ) -type QCborSimpleType int +type QCborSimpleType byte const ( QCborSimpleType__False QCborSimpleType = 20 @@ -22,6 +22,8 @@ const ( QCborSimpleType__Undefined QCborSimpleType = 23 ) +type QCborTag uint64 + type QCborKnownTags int const ( @@ -50,6 +52,8 @@ const ( QCborKnownTags__Signature QCborKnownTags = 55799 ) +type QCborNegativeInteger uint64 + type QCborError__Code int const ( diff --git a/qt/gen_qcborstreamreader.cpp b/qt/gen_qcborstreamreader.cpp index 9cd0557..a1ff0bd 100644 --- a/qt/gen_qcborstreamreader.cpp +++ b/qt/gen_qcborstreamreader.cpp @@ -146,6 +146,10 @@ bool QCborStreamReader_IsInvalid(const QCborStreamReader* self) { return self->isInvalid(); } +bool QCborStreamReader_IsSimpleTypeWithSt(const QCborStreamReader* self, QCborSimpleType st) { + return self->isSimpleType(st); +} + bool QCborStreamReader_IsFalse(const QCborStreamReader* self) { return self->isFalse(); } @@ -194,10 +198,22 @@ bool QCborStreamReader_ToBool(const QCborStreamReader* self) { return self->toBool(); } +QCborTag QCborStreamReader_ToTag(const QCborStreamReader* self) { + return self->toTag(); +} + unsigned long long QCborStreamReader_ToUnsignedInteger(const QCborStreamReader* self) { return self->toUnsignedInteger(); } +QCborNegativeInteger QCborStreamReader_ToNegativeInteger(const QCborStreamReader* self) { + return self->toNegativeInteger(); +} + +QCborSimpleType QCborStreamReader_ToSimpleType(const QCborStreamReader* self) { + return self->toSimpleType(); +} + float QCborStreamReader_ToFloat(const QCborStreamReader* self) { return self->toFloat(); } diff --git a/qt/gen_qcborstreamreader.go b/qt/gen_qcborstreamreader.go index 1b3d56b..985c7d2 100644 --- a/qt/gen_qcborstreamreader.go +++ b/qt/gen_qcborstreamreader.go @@ -13,7 +13,7 @@ import ( "unsafe" ) -type QCborStreamReader__Type int +type QCborStreamReader__Type byte const ( QCborStreamReader__Type__UnsignedInteger QCborStreamReader__Type = 0 @@ -237,6 +237,11 @@ func (this *QCborStreamReader) IsInvalid() bool { return (bool)(_ret) } +func (this *QCborStreamReader) IsSimpleTypeWithSt(st QCborSimpleType) bool { + _ret := C.QCborStreamReader_IsSimpleTypeWithSt(this.h, st) + return (bool)(_ret) +} + func (this *QCborStreamReader) IsFalse() bool { _ret := C.QCborStreamReader_IsFalse(this.h) return (bool)(_ret) @@ -297,11 +302,23 @@ func (this *QCborStreamReader) ToBool() bool { return (bool)(_ret) } +func (this *QCborStreamReader) ToTag() QCborTag { + return C.QCborStreamReader_ToTag(this.h) +} + func (this *QCborStreamReader) ToUnsignedInteger() uint64 { _ret := C.QCborStreamReader_ToUnsignedInteger(this.h) return (uint64)(_ret) } +func (this *QCborStreamReader) ToNegativeInteger() QCborNegativeInteger { + return C.QCborStreamReader_ToNegativeInteger(this.h) +} + +func (this *QCborStreamReader) ToSimpleType() QCborSimpleType { + return C.QCborStreamReader_ToSimpleType(this.h) +} + func (this *QCborStreamReader) ToFloat() float32 { _ret := C.QCborStreamReader_ToFloat(this.h) return (float32)(_ret) diff --git a/qt/gen_qcborstreamreader.h b/qt/gen_qcborstreamreader.h index 66d64dd..677e348 100644 --- a/qt/gen_qcborstreamreader.h +++ b/qt/gen_qcborstreamreader.h @@ -59,6 +59,7 @@ bool QCborStreamReader_IsFloat16(const QCborStreamReader* self); bool QCborStreamReader_IsFloat(const QCborStreamReader* self); bool QCborStreamReader_IsDouble(const QCborStreamReader* self); bool QCborStreamReader_IsInvalid(const QCborStreamReader* self); +bool QCborStreamReader_IsSimpleTypeWithSt(const QCborStreamReader* self, QCborSimpleType st); bool QCborStreamReader_IsFalse(const QCborStreamReader* self); bool QCborStreamReader_IsTrue(const QCborStreamReader* self); bool QCborStreamReader_IsBool(const QCborStreamReader* self); @@ -71,7 +72,10 @@ bool QCborStreamReader_EnterContainer(QCborStreamReader* self); bool QCborStreamReader_LeaveContainer(QCborStreamReader* self); size_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self); bool QCborStreamReader_ToBool(const QCborStreamReader* self); +QCborTag QCborStreamReader_ToTag(const QCborStreamReader* self); unsigned long long QCborStreamReader_ToUnsignedInteger(const QCborStreamReader* self); +QCborNegativeInteger QCborStreamReader_ToNegativeInteger(const QCborStreamReader* self); +QCborSimpleType QCborStreamReader_ToSimpleType(const QCborStreamReader* self); float QCborStreamReader_ToFloat(const QCborStreamReader* self); double QCborStreamReader_ToDouble(const QCborStreamReader* self); long long QCborStreamReader_ToInteger(const QCborStreamReader* self); diff --git a/qt/gen_qcborstreamwriter.cpp b/qt/gen_qcborstreamwriter.cpp index 02a44b8..3ec791d 100644 --- a/qt/gen_qcborstreamwriter.cpp +++ b/qt/gen_qcborstreamwriter.cpp @@ -29,10 +29,26 @@ void QCborStreamWriter_AppendWithQint64(QCborStreamWriter* self, long long i) { self->append(static_cast(i)); } +void QCborStreamWriter_AppendWithQCborNegativeInteger(QCborStreamWriter* self, QCborNegativeInteger n) { + self->append(n); +} + void QCborStreamWriter_AppendWithBa(QCborStreamWriter* self, QByteArray* ba) { self->append(*ba); } +void QCborStreamWriter_AppendWithTag(QCborStreamWriter* self, QCborTag tag) { + self->append(tag); +} + +void QCborStreamWriter_Append3(QCborStreamWriter* self, QCborKnownTags tag) { + self->append(tag); +} + +void QCborStreamWriter_AppendWithSt(QCborStreamWriter* self, QCborSimpleType st) { + self->append(st); +} + void QCborStreamWriter_AppendWithFloat(QCborStreamWriter* self, float f) { self->append(static_cast(f)); } diff --git a/qt/gen_qcborstreamwriter.go b/qt/gen_qcborstreamwriter.go index 571da80..a5ad2a6 100644 --- a/qt/gen_qcborstreamwriter.go +++ b/qt/gen_qcborstreamwriter.go @@ -64,10 +64,26 @@ func (this *QCborStreamWriter) AppendWithQint64(i int64) { C.QCborStreamWriter_AppendWithQint64(this.h, (C.longlong)(i)) } +func (this *QCborStreamWriter) AppendWithQCborNegativeInteger(n QCborNegativeInteger) { + C.QCborStreamWriter_AppendWithQCborNegativeInteger(this.h, n) +} + func (this *QCborStreamWriter) AppendWithBa(ba *QByteArray) { C.QCborStreamWriter_AppendWithBa(this.h, ba.cPointer()) } +func (this *QCborStreamWriter) AppendWithTag(tag QCborTag) { + C.QCborStreamWriter_AppendWithTag(this.h, tag) +} + +func (this *QCborStreamWriter) Append3(tag QCborKnownTags) { + C.QCborStreamWriter_Append3(this.h, tag) +} + +func (this *QCborStreamWriter) AppendWithSt(st QCborSimpleType) { + C.QCborStreamWriter_AppendWithSt(this.h, st) +} + func (this *QCborStreamWriter) AppendWithFloat(f float32) { C.QCborStreamWriter_AppendWithFloat(this.h, (C.float)(f)) } diff --git a/qt/gen_qcborstreamwriter.h b/qt/gen_qcborstreamwriter.h index 7faafdd..50a757e 100644 --- a/qt/gen_qcborstreamwriter.h +++ b/qt/gen_qcborstreamwriter.h @@ -29,7 +29,11 @@ void QCborStreamWriter_SetDevice(QCborStreamWriter* self, QIODevice* device); QIODevice* QCborStreamWriter_Device(const QCborStreamWriter* self); void QCborStreamWriter_Append(QCborStreamWriter* self, unsigned long long u); void QCborStreamWriter_AppendWithQint64(QCborStreamWriter* self, long long i); +void QCborStreamWriter_AppendWithQCborNegativeInteger(QCborStreamWriter* self, QCborNegativeInteger n); void QCborStreamWriter_AppendWithBa(QCborStreamWriter* self, QByteArray* ba); +void QCborStreamWriter_AppendWithTag(QCborStreamWriter* self, QCborTag tag); +void QCborStreamWriter_Append3(QCborStreamWriter* self, QCborKnownTags tag); +void QCborStreamWriter_AppendWithSt(QCborStreamWriter* self, QCborSimpleType st); void QCborStreamWriter_AppendWithFloat(QCborStreamWriter* self, float f); void QCborStreamWriter_AppendWithDouble(QCborStreamWriter* self, double d); void QCborStreamWriter_AppendByteString(QCborStreamWriter* self, const char* data, size_t lenVal); diff --git a/qt/gen_qcborvalue.cpp b/qt/gen_qcborvalue.cpp index af3d089..585f41d 100644 --- a/qt/gen_qcborvalue.cpp +++ b/qt/gen_qcborvalue.cpp @@ -58,47 +58,67 @@ QCborValue* QCborValue_new7(double v) { return new QCborValue(static_cast(v)); } -QCborValue* QCborValue_new8(QByteArray* ba) { +QCborValue* QCborValue_new8(QCborSimpleType st) { + return new QCborValue(st); +} + +QCborValue* QCborValue_new9(QByteArray* ba) { return new QCborValue(*ba); } -QCborValue* QCborValue_new9(struct miqt_string* s) { +QCborValue* QCborValue_new10(struct miqt_string* s) { QString s_QString = QString::fromUtf8(&s->data, s->len); return new QCborValue(s_QString); } -QCborValue* QCborValue_new10(const char* s) { +QCborValue* QCborValue_new11(const char* s) { return new QCborValue(s); } -QCborValue* QCborValue_new11(QCborArray* a) { +QCborValue* QCborValue_new12(QCborArray* a) { return new QCborValue(*a); } -QCborValue* QCborValue_new12(QCborMap* m) { +QCborValue* QCborValue_new13(QCborMap* m) { return new QCborValue(*m); } -QCborValue* QCborValue_new13(QDateTime* dt) { +QCborValue* QCborValue_new14(QCborTag tag) { + return new QCborValue(tag); +} + +QCborValue* QCborValue_new15(QCborKnownTags t_) { + return new QCborValue(t_); +} + +QCborValue* QCborValue_new16(QDateTime* dt) { return new QCborValue(*dt); } -QCborValue* QCborValue_new14(QUrl* url) { +QCborValue* QCborValue_new17(QUrl* url) { return new QCborValue(*url); } -QCborValue* QCborValue_new15(QRegularExpression* rx) { +QCborValue* QCborValue_new18(QRegularExpression* rx) { return new QCborValue(*rx); } -QCborValue* QCborValue_new16(QUuid* uuid) { +QCborValue* QCborValue_new19(QUuid* uuid) { return new QCborValue(*uuid); } -QCborValue* QCborValue_new17(QCborValue* other) { +QCborValue* QCborValue_new20(QCborValue* other) { return new QCborValue(*other); } +QCborValue* QCborValue_new21(QCborTag tag, QCborValue* taggedValue) { + return new QCborValue(tag, *taggedValue); +} + +QCborValue* QCborValue_new22(QCborKnownTags t_, QCborValue* tv) { + return new QCborValue(t_, *tv); +} + void QCborValue_OperatorAssign(QCborValue* self, QCborValue* other) { self->operator=(*other); } @@ -188,6 +208,14 @@ bool QCborValue_IsSimpleType(const QCborValue* self) { return self->isSimpleType(); } +bool QCborValue_IsSimpleTypeWithSt(const QCborValue* self, QCborSimpleType st) { + return self->isSimpleType(st); +} + +QCborSimpleType QCborValue_ToSimpleType(const QCborValue* self) { + return self->toSimpleType(); +} + long long QCborValue_ToInteger(const QCborValue* self) { return self->toInteger(); } @@ -200,6 +228,10 @@ double QCborValue_ToDouble(const QCborValue* self) { return self->toDouble(); } +QCborTag QCborValue_Tag(const QCborValue* self) { + return self->tag(); +} + QCborValue* QCborValue_TaggedValue(const QCborValue* self) { QCborValue _ret = self->taggedValue(); // Copy-construct value returned type into heap-allocated copy @@ -374,6 +406,10 @@ struct miqt_string* QCborValue_ToDiagnosticNotation(const QCborValue* self) { return miqt_strdup(_b.data(), _b.length()); } +QCborSimpleType QCborValue_ToSimpleType1(const QCborValue* self, QCborSimpleType defaultValue) { + return self->toSimpleType(defaultValue); +} + long long QCborValue_ToInteger1(const QCborValue* self, long long defaultValue) { return self->toInteger(static_cast(defaultValue)); } @@ -386,6 +422,10 @@ double QCborValue_ToDouble1(const QCborValue* self, double defaultValue) { return self->toDouble(static_cast(defaultValue)); } +QCborTag QCborValue_Tag1(const QCborValue* self, QCborTag defaultValue) { + return self->tag(defaultValue); +} + QCborValue* QCborValue_TaggedValue1(const QCborValue* self, QCborValue* defaultValue) { QCborValue _ret = self->taggedValue(*defaultValue); // Copy-construct value returned type into heap-allocated copy @@ -562,6 +602,14 @@ bool QCborValueRef_IsSimpleType(const QCborValueRef* self) { return self->isSimpleType(); } +bool QCborValueRef_IsSimpleTypeWithSt(const QCborValueRef* self, QCborSimpleType st) { + return self->isSimpleType(st); +} + +QCborTag QCborValueRef_Tag(const QCborValueRef* self) { + return self->tag(); +} + QCborValue* QCborValueRef_TaggedValue(const QCborValueRef* self) { QCborValue _ret = self->taggedValue(); // Copy-construct value returned type into heap-allocated copy @@ -712,6 +760,10 @@ struct miqt_string* QCborValueRef_ToDiagnosticNotation(QCborValueRef* self) { return miqt_strdup(_b.data(), _b.length()); } +QCborTag QCborValueRef_Tag1(const QCborValueRef* self, QCborTag defaultValue) { + return self->tag(defaultValue); +} + QCborValue* QCborValueRef_TaggedValue1(const QCborValueRef* self, QCborValue* defaultValue) { QCborValue _ret = self->taggedValue(*defaultValue); // Copy-construct value returned type into heap-allocated copy diff --git a/qt/gen_qcborvalue.go b/qt/gen_qcborvalue.go index bc30131..f917003 100644 --- a/qt/gen_qcborvalue.go +++ b/qt/gen_qcborvalue.go @@ -161,66 +161,96 @@ func NewQCborValue7(v float64) *QCborValue { } // NewQCborValue8 constructs a new QCborValue object. -func NewQCborValue8(ba *QByteArray) *QCborValue { - ret := C.QCborValue_new8(ba.cPointer()) +func NewQCborValue8(st QCborSimpleType) *QCborValue { + ret := C.QCborValue_new8(st) return newQCborValue(ret) } // NewQCborValue9 constructs a new QCborValue object. -func NewQCborValue9(s string) *QCborValue { - s_ms := miqt_strdupg(s) - defer C.free(s_ms) - ret := C.QCborValue_new9((*C.struct_miqt_string)(s_ms)) +func NewQCborValue9(ba *QByteArray) *QCborValue { + ret := C.QCborValue_new9(ba.cPointer()) return newQCborValue(ret) } // NewQCborValue10 constructs a new QCborValue object. func NewQCborValue10(s string) *QCborValue { - s_Cstring := C.CString(s) - defer C.free(unsafe.Pointer(s_Cstring)) - ret := C.QCborValue_new10(s_Cstring) + s_ms := miqt_strdupg(s) + defer C.free(s_ms) + ret := C.QCborValue_new10((*C.struct_miqt_string)(s_ms)) return newQCborValue(ret) } // NewQCborValue11 constructs a new QCborValue object. -func NewQCborValue11(a *QCborArray) *QCborValue { - ret := C.QCborValue_new11(a.cPointer()) +func NewQCborValue11(s string) *QCborValue { + s_Cstring := C.CString(s) + defer C.free(unsafe.Pointer(s_Cstring)) + ret := C.QCborValue_new11(s_Cstring) return newQCborValue(ret) } // NewQCborValue12 constructs a new QCborValue object. -func NewQCborValue12(m *QCborMap) *QCborValue { - ret := C.QCborValue_new12(m.cPointer()) +func NewQCborValue12(a *QCborArray) *QCborValue { + ret := C.QCborValue_new12(a.cPointer()) return newQCborValue(ret) } // NewQCborValue13 constructs a new QCborValue object. -func NewQCborValue13(dt *QDateTime) *QCborValue { - ret := C.QCborValue_new13(dt.cPointer()) +func NewQCborValue13(m *QCborMap) *QCborValue { + ret := C.QCborValue_new13(m.cPointer()) return newQCborValue(ret) } // NewQCborValue14 constructs a new QCborValue object. -func NewQCborValue14(url *QUrl) *QCborValue { - ret := C.QCborValue_new14(url.cPointer()) +func NewQCborValue14(tag QCborTag) *QCborValue { + ret := C.QCborValue_new14(tag) return newQCborValue(ret) } // NewQCborValue15 constructs a new QCborValue object. -func NewQCborValue15(rx *QRegularExpression) *QCborValue { - ret := C.QCborValue_new15(rx.cPointer()) +func NewQCborValue15(t_ QCborKnownTags) *QCborValue { + ret := C.QCborValue_new15(t_) return newQCborValue(ret) } // NewQCborValue16 constructs a new QCborValue object. -func NewQCborValue16(uuid *QUuid) *QCborValue { - ret := C.QCborValue_new16(uuid.cPointer()) +func NewQCborValue16(dt *QDateTime) *QCborValue { + ret := C.QCborValue_new16(dt.cPointer()) return newQCborValue(ret) } // NewQCborValue17 constructs a new QCborValue object. -func NewQCborValue17(other *QCborValue) *QCborValue { - ret := C.QCborValue_new17(other.cPointer()) +func NewQCborValue17(url *QUrl) *QCborValue { + ret := C.QCborValue_new17(url.cPointer()) + return newQCborValue(ret) +} + +// NewQCborValue18 constructs a new QCborValue object. +func NewQCborValue18(rx *QRegularExpression) *QCborValue { + ret := C.QCborValue_new18(rx.cPointer()) + return newQCborValue(ret) +} + +// NewQCborValue19 constructs a new QCborValue object. +func NewQCborValue19(uuid *QUuid) *QCborValue { + ret := C.QCborValue_new19(uuid.cPointer()) + return newQCborValue(ret) +} + +// NewQCborValue20 constructs a new QCborValue object. +func NewQCborValue20(other *QCborValue) *QCborValue { + ret := C.QCborValue_new20(other.cPointer()) + return newQCborValue(ret) +} + +// NewQCborValue21 constructs a new QCborValue object. +func NewQCborValue21(tag QCborTag, taggedValue *QCborValue) *QCborValue { + ret := C.QCborValue_new21(tag, taggedValue.cPointer()) + return newQCborValue(ret) +} + +// NewQCborValue22 constructs a new QCborValue object. +func NewQCborValue22(t_ QCborKnownTags, tv *QCborValue) *QCborValue { + ret := C.QCborValue_new22(t_, tv.cPointer()) return newQCborValue(ret) } @@ -332,6 +362,15 @@ func (this *QCborValue) IsSimpleType() bool { return (bool)(_ret) } +func (this *QCborValue) IsSimpleTypeWithSt(st QCborSimpleType) bool { + _ret := C.QCborValue_IsSimpleTypeWithSt(this.h, st) + return (bool)(_ret) +} + +func (this *QCborValue) ToSimpleType() QCborSimpleType { + return C.QCborValue_ToSimpleType(this.h) +} + func (this *QCborValue) ToInteger() int64 { _ret := C.QCborValue_ToInteger(this.h) return (int64)(_ret) @@ -347,6 +386,10 @@ func (this *QCborValue) ToDouble() float64 { return (float64)(_ret) } +func (this *QCborValue) Tag() QCborTag { + return C.QCborValue_Tag(this.h) +} + func (this *QCborValue) TaggedValue() *QCborValue { _ret := C.QCborValue_TaggedValue(this.h) _goptr := newQCborValue(_ret) @@ -552,6 +595,10 @@ func (this *QCborValue) ToDiagnosticNotation() string { return _ret } +func (this *QCborValue) ToSimpleType1(defaultValue QCborSimpleType) QCborSimpleType { + return C.QCborValue_ToSimpleType1(this.h, defaultValue) +} + func (this *QCborValue) ToInteger1(defaultValue int64) int64 { _ret := C.QCborValue_ToInteger1(this.h, (C.longlong)(defaultValue)) return (int64)(_ret) @@ -567,6 +614,10 @@ func (this *QCborValue) ToDouble1(defaultValue float64) float64 { return (float64)(_ret) } +func (this *QCborValue) Tag1(defaultValue QCborTag) QCborTag { + return C.QCborValue_Tag1(this.h, defaultValue) +} + func (this *QCborValue) TaggedValue1(defaultValue *QCborValue) *QCborValue { _ret := C.QCborValue_TaggedValue1(this.h, defaultValue.cPointer()) _goptr := newQCborValue(_ret) @@ -809,6 +860,15 @@ func (this *QCborValueRef) IsSimpleType() bool { return (bool)(_ret) } +func (this *QCborValueRef) IsSimpleTypeWithSt(st QCborSimpleType) bool { + _ret := C.QCborValueRef_IsSimpleTypeWithSt(this.h, st) + return (bool)(_ret) +} + +func (this *QCborValueRef) Tag() QCborTag { + return C.QCborValueRef_Tag(this.h) +} + func (this *QCborValueRef) TaggedValue() *QCborValue { _ret := C.QCborValueRef_TaggedValue(this.h) _goptr := newQCborValue(_ret) @@ -985,6 +1045,10 @@ func (this *QCborValueRef) ToDiagnosticNotation() string { return _ret } +func (this *QCborValueRef) Tag1(defaultValue QCborTag) QCborTag { + return C.QCborValueRef_Tag1(this.h, defaultValue) +} + func (this *QCborValueRef) TaggedValue1(defaultValue *QCborValue) *QCborValue { _ret := C.QCborValueRef_TaggedValue1(this.h, defaultValue.cPointer()) _goptr := newQCborValue(_ret) diff --git a/qt/gen_qcborvalue.h b/qt/gen_qcborvalue.h index 2e08d80..2d765f1 100644 --- a/qt/gen_qcborvalue.h +++ b/qt/gen_qcborvalue.h @@ -55,16 +55,21 @@ QCborValue* QCborValue_new4(int i); QCborValue* QCborValue_new5(unsigned int u); QCborValue* QCborValue_new6(long long i); QCborValue* QCborValue_new7(double v); -QCborValue* QCborValue_new8(QByteArray* ba); -QCborValue* QCborValue_new9(struct miqt_string* s); -QCborValue* QCborValue_new10(const char* s); -QCborValue* QCborValue_new11(QCborArray* a); -QCborValue* QCborValue_new12(QCborMap* m); -QCborValue* QCborValue_new13(QDateTime* dt); -QCborValue* QCborValue_new14(QUrl* url); -QCborValue* QCborValue_new15(QRegularExpression* rx); -QCborValue* QCborValue_new16(QUuid* uuid); -QCborValue* QCborValue_new17(QCborValue* other); +QCborValue* QCborValue_new8(QCborSimpleType st); +QCborValue* QCborValue_new9(QByteArray* ba); +QCborValue* QCborValue_new10(struct miqt_string* s); +QCborValue* QCborValue_new11(const char* s); +QCborValue* QCborValue_new12(QCborArray* a); +QCborValue* QCborValue_new13(QCborMap* m); +QCborValue* QCborValue_new14(QCborTag tag); +QCborValue* QCborValue_new15(QCborKnownTags t_); +QCborValue* QCborValue_new16(QDateTime* dt); +QCborValue* QCborValue_new17(QUrl* url); +QCborValue* QCborValue_new18(QRegularExpression* rx); +QCborValue* QCborValue_new19(QUuid* uuid); +QCborValue* QCborValue_new20(QCborValue* other); +QCborValue* QCborValue_new21(QCborTag tag, QCborValue* taggedValue); +QCborValue* QCborValue_new22(QCborKnownTags t_, QCborValue* tv); void QCborValue_OperatorAssign(QCborValue* self, QCborValue* other); void QCborValue_Swap(QCborValue* self, QCborValue* other); uintptr_t QCborValue_Type(const QCborValue* self); @@ -87,9 +92,12 @@ bool QCborValue_IsUuid(const QCborValue* self); bool QCborValue_IsInvalid(const QCborValue* self); bool QCborValue_IsContainer(const QCborValue* self); bool QCborValue_IsSimpleType(const QCborValue* self); +bool QCborValue_IsSimpleTypeWithSt(const QCborValue* self, QCborSimpleType st); +QCborSimpleType QCborValue_ToSimpleType(const QCborValue* self); long long QCborValue_ToInteger(const QCborValue* self); bool QCborValue_ToBool(const QCborValue* self); double QCborValue_ToDouble(const QCborValue* self); +QCborTag QCborValue_Tag(const QCborValue* self); QCborValue* QCborValue_TaggedValue(const QCborValue* self); QByteArray* QCborValue_ToByteArray(const QCborValue* self); struct miqt_string* QCborValue_ToString(const QCborValue* self); @@ -120,9 +128,11 @@ QCborValue* QCborValue_FromCbor3(const unsigned char* data, size_t lenVal); QByteArray* QCborValue_ToCbor(QCborValue* self); void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer); struct miqt_string* QCborValue_ToDiagnosticNotation(const QCborValue* self); +QCborSimpleType QCborValue_ToSimpleType1(const QCborValue* self, QCborSimpleType defaultValue); long long QCborValue_ToInteger1(const QCborValue* self, long long defaultValue); bool QCborValue_ToBool1(const QCborValue* self, bool defaultValue); double QCborValue_ToDouble1(const QCborValue* self, double defaultValue); +QCborTag QCborValue_Tag1(const QCborValue* self, QCborTag defaultValue); QCborValue* QCborValue_TaggedValue1(const QCborValue* self, QCborValue* defaultValue); QByteArray* QCborValue_ToByteArray1(const QCborValue* self, QByteArray* defaultValue); struct miqt_string* QCborValue_ToString1(const QCborValue* self, struct miqt_string* defaultValue); @@ -161,6 +171,8 @@ bool QCborValueRef_IsUuid(const QCborValueRef* self); bool QCborValueRef_IsInvalid(const QCborValueRef* self); bool QCborValueRef_IsContainer(const QCborValueRef* self); bool QCborValueRef_IsSimpleType(const QCborValueRef* self); +bool QCborValueRef_IsSimpleTypeWithSt(const QCborValueRef* self, QCborSimpleType st); +QCborTag QCborValueRef_Tag(const QCborValueRef* self); QCborValue* QCborValueRef_TaggedValue(const QCborValueRef* self); long long QCborValueRef_ToInteger(const QCborValueRef* self); bool QCborValueRef_ToBool(const QCborValueRef* self); @@ -188,6 +200,7 @@ QJsonValue* QCborValueRef_ToJsonValue(const QCborValueRef* self); QByteArray* QCborValueRef_ToCbor(QCborValueRef* self); void QCborValueRef_ToCborWithWriter(QCborValueRef* self, QCborStreamWriter* writer); struct miqt_string* QCborValueRef_ToDiagnosticNotation(QCborValueRef* self); +QCborTag QCborValueRef_Tag1(const QCborValueRef* self, QCborTag defaultValue); QCborValue* QCborValueRef_TaggedValue1(const QCborValueRef* self, QCborValue* defaultValue); long long QCborValueRef_ToInteger1(const QCborValueRef* self, long long defaultValue); bool QCborValueRef_ToBool1(const QCborValueRef* self, bool defaultValue); diff --git a/qt/gen_qdatetime.go b/qt/gen_qdatetime.go index c6200a3..4887716 100644 --- a/qt/gen_qdatetime.go +++ b/qt/gen_qdatetime.go @@ -20,7 +20,7 @@ const ( QDate__MonthNameType__StandaloneFormat QDate__MonthNameType = 1 ) -type QDateTime__YearRange int +type QDateTime__YearRange int32 const ( QDateTime__YearRange__First QDateTime__YearRange = -292275056 diff --git a/qt/gen_qglobal.go b/qt/gen_qglobal.go index f5a9967..ac63828 100644 --- a/qt/gen_qglobal.go +++ b/qt/gen_qglobal.go @@ -7,3 +7,5 @@ package qt */ import "C" + +type QtPrivate__Deprecated_t int