package qt /* #cgo CFLAGS: -fPIC #cgo pkg-config: Qt5Widgets #include "gen_qbytearray.h" #include */ import "C" import ( "runtime" "unsafe" ) type QByteArrayDataPtr struct { h *C.QByteArrayDataPtr } func (this *QByteArrayDataPtr) cPointer() *C.QByteArrayDataPtr { if this == nil { return nil } return this.h } func newQByteArrayDataPtr(h *C.QByteArrayDataPtr) *QByteArrayDataPtr { return &QByteArrayDataPtr{h: h} } func newQByteArrayDataPtr_U(h unsafe.Pointer) *QByteArrayDataPtr { return newQByteArrayDataPtr((*C.QByteArrayDataPtr)(h)) } // NewQByteArrayDataPtr constructs a new QByteArrayDataPtr object. func NewQByteArrayDataPtr() *QByteArrayDataPtr { ret := C.QByteArrayDataPtr_new() return newQByteArrayDataPtr(ret) } // NewQByteArrayDataPtr2 constructs a new QByteArrayDataPtr object. func NewQByteArrayDataPtr2(param1 *QByteArrayDataPtr) *QByteArrayDataPtr { ret := C.QByteArrayDataPtr_new2(param1.cPointer()) return newQByteArrayDataPtr(ret) } func (this *QByteArrayDataPtr) Delete() { C.QByteArrayDataPtr_Delete(this.h) } type QByteArray struct { h *C.QByteArray } func (this *QByteArray) cPointer() *C.QByteArray { if this == nil { return nil } return this.h } func newQByteArray(h *C.QByteArray) *QByteArray { return &QByteArray{h: h} } func newQByteArray_U(h unsafe.Pointer) *QByteArray { return newQByteArray((*C.QByteArray)(h)) } // NewQByteArray constructs a new QByteArray object. func NewQByteArray() *QByteArray { ret := C.QByteArray_new() return newQByteArray(ret) } // NewQByteArray2 constructs a new QByteArray object. func NewQByteArray2(param1 string) *QByteArray { param1_Cstring := C.CString(param1) defer C.free(unsafe.Pointer(param1_Cstring)) ret := C.QByteArray_new2(param1_Cstring) return newQByteArray(ret) } // NewQByteArray3 constructs a new QByteArray object. func NewQByteArray3(size int, c byte) *QByteArray { ret := C.QByteArray_new3((C.int)(size), (C.char)(c)) return newQByteArray(ret) } // NewQByteArray4 constructs a new QByteArray object. func NewQByteArray4(param1 *QByteArray) *QByteArray { ret := C.QByteArray_new4(param1.cPointer()) return newQByteArray(ret) } // NewQByteArray5 constructs a new QByteArray object. func NewQByteArray5(dd QByteArrayDataPtr) *QByteArray { ret := C.QByteArray_new5(dd.cPointer()) return newQByteArray(ret) } // NewQByteArray6 constructs a new QByteArray object. func NewQByteArray6(param1 string, size int) *QByteArray { param1_Cstring := C.CString(param1) defer C.free(unsafe.Pointer(param1_Cstring)) ret := C.QByteArray_new6(param1_Cstring, (C.int)(size)) return newQByteArray(ret) } func (this *QByteArray) OperatorAssign(param1 *QByteArray) { C.QByteArray_OperatorAssign(this.h, param1.cPointer()) } func (this *QByteArray) OperatorAssignWithStr(str string) { str_Cstring := C.CString(str) defer C.free(unsafe.Pointer(str_Cstring)) C.QByteArray_OperatorAssignWithStr(this.h, str_Cstring) } func (this *QByteArray) Swap(other *QByteArray) { C.QByteArray_Swap(this.h, other.cPointer()) } func (this *QByteArray) Size() int { ret := C.QByteArray_Size(this.h) return (int)(ret) } func (this *QByteArray) IsEmpty() bool { ret := C.QByteArray_IsEmpty(this.h) return (bool)(ret) } func (this *QByteArray) Resize(size int) { C.QByteArray_Resize(this.h, (C.int)(size)) } func (this *QByteArray) Fill(c byte) *QByteArray { ret := C.QByteArray_Fill(this.h, (C.char)(c)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Capacity() int { ret := C.QByteArray_Capacity(this.h) return (int)(ret) } func (this *QByteArray) Reserve(size int) { C.QByteArray_Reserve(this.h, (C.int)(size)) } func (this *QByteArray) Squeeze() { C.QByteArray_Squeeze(this.h) } func (this *QByteArray) Data() unsafe.Pointer { ret := C.QByteArray_Data(this.h) return (unsafe.Pointer)(ret) } func (this *QByteArray) Data2() unsafe.Pointer { ret := C.QByteArray_Data2(this.h) return (unsafe.Pointer)(ret) } func (this *QByteArray) ConstData() unsafe.Pointer { ret := C.QByteArray_ConstData(this.h) return (unsafe.Pointer)(ret) } func (this *QByteArray) Detach() { C.QByteArray_Detach(this.h) } func (this *QByteArray) IsDetached() bool { ret := C.QByteArray_IsDetached(this.h) return (bool)(ret) } func (this *QByteArray) IsSharedWith(other *QByteArray) bool { ret := C.QByteArray_IsSharedWith(this.h, other.cPointer()) return (bool)(ret) } func (this *QByteArray) Clear() { C.QByteArray_Clear(this.h) } func (this *QByteArray) At(i int) byte { ret := C.QByteArray_At(this.h, (C.int)(i)) return (byte)(ret) } func (this *QByteArray) OperatorSubscript(i int) byte { ret := C.QByteArray_OperatorSubscript(this.h, (C.int)(i)) return (byte)(ret) } func (this *QByteArray) OperatorSubscriptWithUint(i uint) byte { ret := C.QByteArray_OperatorSubscriptWithUint(this.h, (C.uint)(i)) return (byte)(ret) } func (this *QByteArray) OperatorSubscriptWithInt(i int) *QByteRef { ret := C.QByteArray_OperatorSubscriptWithInt(this.h, (C.int)(i)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteRef(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteRef) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) OperatorSubscript2(i uint) *QByteRef { ret := C.QByteArray_OperatorSubscript2(this.h, (C.uint)(i)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteRef(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteRef) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Front() byte { ret := C.QByteArray_Front(this.h) return (byte)(ret) } func (this *QByteArray) Front2() *QByteRef { ret := C.QByteArray_Front2(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteRef(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteRef) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Back() byte { ret := C.QByteArray_Back(this.h) return (byte)(ret) } func (this *QByteArray) Back2() *QByteRef { ret := C.QByteArray_Back2(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteRef(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteRef) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) IndexOf(c byte) int { ret := C.QByteArray_IndexOf(this.h, (C.char)(c)) return (int)(ret) } func (this *QByteArray) IndexOfWithChar(c string) int { c_Cstring := C.CString(c) defer C.free(unsafe.Pointer(c_Cstring)) ret := C.QByteArray_IndexOfWithChar(this.h, c_Cstring) return (int)(ret) } func (this *QByteArray) IndexOfWithQByteArray(a *QByteArray) int { ret := C.QByteArray_IndexOfWithQByteArray(this.h, a.cPointer()) return (int)(ret) } func (this *QByteArray) LastIndexOf(c byte) int { ret := C.QByteArray_LastIndexOf(this.h, (C.char)(c)) return (int)(ret) } func (this *QByteArray) LastIndexOfWithChar(c string) int { c_Cstring := C.CString(c) defer C.free(unsafe.Pointer(c_Cstring)) ret := C.QByteArray_LastIndexOfWithChar(this.h, c_Cstring) return (int)(ret) } func (this *QByteArray) LastIndexOfWithQByteArray(a *QByteArray) int { ret := C.QByteArray_LastIndexOfWithQByteArray(this.h, a.cPointer()) return (int)(ret) } func (this *QByteArray) Contains(c byte) bool { ret := C.QByteArray_Contains(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteArray) ContainsWithChar(a string) bool { a_Cstring := C.CString(a) defer C.free(unsafe.Pointer(a_Cstring)) ret := C.QByteArray_ContainsWithChar(this.h, a_Cstring) return (bool)(ret) } func (this *QByteArray) ContainsWithQByteArray(a *QByteArray) bool { ret := C.QByteArray_ContainsWithQByteArray(this.h, a.cPointer()) return (bool)(ret) } func (this *QByteArray) Count(c byte) int { ret := C.QByteArray_Count(this.h, (C.char)(c)) return (int)(ret) } func (this *QByteArray) CountWithChar(a string) int { a_Cstring := C.CString(a) defer C.free(unsafe.Pointer(a_Cstring)) ret := C.QByteArray_CountWithChar(this.h, a_Cstring) return (int)(ret) } func (this *QByteArray) CountWithQByteArray(a *QByteArray) int { ret := C.QByteArray_CountWithQByteArray(this.h, a.cPointer()) return (int)(ret) } func (this *QByteArray) Left(lenVal int) *QByteArray { ret := C.QByteArray_Left(this.h, (C.int)(lenVal)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Right(lenVal int) *QByteArray { ret := C.QByteArray_Right(this.h, (C.int)(lenVal)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Mid(index int) *QByteArray { ret := C.QByteArray_Mid(this.h, (C.int)(index)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Chopped(lenVal int) *QByteArray { ret := C.QByteArray_Chopped(this.h, (C.int)(lenVal)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) StartsWith(a *QByteArray) bool { ret := C.QByteArray_StartsWith(this.h, a.cPointer()) return (bool)(ret) } func (this *QByteArray) StartsWithWithChar(c byte) bool { ret := C.QByteArray_StartsWithWithChar(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteArray) StartsWith2(c string) bool { c_Cstring := C.CString(c) defer C.free(unsafe.Pointer(c_Cstring)) ret := C.QByteArray_StartsWith2(this.h, c_Cstring) return (bool)(ret) } func (this *QByteArray) EndsWith(a *QByteArray) bool { ret := C.QByteArray_EndsWith(this.h, a.cPointer()) return (bool)(ret) } func (this *QByteArray) EndsWithWithChar(c byte) bool { ret := C.QByteArray_EndsWithWithChar(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteArray) EndsWith2(c string) bool { c_Cstring := C.CString(c) defer C.free(unsafe.Pointer(c_Cstring)) ret := C.QByteArray_EndsWith2(this.h, c_Cstring) return (bool)(ret) } func (this *QByteArray) IsUpper() bool { ret := C.QByteArray_IsUpper(this.h) return (bool)(ret) } func (this *QByteArray) IsLower() bool { ret := C.QByteArray_IsLower(this.h) return (bool)(ret) } func (this *QByteArray) Truncate(pos int) { C.QByteArray_Truncate(this.h, (C.int)(pos)) } func (this *QByteArray) Chop(n int) { C.QByteArray_Chop(this.h, (C.int)(n)) } func (this *QByteArray) ToLower() *QByteArray { ret := C.QByteArray_ToLower(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) ToUpper() *QByteArray { ret := C.QByteArray_ToUpper(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Trimmed() *QByteArray { ret := C.QByteArray_Trimmed(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Simplified() *QByteArray { ret := C.QByteArray_Simplified(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) LeftJustified(width int) *QByteArray { ret := C.QByteArray_LeftJustified(this.h, (C.int)(width)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) RightJustified(width int) *QByteArray { ret := C.QByteArray_RightJustified(this.h, (C.int)(width)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Prepend(c byte) *QByteArray { ret := C.QByteArray_Prepend(this.h, (C.char)(c)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Prepend2(count int, c byte) *QByteArray { ret := C.QByteArray_Prepend2(this.h, (C.int)(count), (C.char)(c)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) PrependWithChar(s string) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_PrependWithChar(this.h, s_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Prepend3(s string, lenVal int) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_Prepend3(this.h, s_Cstring, (C.int)(lenVal)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) PrependWithQByteArray(a *QByteArray) *QByteArray { ret := C.QByteArray_PrependWithQByteArray(this.h, a.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Append(c byte) *QByteArray { ret := C.QByteArray_Append(this.h, (C.char)(c)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Append2(count int, c byte) *QByteArray { ret := C.QByteArray_Append2(this.h, (C.int)(count), (C.char)(c)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) AppendWithChar(s string) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_AppendWithChar(this.h, s_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Append3(s string, lenVal int) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_Append3(this.h, s_Cstring, (C.int)(lenVal)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) AppendWithQByteArray(a *QByteArray) *QByteArray { ret := C.QByteArray_AppendWithQByteArray(this.h, a.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Insert(i int, c byte) *QByteArray { ret := C.QByteArray_Insert(this.h, (C.int)(i), (C.char)(c)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Insert2(i int, count int, c byte) *QByteArray { ret := C.QByteArray_Insert2(this.h, (C.int)(i), (C.int)(count), (C.char)(c)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Insert3(i int, s string) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_Insert3(this.h, (C.int)(i), s_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Insert4(i int, s string, lenVal int) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_Insert4(this.h, (C.int)(i), s_Cstring, (C.int)(lenVal)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Insert5(i int, a *QByteArray) *QByteArray { ret := C.QByteArray_Insert5(this.h, (C.int)(i), a.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Remove(index int, lenVal int) *QByteArray { ret := C.QByteArray_Remove(this.h, (C.int)(index), (C.int)(lenVal)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace(index int, lenVal int, s string) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_Replace(this.h, (C.int)(index), (C.int)(lenVal), s_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace2(index int, lenVal int, s string, alen int) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_Replace2(this.h, (C.int)(index), (C.int)(lenVal), s_Cstring, (C.int)(alen)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace3(index int, lenVal int, s *QByteArray) *QByteArray { ret := C.QByteArray_Replace3(this.h, (C.int)(index), (C.int)(lenVal), s.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace4(before byte, after string) *QByteArray { after_Cstring := C.CString(after) defer C.free(unsafe.Pointer(after_Cstring)) ret := C.QByteArray_Replace4(this.h, (C.char)(before), after_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace5(before byte, after *QByteArray) *QByteArray { ret := C.QByteArray_Replace5(this.h, (C.char)(before), after.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace6(before string, after string) *QByteArray { before_Cstring := C.CString(before) defer C.free(unsafe.Pointer(before_Cstring)) after_Cstring := C.CString(after) defer C.free(unsafe.Pointer(after_Cstring)) ret := C.QByteArray_Replace6(this.h, before_Cstring, after_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace7(before string, bsize int, after string, asize int) *QByteArray { before_Cstring := C.CString(before) defer C.free(unsafe.Pointer(before_Cstring)) after_Cstring := C.CString(after) defer C.free(unsafe.Pointer(after_Cstring)) ret := C.QByteArray_Replace7(this.h, before_Cstring, (C.int)(bsize), after_Cstring, (C.int)(asize)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace8(before *QByteArray, after *QByteArray) *QByteArray { ret := C.QByteArray_Replace8(this.h, before.cPointer(), after.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace9(before *QByteArray, after string) *QByteArray { after_Cstring := C.CString(after) defer C.free(unsafe.Pointer(after_Cstring)) ret := C.QByteArray_Replace9(this.h, before.cPointer(), after_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace10(before string, after *QByteArray) *QByteArray { before_Cstring := C.CString(before) defer C.free(unsafe.Pointer(before_Cstring)) ret := C.QByteArray_Replace10(this.h, before_Cstring, after.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace11(before byte, after byte) *QByteArray { ret := C.QByteArray_Replace11(this.h, (C.char)(before), (C.char)(after)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) OperatorPlusAssign(c byte) *QByteArray { ret := C.QByteArray_OperatorPlusAssign(this.h, (C.char)(c)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) OperatorPlusAssignWithChar(s string) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_OperatorPlusAssignWithChar(this.h, s_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) OperatorPlusAssignWithQByteArray(a *QByteArray) *QByteArray { ret := C.QByteArray_OperatorPlusAssignWithQByteArray(this.h, a.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Split(sep byte) []QByteArray { var _out **C.QByteArray = nil var _out_len C.size_t = 0 C.QByteArray_Split(this.h, (C.char)(sep), &_out, &_out_len) ret := make([]QByteArray, int(_out_len)) _outCast := (*[0xffff]*C.QByteArray)(unsafe.Pointer(_out)) // so fresh so clean for i := 0; i < int(_out_len); i++ { ret[i] = *newQByteArray(_outCast[i]) } C.free(unsafe.Pointer(_out)) return ret } func (this *QByteArray) Repeated(times int) *QByteArray { ret := C.QByteArray_Repeated(this.h, (C.int)(times)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) AppendWithQString(s string) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_AppendWithQString(this.h, s_Cstring, C.ulong(len(s))) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Insert6(i int, s string) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_Insert6(this.h, (C.int)(i), s_Cstring, C.ulong(len(s))) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace12(before string, after string) *QByteArray { before_Cstring := C.CString(before) defer C.free(unsafe.Pointer(before_Cstring)) after_Cstring := C.CString(after) defer C.free(unsafe.Pointer(after_Cstring)) ret := C.QByteArray_Replace12(this.h, before_Cstring, C.ulong(len(before)), after_Cstring) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace13(c byte, after string) *QByteArray { after_Cstring := C.CString(after) defer C.free(unsafe.Pointer(after_Cstring)) ret := C.QByteArray_Replace13(this.h, (C.char)(c), after_Cstring, C.ulong(len(after))) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) Replace14(before string, after *QByteArray) *QByteArray { before_Cstring := C.CString(before) defer C.free(unsafe.Pointer(before_Cstring)) ret := C.QByteArray_Replace14(this.h, before_Cstring, C.ulong(len(before)), after.cPointer()) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) OperatorPlusAssignWithQString(s string) *QByteArray { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_OperatorPlusAssignWithQString(this.h, s_Cstring, C.ulong(len(s))) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) IndexOfWithQString(s string) int { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_IndexOfWithQString(this.h, s_Cstring, C.ulong(len(s))) return (int)(ret) } func (this *QByteArray) LastIndexOfWithQString(s string) int { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_LastIndexOfWithQString(this.h, s_Cstring, C.ulong(len(s))) return (int)(ret) } func (this *QByteArray) OperatorEqual(s2 string) bool { s2_Cstring := C.CString(s2) defer C.free(unsafe.Pointer(s2_Cstring)) ret := C.QByteArray_OperatorEqual(this.h, s2_Cstring, C.ulong(len(s2))) return (bool)(ret) } func (this *QByteArray) OperatorNotEqual(s2 string) bool { s2_Cstring := C.CString(s2) defer C.free(unsafe.Pointer(s2_Cstring)) ret := C.QByteArray_OperatorNotEqual(this.h, s2_Cstring, C.ulong(len(s2))) return (bool)(ret) } func (this *QByteArray) OperatorLesser(s2 string) bool { s2_Cstring := C.CString(s2) defer C.free(unsafe.Pointer(s2_Cstring)) ret := C.QByteArray_OperatorLesser(this.h, s2_Cstring, C.ulong(len(s2))) return (bool)(ret) } func (this *QByteArray) OperatorGreater(s2 string) bool { s2_Cstring := C.CString(s2) defer C.free(unsafe.Pointer(s2_Cstring)) ret := C.QByteArray_OperatorGreater(this.h, s2_Cstring, C.ulong(len(s2))) return (bool)(ret) } func (this *QByteArray) OperatorLesserOrEqual(s2 string) bool { s2_Cstring := C.CString(s2) defer C.free(unsafe.Pointer(s2_Cstring)) ret := C.QByteArray_OperatorLesserOrEqual(this.h, s2_Cstring, C.ulong(len(s2))) return (bool)(ret) } func (this *QByteArray) OperatorGreaterOrEqual(s2 string) bool { s2_Cstring := C.CString(s2) defer C.free(unsafe.Pointer(s2_Cstring)) ret := C.QByteArray_OperatorGreaterOrEqual(this.h, s2_Cstring, C.ulong(len(s2))) return (bool)(ret) } func (this *QByteArray) ToShort() int16 { ret := C.QByteArray_ToShort(this.h) return (int16)(ret) } func (this *QByteArray) ToUShort() uint16 { ret := C.QByteArray_ToUShort(this.h) return (uint16)(ret) } func (this *QByteArray) ToInt() int { ret := C.QByteArray_ToInt(this.h) return (int)(ret) } func (this *QByteArray) ToUInt() uint { ret := C.QByteArray_ToUInt(this.h) return (uint)(ret) } func (this *QByteArray) ToLong() int64 { ret := C.QByteArray_ToLong(this.h) return (int64)(ret) } func (this *QByteArray) ToULong() uint64 { ret := C.QByteArray_ToULong(this.h) return (uint64)(ret) } func (this *QByteArray) ToLongLong() int64 { ret := C.QByteArray_ToLongLong(this.h) return (int64)(ret) } func (this *QByteArray) ToULongLong() uint64 { ret := C.QByteArray_ToULongLong(this.h) return (uint64)(ret) } func (this *QByteArray) ToFloat() float32 { ret := C.QByteArray_ToFloat(this.h) return (float32)(ret) } func (this *QByteArray) ToDouble() float64 { ret := C.QByteArray_ToDouble(this.h) return (float64)(ret) } func (this *QByteArray) ToBase64() *QByteArray { ret := C.QByteArray_ToBase64(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) ToHex() *QByteArray { ret := C.QByteArray_ToHex(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) ToHexWithSeparator(separator byte) *QByteArray { ret := C.QByteArray_ToHexWithSeparator(this.h, (C.char)(separator)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) ToPercentEncoding() *QByteArray { ret := C.QByteArray_ToPercentEncoding(this.h) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) SetNum(param1 int16) *QByteArray { ret := C.QByteArray_SetNum(this.h, (C.int16_t)(param1)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNumWithUshort(param1 uint16) *QByteArray { ret := C.QByteArray_SetNumWithUshort(this.h, (C.uint16_t)(param1)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNumWithInt(param1 int) *QByteArray { ret := C.QByteArray_SetNumWithInt(this.h, (C.int)(param1)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNumWithUint(param1 uint) *QByteArray { ret := C.QByteArray_SetNumWithUint(this.h, (C.uint)(param1)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNumWithQlonglong(param1 int64) *QByteArray { ret := C.QByteArray_SetNumWithQlonglong(this.h, (C.int64_t)(param1)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNumWithQulonglong(param1 uint64) *QByteArray { ret := C.QByteArray_SetNumWithQulonglong(this.h, (C.uint64_t)(param1)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNumWithFloat(param1 float32) *QByteArray { ret := C.QByteArray_SetNumWithFloat(this.h, (C.float)(param1)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNumWithDouble(param1 float64) *QByteArray { ret := C.QByteArray_SetNumWithDouble(this.h, (C.double)(param1)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetRawData(a string, n uint) *QByteArray { a_Cstring := C.CString(a) defer C.free(unsafe.Pointer(a_Cstring)) ret := C.QByteArray_SetRawData(this.h, a_Cstring, (C.uint)(n)) return newQByteArray_U(unsafe.Pointer(ret)) } func QByteArray_Number(param1 int) *QByteArray { ret := C.QByteArray_Number((C.int)(param1)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_NumberWithUint(param1 uint) *QByteArray { ret := C.QByteArray_NumberWithUint((C.uint)(param1)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_NumberWithQlonglong(param1 int64) *QByteArray { ret := C.QByteArray_NumberWithQlonglong((C.int64_t)(param1)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_NumberWithQulonglong(param1 uint64) *QByteArray { ret := C.QByteArray_NumberWithQulonglong((C.uint64_t)(param1)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_NumberWithDouble(param1 float64) *QByteArray { ret := C.QByteArray_NumberWithDouble((C.double)(param1)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_FromRawData(param1 string, size int) *QByteArray { param1_Cstring := C.CString(param1) defer C.free(unsafe.Pointer(param1_Cstring)) ret := C.QByteArray_FromRawData(param1_Cstring, (C.int)(size)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_FromBase64(base64 *QByteArray) *QByteArray { ret := C.QByteArray_FromBase64(base64.cPointer()) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_FromHex(hexEncoded *QByteArray) *QByteArray { ret := C.QByteArray_FromHex(hexEncoded.cPointer()) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_FromPercentEncoding(pctEncoded *QByteArray) *QByteArray { ret := C.QByteArray_FromPercentEncoding(pctEncoded.cPointer()) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) PushBack(c byte) { C.QByteArray_PushBack(this.h, (C.char)(c)) } func (this *QByteArray) PushBackWithChar(c string) { c_Cstring := C.CString(c) defer C.free(unsafe.Pointer(c_Cstring)) C.QByteArray_PushBackWithChar(this.h, c_Cstring) } func (this *QByteArray) PushBackWithQByteArray(a *QByteArray) { C.QByteArray_PushBackWithQByteArray(this.h, a.cPointer()) } func (this *QByteArray) PushFront(c byte) { C.QByteArray_PushFront(this.h, (C.char)(c)) } func (this *QByteArray) PushFrontWithChar(c string) { c_Cstring := C.CString(c) defer C.free(unsafe.Pointer(c_Cstring)) C.QByteArray_PushFrontWithChar(this.h, c_Cstring) } func (this *QByteArray) PushFrontWithQByteArray(a *QByteArray) { C.QByteArray_PushFrontWithQByteArray(this.h, a.cPointer()) } func (this *QByteArray) ShrinkToFit() { C.QByteArray_ShrinkToFit(this.h) } func (this *QByteArray) Count2() int { ret := C.QByteArray_Count2(this.h) return (int)(ret) } func (this *QByteArray) Length() int { ret := C.QByteArray_Length(this.h) return (int)(ret) } func (this *QByteArray) IsNull() bool { ret := C.QByteArray_IsNull(this.h) return (bool)(ret) } func (this *QByteArray) Fill2(c byte, size int) *QByteArray { ret := C.QByteArray_Fill2(this.h, (C.char)(c), (C.int)(size)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) IndexOf2(c byte, from int) int { ret := C.QByteArray_IndexOf2(this.h, (C.char)(c), (C.int)(from)) return (int)(ret) } func (this *QByteArray) IndexOf22(c string, from int) int { c_Cstring := C.CString(c) defer C.free(unsafe.Pointer(c_Cstring)) ret := C.QByteArray_IndexOf22(this.h, c_Cstring, (C.int)(from)) return (int)(ret) } func (this *QByteArray) IndexOf23(a *QByteArray, from int) int { ret := C.QByteArray_IndexOf23(this.h, a.cPointer(), (C.int)(from)) return (int)(ret) } func (this *QByteArray) LastIndexOf2(c byte, from int) int { ret := C.QByteArray_LastIndexOf2(this.h, (C.char)(c), (C.int)(from)) return (int)(ret) } func (this *QByteArray) LastIndexOf22(c string, from int) int { c_Cstring := C.CString(c) defer C.free(unsafe.Pointer(c_Cstring)) ret := C.QByteArray_LastIndexOf22(this.h, c_Cstring, (C.int)(from)) return (int)(ret) } func (this *QByteArray) LastIndexOf23(a *QByteArray, from int) int { ret := C.QByteArray_LastIndexOf23(this.h, a.cPointer(), (C.int)(from)) return (int)(ret) } func (this *QByteArray) Mid2(index int, lenVal int) *QByteArray { ret := C.QByteArray_Mid2(this.h, (C.int)(index), (C.int)(lenVal)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) LeftJustified2(width int, fill byte) *QByteArray { ret := C.QByteArray_LeftJustified2(this.h, (C.int)(width), (C.char)(fill)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) LeftJustified3(width int, fill byte, truncate bool) *QByteArray { ret := C.QByteArray_LeftJustified3(this.h, (C.int)(width), (C.char)(fill), (C.bool)(truncate)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) RightJustified2(width int, fill byte) *QByteArray { ret := C.QByteArray_RightJustified2(this.h, (C.int)(width), (C.char)(fill)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) RightJustified3(width int, fill byte, truncate bool) *QByteArray { ret := C.QByteArray_RightJustified3(this.h, (C.int)(width), (C.char)(fill), (C.bool)(truncate)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) IndexOf24(s string, from int) int { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_IndexOf24(this.h, s_Cstring, C.ulong(len(s)), (C.int)(from)) return (int)(ret) } func (this *QByteArray) LastIndexOf24(s string, from int) int { s_Cstring := C.CString(s) defer C.free(unsafe.Pointer(s_Cstring)) ret := C.QByteArray_LastIndexOf24(this.h, s_Cstring, C.ulong(len(s)), (C.int)(from)) return (int)(ret) } func (this *QByteArray) ToShort1(ok *bool) int16 { ret := C.QByteArray_ToShort1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (int16)(ret) } func (this *QByteArray) ToShort2(ok *bool, base int) int16 { ret := C.QByteArray_ToShort2(this.h, (*C.bool)(unsafe.Pointer(ok)), (C.int)(base)) return (int16)(ret) } func (this *QByteArray) ToUShort1(ok *bool) uint16 { ret := C.QByteArray_ToUShort1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (uint16)(ret) } func (this *QByteArray) ToUShort2(ok *bool, base int) uint16 { ret := C.QByteArray_ToUShort2(this.h, (*C.bool)(unsafe.Pointer(ok)), (C.int)(base)) return (uint16)(ret) } func (this *QByteArray) ToInt1(ok *bool) int { ret := C.QByteArray_ToInt1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (int)(ret) } func (this *QByteArray) ToInt2(ok *bool, base int) int { ret := C.QByteArray_ToInt2(this.h, (*C.bool)(unsafe.Pointer(ok)), (C.int)(base)) return (int)(ret) } func (this *QByteArray) ToUInt1(ok *bool) uint { ret := C.QByteArray_ToUInt1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (uint)(ret) } func (this *QByteArray) ToUInt2(ok *bool, base int) uint { ret := C.QByteArray_ToUInt2(this.h, (*C.bool)(unsafe.Pointer(ok)), (C.int)(base)) return (uint)(ret) } func (this *QByteArray) ToLong1(ok *bool) int64 { ret := C.QByteArray_ToLong1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (int64)(ret) } func (this *QByteArray) ToLong2(ok *bool, base int) int64 { ret := C.QByteArray_ToLong2(this.h, (*C.bool)(unsafe.Pointer(ok)), (C.int)(base)) return (int64)(ret) } func (this *QByteArray) ToULong1(ok *bool) uint64 { ret := C.QByteArray_ToULong1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (uint64)(ret) } func (this *QByteArray) ToULong2(ok *bool, base int) uint64 { ret := C.QByteArray_ToULong2(this.h, (*C.bool)(unsafe.Pointer(ok)), (C.int)(base)) return (uint64)(ret) } func (this *QByteArray) ToLongLong1(ok *bool) int64 { ret := C.QByteArray_ToLongLong1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (int64)(ret) } func (this *QByteArray) ToLongLong2(ok *bool, base int) int64 { ret := C.QByteArray_ToLongLong2(this.h, (*C.bool)(unsafe.Pointer(ok)), (C.int)(base)) return (int64)(ret) } func (this *QByteArray) ToULongLong1(ok *bool) uint64 { ret := C.QByteArray_ToULongLong1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (uint64)(ret) } func (this *QByteArray) ToULongLong2(ok *bool, base int) uint64 { ret := C.QByteArray_ToULongLong2(this.h, (*C.bool)(unsafe.Pointer(ok)), (C.int)(base)) return (uint64)(ret) } func (this *QByteArray) ToFloat1(ok *bool) float32 { ret := C.QByteArray_ToFloat1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (float32)(ret) } func (this *QByteArray) ToDouble1(ok *bool) float64 { ret := C.QByteArray_ToDouble1(this.h, (*C.bool)(unsafe.Pointer(ok))) return (float64)(ret) } func (this *QByteArray) ToPercentEncoding1(exclude *QByteArray) *QByteArray { ret := C.QByteArray_ToPercentEncoding1(this.h, exclude.cPointer()) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) ToPercentEncoding2(exclude *QByteArray, include *QByteArray) *QByteArray { ret := C.QByteArray_ToPercentEncoding2(this.h, exclude.cPointer(), include.cPointer()) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) ToPercentEncoding3(exclude *QByteArray, include *QByteArray, percent byte) *QByteArray { ret := C.QByteArray_ToPercentEncoding3(this.h, exclude.cPointer(), include.cPointer(), (C.char)(percent)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) SetNum2(param1 int16, base int) *QByteArray { ret := C.QByteArray_SetNum2(this.h, (C.int16_t)(param1), (C.int)(base)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum22(param1 uint16, base int) *QByteArray { ret := C.QByteArray_SetNum22(this.h, (C.uint16_t)(param1), (C.int)(base)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum23(param1 int, base int) *QByteArray { ret := C.QByteArray_SetNum23(this.h, (C.int)(param1), (C.int)(base)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum24(param1 uint, base int) *QByteArray { ret := C.QByteArray_SetNum24(this.h, (C.uint)(param1), (C.int)(base)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum25(param1 int64, base int) *QByteArray { ret := C.QByteArray_SetNum25(this.h, (C.int64_t)(param1), (C.int)(base)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum26(param1 uint64, base int) *QByteArray { ret := C.QByteArray_SetNum26(this.h, (C.uint64_t)(param1), (C.int)(base)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum27(param1 float32, f byte) *QByteArray { ret := C.QByteArray_SetNum27(this.h, (C.float)(param1), (C.char)(f)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum3(param1 float32, f byte, prec int) *QByteArray { ret := C.QByteArray_SetNum3(this.h, (C.float)(param1), (C.char)(f), (C.int)(prec)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum28(param1 float64, f byte) *QByteArray { ret := C.QByteArray_SetNum28(this.h, (C.double)(param1), (C.char)(f)) return newQByteArray_U(unsafe.Pointer(ret)) } func (this *QByteArray) SetNum32(param1 float64, f byte, prec int) *QByteArray { ret := C.QByteArray_SetNum32(this.h, (C.double)(param1), (C.char)(f), (C.int)(prec)) return newQByteArray_U(unsafe.Pointer(ret)) } func QByteArray_Number2(param1 int, base int) *QByteArray { ret := C.QByteArray_Number2((C.int)(param1), (C.int)(base)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_Number22(param1 uint, base int) *QByteArray { ret := C.QByteArray_Number22((C.uint)(param1), (C.int)(base)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_Number23(param1 int64, base int) *QByteArray { ret := C.QByteArray_Number23((C.int64_t)(param1), (C.int)(base)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_Number24(param1 uint64, base int) *QByteArray { ret := C.QByteArray_Number24((C.uint64_t)(param1), (C.int)(base)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_Number25(param1 float64, f byte) *QByteArray { ret := C.QByteArray_Number25((C.double)(param1), (C.char)(f)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_Number3(param1 float64, f byte, prec int) *QByteArray { ret := C.QByteArray_Number3((C.double)(param1), (C.char)(f), (C.int)(prec)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func QByteArray_FromPercentEncoding2(pctEncoded *QByteArray, percent byte) *QByteArray { ret := C.QByteArray_FromPercentEncoding2(pctEncoded.cPointer(), (C.char)(percent)) // Qt uses pass-by-value semantics for this type. Mimic with finalizer ret1 := newQByteArray(ret) runtime.SetFinalizer(ret1, func(ret2 *QByteArray) { ret2.Delete() runtime.KeepAlive(ret2.h) }) return ret1 } func (this *QByteArray) Delete() { C.QByteArray_Delete(this.h) } type QByteRef struct { h *C.QByteRef } func (this *QByteRef) cPointer() *C.QByteRef { if this == nil { return nil } return this.h } func newQByteRef(h *C.QByteRef) *QByteRef { return &QByteRef{h: h} } func newQByteRef_U(h unsafe.Pointer) *QByteRef { return newQByteRef((*C.QByteRef)(h)) } // NewQByteRef constructs a new QByteRef object. func NewQByteRef(param1 *QByteRef) *QByteRef { ret := C.QByteRef_new(param1.cPointer()) return newQByteRef(ret) } func (this *QByteRef) OperatorAssign(c byte) { C.QByteRef_OperatorAssign(this.h, (C.char)(c)) } func (this *QByteRef) OperatorAssignWithQByteRef(c *QByteRef) { C.QByteRef_OperatorAssignWithQByteRef(this.h, c.cPointer()) } func (this *QByteRef) OperatorEqual(c byte) bool { ret := C.QByteRef_OperatorEqual(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteRef) OperatorNotEqual(c byte) bool { ret := C.QByteRef_OperatorNotEqual(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteRef) OperatorGreater(c byte) bool { ret := C.QByteRef_OperatorGreater(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteRef) OperatorGreaterOrEqual(c byte) bool { ret := C.QByteRef_OperatorGreaterOrEqual(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteRef) OperatorLesser(c byte) bool { ret := C.QByteRef_OperatorLesser(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteRef) OperatorLesserOrEqual(c byte) bool { ret := C.QByteRef_OperatorLesserOrEqual(this.h, (C.char)(c)) return (bool)(ret) } func (this *QByteRef) Delete() { C.QByteRef_Delete(this.h) }