mirror of
https://github.com/mappu/miqt.git
synced 2024-12-30 12:18:37 +00:00
qt: rebuild (changes for some integer types)
This commit is contained in:
parent
bcfdb4ea15
commit
b7d84fd707
qt
gen_qbitarray.cppgen_qbitarray.gogen_qbitarray.hgen_qbytearray.gogen_qcborarray.cppgen_qcborarray.gogen_qcborarray.hgen_qcbormap.cppgen_qcbormap.gogen_qcbormap.hgen_qcborstreamreader.cppgen_qcborstreamreader.gogen_qcborstreamreader.hgen_qcborstreamwriter.cppgen_qcborstreamwriter.gogen_qcborstreamwriter.hgen_qcborvalue.cppgen_qcborvalue.gogen_qcborvalue.hgen_qchar.gogen_qcontainerfwd.cppgen_qcontainerfwd.gogen_qcontainerfwd.hgen_qdatastream.gogen_qdebug.gogen_qimage.cppgen_qimage.gogen_qimage.hgen_qiodevice.gogen_qlocale.gogen_qrandom.cppgen_qrandom.gogen_qrandom.hgen_qsocketnotifier.cppgen_qsocketnotifier.gogen_qstringview.cppgen_qstringview.gogen_qstringview.hgen_qtextstream.go
@ -144,8 +144,8 @@ const char* QBitArray_Bits(const QBitArray* self) {
|
||||
return (const char*) self->bits();
|
||||
}
|
||||
|
||||
QBitArray* QBitArray_FromBits(const char* data, size_t lenVal) {
|
||||
return new QBitArray(QBitArray::fromBits(data, static_cast<qsizetype>(lenVal)));
|
||||
QBitArray* QBitArray_FromBits(const char* data, ptrdiff_t lenVal) {
|
||||
return new QBitArray(QBitArray::fromBits(data, (qsizetype)(lenVal)));
|
||||
}
|
||||
|
||||
bool QBitArray_Fill22(QBitArray* self, bool val, int size) {
|
||||
|
@ -193,10 +193,10 @@ func (this *QBitArray) Bits() unsafe.Pointer {
|
||||
return (unsafe.Pointer)(_ret)
|
||||
}
|
||||
|
||||
func QBitArray_FromBits(data string, lenVal uint64) *QBitArray {
|
||||
func QBitArray_FromBits(data string, lenVal int64) *QBitArray {
|
||||
data_Cstring := C.CString(data)
|
||||
defer C.free(unsafe.Pointer(data_Cstring))
|
||||
_ret := C.QBitArray_FromBits(data_Cstring, (C.size_t)(lenVal))
|
||||
_ret := C.QBitArray_FromBits(data_Cstring, (C.ptrdiff_t)(lenVal))
|
||||
_goptr := newQBitArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
|
@ -56,7 +56,7 @@ bool QBitArray_Fill(QBitArray* self, bool val);
|
||||
void QBitArray_Fill2(QBitArray* self, bool val, int first, int last);
|
||||
void QBitArray_Truncate(QBitArray* self, int pos);
|
||||
const char* QBitArray_Bits(const QBitArray* self);
|
||||
QBitArray* QBitArray_FromBits(const char* data, size_t lenVal);
|
||||
QBitArray* QBitArray_FromBits(const char* data, ptrdiff_t lenVal);
|
||||
bool QBitArray_Fill22(QBitArray* self, bool val, int size);
|
||||
void QBitArray_Delete(QBitArray* self);
|
||||
|
||||
|
@ -132,7 +132,7 @@ func NewQByteArray2(param1 string) *QByteArray {
|
||||
}
|
||||
|
||||
// NewQByteArray3 constructs a new QByteArray object.
|
||||
func NewQByteArray3(size int, c byte) *QByteArray {
|
||||
func NewQByteArray3(size int, c int8) *QByteArray {
|
||||
ret := C.QByteArray_new3((C.int)(size), (C.char)(c))
|
||||
return newQByteArray(ret)
|
||||
}
|
||||
@ -189,7 +189,7 @@ func (this *QByteArray) Resize(size int) {
|
||||
C.QByteArray_Resize(this.h, (C.int)(size))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Fill(c byte) *QByteArray {
|
||||
func (this *QByteArray) Fill(c int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Fill(this.h, (C.char)(c))))
|
||||
}
|
||||
|
||||
@ -236,16 +236,16 @@ func (this *QByteArray) Clear() {
|
||||
C.QByteArray_Clear(this.h)
|
||||
}
|
||||
|
||||
func (this *QByteArray) At(i int) byte {
|
||||
return (byte)(C.QByteArray_At(this.h, (C.int)(i)))
|
||||
func (this *QByteArray) At(i int) int8 {
|
||||
return (int8)(C.QByteArray_At(this.h, (C.int)(i)))
|
||||
}
|
||||
|
||||
func (this *QByteArray) OperatorSubscript(i int) byte {
|
||||
return (byte)(C.QByteArray_OperatorSubscript(this.h, (C.int)(i)))
|
||||
func (this *QByteArray) OperatorSubscript(i int) int8 {
|
||||
return (int8)(C.QByteArray_OperatorSubscript(this.h, (C.int)(i)))
|
||||
}
|
||||
|
||||
func (this *QByteArray) OperatorSubscriptWithUint(i uint) byte {
|
||||
return (byte)(C.QByteArray_OperatorSubscriptWithUint(this.h, (C.uint)(i)))
|
||||
func (this *QByteArray) OperatorSubscriptWithUint(i uint) int8 {
|
||||
return (int8)(C.QByteArray_OperatorSubscriptWithUint(this.h, (C.uint)(i)))
|
||||
}
|
||||
|
||||
func (this *QByteArray) OperatorSubscriptWithInt(i int) *QByteRef {
|
||||
@ -262,8 +262,8 @@ func (this *QByteArray) OperatorSubscript2(i uint) *QByteRef {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) Front() byte {
|
||||
return (byte)(C.QByteArray_Front(this.h))
|
||||
func (this *QByteArray) Front() int8 {
|
||||
return (int8)(C.QByteArray_Front(this.h))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Front2() *QByteRef {
|
||||
@ -273,8 +273,8 @@ func (this *QByteArray) Front2() *QByteRef {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) Back() byte {
|
||||
return (byte)(C.QByteArray_Back(this.h))
|
||||
func (this *QByteArray) Back() int8 {
|
||||
return (int8)(C.QByteArray_Back(this.h))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Back2() *QByteRef {
|
||||
@ -284,7 +284,7 @@ func (this *QByteArray) Back2() *QByteRef {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) IndexOf(c byte) int {
|
||||
func (this *QByteArray) IndexOf(c int8) int {
|
||||
return (int)(C.QByteArray_IndexOf(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
@ -298,7 +298,7 @@ func (this *QByteArray) IndexOfWithQByteArray(a *QByteArray) int {
|
||||
return (int)(C.QByteArray_IndexOfWithQByteArray(this.h, a.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QByteArray) LastIndexOf(c byte) int {
|
||||
func (this *QByteArray) LastIndexOf(c int8) int {
|
||||
return (int)(C.QByteArray_LastIndexOf(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
@ -312,7 +312,7 @@ func (this *QByteArray) LastIndexOfWithQByteArray(a *QByteArray) int {
|
||||
return (int)(C.QByteArray_LastIndexOfWithQByteArray(this.h, a.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Contains(c byte) bool {
|
||||
func (this *QByteArray) Contains(c int8) bool {
|
||||
return (bool)(C.QByteArray_Contains(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
@ -326,7 +326,7 @@ func (this *QByteArray) ContainsWithQByteArray(a *QByteArray) bool {
|
||||
return (bool)(C.QByteArray_ContainsWithQByteArray(this.h, a.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Count(c byte) int {
|
||||
func (this *QByteArray) Count(c int8) int {
|
||||
return (int)(C.QByteArray_Count(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
@ -382,7 +382,7 @@ func (this *QByteArray) StartsWith(a *QByteArray) bool {
|
||||
return (bool)(C.QByteArray_StartsWith(this.h, a.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QByteArray) StartsWithWithChar(c byte) bool {
|
||||
func (this *QByteArray) StartsWithWithChar(c int8) bool {
|
||||
return (bool)(C.QByteArray_StartsWithWithChar(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
@ -396,7 +396,7 @@ func (this *QByteArray) EndsWith(a *QByteArray) bool {
|
||||
return (bool)(C.QByteArray_EndsWith(this.h, a.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QByteArray) EndsWithWithChar(c byte) bool {
|
||||
func (this *QByteArray) EndsWithWithChar(c int8) bool {
|
||||
return (bool)(C.QByteArray_EndsWithWithChar(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
@ -464,11 +464,11 @@ func (this *QByteArray) RightJustified(width int) *QByteArray {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) Prepend(c byte) *QByteArray {
|
||||
func (this *QByteArray) Prepend(c int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Prepend(this.h, (C.char)(c))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Prepend2(count int, c byte) *QByteArray {
|
||||
func (this *QByteArray) Prepend2(count int, c int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Prepend2(this.h, (C.int)(count), (C.char)(c))))
|
||||
}
|
||||
|
||||
@ -488,11 +488,11 @@ func (this *QByteArray) PrependWithQByteArray(a *QByteArray) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_PrependWithQByteArray(this.h, a.cPointer())))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Append(c byte) *QByteArray {
|
||||
func (this *QByteArray) Append(c int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Append(this.h, (C.char)(c))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Append2(count int, c byte) *QByteArray {
|
||||
func (this *QByteArray) Append2(count int, c int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Append2(this.h, (C.int)(count), (C.char)(c))))
|
||||
}
|
||||
|
||||
@ -512,11 +512,11 @@ func (this *QByteArray) AppendWithQByteArray(a *QByteArray) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_AppendWithQByteArray(this.h, a.cPointer())))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Insert(i int, c byte) *QByteArray {
|
||||
func (this *QByteArray) Insert(i int, c int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Insert(this.h, (C.int)(i), (C.char)(c))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Insert2(i int, count int, c byte) *QByteArray {
|
||||
func (this *QByteArray) Insert2(i int, count int, c int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Insert2(this.h, (C.int)(i), (C.int)(count), (C.char)(c))))
|
||||
}
|
||||
|
||||
@ -556,13 +556,13 @@ func (this *QByteArray) Replace3(index int, lenVal int, s *QByteArray) *QByteArr
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace3(this.h, (C.int)(index), (C.int)(lenVal), s.cPointer())))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Replace4(before byte, after string) *QByteArray {
|
||||
func (this *QByteArray) Replace4(before int8, after string) *QByteArray {
|
||||
after_Cstring := C.CString(after)
|
||||
defer C.free(unsafe.Pointer(after_Cstring))
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace4(this.h, (C.char)(before), after_Cstring)))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Replace5(before byte, after *QByteArray) *QByteArray {
|
||||
func (this *QByteArray) Replace5(before int8, after *QByteArray) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace5(this.h, (C.char)(before), after.cPointer())))
|
||||
}
|
||||
|
||||
@ -598,11 +598,11 @@ func (this *QByteArray) Replace10(before string, after *QByteArray) *QByteArray
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace10(this.h, before_Cstring, after.cPointer())))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Replace11(before byte, after byte) *QByteArray {
|
||||
func (this *QByteArray) Replace11(before int8, after int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace11(this.h, (C.char)(before), (C.char)(after))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) OperatorPlusAssign(c byte) *QByteArray {
|
||||
func (this *QByteArray) OperatorPlusAssign(c int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_OperatorPlusAssign(this.h, (C.char)(c))))
|
||||
}
|
||||
|
||||
@ -616,7 +616,7 @@ func (this *QByteArray) OperatorPlusAssignWithQByteArray(a *QByteArray) *QByteAr
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_OperatorPlusAssignWithQByteArray(this.h, a.cPointer())))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Split(sep byte) []QByteArray {
|
||||
func (this *QByteArray) Split(sep int8) []QByteArray {
|
||||
var _ma *C.struct_miqt_array = C.QByteArray_Split(this.h, (C.char)(sep))
|
||||
_ret := make([]QByteArray, int(_ma.len))
|
||||
_outCast := (*[0xffff]*C.QByteArray)(unsafe.Pointer(_ma.data)) // hey ya
|
||||
@ -657,7 +657,7 @@ func (this *QByteArray) Replace12(before string, after string) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace12(this.h, (*C.struct_miqt_string)(before_ms), after_Cstring)))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Replace13(c byte, after string) *QByteArray {
|
||||
func (this *QByteArray) Replace13(c int8, after string) *QByteArray {
|
||||
after_ms := miqt_strdupg(after)
|
||||
defer C.free(after_ms)
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Replace13(this.h, (C.char)(c), (*C.struct_miqt_string)(after_ms))))
|
||||
@ -784,7 +784,7 @@ func (this *QByteArray) ToHex() *QByteArray {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) ToHexWithSeparator(separator byte) *QByteArray {
|
||||
func (this *QByteArray) ToHexWithSeparator(separator int8) *QByteArray {
|
||||
_ret := C.QByteArray_ToHexWithSeparator(this.h, (C.char)(separator))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
@ -955,7 +955,7 @@ func (this *QByteArray) ConstEnd() unsafe.Pointer {
|
||||
return (unsafe.Pointer)(_ret)
|
||||
}
|
||||
|
||||
func (this *QByteArray) PushBack(c byte) {
|
||||
func (this *QByteArray) PushBack(c int8) {
|
||||
C.QByteArray_PushBack(this.h, (C.char)(c))
|
||||
}
|
||||
|
||||
@ -969,7 +969,7 @@ func (this *QByteArray) PushBackWithQByteArray(a *QByteArray) {
|
||||
C.QByteArray_PushBackWithQByteArray(this.h, a.cPointer())
|
||||
}
|
||||
|
||||
func (this *QByteArray) PushFront(c byte) {
|
||||
func (this *QByteArray) PushFront(c int8) {
|
||||
C.QByteArray_PushFront(this.h, (C.char)(c))
|
||||
}
|
||||
|
||||
@ -999,11 +999,11 @@ func (this *QByteArray) IsNull() bool {
|
||||
return (bool)(C.QByteArray_IsNull(this.h))
|
||||
}
|
||||
|
||||
func (this *QByteArray) Fill2(c byte, size int) *QByteArray {
|
||||
func (this *QByteArray) Fill2(c int8, size int) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_Fill2(this.h, (C.char)(c), (C.int)(size))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) IndexOf2(c byte, from int) int {
|
||||
func (this *QByteArray) IndexOf2(c int8, from int) int {
|
||||
return (int)(C.QByteArray_IndexOf2(this.h, (C.char)(c), (C.int)(from)))
|
||||
}
|
||||
|
||||
@ -1017,7 +1017,7 @@ func (this *QByteArray) IndexOf23(a *QByteArray, from int) int {
|
||||
return (int)(C.QByteArray_IndexOf23(this.h, a.cPointer(), (C.int)(from)))
|
||||
}
|
||||
|
||||
func (this *QByteArray) LastIndexOf2(c byte, from int) int {
|
||||
func (this *QByteArray) LastIndexOf2(c int8, from int) int {
|
||||
return (int)(C.QByteArray_LastIndexOf2(this.h, (C.char)(c), (C.int)(from)))
|
||||
}
|
||||
|
||||
@ -1048,28 +1048,28 @@ func (this *QByteArray) Mid2(index int, lenVal int) *QByteArray {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) LeftJustified2(width int, fill byte) *QByteArray {
|
||||
func (this *QByteArray) LeftJustified2(width int, fill int8) *QByteArray {
|
||||
_ret := C.QByteArray_LeftJustified2(this.h, (C.int)(width), (C.char)(fill))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) LeftJustified3(width int, fill byte, truncate bool) *QByteArray {
|
||||
func (this *QByteArray) LeftJustified3(width int, fill int8, truncate bool) *QByteArray {
|
||||
_ret := C.QByteArray_LeftJustified3(this.h, (C.int)(width), (C.char)(fill), (C.bool)(truncate))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) RightJustified2(width int, fill byte) *QByteArray {
|
||||
func (this *QByteArray) RightJustified2(width int, fill int8) *QByteArray {
|
||||
_ret := C.QByteArray_RightJustified2(this.h, (C.int)(width), (C.char)(fill))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) RightJustified3(width int, fill byte, truncate bool) *QByteArray {
|
||||
func (this *QByteArray) RightJustified3(width int, fill int8, truncate bool) *QByteArray {
|
||||
_ret := C.QByteArray_RightJustified3(this.h, (C.int)(width), (C.char)(fill), (C.bool)(truncate))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
@ -1174,7 +1174,7 @@ func (this *QByteArray) ToPercentEncoding2(exclude *QByteArray, include *QByteAr
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QByteArray) ToPercentEncoding3(exclude *QByteArray, include *QByteArray, percent byte) *QByteArray {
|
||||
func (this *QByteArray) ToPercentEncoding3(exclude *QByteArray, include *QByteArray, percent int8) *QByteArray {
|
||||
_ret := C.QByteArray_ToPercentEncoding3(this.h, exclude.cPointer(), include.cPointer(), (C.char)(percent))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
@ -1205,19 +1205,19 @@ func (this *QByteArray) SetNum26(param1 uint64, base int) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum26(this.h, (C.ulonglong)(param1), (C.int)(base))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) SetNum27(param1 float32, f byte) *QByteArray {
|
||||
func (this *QByteArray) SetNum27(param1 float32, f int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum27(this.h, (C.float)(param1), (C.char)(f))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) SetNum3(param1 float32, f byte, prec int) *QByteArray {
|
||||
func (this *QByteArray) SetNum3(param1 float32, f int8, prec int) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum3(this.h, (C.float)(param1), (C.char)(f), (C.int)(prec))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) SetNum28(param1 float64, f byte) *QByteArray {
|
||||
func (this *QByteArray) SetNum28(param1 float64, f int8) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum28(this.h, (C.double)(param1), (C.char)(f))))
|
||||
}
|
||||
|
||||
func (this *QByteArray) SetNum32(param1 float64, f byte, prec int) *QByteArray {
|
||||
func (this *QByteArray) SetNum32(param1 float64, f int8, prec int) *QByteArray {
|
||||
return newQByteArray_U(unsafe.Pointer(C.QByteArray_SetNum32(this.h, (C.double)(param1), (C.char)(f), (C.int)(prec))))
|
||||
}
|
||||
|
||||
@ -1249,14 +1249,14 @@ func QByteArray_Number24(param1 uint64, base int) *QByteArray {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func QByteArray_Number25(param1 float64, f byte) *QByteArray {
|
||||
func QByteArray_Number25(param1 float64, f int8) *QByteArray {
|
||||
_ret := C.QByteArray_Number25((C.double)(param1), (C.char)(f))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func QByteArray_Number3(param1 float64, f byte, prec int) *QByteArray {
|
||||
func QByteArray_Number3(param1 float64, f int8, prec int) *QByteArray {
|
||||
_ret := C.QByteArray_Number3((C.double)(param1), (C.char)(f), (C.int)(prec))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
@ -1270,7 +1270,7 @@ func QByteArray_FromBase64Encoding2(base64 *QByteArray, options QByteArray__Base
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func QByteArray_FromPercentEncoding2(pctEncoded *QByteArray, percent byte) *QByteArray {
|
||||
func QByteArray_FromPercentEncoding2(pctEncoded *QByteArray, percent int8) *QByteArray {
|
||||
_ret := C.QByteArray_FromPercentEncoding2(pctEncoded.cPointer(), (C.char)(percent))
|
||||
_goptr := newQByteArray(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
@ -1319,7 +1319,7 @@ func NewQByteRef(param1 *QByteRef) *QByteRef {
|
||||
return newQByteRef(ret)
|
||||
}
|
||||
|
||||
func (this *QByteRef) OperatorAssign(c byte) {
|
||||
func (this *QByteRef) OperatorAssign(c int8) {
|
||||
C.QByteRef_OperatorAssign(this.h, (C.char)(c))
|
||||
}
|
||||
|
||||
@ -1327,27 +1327,27 @@ func (this *QByteRef) OperatorAssignWithQByteRef(c *QByteRef) {
|
||||
C.QByteRef_OperatorAssignWithQByteRef(this.h, c.cPointer())
|
||||
}
|
||||
|
||||
func (this *QByteRef) OperatorEqual(c byte) bool {
|
||||
func (this *QByteRef) OperatorEqual(c int8) bool {
|
||||
return (bool)(C.QByteRef_OperatorEqual(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
func (this *QByteRef) OperatorNotEqual(c byte) bool {
|
||||
func (this *QByteRef) OperatorNotEqual(c int8) bool {
|
||||
return (bool)(C.QByteRef_OperatorNotEqual(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
func (this *QByteRef) OperatorGreater(c byte) bool {
|
||||
func (this *QByteRef) OperatorGreater(c int8) bool {
|
||||
return (bool)(C.QByteRef_OperatorGreater(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
func (this *QByteRef) OperatorGreaterOrEqual(c byte) bool {
|
||||
func (this *QByteRef) OperatorGreaterOrEqual(c int8) bool {
|
||||
return (bool)(C.QByteRef_OperatorGreaterOrEqual(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
func (this *QByteRef) OperatorLesser(c byte) bool {
|
||||
func (this *QByteRef) OperatorLesser(c int8) bool {
|
||||
return (bool)(C.QByteRef_OperatorLesser(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
func (this *QByteRef) OperatorLesserOrEqual(c byte) bool {
|
||||
func (this *QByteRef) OperatorLesserOrEqual(c int8) bool {
|
||||
return (bool)(C.QByteRef_OperatorLesserOrEqual(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
|
@ -32,8 +32,9 @@ QCborValue* QCborArray_ToCborValue(const QCborArray* self) {
|
||||
return new QCborValue(self->toCborValue());
|
||||
}
|
||||
|
||||
size_t QCborArray_Size(const QCborArray* self) {
|
||||
return self->size();
|
||||
ptrdiff_t QCborArray_Size(const QCborArray* self) {
|
||||
qsizetype _ret = self->size();
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
bool QCborArray_IsEmpty(const QCborArray* self) {
|
||||
@ -44,8 +45,8 @@ void QCborArray_Clear(QCborArray* self) {
|
||||
self->clear();
|
||||
}
|
||||
|
||||
QCborValue* QCborArray_At(const QCborArray* self, size_t i) {
|
||||
return new QCborValue(self->at(static_cast<qsizetype>(i)));
|
||||
QCborValue* QCborArray_At(const QCborArray* self, ptrdiff_t i) {
|
||||
return new QCborValue(self->at((qsizetype)(i)));
|
||||
}
|
||||
|
||||
QCborValue* QCborArray_First(const QCborArray* self) {
|
||||
@ -56,8 +57,8 @@ QCborValue* QCborArray_Last(const QCborArray* self) {
|
||||
return new QCborValue(self->last());
|
||||
}
|
||||
|
||||
QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, size_t i) {
|
||||
return new QCborValue(self->operator[](static_cast<qsizetype>(i)));
|
||||
QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, ptrdiff_t i) {
|
||||
return new QCborValue(self->operator[]((qsizetype)(i)));
|
||||
}
|
||||
|
||||
QCborValueRef* QCborArray_First2(QCborArray* self) {
|
||||
@ -68,12 +69,12 @@ QCborValueRef* QCborArray_Last2(QCborArray* self) {
|
||||
return new QCborValueRef(self->last());
|
||||
}
|
||||
|
||||
QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, size_t i) {
|
||||
return new QCborValueRef(self->operator[](static_cast<qsizetype>(i)));
|
||||
QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, ptrdiff_t i) {
|
||||
return new QCborValueRef(self->operator[]((qsizetype)(i)));
|
||||
}
|
||||
|
||||
void QCborArray_Insert(QCborArray* self, size_t i, QCborValue* value) {
|
||||
self->insert(static_cast<qsizetype>(i), *value);
|
||||
void QCborArray_Insert(QCborArray* self, ptrdiff_t i, QCborValue* value) {
|
||||
self->insert((qsizetype)(i), *value);
|
||||
}
|
||||
|
||||
void QCborArray_Prepend(QCborArray* self, QCborValue* value) {
|
||||
@ -92,12 +93,12 @@ QCborValue* QCborArray_ExtractWithIt(QCborArray* self, QCborArray__Iterator* it)
|
||||
return new QCborValue(self->extract(*it));
|
||||
}
|
||||
|
||||
void QCborArray_RemoveAt(QCborArray* self, size_t i) {
|
||||
self->removeAt(static_cast<qsizetype>(i));
|
||||
void QCborArray_RemoveAt(QCborArray* self, ptrdiff_t i) {
|
||||
self->removeAt((qsizetype)(i));
|
||||
}
|
||||
|
||||
QCborValue* QCborArray_TakeAt(QCborArray* self, size_t i) {
|
||||
return new QCborValue(self->takeAt(static_cast<qsizetype>(i)));
|
||||
QCborValue* QCborArray_TakeAt(QCborArray* self, ptrdiff_t i) {
|
||||
return new QCborValue(self->takeAt((qsizetype)(i)));
|
||||
}
|
||||
|
||||
void QCborArray_RemoveFirst(QCborArray* self) {
|
||||
@ -263,8 +264,8 @@ QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Itera
|
||||
return self->operator->();
|
||||
}
|
||||
|
||||
QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, size_t j) {
|
||||
return new QCborValueRef(self->operator[](static_cast<qsizetype>(j)));
|
||||
QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, ptrdiff_t j) {
|
||||
return new QCborValueRef(self->operator[]((qsizetype)(j)));
|
||||
}
|
||||
|
||||
bool QCborArray__Iterator_OperatorEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o) {
|
||||
@ -335,28 +336,29 @@ QCborArray__Iterator* QCborArray__Iterator_OperatorMinusMinusWithInt(QCborArray_
|
||||
return new QCborArray::Iterator(self->operator--(static_cast<int>(param1)));
|
||||
}
|
||||
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlusAssign(QCborArray__Iterator* self, size_t j) {
|
||||
QCborArray::Iterator& _ret = self->operator+=(static_cast<qsizetype>(j));
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlusAssign(QCborArray__Iterator* self, ptrdiff_t j) {
|
||||
QCborArray::Iterator& _ret = self->operator+=((qsizetype)(j));
|
||||
// Cast returned reference into pointer
|
||||
return &_ret;
|
||||
}
|
||||
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinusAssign(QCborArray__Iterator* self, size_t j) {
|
||||
QCborArray::Iterator& _ret = self->operator-=(static_cast<qsizetype>(j));
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinusAssign(QCborArray__Iterator* self, ptrdiff_t j) {
|
||||
QCborArray::Iterator& _ret = self->operator-=((qsizetype)(j));
|
||||
// Cast returned reference into pointer
|
||||
return &_ret;
|
||||
}
|
||||
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, size_t j) {
|
||||
return new QCborArray::Iterator(self->operator+(static_cast<qsizetype>(j)));
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, ptrdiff_t j) {
|
||||
return new QCborArray::Iterator(self->operator+((qsizetype)(j)));
|
||||
}
|
||||
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, size_t j) {
|
||||
return new QCborArray::Iterator(self->operator-(static_cast<qsizetype>(j)));
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, ptrdiff_t j) {
|
||||
return new QCborArray::Iterator(self->operator-((qsizetype)(j)));
|
||||
}
|
||||
|
||||
size_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j) {
|
||||
return self->operator-(*j);
|
||||
ptrdiff_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j) {
|
||||
qsizetype _ret = self->operator-(*j);
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
void QCborArray__Iterator_Delete(QCborArray__Iterator* self) {
|
||||
@ -383,8 +385,8 @@ QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__
|
||||
return (QCborValueRef*) self->operator->();
|
||||
}
|
||||
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, size_t j) {
|
||||
return new QCborValueRef(self->operator[](static_cast<qsizetype>(j)));
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j) {
|
||||
return new QCborValueRef(self->operator[]((qsizetype)(j)));
|
||||
}
|
||||
|
||||
bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o) {
|
||||
@ -455,28 +457,29 @@ QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusMinusWithInt(Q
|
||||
return new QCborArray::ConstIterator(self->operator--(static_cast<int>(param1)));
|
||||
}
|
||||
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusAssign(QCborArray__ConstIterator* self, size_t j) {
|
||||
QCborArray::ConstIterator& _ret = self->operator+=(static_cast<qsizetype>(j));
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusAssign(QCborArray__ConstIterator* self, ptrdiff_t j) {
|
||||
QCborArray::ConstIterator& _ret = self->operator+=((qsizetype)(j));
|
||||
// Cast returned reference into pointer
|
||||
return &_ret;
|
||||
}
|
||||
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusAssign(QCborArray__ConstIterator* self, size_t j) {
|
||||
QCborArray::ConstIterator& _ret = self->operator-=(static_cast<qsizetype>(j));
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusAssign(QCborArray__ConstIterator* self, ptrdiff_t j) {
|
||||
QCborArray::ConstIterator& _ret = self->operator-=((qsizetype)(j));
|
||||
// Cast returned reference into pointer
|
||||
return &_ret;
|
||||
}
|
||||
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, size_t j) {
|
||||
return new QCborArray::ConstIterator(self->operator+(static_cast<qsizetype>(j)));
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, ptrdiff_t j) {
|
||||
return new QCborArray::ConstIterator(self->operator+((qsizetype)(j)));
|
||||
}
|
||||
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, size_t j) {
|
||||
return new QCborArray::ConstIterator(self->operator-(static_cast<qsizetype>(j)));
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, ptrdiff_t j) {
|
||||
return new QCborArray::ConstIterator(self->operator-((qsizetype)(j)));
|
||||
}
|
||||
|
||||
size_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j) {
|
||||
return self->operator-(*j);
|
||||
ptrdiff_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j) {
|
||||
qsizetype _ret = self->operator-(*j);
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
void QCborArray__ConstIterator_Delete(QCborArray__ConstIterator* self) {
|
||||
|
@ -62,8 +62,8 @@ func (this *QCborArray) ToCborValue() *QCborValue {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray) Size() uint64 {
|
||||
return (uint64)(C.QCborArray_Size(this.h))
|
||||
func (this *QCborArray) Size() int64 {
|
||||
return (int64)(C.QCborArray_Size(this.h))
|
||||
}
|
||||
|
||||
func (this *QCborArray) IsEmpty() bool {
|
||||
@ -74,8 +74,8 @@ func (this *QCborArray) Clear() {
|
||||
C.QCborArray_Clear(this.h)
|
||||
}
|
||||
|
||||
func (this *QCborArray) At(i uint64) *QCborValue {
|
||||
_ret := C.QCborArray_At(this.h, (C.size_t)(i))
|
||||
func (this *QCborArray) At(i int64) *QCborValue {
|
||||
_ret := C.QCborArray_At(this.h, (C.ptrdiff_t)(i))
|
||||
_goptr := newQCborValue(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
@ -95,8 +95,8 @@ func (this *QCborArray) Last() *QCborValue {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray) OperatorSubscript(i uint64) *QCborValue {
|
||||
_ret := C.QCborArray_OperatorSubscript(this.h, (C.size_t)(i))
|
||||
func (this *QCborArray) OperatorSubscript(i int64) *QCborValue {
|
||||
_ret := C.QCborArray_OperatorSubscript(this.h, (C.ptrdiff_t)(i))
|
||||
_goptr := newQCborValue(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
@ -116,15 +116,15 @@ func (this *QCborArray) Last2() *QCborValueRef {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray) OperatorSubscriptWithQsizetype(i uint64) *QCborValueRef {
|
||||
_ret := C.QCborArray_OperatorSubscriptWithQsizetype(this.h, (C.size_t)(i))
|
||||
func (this *QCborArray) OperatorSubscriptWithQsizetype(i int64) *QCborValueRef {
|
||||
_ret := C.QCborArray_OperatorSubscriptWithQsizetype(this.h, (C.ptrdiff_t)(i))
|
||||
_goptr := newQCborValueRef(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray) Insert(i uint64, value *QCborValue) {
|
||||
C.QCborArray_Insert(this.h, (C.size_t)(i), value.cPointer())
|
||||
func (this *QCborArray) Insert(i int64, value *QCborValue) {
|
||||
C.QCborArray_Insert(this.h, (C.ptrdiff_t)(i), value.cPointer())
|
||||
}
|
||||
|
||||
func (this *QCborArray) Prepend(value *QCborValue) {
|
||||
@ -149,12 +149,12 @@ func (this *QCborArray) ExtractWithIt(it QCborArray__Iterator) *QCborValue {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray) RemoveAt(i uint64) {
|
||||
C.QCborArray_RemoveAt(this.h, (C.size_t)(i))
|
||||
func (this *QCborArray) RemoveAt(i int64) {
|
||||
C.QCborArray_RemoveAt(this.h, (C.ptrdiff_t)(i))
|
||||
}
|
||||
|
||||
func (this *QCborArray) TakeAt(i uint64) *QCborValue {
|
||||
_ret := C.QCborArray_TakeAt(this.h, (C.size_t)(i))
|
||||
func (this *QCborArray) TakeAt(i int64) *QCborValue {
|
||||
_ret := C.QCborArray_TakeAt(this.h, (C.ptrdiff_t)(i))
|
||||
_goptr := newQCborValue(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
@ -415,8 +415,8 @@ func (this *QCborArray__Iterator) OperatorMinusGreater() *QCborValueRef {
|
||||
return newQCborValueRef_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusGreater(this.h)))
|
||||
}
|
||||
|
||||
func (this *QCborArray__Iterator) OperatorSubscript(j uint64) *QCborValueRef {
|
||||
_ret := C.QCborArray__Iterator_OperatorSubscript(this.h, (C.size_t)(j))
|
||||
func (this *QCborArray__Iterator) OperatorSubscript(j int64) *QCborValueRef {
|
||||
_ret := C.QCborArray__Iterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborValueRef(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
@ -492,30 +492,30 @@ func (this *QCborArray__Iterator) OperatorMinusMinusWithInt(param1 int) *QCborAr
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray__Iterator) OperatorPlusAssign(j uint64) *QCborArray__Iterator {
|
||||
return newQCborArray__Iterator_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorPlusAssign(this.h, (C.size_t)(j))))
|
||||
func (this *QCborArray__Iterator) OperatorPlusAssign(j int64) *QCborArray__Iterator {
|
||||
return newQCborArray__Iterator_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorPlusAssign(this.h, (C.ptrdiff_t)(j))))
|
||||
}
|
||||
|
||||
func (this *QCborArray__Iterator) OperatorMinusAssign(j uint64) *QCborArray__Iterator {
|
||||
return newQCborArray__Iterator_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusAssign(this.h, (C.size_t)(j))))
|
||||
func (this *QCborArray__Iterator) OperatorMinusAssign(j int64) *QCborArray__Iterator {
|
||||
return newQCborArray__Iterator_U(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusAssign(this.h, (C.ptrdiff_t)(j))))
|
||||
}
|
||||
|
||||
func (this *QCborArray__Iterator) OperatorPlus(j uint64) *QCborArray__Iterator {
|
||||
_ret := C.QCborArray__Iterator_OperatorPlus(this.h, (C.size_t)(j))
|
||||
func (this *QCborArray__Iterator) OperatorPlus(j int64) *QCborArray__Iterator {
|
||||
_ret := C.QCborArray__Iterator_OperatorPlus(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborArray__Iterator(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray__Iterator) OperatorMinus(j uint64) *QCborArray__Iterator {
|
||||
_ret := C.QCborArray__Iterator_OperatorMinus(this.h, (C.size_t)(j))
|
||||
func (this *QCborArray__Iterator) OperatorMinus(j int64) *QCborArray__Iterator {
|
||||
_ret := C.QCborArray__Iterator_OperatorMinus(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborArray__Iterator(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray__Iterator) OperatorMinusWithQCborArrayIterator(j QCborArray__Iterator) uint64 {
|
||||
return (uint64)(C.QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(this.h, j.cPointer()))
|
||||
func (this *QCborArray__Iterator) OperatorMinusWithQCborArrayIterator(j QCborArray__Iterator) int64 {
|
||||
return (int64)(C.QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(this.h, j.cPointer()))
|
||||
}
|
||||
|
||||
// Delete this object from C++ memory.
|
||||
@ -581,8 +581,8 @@ func (this *QCborArray__ConstIterator) OperatorMinusGreater() *QCborValueRef {
|
||||
return newQCborValueRef_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusGreater(this.h)))
|
||||
}
|
||||
|
||||
func (this *QCborArray__ConstIterator) OperatorSubscript(j uint64) *QCborValueRef {
|
||||
_ret := C.QCborArray__ConstIterator_OperatorSubscript(this.h, (C.size_t)(j))
|
||||
func (this *QCborArray__ConstIterator) OperatorSubscript(j int64) *QCborValueRef {
|
||||
_ret := C.QCborArray__ConstIterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborValueRef(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
@ -658,30 +658,30 @@ func (this *QCborArray__ConstIterator) OperatorMinusMinusWithInt(param1 int) *QC
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray__ConstIterator) OperatorPlusAssign(j uint64) *QCborArray__ConstIterator {
|
||||
return newQCborArray__ConstIterator_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorPlusAssign(this.h, (C.size_t)(j))))
|
||||
func (this *QCborArray__ConstIterator) OperatorPlusAssign(j int64) *QCborArray__ConstIterator {
|
||||
return newQCborArray__ConstIterator_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorPlusAssign(this.h, (C.ptrdiff_t)(j))))
|
||||
}
|
||||
|
||||
func (this *QCborArray__ConstIterator) OperatorMinusAssign(j uint64) *QCborArray__ConstIterator {
|
||||
return newQCborArray__ConstIterator_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusAssign(this.h, (C.size_t)(j))))
|
||||
func (this *QCborArray__ConstIterator) OperatorMinusAssign(j int64) *QCborArray__ConstIterator {
|
||||
return newQCborArray__ConstIterator_U(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusAssign(this.h, (C.ptrdiff_t)(j))))
|
||||
}
|
||||
|
||||
func (this *QCborArray__ConstIterator) OperatorPlus(j uint64) *QCborArray__ConstIterator {
|
||||
_ret := C.QCborArray__ConstIterator_OperatorPlus(this.h, (C.size_t)(j))
|
||||
func (this *QCborArray__ConstIterator) OperatorPlus(j int64) *QCborArray__ConstIterator {
|
||||
_ret := C.QCborArray__ConstIterator_OperatorPlus(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborArray__ConstIterator(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray__ConstIterator) OperatorMinus(j uint64) *QCborArray__ConstIterator {
|
||||
_ret := C.QCborArray__ConstIterator_OperatorMinus(this.h, (C.size_t)(j))
|
||||
func (this *QCborArray__ConstIterator) OperatorMinus(j int64) *QCborArray__ConstIterator {
|
||||
_ret := C.QCborArray__ConstIterator_OperatorMinus(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborArray__ConstIterator(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray__ConstIterator) OperatorMinusWithQCborArrayConstIterator(j QCborArray__ConstIterator) uint64 {
|
||||
return (uint64)(C.QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(this.h, j.cPointer()))
|
||||
func (this *QCborArray__ConstIterator) OperatorMinusWithQCborArrayConstIterator(j QCborArray__ConstIterator) int64 {
|
||||
return (int64)(C.QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(this.h, j.cPointer()))
|
||||
}
|
||||
|
||||
// Delete this object from C++ memory.
|
||||
|
@ -42,23 +42,23 @@ QCborArray* QCborArray_new2(QCborArray* other);
|
||||
void QCborArray_OperatorAssign(QCborArray* self, QCborArray* other);
|
||||
void QCborArray_Swap(QCborArray* self, QCborArray* other);
|
||||
QCborValue* QCborArray_ToCborValue(const QCborArray* self);
|
||||
size_t QCborArray_Size(const QCborArray* self);
|
||||
ptrdiff_t QCborArray_Size(const QCborArray* self);
|
||||
bool QCborArray_IsEmpty(const QCborArray* self);
|
||||
void QCborArray_Clear(QCborArray* self);
|
||||
QCborValue* QCborArray_At(const QCborArray* self, size_t i);
|
||||
QCborValue* QCborArray_At(const QCborArray* self, ptrdiff_t i);
|
||||
QCborValue* QCborArray_First(const QCborArray* self);
|
||||
QCborValue* QCborArray_Last(const QCborArray* self);
|
||||
QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, size_t i);
|
||||
QCborValue* QCborArray_OperatorSubscript(const QCborArray* self, ptrdiff_t i);
|
||||
QCborValueRef* QCborArray_First2(QCborArray* self);
|
||||
QCborValueRef* QCborArray_Last2(QCborArray* self);
|
||||
QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, size_t i);
|
||||
void QCborArray_Insert(QCborArray* self, size_t i, QCborValue* value);
|
||||
QCborValueRef* QCborArray_OperatorSubscriptWithQsizetype(QCborArray* self, ptrdiff_t i);
|
||||
void QCborArray_Insert(QCborArray* self, ptrdiff_t i, QCborValue* value);
|
||||
void QCborArray_Prepend(QCborArray* self, QCborValue* value);
|
||||
void QCborArray_Append(QCborArray* self, QCborValue* value);
|
||||
QCborValue* QCborArray_Extract(QCborArray* self, QCborArray__ConstIterator* it);
|
||||
QCborValue* QCborArray_ExtractWithIt(QCborArray* self, QCborArray__Iterator* it);
|
||||
void QCborArray_RemoveAt(QCborArray* self, size_t i);
|
||||
QCborValue* QCborArray_TakeAt(QCborArray* self, size_t i);
|
||||
void QCborArray_RemoveAt(QCborArray* self, ptrdiff_t i);
|
||||
QCborValue* QCborArray_TakeAt(QCborArray* self, ptrdiff_t i);
|
||||
void QCborArray_RemoveFirst(QCborArray* self);
|
||||
void QCborArray_RemoveLast(QCborArray* self);
|
||||
QCborValue* QCborArray_TakeFirst(QCborArray* self);
|
||||
@ -98,7 +98,7 @@ QCborArray__Iterator* QCborArray__Iterator_new2(QCborArray__Iterator* param1);
|
||||
void QCborArray__Iterator_OperatorAssign(QCborArray__Iterator* self, QCborArray__Iterator* other);
|
||||
QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator* self);
|
||||
QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Iterator* self);
|
||||
QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, size_t j);
|
||||
QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, ptrdiff_t j);
|
||||
bool QCborArray__Iterator_OperatorEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o);
|
||||
bool QCborArray__Iterator_OperatorNotEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o);
|
||||
bool QCborArray__Iterator_OperatorLesser(const QCborArray__Iterator* self, QCborArray__Iterator* other);
|
||||
@ -115,11 +115,11 @@ QCborArray__Iterator* QCborArray__Iterator_OperatorPlusPlus(QCborArray__Iterator
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlusPlusWithInt(QCborArray__Iterator* self, int param1);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinusMinus(QCborArray__Iterator* self);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinusMinusWithInt(QCborArray__Iterator* self, int param1);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlusAssign(QCborArray__Iterator* self, size_t j);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinusAssign(QCborArray__Iterator* self, size_t j);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, size_t j);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, size_t j);
|
||||
size_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlusAssign(QCborArray__Iterator* self, ptrdiff_t j);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinusAssign(QCborArray__Iterator* self, ptrdiff_t j);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorPlus(const QCborArray__Iterator* self, ptrdiff_t j);
|
||||
QCborArray__Iterator* QCborArray__Iterator_OperatorMinus(const QCborArray__Iterator* self, ptrdiff_t j);
|
||||
ptrdiff_t QCborArray__Iterator_OperatorMinusWithQCborArrayIterator(const QCborArray__Iterator* self, QCborArray__Iterator* j);
|
||||
void QCborArray__Iterator_Delete(QCborArray__Iterator* self);
|
||||
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_new();
|
||||
@ -127,7 +127,7 @@ QCborArray__ConstIterator* QCborArray__ConstIterator_new2(QCborArray__ConstItera
|
||||
void QCborArray__ConstIterator_OperatorAssign(QCborArray__ConstIterator* self, QCborArray__ConstIterator* other);
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self);
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self);
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, size_t j);
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j);
|
||||
bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o);
|
||||
bool QCborArray__ConstIterator_OperatorNotEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o);
|
||||
bool QCborArray__ConstIterator_OperatorLesser(const QCborArray__ConstIterator* self, QCborArray__Iterator* other);
|
||||
@ -144,11 +144,11 @@ QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusPlus(QCborArray
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusPlusWithInt(QCborArray__ConstIterator* self, int param1);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusMinus(QCborArray__ConstIterator* self);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusMinusWithInt(QCborArray__ConstIterator* self, int param1);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusAssign(QCborArray__ConstIterator* self, size_t j);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusAssign(QCborArray__ConstIterator* self, size_t j);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, size_t j);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, size_t j);
|
||||
size_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlusAssign(QCborArray__ConstIterator* self, ptrdiff_t j);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinusAssign(QCborArray__ConstIterator* self, ptrdiff_t j);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorPlus(const QCborArray__ConstIterator* self, ptrdiff_t j);
|
||||
QCborArray__ConstIterator* QCborArray__ConstIterator_OperatorMinus(const QCborArray__ConstIterator* self, ptrdiff_t j);
|
||||
ptrdiff_t QCborArray__ConstIterator_OperatorMinusWithQCborArrayConstIterator(const QCborArray__ConstIterator* self, QCborArray__ConstIterator* j);
|
||||
void QCborArray__ConstIterator_Delete(QCborArray__ConstIterator* self);
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
@ -32,8 +32,9 @@ QCborValue* QCborMap_ToCborValue(const QCborMap* self) {
|
||||
return new QCborValue(self->toCborValue());
|
||||
}
|
||||
|
||||
size_t QCborMap_Size(const QCborMap* self) {
|
||||
return self->size();
|
||||
ptrdiff_t QCborMap_Size(const QCborMap* self) {
|
||||
qsizetype _ret = self->size();
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
bool QCborMap_IsEmpty(const QCborMap* self) {
|
||||
@ -359,28 +360,29 @@ QCborMap__Iterator* QCborMap__Iterator_OperatorMinusMinusWithInt(QCborMap__Itera
|
||||
return new QCborMap::Iterator(self->operator--(static_cast<int>(param1)));
|
||||
}
|
||||
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlusAssign(QCborMap__Iterator* self, size_t j) {
|
||||
QCborMap::Iterator& _ret = self->operator+=(static_cast<qsizetype>(j));
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlusAssign(QCborMap__Iterator* self, ptrdiff_t j) {
|
||||
QCborMap::Iterator& _ret = self->operator+=((qsizetype)(j));
|
||||
// Cast returned reference into pointer
|
||||
return &_ret;
|
||||
}
|
||||
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinusAssign(QCborMap__Iterator* self, size_t j) {
|
||||
QCborMap::Iterator& _ret = self->operator-=(static_cast<qsizetype>(j));
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinusAssign(QCborMap__Iterator* self, ptrdiff_t j) {
|
||||
QCborMap::Iterator& _ret = self->operator-=((qsizetype)(j));
|
||||
// Cast returned reference into pointer
|
||||
return &_ret;
|
||||
}
|
||||
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlus(const QCborMap__Iterator* self, size_t j) {
|
||||
return new QCborMap::Iterator(self->operator+(static_cast<qsizetype>(j)));
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlus(const QCborMap__Iterator* self, ptrdiff_t j) {
|
||||
return new QCborMap::Iterator(self->operator+((qsizetype)(j)));
|
||||
}
|
||||
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinus(const QCborMap__Iterator* self, size_t j) {
|
||||
return new QCborMap::Iterator(self->operator-(static_cast<qsizetype>(j)));
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinus(const QCborMap__Iterator* self, ptrdiff_t j) {
|
||||
return new QCborMap::Iterator(self->operator-((qsizetype)(j)));
|
||||
}
|
||||
|
||||
size_t QCborMap__Iterator_OperatorMinusWithQCborMapIterator(const QCborMap__Iterator* self, QCborMap__Iterator* j) {
|
||||
return self->operator-(*j);
|
||||
ptrdiff_t QCborMap__Iterator_OperatorMinusWithQCborMapIterator(const QCborMap__Iterator* self, QCborMap__Iterator* j) {
|
||||
qsizetype _ret = self->operator-(*j);
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
void QCborMap__Iterator_Delete(QCborMap__Iterator* self) {
|
||||
@ -479,28 +481,29 @@ QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusMinusWithInt(QCbor
|
||||
return new QCborMap::ConstIterator(self->operator--(static_cast<int>(param1)));
|
||||
}
|
||||
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusAssign(QCborMap__ConstIterator* self, size_t j) {
|
||||
QCborMap::ConstIterator& _ret = self->operator+=(static_cast<qsizetype>(j));
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusAssign(QCborMap__ConstIterator* self, ptrdiff_t j) {
|
||||
QCborMap::ConstIterator& _ret = self->operator+=((qsizetype)(j));
|
||||
// Cast returned reference into pointer
|
||||
return &_ret;
|
||||
}
|
||||
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusAssign(QCborMap__ConstIterator* self, size_t j) {
|
||||
QCborMap::ConstIterator& _ret = self->operator-=(static_cast<qsizetype>(j));
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusAssign(QCborMap__ConstIterator* self, ptrdiff_t j) {
|
||||
QCborMap::ConstIterator& _ret = self->operator-=((qsizetype)(j));
|
||||
// Cast returned reference into pointer
|
||||
return &_ret;
|
||||
}
|
||||
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlus(const QCborMap__ConstIterator* self, size_t j) {
|
||||
return new QCborMap::ConstIterator(self->operator+(static_cast<qsizetype>(j)));
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlus(const QCborMap__ConstIterator* self, ptrdiff_t j) {
|
||||
return new QCborMap::ConstIterator(self->operator+((qsizetype)(j)));
|
||||
}
|
||||
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinus(const QCborMap__ConstIterator* self, size_t j) {
|
||||
return new QCborMap::ConstIterator(self->operator-(static_cast<qsizetype>(j)));
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinus(const QCborMap__ConstIterator* self, ptrdiff_t j) {
|
||||
return new QCborMap::ConstIterator(self->operator-((qsizetype)(j)));
|
||||
}
|
||||
|
||||
size_t QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(const QCborMap__ConstIterator* self, QCborMap__ConstIterator* j) {
|
||||
return self->operator-(*j);
|
||||
ptrdiff_t QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(const QCborMap__ConstIterator* self, QCborMap__ConstIterator* j) {
|
||||
qsizetype _ret = self->operator-(*j);
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
void QCborMap__ConstIterator_Delete(QCborMap__ConstIterator* self) {
|
||||
|
@ -62,8 +62,8 @@ func (this *QCborMap) ToCborValue() *QCborValue {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborMap) Size() uint64 {
|
||||
return (uint64)(C.QCborMap_Size(this.h))
|
||||
func (this *QCborMap) Size() int64 {
|
||||
return (int64)(C.QCborMap_Size(this.h))
|
||||
}
|
||||
|
||||
func (this *QCborMap) IsEmpty() bool {
|
||||
@ -558,30 +558,30 @@ func (this *QCborMap__Iterator) OperatorMinusMinusWithInt(param1 int) *QCborMap_
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborMap__Iterator) OperatorPlusAssign(j uint64) *QCborMap__Iterator {
|
||||
return newQCborMap__Iterator_U(unsafe.Pointer(C.QCborMap__Iterator_OperatorPlusAssign(this.h, (C.size_t)(j))))
|
||||
func (this *QCborMap__Iterator) OperatorPlusAssign(j int64) *QCborMap__Iterator {
|
||||
return newQCborMap__Iterator_U(unsafe.Pointer(C.QCborMap__Iterator_OperatorPlusAssign(this.h, (C.ptrdiff_t)(j))))
|
||||
}
|
||||
|
||||
func (this *QCborMap__Iterator) OperatorMinusAssign(j uint64) *QCborMap__Iterator {
|
||||
return newQCborMap__Iterator_U(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusAssign(this.h, (C.size_t)(j))))
|
||||
func (this *QCborMap__Iterator) OperatorMinusAssign(j int64) *QCborMap__Iterator {
|
||||
return newQCborMap__Iterator_U(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusAssign(this.h, (C.ptrdiff_t)(j))))
|
||||
}
|
||||
|
||||
func (this *QCborMap__Iterator) OperatorPlus(j uint64) *QCborMap__Iterator {
|
||||
_ret := C.QCborMap__Iterator_OperatorPlus(this.h, (C.size_t)(j))
|
||||
func (this *QCborMap__Iterator) OperatorPlus(j int64) *QCborMap__Iterator {
|
||||
_ret := C.QCborMap__Iterator_OperatorPlus(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborMap__Iterator(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborMap__Iterator) OperatorMinus(j uint64) *QCborMap__Iterator {
|
||||
_ret := C.QCborMap__Iterator_OperatorMinus(this.h, (C.size_t)(j))
|
||||
func (this *QCborMap__Iterator) OperatorMinus(j int64) *QCborMap__Iterator {
|
||||
_ret := C.QCborMap__Iterator_OperatorMinus(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborMap__Iterator(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborMap__Iterator) OperatorMinusWithQCborMapIterator(j QCborMap__Iterator) uint64 {
|
||||
return (uint64)(C.QCborMap__Iterator_OperatorMinusWithQCborMapIterator(this.h, j.cPointer()))
|
||||
func (this *QCborMap__Iterator) OperatorMinusWithQCborMapIterator(j QCborMap__Iterator) int64 {
|
||||
return (int64)(C.QCborMap__Iterator_OperatorMinusWithQCborMapIterator(this.h, j.cPointer()))
|
||||
}
|
||||
|
||||
// Delete this object from C++ memory.
|
||||
@ -724,30 +724,30 @@ func (this *QCborMap__ConstIterator) OperatorMinusMinusWithInt(param1 int) *QCbo
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborMap__ConstIterator) OperatorPlusAssign(j uint64) *QCborMap__ConstIterator {
|
||||
return newQCborMap__ConstIterator_U(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorPlusAssign(this.h, (C.size_t)(j))))
|
||||
func (this *QCborMap__ConstIterator) OperatorPlusAssign(j int64) *QCborMap__ConstIterator {
|
||||
return newQCborMap__ConstIterator_U(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorPlusAssign(this.h, (C.ptrdiff_t)(j))))
|
||||
}
|
||||
|
||||
func (this *QCborMap__ConstIterator) OperatorMinusAssign(j uint64) *QCborMap__ConstIterator {
|
||||
return newQCborMap__ConstIterator_U(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusAssign(this.h, (C.size_t)(j))))
|
||||
func (this *QCborMap__ConstIterator) OperatorMinusAssign(j int64) *QCborMap__ConstIterator {
|
||||
return newQCborMap__ConstIterator_U(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusAssign(this.h, (C.ptrdiff_t)(j))))
|
||||
}
|
||||
|
||||
func (this *QCborMap__ConstIterator) OperatorPlus(j uint64) *QCborMap__ConstIterator {
|
||||
_ret := C.QCborMap__ConstIterator_OperatorPlus(this.h, (C.size_t)(j))
|
||||
func (this *QCborMap__ConstIterator) OperatorPlus(j int64) *QCborMap__ConstIterator {
|
||||
_ret := C.QCborMap__ConstIterator_OperatorPlus(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborMap__ConstIterator(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborMap__ConstIterator) OperatorMinus(j uint64) *QCborMap__ConstIterator {
|
||||
_ret := C.QCborMap__ConstIterator_OperatorMinus(this.h, (C.size_t)(j))
|
||||
func (this *QCborMap__ConstIterator) OperatorMinus(j int64) *QCborMap__ConstIterator {
|
||||
_ret := C.QCborMap__ConstIterator_OperatorMinus(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborMap__ConstIterator(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborMap__ConstIterator) OperatorMinusWithQCborMapConstIterator(j QCborMap__ConstIterator) uint64 {
|
||||
return (uint64)(C.QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(this.h, j.cPointer()))
|
||||
func (this *QCborMap__ConstIterator) OperatorMinusWithQCborMapConstIterator(j QCborMap__ConstIterator) int64 {
|
||||
return (int64)(C.QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(this.h, j.cPointer()))
|
||||
}
|
||||
|
||||
// Delete this object from C++ memory.
|
||||
|
@ -42,7 +42,7 @@ QCborMap* QCborMap_new2(QCborMap* other);
|
||||
void QCborMap_OperatorAssign(QCborMap* self, QCborMap* other);
|
||||
void QCborMap_Swap(QCborMap* self, QCborMap* other);
|
||||
QCborValue* QCborMap_ToCborValue(const QCborMap* self);
|
||||
size_t QCborMap_Size(const QCborMap* self);
|
||||
ptrdiff_t QCborMap_Size(const QCborMap* self);
|
||||
bool QCborMap_IsEmpty(const QCborMap* self);
|
||||
void QCborMap_Clear(QCborMap* self);
|
||||
struct miqt_array* QCborMap_Keys(const QCborMap* self);
|
||||
@ -119,11 +119,11 @@ QCborMap__Iterator* QCborMap__Iterator_OperatorPlusPlus(QCborMap__Iterator* self
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlusPlusWithInt(QCborMap__Iterator* self, int param1);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinusMinus(QCborMap__Iterator* self);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinusMinusWithInt(QCborMap__Iterator* self, int param1);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlusAssign(QCborMap__Iterator* self, size_t j);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinusAssign(QCborMap__Iterator* self, size_t j);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlus(const QCborMap__Iterator* self, size_t j);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinus(const QCborMap__Iterator* self, size_t j);
|
||||
size_t QCborMap__Iterator_OperatorMinusWithQCborMapIterator(const QCborMap__Iterator* self, QCborMap__Iterator* j);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlusAssign(QCborMap__Iterator* self, ptrdiff_t j);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinusAssign(QCborMap__Iterator* self, ptrdiff_t j);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorPlus(const QCborMap__Iterator* self, ptrdiff_t j);
|
||||
QCborMap__Iterator* QCborMap__Iterator_OperatorMinus(const QCborMap__Iterator* self, ptrdiff_t j);
|
||||
ptrdiff_t QCborMap__Iterator_OperatorMinusWithQCborMapIterator(const QCborMap__Iterator* self, QCborMap__Iterator* j);
|
||||
void QCborMap__Iterator_Delete(QCborMap__Iterator* self);
|
||||
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_new();
|
||||
@ -148,11 +148,11 @@ QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusPlus(QCborMap__Cons
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusPlusWithInt(QCborMap__ConstIterator* self, int param1);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusMinus(QCborMap__ConstIterator* self);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusMinusWithInt(QCborMap__ConstIterator* self, int param1);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusAssign(QCborMap__ConstIterator* self, size_t j);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusAssign(QCborMap__ConstIterator* self, size_t j);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlus(const QCborMap__ConstIterator* self, size_t j);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinus(const QCborMap__ConstIterator* self, size_t j);
|
||||
size_t QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(const QCborMap__ConstIterator* self, QCborMap__ConstIterator* j);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlusAssign(QCborMap__ConstIterator* self, ptrdiff_t j);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinusAssign(QCborMap__ConstIterator* self, ptrdiff_t j);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorPlus(const QCborMap__ConstIterator* self, ptrdiff_t j);
|
||||
QCborMap__ConstIterator* QCborMap__ConstIterator_OperatorMinus(const QCborMap__ConstIterator* self, ptrdiff_t j);
|
||||
ptrdiff_t QCborMap__ConstIterator_OperatorMinusWithQCborMapConstIterator(const QCborMap__ConstIterator* self, QCborMap__ConstIterator* j);
|
||||
void QCborMap__ConstIterator_Delete(QCborMap__ConstIterator* self);
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
@ -10,12 +10,12 @@ QCborStreamReader* QCborStreamReader_new() {
|
||||
return new QCborStreamReader();
|
||||
}
|
||||
|
||||
QCborStreamReader* QCborStreamReader_new2(const char* data, size_t lenVal) {
|
||||
return new QCborStreamReader(data, static_cast<qsizetype>(lenVal));
|
||||
QCborStreamReader* QCborStreamReader_new2(const char* data, ptrdiff_t lenVal) {
|
||||
return new QCborStreamReader(data, (qsizetype)(lenVal));
|
||||
}
|
||||
|
||||
QCborStreamReader* QCborStreamReader_new3(const unsigned char* data, size_t lenVal) {
|
||||
return new QCborStreamReader(static_cast<const quint8*>(data), static_cast<qsizetype>(lenVal));
|
||||
QCborStreamReader* QCborStreamReader_new3(const unsigned char* data, ptrdiff_t lenVal) {
|
||||
return new QCborStreamReader(static_cast<const quint8*>(data), (qsizetype)(lenVal));
|
||||
}
|
||||
|
||||
QCborStreamReader* QCborStreamReader_new4(QByteArray* data) {
|
||||
@ -38,12 +38,12 @@ void QCborStreamReader_AddData(QCborStreamReader* self, QByteArray* data) {
|
||||
self->addData(*data);
|
||||
}
|
||||
|
||||
void QCborStreamReader_AddData2(QCborStreamReader* self, const char* data, size_t lenVal) {
|
||||
self->addData(data, static_cast<qsizetype>(lenVal));
|
||||
void QCborStreamReader_AddData2(QCborStreamReader* self, const char* data, ptrdiff_t lenVal) {
|
||||
self->addData(data, (qsizetype)(lenVal));
|
||||
}
|
||||
|
||||
void QCborStreamReader_AddData3(QCborStreamReader* self, const unsigned char* data, size_t lenVal) {
|
||||
self->addData(static_cast<const quint8*>(data), static_cast<qsizetype>(lenVal));
|
||||
void QCborStreamReader_AddData3(QCborStreamReader* self, const unsigned char* data, ptrdiff_t lenVal) {
|
||||
self->addData(static_cast<const quint8*>(data), (qsizetype)(lenVal));
|
||||
}
|
||||
|
||||
void QCborStreamReader_Reparse(QCborStreamReader* self) {
|
||||
@ -190,8 +190,9 @@ bool QCborStreamReader_LeaveContainer(QCborStreamReader* self) {
|
||||
return self->leaveContainer();
|
||||
}
|
||||
|
||||
size_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self) {
|
||||
return self->currentStringChunkSize();
|
||||
ptrdiff_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self) {
|
||||
qsizetype _ret = self->currentStringChunkSize();
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
bool QCborStreamReader_ToBool(const QCborStreamReader* self) {
|
||||
|
@ -70,16 +70,16 @@ func NewQCborStreamReader() *QCborStreamReader {
|
||||
}
|
||||
|
||||
// NewQCborStreamReader2 constructs a new QCborStreamReader object.
|
||||
func NewQCborStreamReader2(data string, lenVal uint64) *QCborStreamReader {
|
||||
func NewQCborStreamReader2(data string, lenVal int64) *QCborStreamReader {
|
||||
data_Cstring := C.CString(data)
|
||||
defer C.free(unsafe.Pointer(data_Cstring))
|
||||
ret := C.QCborStreamReader_new2(data_Cstring, (C.size_t)(lenVal))
|
||||
ret := C.QCborStreamReader_new2(data_Cstring, (C.ptrdiff_t)(lenVal))
|
||||
return newQCborStreamReader(ret)
|
||||
}
|
||||
|
||||
// NewQCborStreamReader3 constructs a new QCborStreamReader object.
|
||||
func NewQCborStreamReader3(data *byte, lenVal uint64) *QCborStreamReader {
|
||||
ret := C.QCborStreamReader_new3((*C.uchar)(unsafe.Pointer(data)), (C.size_t)(lenVal))
|
||||
func NewQCborStreamReader3(data *byte, lenVal int64) *QCborStreamReader {
|
||||
ret := C.QCborStreamReader_new3((*C.uchar)(unsafe.Pointer(data)), (C.ptrdiff_t)(lenVal))
|
||||
return newQCborStreamReader(ret)
|
||||
}
|
||||
|
||||
@ -107,14 +107,14 @@ func (this *QCborStreamReader) AddData(data *QByteArray) {
|
||||
C.QCborStreamReader_AddData(this.h, data.cPointer())
|
||||
}
|
||||
|
||||
func (this *QCborStreamReader) AddData2(data string, lenVal uint64) {
|
||||
func (this *QCborStreamReader) AddData2(data string, lenVal int64) {
|
||||
data_Cstring := C.CString(data)
|
||||
defer C.free(unsafe.Pointer(data_Cstring))
|
||||
C.QCborStreamReader_AddData2(this.h, data_Cstring, (C.size_t)(lenVal))
|
||||
C.QCborStreamReader_AddData2(this.h, data_Cstring, (C.ptrdiff_t)(lenVal))
|
||||
}
|
||||
|
||||
func (this *QCborStreamReader) AddData3(data *byte, lenVal uint64) {
|
||||
C.QCborStreamReader_AddData3(this.h, (*C.uchar)(unsafe.Pointer(data)), (C.size_t)(lenVal))
|
||||
func (this *QCborStreamReader) AddData3(data *byte, lenVal int64) {
|
||||
C.QCborStreamReader_AddData3(this.h, (*C.uchar)(unsafe.Pointer(data)), (C.ptrdiff_t)(lenVal))
|
||||
}
|
||||
|
||||
func (this *QCborStreamReader) Reparse() {
|
||||
@ -260,8 +260,8 @@ func (this *QCborStreamReader) LeaveContainer() bool {
|
||||
return (bool)(C.QCborStreamReader_LeaveContainer(this.h))
|
||||
}
|
||||
|
||||
func (this *QCborStreamReader) CurrentStringChunkSize() uint64 {
|
||||
return (uint64)(C.QCborStreamReader_CurrentStringChunkSize(this.h))
|
||||
func (this *QCborStreamReader) CurrentStringChunkSize() int64 {
|
||||
return (int64)(C.QCborStreamReader_CurrentStringChunkSize(this.h))
|
||||
}
|
||||
|
||||
func (this *QCborStreamReader) ToBool() bool {
|
||||
|
@ -26,15 +26,15 @@ typedef struct QIODevice QIODevice;
|
||||
#endif
|
||||
|
||||
QCborStreamReader* QCborStreamReader_new();
|
||||
QCborStreamReader* QCborStreamReader_new2(const char* data, size_t lenVal);
|
||||
QCborStreamReader* QCborStreamReader_new3(const unsigned char* data, size_t lenVal);
|
||||
QCborStreamReader* QCborStreamReader_new2(const char* data, ptrdiff_t lenVal);
|
||||
QCborStreamReader* QCborStreamReader_new3(const unsigned char* data, ptrdiff_t lenVal);
|
||||
QCborStreamReader* QCborStreamReader_new4(QByteArray* data);
|
||||
QCborStreamReader* QCborStreamReader_new5(QIODevice* device);
|
||||
void QCborStreamReader_SetDevice(QCborStreamReader* self, QIODevice* device);
|
||||
QIODevice* QCborStreamReader_Device(const QCborStreamReader* self);
|
||||
void QCborStreamReader_AddData(QCborStreamReader* self, QByteArray* data);
|
||||
void QCborStreamReader_AddData2(QCborStreamReader* self, const char* data, size_t lenVal);
|
||||
void QCborStreamReader_AddData3(QCborStreamReader* self, const unsigned char* data, size_t lenVal);
|
||||
void QCborStreamReader_AddData2(QCborStreamReader* self, const char* data, ptrdiff_t lenVal);
|
||||
void QCborStreamReader_AddData3(QCborStreamReader* self, const unsigned char* data, ptrdiff_t lenVal);
|
||||
void QCborStreamReader_Reparse(QCborStreamReader* self);
|
||||
void QCborStreamReader_Clear(QCborStreamReader* self);
|
||||
void QCborStreamReader_Reset(QCborStreamReader* self);
|
||||
@ -70,7 +70,7 @@ unsigned long long QCborStreamReader_Length(const QCborStreamReader* self);
|
||||
bool QCborStreamReader_IsContainer(const QCborStreamReader* self);
|
||||
bool QCborStreamReader_EnterContainer(QCborStreamReader* self);
|
||||
bool QCborStreamReader_LeaveContainer(QCborStreamReader* self);
|
||||
size_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self);
|
||||
ptrdiff_t QCborStreamReader_CurrentStringChunkSize(const QCborStreamReader* self);
|
||||
bool QCborStreamReader_ToBool(const QCborStreamReader* self);
|
||||
uint64_t QCborStreamReader_ToTag(const QCborStreamReader* self);
|
||||
unsigned long long QCborStreamReader_ToUnsignedInteger(const QCborStreamReader* self);
|
||||
|
@ -57,12 +57,12 @@ void QCborStreamWriter_AppendWithDouble(QCborStreamWriter* self, double d) {
|
||||
self->append(static_cast<double>(d));
|
||||
}
|
||||
|
||||
void QCborStreamWriter_AppendByteString(QCborStreamWriter* self, const char* data, size_t lenVal) {
|
||||
self->appendByteString(data, static_cast<qsizetype>(lenVal));
|
||||
void QCborStreamWriter_AppendByteString(QCborStreamWriter* self, const char* data, ptrdiff_t lenVal) {
|
||||
self->appendByteString(data, (qsizetype)(lenVal));
|
||||
}
|
||||
|
||||
void QCborStreamWriter_AppendTextString(QCborStreamWriter* self, const char* utf8, size_t lenVal) {
|
||||
self->appendTextString(utf8, static_cast<qsizetype>(lenVal));
|
||||
void QCborStreamWriter_AppendTextString(QCborStreamWriter* self, const char* utf8, ptrdiff_t lenVal) {
|
||||
self->appendTextString(utf8, (qsizetype)(lenVal));
|
||||
}
|
||||
|
||||
void QCborStreamWriter_AppendWithBool(QCborStreamWriter* self, bool b) {
|
||||
@ -113,8 +113,8 @@ bool QCborStreamWriter_EndMap(QCborStreamWriter* self) {
|
||||
return self->endMap();
|
||||
}
|
||||
|
||||
void QCborStreamWriter_Append22(QCborStreamWriter* self, const char* str, size_t size) {
|
||||
self->append(str, static_cast<qsizetype>(size));
|
||||
void QCborStreamWriter_Append22(QCborStreamWriter* self, const char* str, ptrdiff_t size) {
|
||||
self->append(str, (qsizetype)(size));
|
||||
}
|
||||
|
||||
void QCborStreamWriter_Delete(QCborStreamWriter* self) {
|
||||
|
@ -91,16 +91,16 @@ func (this *QCborStreamWriter) AppendWithDouble(d float64) {
|
||||
C.QCborStreamWriter_AppendWithDouble(this.h, (C.double)(d))
|
||||
}
|
||||
|
||||
func (this *QCborStreamWriter) AppendByteString(data string, lenVal uint64) {
|
||||
func (this *QCborStreamWriter) AppendByteString(data string, lenVal int64) {
|
||||
data_Cstring := C.CString(data)
|
||||
defer C.free(unsafe.Pointer(data_Cstring))
|
||||
C.QCborStreamWriter_AppendByteString(this.h, data_Cstring, (C.size_t)(lenVal))
|
||||
C.QCborStreamWriter_AppendByteString(this.h, data_Cstring, (C.ptrdiff_t)(lenVal))
|
||||
}
|
||||
|
||||
func (this *QCborStreamWriter) AppendTextString(utf8 string, lenVal uint64) {
|
||||
func (this *QCborStreamWriter) AppendTextString(utf8 string, lenVal int64) {
|
||||
utf8_Cstring := C.CString(utf8)
|
||||
defer C.free(unsafe.Pointer(utf8_Cstring))
|
||||
C.QCborStreamWriter_AppendTextString(this.h, utf8_Cstring, (C.size_t)(lenVal))
|
||||
C.QCborStreamWriter_AppendTextString(this.h, utf8_Cstring, (C.ptrdiff_t)(lenVal))
|
||||
}
|
||||
|
||||
func (this *QCborStreamWriter) AppendWithBool(b bool) {
|
||||
@ -153,10 +153,10 @@ func (this *QCborStreamWriter) EndMap() bool {
|
||||
return (bool)(C.QCborStreamWriter_EndMap(this.h))
|
||||
}
|
||||
|
||||
func (this *QCborStreamWriter) Append22(str string, size uint64) {
|
||||
func (this *QCborStreamWriter) Append22(str string, size int64) {
|
||||
str_Cstring := C.CString(str)
|
||||
defer C.free(unsafe.Pointer(str_Cstring))
|
||||
C.QCborStreamWriter_Append22(this.h, str_Cstring, (C.size_t)(size))
|
||||
C.QCborStreamWriter_Append22(this.h, str_Cstring, (C.ptrdiff_t)(size))
|
||||
}
|
||||
|
||||
// Delete this object from C++ memory.
|
||||
|
@ -36,8 +36,8 @@ void QCborStreamWriter_Append3(QCborStreamWriter* self, int tag);
|
||||
void QCborStreamWriter_AppendWithSt(QCborStreamWriter* self, uint8_t 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);
|
||||
void QCborStreamWriter_AppendTextString(QCborStreamWriter* self, const char* utf8, size_t lenVal);
|
||||
void QCborStreamWriter_AppendByteString(QCborStreamWriter* self, const char* data, ptrdiff_t lenVal);
|
||||
void QCborStreamWriter_AppendTextString(QCborStreamWriter* self, const char* utf8, ptrdiff_t lenVal);
|
||||
void QCborStreamWriter_AppendWithBool(QCborStreamWriter* self, bool b);
|
||||
void QCborStreamWriter_AppendNull(QCborStreamWriter* self);
|
||||
void QCborStreamWriter_AppendUndefined(QCborStreamWriter* self);
|
||||
@ -50,7 +50,7 @@ bool QCborStreamWriter_EndArray(QCborStreamWriter* self);
|
||||
void QCborStreamWriter_StartMap(QCborStreamWriter* self);
|
||||
void QCborStreamWriter_StartMapWithCount(QCborStreamWriter* self, unsigned long long count);
|
||||
bool QCborStreamWriter_EndMap(QCborStreamWriter* self);
|
||||
void QCborStreamWriter_Append22(QCborStreamWriter* self, const char* str, size_t size);
|
||||
void QCborStreamWriter_Append22(QCborStreamWriter* self, const char* str, ptrdiff_t size);
|
||||
void QCborStreamWriter_Delete(QCborStreamWriter* self);
|
||||
|
||||
#ifdef __cplusplus
|
||||
|
@ -340,12 +340,12 @@ QCborValue* QCborValue_FromCborWithBa(QByteArray* ba) {
|
||||
return new QCborValue(QCborValue::fromCbor(*ba));
|
||||
}
|
||||
|
||||
QCborValue* QCborValue_FromCbor2(const char* data, size_t lenVal) {
|
||||
return new QCborValue(QCborValue::fromCbor(data, static_cast<qsizetype>(lenVal)));
|
||||
QCborValue* QCborValue_FromCbor2(const char* data, ptrdiff_t lenVal) {
|
||||
return new QCborValue(QCborValue::fromCbor(data, (qsizetype)(lenVal)));
|
||||
}
|
||||
|
||||
QCborValue* QCborValue_FromCbor3(const unsigned char* data, size_t lenVal) {
|
||||
return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), static_cast<qsizetype>(lenVal)));
|
||||
QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal) {
|
||||
return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal)));
|
||||
}
|
||||
|
||||
QByteArray* QCborValue_ToCbor(QCborValue* self) {
|
||||
@ -422,12 +422,12 @@ QCborValue* QCborValue_FromCbor22(QByteArray* ba, QCborParserError* error) {
|
||||
return new QCborValue(QCborValue::fromCbor(*ba, error));
|
||||
}
|
||||
|
||||
QCborValue* QCborValue_FromCbor32(const char* data, size_t lenVal, QCborParserError* error) {
|
||||
return new QCborValue(QCborValue::fromCbor(data, static_cast<qsizetype>(lenVal), error));
|
||||
QCborValue* QCborValue_FromCbor32(const char* data, ptrdiff_t lenVal, QCborParserError* error) {
|
||||
return new QCborValue(QCborValue::fromCbor(data, (qsizetype)(lenVal), error));
|
||||
}
|
||||
|
||||
QCborValue* QCborValue_FromCbor33(const unsigned char* data, size_t lenVal, QCborParserError* error) {
|
||||
return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), static_cast<qsizetype>(lenVal), error));
|
||||
QCborValue* QCborValue_FromCbor33(const unsigned char* data, ptrdiff_t lenVal, QCborParserError* error) {
|
||||
return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal), error));
|
||||
}
|
||||
|
||||
QByteArray* QCborValue_ToCbor1(QCborValue* self, int opt) {
|
||||
|
@ -533,17 +533,17 @@ func QCborValue_FromCborWithBa(ba *QByteArray) *QCborValue {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func QCborValue_FromCbor2(data string, lenVal uint64) *QCborValue {
|
||||
func QCborValue_FromCbor2(data string, lenVal int64) *QCborValue {
|
||||
data_Cstring := C.CString(data)
|
||||
defer C.free(unsafe.Pointer(data_Cstring))
|
||||
_ret := C.QCborValue_FromCbor2(data_Cstring, (C.size_t)(lenVal))
|
||||
_ret := C.QCborValue_FromCbor2(data_Cstring, (C.ptrdiff_t)(lenVal))
|
||||
_goptr := newQCborValue(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func QCborValue_FromCbor3(data *byte, lenVal uint64) *QCborValue {
|
||||
_ret := C.QCborValue_FromCbor3((*C.uchar)(unsafe.Pointer(data)), (C.size_t)(lenVal))
|
||||
func QCborValue_FromCbor3(data *byte, lenVal int64) *QCborValue {
|
||||
_ret := C.QCborValue_FromCbor3((*C.uchar)(unsafe.Pointer(data)), (C.ptrdiff_t)(lenVal))
|
||||
_goptr := newQCborValue(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
@ -645,17 +645,17 @@ func QCborValue_FromCbor22(ba *QByteArray, error *QCborParserError) *QCborValue
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func QCborValue_FromCbor32(data string, lenVal uint64, error *QCborParserError) *QCborValue {
|
||||
func QCborValue_FromCbor32(data string, lenVal int64, error *QCborParserError) *QCborValue {
|
||||
data_Cstring := C.CString(data)
|
||||
defer C.free(unsafe.Pointer(data_Cstring))
|
||||
_ret := C.QCborValue_FromCbor32(data_Cstring, (C.size_t)(lenVal), error.cPointer())
|
||||
_ret := C.QCborValue_FromCbor32(data_Cstring, (C.ptrdiff_t)(lenVal), error.cPointer())
|
||||
_goptr := newQCborValue(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func QCborValue_FromCbor33(data *byte, lenVal uint64, error *QCborParserError) *QCborValue {
|
||||
_ret := C.QCborValue_FromCbor33((*C.uchar)(unsafe.Pointer(data)), (C.size_t)(lenVal), error.cPointer())
|
||||
func QCborValue_FromCbor33(data *byte, lenVal int64, error *QCborParserError) *QCborValue {
|
||||
_ret := C.QCborValue_FromCbor33((*C.uchar)(unsafe.Pointer(data)), (C.ptrdiff_t)(lenVal), error.cPointer())
|
||||
_goptr := newQCborValue(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
|
@ -123,8 +123,8 @@ QCborValue* QCborValue_FromJsonValue(QJsonValue* v);
|
||||
QJsonValue* QCborValue_ToJsonValue(const QCborValue* self);
|
||||
QCborValue* QCborValue_FromCbor(QCborStreamReader* reader);
|
||||
QCborValue* QCborValue_FromCborWithBa(QByteArray* ba);
|
||||
QCborValue* QCborValue_FromCbor2(const char* data, size_t lenVal);
|
||||
QCborValue* QCborValue_FromCbor3(const unsigned char* data, size_t lenVal);
|
||||
QCborValue* QCborValue_FromCbor2(const char* data, ptrdiff_t lenVal);
|
||||
QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal);
|
||||
QByteArray* QCborValue_ToCbor(QCborValue* self);
|
||||
void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer);
|
||||
struct miqt_string* QCborValue_ToDiagnosticNotation(const QCborValue* self);
|
||||
@ -141,8 +141,8 @@ QUrl* QCborValue_ToUrl1(const QCborValue* self, QUrl* defaultValue);
|
||||
QRegularExpression* QCborValue_ToRegularExpression1(const QCborValue* self, QRegularExpression* defaultValue);
|
||||
QUuid* QCborValue_ToUuid1(const QCborValue* self, QUuid* defaultValue);
|
||||
QCborValue* QCborValue_FromCbor22(QByteArray* ba, QCborParserError* error);
|
||||
QCborValue* QCborValue_FromCbor32(const char* data, size_t lenVal, QCborParserError* error);
|
||||
QCborValue* QCborValue_FromCbor33(const unsigned char* data, size_t lenVal, QCborParserError* error);
|
||||
QCborValue* QCborValue_FromCbor32(const char* data, ptrdiff_t lenVal, QCborParserError* error);
|
||||
QCborValue* QCborValue_FromCbor33(const unsigned char* data, ptrdiff_t lenVal, QCborParserError* error);
|
||||
QByteArray* QCborValue_ToCbor1(QCborValue* self, int opt);
|
||||
void QCborValue_ToCbor2(QCborValue* self, QCborStreamWriter* writer, int opt);
|
||||
struct miqt_string* QCborValue_ToDiagnosticNotation1(const QCborValue* self, int opts);
|
||||
|
@ -378,7 +378,7 @@ func newQLatin1Char_U(h unsafe.Pointer) *QLatin1Char {
|
||||
}
|
||||
|
||||
// NewQLatin1Char constructs a new QLatin1Char object.
|
||||
func NewQLatin1Char(c byte) *QLatin1Char {
|
||||
func NewQLatin1Char(c int8) *QLatin1Char {
|
||||
ret := C.QLatin1Char_new((C.char)(c))
|
||||
return newQLatin1Char(ret)
|
||||
}
|
||||
@ -389,8 +389,8 @@ func NewQLatin1Char2(param1 *QLatin1Char) *QLatin1Char {
|
||||
return newQLatin1Char(ret)
|
||||
}
|
||||
|
||||
func (this *QLatin1Char) ToLatin1() byte {
|
||||
return (byte)(C.QLatin1Char_ToLatin1(this.h))
|
||||
func (this *QLatin1Char) ToLatin1() int8 {
|
||||
return (int8)(C.QLatin1Char_ToLatin1(this.h))
|
||||
}
|
||||
|
||||
func (this *QLatin1Char) Unicode() uint16 {
|
||||
@ -482,7 +482,7 @@ func NewQChar8(ch QLatin1Char) *QChar {
|
||||
}
|
||||
|
||||
// NewQChar9 constructs a new QChar object.
|
||||
func NewQChar9(c byte) *QChar {
|
||||
func NewQChar9(c int8) *QChar {
|
||||
ret := C.QChar_new9((C.char)(c))
|
||||
return newQChar(ret)
|
||||
}
|
||||
@ -581,15 +581,15 @@ func (this *QChar) UnicodeVersion() QChar__UnicodeVersion {
|
||||
return (QChar__UnicodeVersion)(C.QChar_UnicodeVersion(this.h))
|
||||
}
|
||||
|
||||
func (this *QChar) ToLatin1() byte {
|
||||
return (byte)(C.QChar_ToLatin1(this.h))
|
||||
func (this *QChar) ToLatin1() int8 {
|
||||
return (int8)(C.QChar_ToLatin1(this.h))
|
||||
}
|
||||
|
||||
func (this *QChar) Unicode() uint16 {
|
||||
return (uint16)(C.QChar_Unicode(this.h))
|
||||
}
|
||||
|
||||
func QChar_FromLatin1(c byte) *QChar {
|
||||
func QChar_FromLatin1(c int8) *QChar {
|
||||
_ret := C.QChar_FromLatin1((C.char)(c))
|
||||
_goptr := newQChar(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
|
4
qt/gen_qcontainerfwd.cpp
Normal file
4
qt/gen_qcontainerfwd.cpp
Normal file
@ -0,0 +1,4 @@
|
||||
#include "qcontainerfwd.h"
|
||||
#include "gen_qcontainerfwd.h"
|
||||
#include "_cgo_export.h"
|
||||
|
9
qt/gen_qcontainerfwd.go
Normal file
9
qt/gen_qcontainerfwd.go
Normal file
@ -0,0 +1,9 @@
|
||||
package qt
|
||||
|
||||
/*
|
||||
|
||||
#include "gen_qcontainerfwd.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
*/
|
||||
import "C"
|
24
qt/gen_qcontainerfwd.h
Normal file
24
qt/gen_qcontainerfwd.h
Normal file
@ -0,0 +1,24 @@
|
||||
#ifndef GEN_QCONTAINERFWD_H
|
||||
#define GEN_QCONTAINERFWD_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
|
||||
|
||||
#include "binding.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#else
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern C */
|
||||
#endif
|
||||
|
||||
#endif
|
@ -172,7 +172,7 @@ func (this *QDataStream) SetVersion(version int) {
|
||||
C.QDataStream_SetVersion(this.h, (C.int)(version))
|
||||
}
|
||||
|
||||
func (this *QDataStream) OperatorShiftRight(i *byte) {
|
||||
func (this *QDataStream) OperatorShiftRight(i *int8) {
|
||||
C.QDataStream_OperatorShiftRight(this.h, (*C.schar)(unsafe.Pointer(i)))
|
||||
}
|
||||
|
||||
@ -222,7 +222,7 @@ func (this *QDataStream) OperatorShiftRightWithStr(str string) {
|
||||
C.QDataStream_OperatorShiftRightWithStr(this.h, str_Cstring)
|
||||
}
|
||||
|
||||
func (this *QDataStream) OperatorShiftLeft(i byte) {
|
||||
func (this *QDataStream) OperatorShiftLeft(i int8) {
|
||||
C.QDataStream_OperatorShiftLeft(this.h, (C.schar)(i))
|
||||
}
|
||||
|
||||
|
@ -119,7 +119,7 @@ func (this *QDebug) OperatorShiftLeftWithBool(t bool) *QDebug {
|
||||
return newQDebug_U(unsafe.Pointer(C.QDebug_OperatorShiftLeftWithBool(this.h, (C.bool)(t))))
|
||||
}
|
||||
|
||||
func (this *QDebug) OperatorShiftLeftWithChar(t byte) *QDebug {
|
||||
func (this *QDebug) OperatorShiftLeftWithChar(t int8) *QDebug {
|
||||
return newQDebug_U(unsafe.Pointer(C.QDebug_OperatorShiftLeftWithChar(this.h, (C.char)(t))))
|
||||
}
|
||||
|
||||
@ -183,7 +183,7 @@ func (this *QDebug) OperatorShiftLeftWithVoid(t unsafe.Pointer) *QDebug {
|
||||
return newQDebug_U(unsafe.Pointer(C.QDebug_OperatorShiftLeftWithVoid(this.h, t)))
|
||||
}
|
||||
|
||||
func (this *QDebug) MaybeQuote1(c byte) *QDebug {
|
||||
func (this *QDebug) MaybeQuote1(c int8) *QDebug {
|
||||
return newQDebug_U(unsafe.Pointer(C.QDebug_MaybeQuote1(this.h, (C.char)(c))))
|
||||
}
|
||||
|
||||
@ -293,7 +293,7 @@ func (this *QNoDebug) Verbosity(param1 int) *QNoDebug {
|
||||
return newQNoDebug_U(unsafe.Pointer(C.QNoDebug_Verbosity(this.h, (C.int)(param1))))
|
||||
}
|
||||
|
||||
func (this *QNoDebug) MaybeQuote1(param1 byte) *QNoDebug {
|
||||
func (this *QNoDebug) MaybeQuote1(param1 int8) *QNoDebug {
|
||||
return newQNoDebug_U(unsafe.Pointer(C.QNoDebug_MaybeQuote1(this.h, (C.char)(param1))))
|
||||
}
|
||||
|
||||
|
@ -196,8 +196,9 @@ int QImage_ByteCount(const QImage* self) {
|
||||
return self->byteCount();
|
||||
}
|
||||
|
||||
size_t QImage_SizeInBytes(const QImage* self) {
|
||||
return self->sizeInBytes();
|
||||
ptrdiff_t QImage_SizeInBytes(const QImage* self) {
|
||||
qsizetype _ret = self->sizeInBytes();
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
unsigned char* QImage_ScanLine(QImage* self, int param1) {
|
||||
|
@ -295,8 +295,8 @@ func (this *QImage) ByteCount() int {
|
||||
return (int)(C.QImage_ByteCount(this.h))
|
||||
}
|
||||
|
||||
func (this *QImage) SizeInBytes() uint64 {
|
||||
return (uint64)(C.QImage_SizeInBytes(this.h))
|
||||
func (this *QImage) SizeInBytes() int64 {
|
||||
return (int64)(C.QImage_SizeInBytes(this.h))
|
||||
}
|
||||
|
||||
func (this *QImage) ScanLine(param1 int) *byte {
|
||||
|
@ -84,7 +84,7 @@ unsigned char* QImage_Bits(QImage* self);
|
||||
const unsigned char* QImage_Bits2(const QImage* self);
|
||||
const unsigned char* QImage_ConstBits(const QImage* self);
|
||||
int QImage_ByteCount(const QImage* self);
|
||||
size_t QImage_SizeInBytes(const QImage* self);
|
||||
ptrdiff_t QImage_SizeInBytes(const QImage* self);
|
||||
unsigned char* QImage_ScanLine(QImage* self, int param1);
|
||||
const unsigned char* QImage_ScanLineWithInt(const QImage* self, int param1);
|
||||
const unsigned char* QImage_ConstScanLine(const QImage* self, int param1);
|
||||
|
@ -262,11 +262,11 @@ func (this *QIODevice) WaitForBytesWritten(msecs int) bool {
|
||||
return (bool)(C.QIODevice_WaitForBytesWritten(this.h, (C.int)(msecs)))
|
||||
}
|
||||
|
||||
func (this *QIODevice) UngetChar(c byte) {
|
||||
func (this *QIODevice) UngetChar(c int8) {
|
||||
C.QIODevice_UngetChar(this.h, (C.char)(c))
|
||||
}
|
||||
|
||||
func (this *QIODevice) PutChar(c byte) bool {
|
||||
func (this *QIODevice) PutChar(c int8) bool {
|
||||
return (bool)(C.QIODevice_PutChar(this.h, (C.char)(c)))
|
||||
}
|
||||
|
||||
|
@ -1746,28 +1746,28 @@ func (this *QLocale) ToDouble2(s string, ok *bool) float64 {
|
||||
return (float64)(C.QLocale_ToDouble2(this.h, (*C.struct_miqt_string)(s_ms), (*C.bool)(unsafe.Pointer(ok))))
|
||||
}
|
||||
|
||||
func (this *QLocale) ToString22(i float64, f byte) string {
|
||||
func (this *QLocale) ToString22(i float64, f int8) string {
|
||||
var _ms *C.struct_miqt_string = C.QLocale_ToString22(this.h, (C.double)(i), (C.char)(f))
|
||||
_ret := C.GoStringN(&_ms.data, C.int(int64(_ms.len)))
|
||||
C.free(unsafe.Pointer(_ms))
|
||||
return _ret
|
||||
}
|
||||
|
||||
func (this *QLocale) ToString32(i float64, f byte, prec int) string {
|
||||
func (this *QLocale) ToString32(i float64, f int8, prec int) string {
|
||||
var _ms *C.struct_miqt_string = C.QLocale_ToString32(this.h, (C.double)(i), (C.char)(f), (C.int)(prec))
|
||||
_ret := C.GoStringN(&_ms.data, C.int(int64(_ms.len)))
|
||||
C.free(unsafe.Pointer(_ms))
|
||||
return _ret
|
||||
}
|
||||
|
||||
func (this *QLocale) ToString23(i float32, f byte) string {
|
||||
func (this *QLocale) ToString23(i float32, f int8) string {
|
||||
var _ms *C.struct_miqt_string = C.QLocale_ToString23(this.h, (C.float)(i), (C.char)(f))
|
||||
_ret := C.GoStringN(&_ms.data, C.int(int64(_ms.len)))
|
||||
C.free(unsafe.Pointer(_ms))
|
||||
return _ret
|
||||
}
|
||||
|
||||
func (this *QLocale) ToString33(i float32, f byte, prec int) string {
|
||||
func (this *QLocale) ToString33(i float32, f int8, prec int) string {
|
||||
var _ms *C.struct_miqt_string = C.QLocale_ToString33(this.h, (C.float)(i), (C.char)(f), (C.int)(prec))
|
||||
_ret := C.GoStringN(&_ms.data, C.int(int64(_ms.len)))
|
||||
C.free(unsafe.Pointer(_ms))
|
||||
|
@ -8,8 +8,8 @@ QRandomGenerator* QRandomGenerator_new() {
|
||||
return new QRandomGenerator();
|
||||
}
|
||||
|
||||
QRandomGenerator* QRandomGenerator_new2(const unsigned int* seedBuffer, size_t lenVal) {
|
||||
return new QRandomGenerator(static_cast<const quint32*>(seedBuffer), static_cast<qsizetype>(lenVal));
|
||||
QRandomGenerator* QRandomGenerator_new2(const unsigned int* seedBuffer, ptrdiff_t lenVal) {
|
||||
return new QRandomGenerator(static_cast<const quint32*>(seedBuffer), (qsizetype)(lenVal));
|
||||
}
|
||||
|
||||
QRandomGenerator* QRandomGenerator_new3(const unsigned int* begin, const unsigned int* end) {
|
||||
@ -115,8 +115,8 @@ QRandomGenerator64* QRandomGenerator64_new() {
|
||||
return new QRandomGenerator64();
|
||||
}
|
||||
|
||||
QRandomGenerator64* QRandomGenerator64_new2(const unsigned int* seedBuffer, size_t lenVal) {
|
||||
return new QRandomGenerator64(static_cast<const quint32*>(seedBuffer), static_cast<qsizetype>(lenVal));
|
||||
QRandomGenerator64* QRandomGenerator64_new2(const unsigned int* seedBuffer, ptrdiff_t lenVal) {
|
||||
return new QRandomGenerator64(static_cast<const quint32*>(seedBuffer), (qsizetype)(lenVal));
|
||||
}
|
||||
|
||||
QRandomGenerator64* QRandomGenerator64_new3(const unsigned int* begin, const unsigned int* end) {
|
||||
|
@ -42,8 +42,8 @@ func NewQRandomGenerator() *QRandomGenerator {
|
||||
}
|
||||
|
||||
// NewQRandomGenerator2 constructs a new QRandomGenerator object.
|
||||
func NewQRandomGenerator2(seedBuffer *uint, lenVal uint64) *QRandomGenerator {
|
||||
ret := C.QRandomGenerator_new2((*C.uint)(unsafe.Pointer(seedBuffer)), (C.size_t)(lenVal))
|
||||
func NewQRandomGenerator2(seedBuffer *uint, lenVal int64) *QRandomGenerator {
|
||||
ret := C.QRandomGenerator_new2((*C.uint)(unsafe.Pointer(seedBuffer)), (C.ptrdiff_t)(lenVal))
|
||||
return newQRandomGenerator(ret)
|
||||
}
|
||||
|
||||
@ -188,8 +188,8 @@ func NewQRandomGenerator64() *QRandomGenerator64 {
|
||||
}
|
||||
|
||||
// NewQRandomGenerator642 constructs a new QRandomGenerator64 object.
|
||||
func NewQRandomGenerator642(seedBuffer *uint, lenVal uint64) *QRandomGenerator64 {
|
||||
ret := C.QRandomGenerator64_new2((*C.uint)(unsafe.Pointer(seedBuffer)), (C.size_t)(lenVal))
|
||||
func NewQRandomGenerator642(seedBuffer *uint, lenVal int64) *QRandomGenerator64 {
|
||||
ret := C.QRandomGenerator64_new2((*C.uint)(unsafe.Pointer(seedBuffer)), (C.ptrdiff_t)(lenVal))
|
||||
return newQRandomGenerator64(ret)
|
||||
}
|
||||
|
||||
|
@ -22,7 +22,7 @@ typedef struct QRandomGenerator64 QRandomGenerator64;
|
||||
#endif
|
||||
|
||||
QRandomGenerator* QRandomGenerator_new();
|
||||
QRandomGenerator* QRandomGenerator_new2(const unsigned int* seedBuffer, size_t lenVal);
|
||||
QRandomGenerator* QRandomGenerator_new2(const unsigned int* seedBuffer, ptrdiff_t lenVal);
|
||||
QRandomGenerator* QRandomGenerator_new3(const unsigned int* begin, const unsigned int* end);
|
||||
QRandomGenerator* QRandomGenerator_new4(QRandomGenerator* other);
|
||||
QRandomGenerator* QRandomGenerator_new5(unsigned int seedValue);
|
||||
@ -48,7 +48,7 @@ void QRandomGenerator_Seed1(QRandomGenerator* self, unsigned int s);
|
||||
void QRandomGenerator_Delete(QRandomGenerator* self);
|
||||
|
||||
QRandomGenerator64* QRandomGenerator64_new();
|
||||
QRandomGenerator64* QRandomGenerator64_new2(const unsigned int* seedBuffer, size_t lenVal);
|
||||
QRandomGenerator64* QRandomGenerator64_new2(const unsigned int* seedBuffer, ptrdiff_t lenVal);
|
||||
QRandomGenerator64* QRandomGenerator64_new3(const unsigned int* begin, const unsigned int* end);
|
||||
QRandomGenerator64* QRandomGenerator64_new4(QRandomGenerator* other);
|
||||
QRandomGenerator64* QRandomGenerator64_new5(QRandomGenerator64* param1);
|
||||
|
@ -10,11 +10,11 @@
|
||||
#include "_cgo_export.h"
|
||||
|
||||
QSocketNotifier* QSocketNotifier_new(intptr_t socket, int param2) {
|
||||
return new QSocketNotifier(static_cast<qintptr>(socket), static_cast<QSocketNotifier::Type>(param2));
|
||||
return new QSocketNotifier((qintptr)(socket), static_cast<QSocketNotifier::Type>(param2));
|
||||
}
|
||||
|
||||
QSocketNotifier* QSocketNotifier_new2(intptr_t socket, int param2, QObject* parent) {
|
||||
return new QSocketNotifier(static_cast<qintptr>(socket), static_cast<QSocketNotifier::Type>(param2), parent);
|
||||
return new QSocketNotifier((qintptr)(socket), static_cast<QSocketNotifier::Type>(param2), parent);
|
||||
}
|
||||
|
||||
QMetaObject* QSocketNotifier_MetaObject(const QSocketNotifier* self) {
|
||||
|
@ -193,7 +193,7 @@ func NewQSocketDescriptor2(param1 *QSocketDescriptor) *QSocketDescriptor {
|
||||
}
|
||||
|
||||
// NewQSocketDescriptor3 constructs a new QSocketDescriptor object.
|
||||
func NewQSocketDescriptor3(descriptor QSocketNotifier__Type) *QSocketDescriptor {
|
||||
func NewQSocketDescriptor3(descriptor int) *QSocketDescriptor {
|
||||
if runtime.GOOS == "linux" {
|
||||
ret := C.QSocketDescriptor_new3((C.int)(descriptor))
|
||||
return newQSocketDescriptor(ret)
|
||||
|
@ -20,8 +20,9 @@ struct miqt_string* QStringView_ToString(const QStringView* self) {
|
||||
return miqt_strdup(_b.data(), _b.length());
|
||||
}
|
||||
|
||||
size_t QStringView_Size(const QStringView* self) {
|
||||
return self->size();
|
||||
ptrdiff_t QStringView_Size(const QStringView* self) {
|
||||
qsizetype _ret = self->size();
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
QChar* QStringView_Data(const QStringView* self) {
|
||||
@ -29,8 +30,8 @@ QChar* QStringView_Data(const QStringView* self) {
|
||||
return const_cast<QChar*>(static_cast<const QChar*>(_ret));
|
||||
}
|
||||
|
||||
QChar* QStringView_OperatorSubscript(const QStringView* self, size_t n) {
|
||||
return new QChar(self->operator[](static_cast<qsizetype>(n)));
|
||||
QChar* QStringView_OperatorSubscript(const QStringView* self, ptrdiff_t n) {
|
||||
return new QChar(self->operator[]((qsizetype)(n)));
|
||||
}
|
||||
|
||||
QByteArray* QStringView_ToLatin1(const QStringView* self) {
|
||||
@ -58,16 +59,16 @@ struct miqt_array* QStringView_ToUcs4(const QStringView* self) {
|
||||
return _out;
|
||||
}
|
||||
|
||||
QChar* QStringView_At(const QStringView* self, size_t n) {
|
||||
return new QChar(self->at(static_cast<qsizetype>(n)));
|
||||
QChar* QStringView_At(const QStringView* self, ptrdiff_t n) {
|
||||
return new QChar(self->at((qsizetype)(n)));
|
||||
}
|
||||
|
||||
void QStringView_Truncate(QStringView* self, size_t n) {
|
||||
self->truncate(static_cast<qsizetype>(n));
|
||||
void QStringView_Truncate(QStringView* self, ptrdiff_t n) {
|
||||
self->truncate((qsizetype)(n));
|
||||
}
|
||||
|
||||
void QStringView_Chop(QStringView* self, size_t n) {
|
||||
self->chop(static_cast<qsizetype>(n));
|
||||
void QStringView_Chop(QStringView* self, ptrdiff_t n) {
|
||||
self->chop((qsizetype)(n));
|
||||
}
|
||||
|
||||
int QStringView_CompareWithQChar(const QStringView* self, QChar* c) {
|
||||
@ -94,20 +95,23 @@ bool QStringView_EndsWith2(const QStringView* self, QChar* c, int cs) {
|
||||
return self->endsWith(*c, static_cast<Qt::CaseSensitivity>(cs));
|
||||
}
|
||||
|
||||
size_t QStringView_IndexOf(const QStringView* self, QChar* c) {
|
||||
return self->indexOf(*c);
|
||||
ptrdiff_t QStringView_IndexOf(const QStringView* self, QChar* c) {
|
||||
qsizetype _ret = self->indexOf(*c);
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
bool QStringView_Contains(const QStringView* self, QChar* c) {
|
||||
return self->contains(*c);
|
||||
}
|
||||
|
||||
size_t QStringView_Count(const QStringView* self, QChar* c) {
|
||||
return self->count(*c);
|
||||
ptrdiff_t QStringView_Count(const QStringView* self, QChar* c) {
|
||||
qsizetype _ret = self->count(*c);
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
size_t QStringView_LastIndexOf(const QStringView* self, QChar* c) {
|
||||
return self->lastIndexOf(*c);
|
||||
ptrdiff_t QStringView_LastIndexOf(const QStringView* self, QChar* c) {
|
||||
qsizetype _ret = self->lastIndexOf(*c);
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
bool QStringView_IsRightToLeft(const QStringView* self) {
|
||||
@ -215,28 +219,33 @@ QChar* QStringView_Last(const QStringView* self) {
|
||||
return new QChar(self->last());
|
||||
}
|
||||
|
||||
size_t QStringView_IndexOf2(const QStringView* self, QChar* c, size_t from) {
|
||||
return self->indexOf(*c, static_cast<qsizetype>(from));
|
||||
ptrdiff_t QStringView_IndexOf2(const QStringView* self, QChar* c, ptrdiff_t from) {
|
||||
qsizetype _ret = self->indexOf(*c, (qsizetype)(from));
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
size_t QStringView_IndexOf3(const QStringView* self, QChar* c, size_t from, int cs) {
|
||||
return self->indexOf(*c, static_cast<qsizetype>(from), static_cast<Qt::CaseSensitivity>(cs));
|
||||
ptrdiff_t QStringView_IndexOf3(const QStringView* self, QChar* c, ptrdiff_t from, int cs) {
|
||||
qsizetype _ret = self->indexOf(*c, (qsizetype)(from), static_cast<Qt::CaseSensitivity>(cs));
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
bool QStringView_Contains2(const QStringView* self, QChar* c, int cs) {
|
||||
return self->contains(*c, static_cast<Qt::CaseSensitivity>(cs));
|
||||
}
|
||||
|
||||
size_t QStringView_Count2(const QStringView* self, QChar* c, int cs) {
|
||||
return self->count(*c, static_cast<Qt::CaseSensitivity>(cs));
|
||||
ptrdiff_t QStringView_Count2(const QStringView* self, QChar* c, int cs) {
|
||||
qsizetype _ret = self->count(*c, static_cast<Qt::CaseSensitivity>(cs));
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
size_t QStringView_LastIndexOf2(const QStringView* self, QChar* c, size_t from) {
|
||||
return self->lastIndexOf(*c, static_cast<qsizetype>(from));
|
||||
ptrdiff_t QStringView_LastIndexOf2(const QStringView* self, QChar* c, ptrdiff_t from) {
|
||||
qsizetype _ret = self->lastIndexOf(*c, (qsizetype)(from));
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
size_t QStringView_LastIndexOf3(const QStringView* self, QChar* c, size_t from, int cs) {
|
||||
return self->lastIndexOf(*c, static_cast<qsizetype>(from), static_cast<Qt::CaseSensitivity>(cs));
|
||||
ptrdiff_t QStringView_LastIndexOf3(const QStringView* self, QChar* c, ptrdiff_t from, int cs) {
|
||||
qsizetype _ret = self->lastIndexOf(*c, (qsizetype)(from), static_cast<Qt::CaseSensitivity>(cs));
|
||||
return static_cast<ptrdiff_t>(_ret);
|
||||
}
|
||||
|
||||
int16_t QStringView_ToShort1(const QStringView* self, bool* ok) {
|
||||
|
@ -48,16 +48,16 @@ func (this *QStringView) ToString() string {
|
||||
return _ret
|
||||
}
|
||||
|
||||
func (this *QStringView) Size() uint64 {
|
||||
return (uint64)(C.QStringView_Size(this.h))
|
||||
func (this *QStringView) Size() int64 {
|
||||
return (int64)(C.QStringView_Size(this.h))
|
||||
}
|
||||
|
||||
func (this *QStringView) Data() *QChar {
|
||||
return newQChar_U(unsafe.Pointer(C.QStringView_Data(this.h)))
|
||||
}
|
||||
|
||||
func (this *QStringView) OperatorSubscript(n uint64) *QChar {
|
||||
_ret := C.QStringView_OperatorSubscript(this.h, (C.size_t)(n))
|
||||
func (this *QStringView) OperatorSubscript(n int64) *QChar {
|
||||
_ret := C.QStringView_OperatorSubscript(this.h, (C.ptrdiff_t)(n))
|
||||
_goptr := newQChar(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
@ -95,19 +95,19 @@ func (this *QStringView) ToUcs4() []uint {
|
||||
return _ret
|
||||
}
|
||||
|
||||
func (this *QStringView) At(n uint64) *QChar {
|
||||
_ret := C.QStringView_At(this.h, (C.size_t)(n))
|
||||
func (this *QStringView) At(n int64) *QChar {
|
||||
_ret := C.QStringView_At(this.h, (C.ptrdiff_t)(n))
|
||||
_goptr := newQChar(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QStringView) Truncate(n uint64) {
|
||||
C.QStringView_Truncate(this.h, (C.size_t)(n))
|
||||
func (this *QStringView) Truncate(n int64) {
|
||||
C.QStringView_Truncate(this.h, (C.ptrdiff_t)(n))
|
||||
}
|
||||
|
||||
func (this *QStringView) Chop(n uint64) {
|
||||
C.QStringView_Chop(this.h, (C.size_t)(n))
|
||||
func (this *QStringView) Chop(n int64) {
|
||||
C.QStringView_Chop(this.h, (C.ptrdiff_t)(n))
|
||||
}
|
||||
|
||||
func (this *QStringView) CompareWithQChar(c QChar) int {
|
||||
@ -134,20 +134,20 @@ func (this *QStringView) EndsWith2(c QChar, cs CaseSensitivity) bool {
|
||||
return (bool)(C.QStringView_EndsWith2(this.h, c.cPointer(), (C.int)(cs)))
|
||||
}
|
||||
|
||||
func (this *QStringView) IndexOf(c QChar) uint64 {
|
||||
return (uint64)(C.QStringView_IndexOf(this.h, c.cPointer()))
|
||||
func (this *QStringView) IndexOf(c QChar) int64 {
|
||||
return (int64)(C.QStringView_IndexOf(this.h, c.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QStringView) Contains(c QChar) bool {
|
||||
return (bool)(C.QStringView_Contains(this.h, c.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QStringView) Count(c QChar) uint64 {
|
||||
return (uint64)(C.QStringView_Count(this.h, c.cPointer()))
|
||||
func (this *QStringView) Count(c QChar) int64 {
|
||||
return (int64)(C.QStringView_Count(this.h, c.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QStringView) LastIndexOf(c QChar) uint64 {
|
||||
return (uint64)(C.QStringView_LastIndexOf(this.h, c.cPointer()))
|
||||
func (this *QStringView) LastIndexOf(c QChar) int64 {
|
||||
return (int64)(C.QStringView_LastIndexOf(this.h, c.cPointer()))
|
||||
}
|
||||
|
||||
func (this *QStringView) IsRightToLeft() bool {
|
||||
@ -258,28 +258,28 @@ func (this *QStringView) Last() *QChar {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QStringView) IndexOf2(c QChar, from uint64) uint64 {
|
||||
return (uint64)(C.QStringView_IndexOf2(this.h, c.cPointer(), (C.size_t)(from)))
|
||||
func (this *QStringView) IndexOf2(c QChar, from int64) int64 {
|
||||
return (int64)(C.QStringView_IndexOf2(this.h, c.cPointer(), (C.ptrdiff_t)(from)))
|
||||
}
|
||||
|
||||
func (this *QStringView) IndexOf3(c QChar, from uint64, cs CaseSensitivity) uint64 {
|
||||
return (uint64)(C.QStringView_IndexOf3(this.h, c.cPointer(), (C.size_t)(from), (C.int)(cs)))
|
||||
func (this *QStringView) IndexOf3(c QChar, from int64, cs CaseSensitivity) int64 {
|
||||
return (int64)(C.QStringView_IndexOf3(this.h, c.cPointer(), (C.ptrdiff_t)(from), (C.int)(cs)))
|
||||
}
|
||||
|
||||
func (this *QStringView) Contains2(c QChar, cs CaseSensitivity) bool {
|
||||
return (bool)(C.QStringView_Contains2(this.h, c.cPointer(), (C.int)(cs)))
|
||||
}
|
||||
|
||||
func (this *QStringView) Count2(c QChar, cs CaseSensitivity) uint64 {
|
||||
return (uint64)(C.QStringView_Count2(this.h, c.cPointer(), (C.int)(cs)))
|
||||
func (this *QStringView) Count2(c QChar, cs CaseSensitivity) int64 {
|
||||
return (int64)(C.QStringView_Count2(this.h, c.cPointer(), (C.int)(cs)))
|
||||
}
|
||||
|
||||
func (this *QStringView) LastIndexOf2(c QChar, from uint64) uint64 {
|
||||
return (uint64)(C.QStringView_LastIndexOf2(this.h, c.cPointer(), (C.size_t)(from)))
|
||||
func (this *QStringView) LastIndexOf2(c QChar, from int64) int64 {
|
||||
return (int64)(C.QStringView_LastIndexOf2(this.h, c.cPointer(), (C.ptrdiff_t)(from)))
|
||||
}
|
||||
|
||||
func (this *QStringView) LastIndexOf3(c QChar, from uint64, cs CaseSensitivity) uint64 {
|
||||
return (uint64)(C.QStringView_LastIndexOf3(this.h, c.cPointer(), (C.size_t)(from), (C.int)(cs)))
|
||||
func (this *QStringView) LastIndexOf3(c QChar, from int64, cs CaseSensitivity) int64 {
|
||||
return (int64)(C.QStringView_LastIndexOf3(this.h, c.cPointer(), (C.ptrdiff_t)(from), (C.int)(cs)))
|
||||
}
|
||||
|
||||
func (this *QStringView) ToShort1(ok *bool) int16 {
|
||||
|
@ -25,26 +25,26 @@ typedef struct QStringView QStringView;
|
||||
|
||||
QStringView* QStringView_new();
|
||||
struct miqt_string* QStringView_ToString(const QStringView* self);
|
||||
size_t QStringView_Size(const QStringView* self);
|
||||
ptrdiff_t QStringView_Size(const QStringView* self);
|
||||
QChar* QStringView_Data(const QStringView* self);
|
||||
QChar* QStringView_OperatorSubscript(const QStringView* self, size_t n);
|
||||
QChar* QStringView_OperatorSubscript(const QStringView* self, ptrdiff_t n);
|
||||
QByteArray* QStringView_ToLatin1(const QStringView* self);
|
||||
QByteArray* QStringView_ToUtf8(const QStringView* self);
|
||||
QByteArray* QStringView_ToLocal8Bit(const QStringView* self);
|
||||
struct miqt_array* QStringView_ToUcs4(const QStringView* self);
|
||||
QChar* QStringView_At(const QStringView* self, size_t n);
|
||||
void QStringView_Truncate(QStringView* self, size_t n);
|
||||
void QStringView_Chop(QStringView* self, size_t n);
|
||||
QChar* QStringView_At(const QStringView* self, ptrdiff_t n);
|
||||
void QStringView_Truncate(QStringView* self, ptrdiff_t n);
|
||||
void QStringView_Chop(QStringView* self, ptrdiff_t n);
|
||||
int QStringView_CompareWithQChar(const QStringView* self, QChar* c);
|
||||
int QStringView_Compare2(const QStringView* self, QChar* c, int cs);
|
||||
bool QStringView_StartsWithWithQChar(const QStringView* self, QChar* c);
|
||||
bool QStringView_StartsWith2(const QStringView* self, QChar* c, int cs);
|
||||
bool QStringView_EndsWithWithQChar(const QStringView* self, QChar* c);
|
||||
bool QStringView_EndsWith2(const QStringView* self, QChar* c, int cs);
|
||||
size_t QStringView_IndexOf(const QStringView* self, QChar* c);
|
||||
ptrdiff_t QStringView_IndexOf(const QStringView* self, QChar* c);
|
||||
bool QStringView_Contains(const QStringView* self, QChar* c);
|
||||
size_t QStringView_Count(const QStringView* self, QChar* c);
|
||||
size_t QStringView_LastIndexOf(const QStringView* self, QChar* c);
|
||||
ptrdiff_t QStringView_Count(const QStringView* self, QChar* c);
|
||||
ptrdiff_t QStringView_LastIndexOf(const QStringView* self, QChar* c);
|
||||
bool QStringView_IsRightToLeft(const QStringView* self);
|
||||
bool QStringView_IsValidUtf16(const QStringView* self);
|
||||
int16_t QStringView_ToShort(const QStringView* self);
|
||||
@ -69,12 +69,12 @@ bool QStringView_IsEmpty(const QStringView* self);
|
||||
int QStringView_Length(const QStringView* self);
|
||||
QChar* QStringView_First(const QStringView* self);
|
||||
QChar* QStringView_Last(const QStringView* self);
|
||||
size_t QStringView_IndexOf2(const QStringView* self, QChar* c, size_t from);
|
||||
size_t QStringView_IndexOf3(const QStringView* self, QChar* c, size_t from, int cs);
|
||||
ptrdiff_t QStringView_IndexOf2(const QStringView* self, QChar* c, ptrdiff_t from);
|
||||
ptrdiff_t QStringView_IndexOf3(const QStringView* self, QChar* c, ptrdiff_t from, int cs);
|
||||
bool QStringView_Contains2(const QStringView* self, QChar* c, int cs);
|
||||
size_t QStringView_Count2(const QStringView* self, QChar* c, int cs);
|
||||
size_t QStringView_LastIndexOf2(const QStringView* self, QChar* c, size_t from);
|
||||
size_t QStringView_LastIndexOf3(const QStringView* self, QChar* c, size_t from, int cs);
|
||||
ptrdiff_t QStringView_Count2(const QStringView* self, QChar* c, int cs);
|
||||
ptrdiff_t QStringView_LastIndexOf2(const QStringView* self, QChar* c, ptrdiff_t from);
|
||||
ptrdiff_t QStringView_LastIndexOf3(const QStringView* self, QChar* c, ptrdiff_t from, int cs);
|
||||
int16_t QStringView_ToShort1(const QStringView* self, bool* ok);
|
||||
int16_t QStringView_ToShort2(const QStringView* self, bool* ok, int base);
|
||||
uint16_t QStringView_ToUShort1(const QStringView* self, bool* ok);
|
||||
|
@ -283,7 +283,7 @@ func (this *QTextStream) OperatorShiftRight(ch *QChar) *QTextStream {
|
||||
return newQTextStream_U(unsafe.Pointer(C.QTextStream_OperatorShiftRight(this.h, ch.cPointer())))
|
||||
}
|
||||
|
||||
func (this *QTextStream) OperatorShiftRightWithCh(ch *byte) *QTextStream {
|
||||
func (this *QTextStream) OperatorShiftRightWithCh(ch *int8) *QTextStream {
|
||||
return newQTextStream_U(unsafe.Pointer(C.QTextStream_OperatorShiftRightWithCh(this.h, (*C.char)(unsafe.Pointer(ch)))))
|
||||
}
|
||||
|
||||
@ -347,7 +347,7 @@ func (this *QTextStream) OperatorShiftLeft(ch QChar) *QTextStream {
|
||||
return newQTextStream_U(unsafe.Pointer(C.QTextStream_OperatorShiftLeft(this.h, ch.cPointer())))
|
||||
}
|
||||
|
||||
func (this *QTextStream) OperatorShiftLeftWithCh(ch byte) *QTextStream {
|
||||
func (this *QTextStream) OperatorShiftLeftWithCh(ch int8) *QTextStream {
|
||||
return newQTextStream_U(unsafe.Pointer(C.QTextStream_OperatorShiftLeftWithCh(this.h, (C.char)(ch))))
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user