code.ivysaur.me/miqt
1
0
Fork 0
mirror of https://github.com/mappu/miqt.git synced 2025-04-02 11:50:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #82 from rcalixte/qt6_cbor

Browse Source 
Modify qt6/cbor for proper builds
This commit is contained in:
mappu 2024-11-19 08:00:10 +13:00 committed by GitHub
commit 30c6cb4f07
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 1004 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/genbindings/config-libraries.go
View File

@ -147,7 +147,7 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
generate( generate(
"qt6/cbor", "qt6/cbor",
[]string{ []string{
"/usr/include/x86_64-linux-gnu/qt5/QtCore", "/usr/include/x86_64-linux-gnu/qt6/QtCore",
}, },
func(fullpath string) bool { func(fullpath string) bool {
// Only include the same json, xml, cbor files excluded above // Only include the same json, xml, cbor files excluded above
@ -155,7 +155,7 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
return strings.HasPrefix(fname, "qcbor") return strings.HasPrefix(fname, "qcbor")
}, },
clangBin, clangBin,
pkgConfigCflags("Qt6Core"), "--std=c++20 "+pkgConfigCflags("Qt6Core"),
outDir, outDir,
ClangMatchSameHeaderDefinitionOnly, ClangMatchSameHeaderDefinitionOnly,
) )

21
qt6/cbor/gen_qcborarray.cpp
View File

@ -2,6 +2,7 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__ConstIterator #define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__ConstIterator
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__Iterator #define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__Iterator
#include <QCborValue> #include <QCborValue>
#include <QCborValueConstRef>
#include <QCborValueRef> #include <QCborValueRef>
#include <QJsonArray> #include <QJsonArray>
#include <QList> #include <QList>
@ -260,11 +261,15 @@ QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator*
return new QCborValueRef(self->operator*()); return new QCborValueRef(self->operator*());
} }
QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Iterator* self) { QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(QCborArray__Iterator* self) {
return self->operator->(); return self->operator->();
} }
QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, ptrdiff_t j) { QCborValueConstRef* QCborArray__Iterator_OperatorMinusGreater2(const QCborArray__Iterator* self) {
return (QCborValueConstRef*) self->operator->();
}
QCborValueRef* QCborArray__Iterator_OperatorSubscript(const QCborArray__Iterator* self, ptrdiff_t j) {
return new QCborValueRef(self->operator[]((qsizetype)(j))); return new QCborValueRef(self->operator[]((qsizetype)(j)));
} }
@ -377,16 +382,16 @@ void QCborArray__ConstIterator_OperatorAssign(QCborArray__ConstIterator* self, Q
self->operator=(*other); self->operator=(*other);
} }
QCborValueRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self) { QCborValueConstRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self) {
return new QCborValueRef(self->operator*()); return new QCborValueConstRef(self->operator*());
} }
QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self) { QCborValueConstRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self) {
return (QCborValueRef*) self->operator->(); return (QCborValueConstRef*) self->operator->();
} }
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j) { QCborValueConstRef* QCborArray__ConstIterator_OperatorSubscript(const QCborArray__ConstIterator* self, ptrdiff_t j) {
return new QCborValueRef(self->operator[]((qsizetype)(j))); return new QCborValueConstRef(self->operator[]((qsizetype)(j)));
} }
bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o) { bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o) {

16
qt6/cbor/gen_qcborarray.go
View File

@ -430,6 +430,10 @@ func (this *QCborArray__Iterator) OperatorMinusGreater() *QCborValueRef {
return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusGreater(this.h))) return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusGreater(this.h)))
} }
func (this *QCborArray__Iterator) OperatorMinusGreater2() *QCborValueConstRef {
return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborArray__Iterator_OperatorMinusGreater2(this.h)))
}
func (this *QCborArray__Iterator) OperatorSubscript(j int64) *QCborValueRef { func (this *QCborArray__Iterator) OperatorSubscript(j int64) *QCborValueRef {
_ret := C.QCborArray__Iterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j)) _ret := C.QCborArray__Iterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
_goptr := newQCborValueRef(_ret) _goptr := newQCborValueRef(_ret)
@ -592,20 +596,20 @@ func (this *QCborArray__ConstIterator) OperatorAssign(other *QCborArray__ConstIt
C.QCborArray__ConstIterator_OperatorAssign(this.h, other.cPointer()) C.QCborArray__ConstIterator_OperatorAssign(this.h, other.cPointer())
} }
func (this *QCborArray__ConstIterator) OperatorMultiply() *QCborValueRef { func (this *QCborArray__ConstIterator) OperatorMultiply() *QCborValueConstRef {
_ret := C.QCborArray__ConstIterator_OperatorMultiply(this.h) _ret := C.QCborArray__ConstIterator_OperatorMultiply(this.h)
_goptr := newQCborValueRef(_ret) _goptr := newQCborValueConstRef(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr return _goptr
} }
func (this *QCborArray__ConstIterator) OperatorMinusGreater() *QCborValueRef { func (this *QCborArray__ConstIterator) OperatorMinusGreater() *QCborValueConstRef {
return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusGreater(this.h))) return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusGreater(this.h)))
} }
func (this *QCborArray__ConstIterator) OperatorSubscript(j int64) *QCborValueRef { func (this *QCborArray__ConstIterator) OperatorSubscript(j int64) *QCborValueConstRef {
_ret := C.QCborArray__ConstIterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j)) _ret := C.QCborArray__ConstIterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
_goptr := newQCborValueRef(_ret) _goptr := newQCborValueConstRef(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr return _goptr
} }

13
qt6/cbor/gen_qcborarray.h
View File

@ -27,6 +27,7 @@ typedef QCborArray::Iterator QCborArray__Iterator;
class QCborArray__Iterator; class QCborArray__Iterator;
#endif #endif
class QCborValue; class QCborValue;
class QCborValueConstRef;
class QCborValueRef; class QCborValueRef;
class QJsonArray; class QJsonArray;
#else #else
@ -34,6 +35,7 @@ typedef struct QCborArray QCborArray;
typedef struct QCborArray__ConstIterator QCborArray__ConstIterator; typedef struct QCborArray__ConstIterator QCborArray__ConstIterator;
typedef struct QCborArray__Iterator QCborArray__Iterator; typedef struct QCborArray__Iterator QCborArray__Iterator;
typedef struct QCborValue QCborValue; typedef struct QCborValue QCborValue;
typedef struct QCborValueConstRef QCborValueConstRef;
typedef struct QCborValueRef QCborValueRef; typedef struct QCborValueRef QCborValueRef;
typedef struct QJsonArray QJsonArray; typedef struct QJsonArray QJsonArray;
#endif #endif
@ -98,8 +100,9 @@ QCborArray__Iterator* QCborArray__Iterator_new();
QCborArray__Iterator* QCborArray__Iterator_new2(QCborArray__Iterator* param1); QCborArray__Iterator* QCborArray__Iterator_new2(QCborArray__Iterator* param1);
void QCborArray__Iterator_OperatorAssign(QCborArray__Iterator* self, QCborArray__Iterator* other); void QCborArray__Iterator_OperatorAssign(QCborArray__Iterator* self, QCborArray__Iterator* other);
QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator* self); QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator* self);
QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Iterator* self); QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(QCborArray__Iterator* self);
QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, ptrdiff_t j); QCborValueConstRef* QCborArray__Iterator_OperatorMinusGreater2(const QCborArray__Iterator* self);
QCborValueRef* QCborArray__Iterator_OperatorSubscript(const QCborArray__Iterator* self, ptrdiff_t j);
bool QCborArray__Iterator_OperatorEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o); 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_OperatorNotEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o);
bool QCborArray__Iterator_OperatorLesser(const QCborArray__Iterator* self, QCborArray__Iterator* other); bool QCborArray__Iterator_OperatorLesser(const QCborArray__Iterator* self, QCborArray__Iterator* other);
@ -126,9 +129,9 @@ void QCborArray__Iterator_Delete(QCborArray__Iterator* self);
QCborArray__ConstIterator* QCborArray__ConstIterator_new(); QCborArray__ConstIterator* QCborArray__ConstIterator_new();
QCborArray__ConstIterator* QCborArray__ConstIterator_new2(QCborArray__ConstIterator* param1); QCborArray__ConstIterator* QCborArray__ConstIterator_new2(QCborArray__ConstIterator* param1);
void QCborArray__ConstIterator_OperatorAssign(QCborArray__ConstIterator* self, QCborArray__ConstIterator* other); void QCborArray__ConstIterator_OperatorAssign(QCborArray__ConstIterator* self, QCborArray__ConstIterator* other);
QCborValueRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self); QCborValueConstRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self);
QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self); QCborValueConstRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self);
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j); QCborValueConstRef* QCborArray__ConstIterator_OperatorSubscript(const QCborArray__ConstIterator* self, ptrdiff_t j);
bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o); 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_OperatorNotEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o);
bool QCborArray__ConstIterator_OperatorLesser(const QCborArray__ConstIterator* self, QCborArray__Iterator* other); bool QCborArray__ConstIterator_OperatorLesser(const QCborArray__ConstIterator* self, QCborArray__Iterator* other);

61
qt6/cbor/gen_qcbormap.cpp
View File

@ -2,6 +2,7 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborMap__ConstIterator #define WORKAROUND_INNER_CLASS_DEFINITION_QCborMap__ConstIterator
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborMap__Iterator #define WORKAROUND_INNER_CLASS_DEFINITION_QCborMap__Iterator
#include <QCborValue> #include <QCborValue>
#include <QCborValueConstRef>
#include <QCborValueRef> #include <QCborValueRef>
#include <QJsonObject> #include <QJsonObject>
#include <QList> #include <QList>
@ -48,7 +49,7 @@ void QCborMap_Clear(QCborMap* self) {
} }
struct miqt_array /* of QCborValue* */ QCborMap_Keys(const QCborMap* self) { struct miqt_array /* of QCborValue* */ QCborMap_Keys(const QCborMap* self) {
QVector<QCborValue> _ret = self->keys(); QList<QCborValue> _ret = self->keys();
// Convert QList<> from C++ memory to manually-managed C memory // Convert QList<> from C++ memory to manually-managed C memory
QCborValue** _arr = static_cast<QCborValue**>(malloc(sizeof(QCborValue*) * _ret.length())); QCborValue** _arr = static_cast<QCborValue**>(malloc(sizeof(QCborValue*) * _ret.length()));
for (size_t i = 0, e = _ret.length(); i < e; ++i) { for (size_t i = 0, e = _ret.length(); i < e; ++i) {
@ -364,12 +365,12 @@ void QCborMap__Iterator_OperatorAssign(QCborMap__Iterator* self, QCborMap__Itera
self->operator=(*other); self->operator=(*other);
} }
struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */ QCborMap__Iterator_OperatorMultiply(const QCborMap__Iterator* self) { struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */ QCborMap__Iterator_OperatorMultiply(const QCborMap__Iterator* self) {
QCborMap::Iterator::value_type _ret = self->operator*(); QCborMap::Iterator::value_type _ret = self->operator*();
// Convert QPair<> from C++ memory to manually-managed C memory // Convert QPair<> from C++ memory to manually-managed C memory
QCborValueRef** _first_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*))); QCborValueConstRef** _first_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
QCborValueRef** _second_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*))); QCborValueRef** _second_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
_first_arr[0] = new QCborValueRef(_ret.first); _first_arr[0] = new QCborValueConstRef(_ret.first);
_second_arr[0] = new QCborValueRef(_ret.second); _second_arr[0] = new QCborValueRef(_ret.second);
struct miqt_map _out; struct miqt_map _out;
_out.len = 1; _out.len = 1;
@ -378,10 +379,28 @@ struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */ QCborMap__Iter
return _out; return _out;
} }
QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(const QCborMap__Iterator* self) { struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */ QCborMap__Iterator_OperatorSubscript(const QCborMap__Iterator* self, ptrdiff_t j) {
QCborMap::Iterator::value_type _ret = self->operator[]((qsizetype)(j));
// Convert QPair<> from C++ memory to manually-managed C memory
QCborValueConstRef** _first_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
QCborValueRef** _second_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
_first_arr[0] = new QCborValueConstRef(_ret.first);
_second_arr[0] = new QCborValueRef(_ret.second);
struct miqt_map _out;
_out.len = 1;
_out.keys = static_cast<void*>(_first_arr);
_out.values = static_cast<void*>(_second_arr);
return _out;
}
QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(QCborMap__Iterator* self) {
return self->operator->(); return self->operator->();
} }
QCborValueConstRef* QCborMap__Iterator_OperatorMinusGreater2(const QCborMap__Iterator* self) {
return (QCborValueConstRef*) self->operator->();
}
QCborValue* QCborMap__Iterator_Key(const QCborMap__Iterator* self) { QCborValue* QCborMap__Iterator_Key(const QCborMap__Iterator* self) {
return new QCborValue(self->key()); return new QCborValue(self->key());
} }
@ -499,13 +518,13 @@ void QCborMap__ConstIterator_OperatorAssign(QCborMap__ConstIterator* self, QCbor
self->operator=(*other); self->operator=(*other);
} }
struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */ QCborMap__ConstIterator_OperatorMultiply(const QCborMap__ConstIterator* self) { struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCborMap__ConstIterator_OperatorMultiply(const QCborMap__ConstIterator* self) {
QCborMap::ConstIterator::value_type _ret = self->operator*(); QCborMap::ConstIterator::value_type _ret = self->operator*();
// Convert QPair<> from C++ memory to manually-managed C memory // Convert QPair<> from C++ memory to manually-managed C memory
QCborValueRef** _first_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*))); QCborValueConstRef** _first_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
QCborValueRef** _second_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*))); QCborValueConstRef** _second_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
_first_arr[0] = new QCborValueRef(_ret.first); _first_arr[0] = new QCborValueConstRef(_ret.first);
_second_arr[0] = new QCborValueRef(_ret.second); _second_arr[0] = new QCborValueConstRef(_ret.second);
struct miqt_map _out; struct miqt_map _out;
_out.len = 1; _out.len = 1;
_out.keys = static_cast<void*>(_first_arr); _out.keys = static_cast<void*>(_first_arr);
@ -513,16 +532,30 @@ struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */ QCborMap__Cons
return _out; return _out;
} }
QCborValueRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self) { struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCborMap__ConstIterator_OperatorSubscript(const QCborMap__ConstIterator* self, ptrdiff_t j) {
return (QCborValueRef*) self->operator->(); QCborMap::ConstIterator::value_type _ret = self->operator[]((qsizetype)(j));
// Convert QPair<> from C++ memory to manually-managed C memory
QCborValueConstRef** _first_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
QCborValueConstRef** _second_arr = static_cast<QCborValueConstRef**>(malloc(sizeof(QCborValueConstRef*)));
_first_arr[0] = new QCborValueConstRef(_ret.first);
_second_arr[0] = new QCborValueConstRef(_ret.second);
struct miqt_map _out;
_out.len = 1;
_out.keys = static_cast<void*>(_first_arr);
_out.values = static_cast<void*>(_second_arr);
return _out;
}
QCborValueConstRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self) {
return (QCborValueConstRef*) self->operator->();
} }
QCborValue* QCborMap__ConstIterator_Key(const QCborMap__ConstIterator* self) { QCborValue* QCborMap__ConstIterator_Key(const QCborMap__ConstIterator* self) {
return new QCborValue(self->key()); return new QCborValue(self->key());
} }
QCborValueRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self) { QCborValueConstRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self) {
return new QCborValueRef(self->value()); return new QCborValueConstRef(self->value());
} }
bool QCborMap__ConstIterator_OperatorEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o) { bool QCborMap__ConstIterator_OperatorEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o) {

90
qt6/cbor/gen_qcbormap.go
View File

@ -87,10 +87,10 @@ func (this *QCborMap) Keys() []QCborValue {
_ret := make([]QCborValue, int(_ma.len)) _ret := make([]QCborValue, int(_ma.len))
_outCast := (*[0xffff]*C.QCborValue)(unsafe.Pointer(_ma.data)) // hey ya _outCast := (*[0xffff]*C.QCborValue)(unsafe.Pointer(_ma.data)) // hey ya
for i := 0; i < int(_ma.len); i++ { for i := 0; i < int(_ma.len); i++ {
_vv_ret := _outCast[i] _lv_ret := _outCast[i]
_vv_goptr := newQCborValue(_vv_ret) _lv_goptr := newQCborValue(_lv_ret)
_vv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_ret[i] = *_vv_goptr _ret[i] = *_lv_goptr
} }
return _ret return _ret
} }
@ -618,14 +618,14 @@ func (this *QCborMap__Iterator) OperatorAssign(other *QCborMap__Iterator) {
} }
func (this *QCborMap__Iterator) OperatorMultiply() struct { func (this *QCborMap__Iterator) OperatorMultiply() struct {
First QCborValueRef First QCborValueConstRef
Second QCborValueRef Second QCborValueRef
} { } {
var _mm C.struct_miqt_map = C.QCborMap__Iterator_OperatorMultiply(this.h) var _mm C.struct_miqt_map = C.QCborMap__Iterator_OperatorMultiply(this.h)
_First_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.keys)) _First_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.keys))
_Second_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.values)) _Second_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.values))
_first_ret := _First_CArray[0] _first_ret := _First_CArray[0]
_first_goptr := newQCborValueRef(_first_ret) _first_goptr := newQCborValueConstRef(_first_ret)
_first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_entry_First := *_first_goptr _entry_First := *_first_goptr
@ -635,7 +635,30 @@ func (this *QCborMap__Iterator) OperatorMultiply() struct {
_entry_Second := *_second_goptr _entry_Second := *_second_goptr
return struct { return struct {
First QCborValueRef First QCborValueConstRef
Second QCborValueRef
}{First: _entry_First, Second: _entry_Second}
}
func (this *QCborMap__Iterator) OperatorSubscript(j int64) struct {
First QCborValueConstRef
Second QCborValueRef
} {
var _mm C.struct_miqt_map = C.QCborMap__Iterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
_First_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.keys))
_Second_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.values))
_first_ret := _First_CArray[0]
_first_goptr := newQCborValueConstRef(_first_ret)
_first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_entry_First := *_first_goptr
_second_ret := _Second_CArray[0]
_second_goptr := newQCborValueRef(_second_ret)
_second_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_entry_Second := *_second_goptr
return struct {
First QCborValueConstRef
Second QCborValueRef Second QCborValueRef
}{First: _entry_First, Second: _entry_Second} }{First: _entry_First, Second: _entry_Second}
} }
@ -644,6 +667,10 @@ func (this *QCborMap__Iterator) OperatorMinusGreater() *QCborValueRef {
return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusGreater(this.h))) return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusGreater(this.h)))
} }
func (this *QCborMap__Iterator) OperatorMinusGreater2() *QCborValueConstRef {
return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusGreater2(this.h)))
}
func (this *QCborMap__Iterator) Key() *QCborValue { func (this *QCborMap__Iterator) Key() *QCborValue {
_ret := C.QCborMap__Iterator_Key(this.h) _ret := C.QCborMap__Iterator_Key(this.h)
_goptr := newQCborValue(_ret) _goptr := newQCborValue(_ret)
@ -814,30 +841,53 @@ func (this *QCborMap__ConstIterator) OperatorAssign(other *QCborMap__ConstIterat
} }
func (this *QCborMap__ConstIterator) OperatorMultiply() struct { func (this *QCborMap__ConstIterator) OperatorMultiply() struct {
First QCborValueRef First QCborValueConstRef
Second QCborValueRef Second QCborValueConstRef
} { } {
var _mm C.struct_miqt_map = C.QCborMap__ConstIterator_OperatorMultiply(this.h) var _mm C.struct_miqt_map = C.QCborMap__ConstIterator_OperatorMultiply(this.h)
_First_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.keys)) _First_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.keys))
_Second_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.values)) _Second_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.values))
_first_ret := _First_CArray[0] _first_ret := _First_CArray[0]
_first_goptr := newQCborValueRef(_first_ret) _first_goptr := newQCborValueConstRef(_first_ret)
_first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_entry_First := *_first_goptr _entry_First := *_first_goptr
_second_ret := _Second_CArray[0] _second_ret := _Second_CArray[0]
_second_goptr := newQCborValueRef(_second_ret) _second_goptr := newQCborValueConstRef(_second_ret)
_second_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _second_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_entry_Second := *_second_goptr _entry_Second := *_second_goptr
return struct { return struct {
First QCborValueRef First QCborValueConstRef
Second QCborValueRef Second QCborValueConstRef
}{First: _entry_First, Second: _entry_Second} }{First: _entry_First, Second: _entry_Second}
} }
func (this *QCborMap__ConstIterator) OperatorMinusGreater() *QCborValueRef { func (this *QCborMap__ConstIterator) OperatorSubscript(j int64) struct {
return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusGreater(this.h))) First QCborValueConstRef
Second QCborValueConstRef
} {
var _mm C.struct_miqt_map = C.QCborMap__ConstIterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
_First_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.keys))
_Second_CArray := (*[0xffff]*C.QCborValueConstRef)(unsafe.Pointer(_mm.values))
_first_ret := _First_CArray[0]
_first_goptr := newQCborValueConstRef(_first_ret)
_first_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_entry_First := *_first_goptr
_second_ret := _Second_CArray[0]
_second_goptr := newQCborValueConstRef(_second_ret)
_second_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_entry_Second := *_second_goptr
return struct {
First QCborValueConstRef
Second QCborValueConstRef
}{First: _entry_First, Second: _entry_Second}
}
func (this *QCborMap__ConstIterator) OperatorMinusGreater() *QCborValueConstRef {
return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusGreater(this.h)))
} }
func (this *QCborMap__ConstIterator) Key() *QCborValue { func (this *QCborMap__ConstIterator) Key() *QCborValue {
@ -847,9 +897,9 @@ func (this *QCborMap__ConstIterator) Key() *QCborValue {
return _goptr return _goptr
} }
func (this *QCborMap__ConstIterator) Value() *QCborValueRef { func (this *QCborMap__ConstIterator) Value() *QCborValueConstRef {
_ret := C.QCborMap__ConstIterator_Value(this.h) _ret := C.QCborMap__ConstIterator_Value(this.h)
_goptr := newQCborValueRef(_ret) _goptr := newQCborValueConstRef(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr return _goptr
} }

15
qt6/cbor/gen_qcbormap.h
View File

@ -27,6 +27,7 @@ typedef QCborMap::Iterator QCborMap__Iterator;
class QCborMap__Iterator; class QCborMap__Iterator;
#endif #endif
class QCborValue; class QCborValue;
class QCborValueConstRef;
class QCborValueRef; class QCborValueRef;
class QJsonObject; class QJsonObject;
class QVariant; class QVariant;
@ -35,6 +36,7 @@ typedef struct QCborMap QCborMap;
typedef struct QCborMap__ConstIterator QCborMap__ConstIterator; typedef struct QCborMap__ConstIterator QCborMap__ConstIterator;
typedef struct QCborMap__Iterator QCborMap__Iterator; typedef struct QCborMap__Iterator QCborMap__Iterator;
typedef struct QCborValue QCborValue; typedef struct QCborValue QCborValue;
typedef struct QCborValueConstRef QCborValueConstRef;
typedef struct QCborValueRef QCborValueRef; typedef struct QCborValueRef QCborValueRef;
typedef struct QJsonObject QJsonObject; typedef struct QJsonObject QJsonObject;
typedef struct QVariant QVariant; typedef struct QVariant QVariant;
@ -108,8 +110,10 @@ void QCborMap_Delete(QCborMap* self);
QCborMap__Iterator* QCborMap__Iterator_new(); QCborMap__Iterator* QCborMap__Iterator_new();
QCborMap__Iterator* QCborMap__Iterator_new2(QCborMap__Iterator* param1); QCborMap__Iterator* QCborMap__Iterator_new2(QCborMap__Iterator* param1);
void QCborMap__Iterator_OperatorAssign(QCborMap__Iterator* self, QCborMap__Iterator* other); void QCborMap__Iterator_OperatorAssign(QCborMap__Iterator* self, QCborMap__Iterator* other);
struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */ QCborMap__Iterator_OperatorMultiply(const QCborMap__Iterator* self); struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */ QCborMap__Iterator_OperatorMultiply(const QCborMap__Iterator* self);
QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(const QCborMap__Iterator* self); struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */ QCborMap__Iterator_OperatorSubscript(const QCborMap__Iterator* self, ptrdiff_t j);
QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(QCborMap__Iterator* self);
QCborValueConstRef* QCborMap__Iterator_OperatorMinusGreater2(const QCborMap__Iterator* self);
QCborValue* QCborMap__Iterator_Key(const QCborMap__Iterator* self); QCborValue* QCborMap__Iterator_Key(const QCborMap__Iterator* self);
QCborValueRef* QCborMap__Iterator_Value(const QCborMap__Iterator* self); QCborValueRef* QCborMap__Iterator_Value(const QCborMap__Iterator* self);
bool QCborMap__Iterator_OperatorEqual(const QCborMap__Iterator* self, QCborMap__Iterator* o); bool QCborMap__Iterator_OperatorEqual(const QCborMap__Iterator* self, QCborMap__Iterator* o);
@ -138,10 +142,11 @@ void QCborMap__Iterator_Delete(QCborMap__Iterator* self);
QCborMap__ConstIterator* QCborMap__ConstIterator_new(); QCborMap__ConstIterator* QCborMap__ConstIterator_new();
QCborMap__ConstIterator* QCborMap__ConstIterator_new2(QCborMap__ConstIterator* param1); QCborMap__ConstIterator* QCborMap__ConstIterator_new2(QCborMap__ConstIterator* param1);
void QCborMap__ConstIterator_OperatorAssign(QCborMap__ConstIterator* self, QCborMap__ConstIterator* other); void QCborMap__ConstIterator_OperatorAssign(QCborMap__ConstIterator* self, QCborMap__ConstIterator* other);
struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */ QCborMap__ConstIterator_OperatorMultiply(const QCborMap__ConstIterator* self); struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCborMap__ConstIterator_OperatorMultiply(const QCborMap__ConstIterator* self);
QCborValueRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self); struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCborMap__ConstIterator_OperatorSubscript(const QCborMap__ConstIterator* self, ptrdiff_t j);
QCborValueConstRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self);
QCborValue* QCborMap__ConstIterator_Key(const QCborMap__ConstIterator* self); QCborValue* QCborMap__ConstIterator_Key(const QCborMap__ConstIterator* self);
QCborValueRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self); QCborValueConstRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self);
bool QCborMap__ConstIterator_OperatorEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o); bool QCborMap__ConstIterator_OperatorEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o);
bool QCborMap__ConstIterator_OperatorNotEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o); bool QCborMap__ConstIterator_OperatorNotEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o);
bool QCborMap__ConstIterator_OperatorLesser(const QCborMap__ConstIterator* self, QCborMap__Iterator* other); bool QCborMap__ConstIterator_OperatorLesser(const QCborMap__ConstIterator* self, QCborMap__Iterator* other);

359
qt6/cbor/gen_qcborvalue.cpp
View File

@ -5,6 +5,7 @@
#include <QCborStreamReader> #include <QCborStreamReader>
#include <QCborStreamWriter> #include <QCborStreamWriter>
#include <QCborValue> #include <QCborValue>
#include <QCborValueConstRef>
#include <QCborValueRef> #include <QCborValueRef>
#include <QDateTime> #include <QDateTime>
#include <QJsonValue> #include <QJsonValue>
@ -363,7 +364,7 @@ QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal) {
return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal))); return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal)));
} }
struct miqt_string QCborValue_ToCbor(QCborValue* self) { struct miqt_string QCborValue_ToCbor(const QCborValue* self) {
QByteArray _qb = self->toCbor(); QByteArray _qb = self->toCbor();
struct miqt_string _ms; struct miqt_string _ms;
_ms.len = _qb.length(); _ms.len = _qb.length();
@ -372,7 +373,7 @@ struct miqt_string QCborValue_ToCbor(QCborValue* self) {
return _ms; return _ms;
} }
void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer) { void QCborValue_ToCborWithWriter(const QCborValue* self, QCborStreamWriter* writer) {
self->toCbor(*writer); self->toCbor(*writer);
} }
@ -465,7 +466,7 @@ QCborValue* QCborValue_FromCbor33(const unsigned char* data, ptrdiff_t lenVal, Q
return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal), error)); return new QCborValue(QCborValue::fromCbor(static_cast<const quint8*>(data), (qsizetype)(lenVal), error));
} }
struct miqt_string QCborValue_ToCbor1(QCborValue* self, int opt) { struct miqt_string QCborValue_ToCbor1(const QCborValue* self, int opt) {
QByteArray _qb = self->toCbor(static_cast<QCborValue::EncodingOptions>(opt)); QByteArray _qb = self->toCbor(static_cast<QCborValue::EncodingOptions>(opt));
struct miqt_string _ms; struct miqt_string _ms;
_ms.len = _qb.length(); _ms.len = _qb.length();
@ -474,7 +475,7 @@ struct miqt_string QCborValue_ToCbor1(QCborValue* self, int opt) {
return _ms; return _ms;
} }
void QCborValue_ToCbor2(QCborValue* self, QCborStreamWriter* writer, int opt) { void QCborValue_ToCbor2(const QCborValue* self, QCborStreamWriter* writer, int opt) {
self->toCbor(*writer, static_cast<QCborValue::EncodingOptions>(opt)); self->toCbor(*writer, static_cast<QCborValue::EncodingOptions>(opt));
} }
@ -493,6 +494,324 @@ void QCborValue_Delete(QCborValue* self) {
delete self; delete self;
} }
QCborValueConstRef* QCborValueConstRef_new(QCborValueConstRef* param1) {
return new QCborValueConstRef(*param1);
}
int QCborValueConstRef_Type(const QCborValueConstRef* self) {
QCborValue::Type _ret = self->type();
return static_cast<int>(_ret);
}
bool QCborValueConstRef_IsInteger(const QCborValueConstRef* self) {
return self->isInteger();
}
bool QCborValueConstRef_IsByteArray(const QCborValueConstRef* self) {
return self->isByteArray();
}
bool QCborValueConstRef_IsString(const QCborValueConstRef* self) {
return self->isString();
}
bool QCborValueConstRef_IsArray(const QCborValueConstRef* self) {
return self->isArray();
}
bool QCborValueConstRef_IsMap(const QCborValueConstRef* self) {
return self->isMap();
}
bool QCborValueConstRef_IsTag(const QCborValueConstRef* self) {
return self->isTag();
}
bool QCborValueConstRef_IsFalse(const QCborValueConstRef* self) {
return self->isFalse();
}
bool QCborValueConstRef_IsTrue(const QCborValueConstRef* self) {
return self->isTrue();
}
bool QCborValueConstRef_IsBool(const QCborValueConstRef* self) {
return self->isBool();
}
bool QCborValueConstRef_IsNull(const QCborValueConstRef* self) {
return self->isNull();
}
bool QCborValueConstRef_IsUndefined(const QCborValueConstRef* self) {
return self->isUndefined();
}
bool QCborValueConstRef_IsDouble(const QCborValueConstRef* self) {
return self->isDouble();
}
bool QCborValueConstRef_IsDateTime(const QCborValueConstRef* self) {
return self->isDateTime();
}
bool QCborValueConstRef_IsUrl(const QCborValueConstRef* self) {
return self->isUrl();
}
bool QCborValueConstRef_IsRegularExpression(const QCborValueConstRef* self) {
return self->isRegularExpression();
}
bool QCborValueConstRef_IsUuid(const QCborValueConstRef* self) {
return self->isUuid();
}
bool QCborValueConstRef_IsInvalid(const QCborValueConstRef* self) {
return self->isInvalid();
}
bool QCborValueConstRef_IsContainer(const QCborValueConstRef* self) {
return self->isContainer();
}
bool QCborValueConstRef_IsSimpleType(const QCborValueConstRef* self) {
return self->isSimpleType();
}
bool QCborValueConstRef_IsSimpleTypeWithSt(const QCborValueConstRef* self, uint8_t st) {
return self->isSimpleType(static_cast<QCborSimpleType>(st));
}
uint8_t QCborValueConstRef_ToSimpleType(const QCborValueConstRef* self) {
QCborSimpleType _ret = self->toSimpleType();
return static_cast<uint8_t>(_ret);
}
uint64_t QCborValueConstRef_Tag(const QCborValueConstRef* self) {
QCborTag _ret = self->tag();
return static_cast<uint64_t>(_ret);
}
QCborValue* QCborValueConstRef_TaggedValue(const QCborValueConstRef* self) {
return new QCborValue(self->taggedValue());
}
long long QCborValueConstRef_ToInteger(const QCborValueConstRef* self) {
qint64 _ret = self->toInteger();
return static_cast<long long>(_ret);
}
bool QCborValueConstRef_ToBool(const QCborValueConstRef* self) {
return self->toBool();
}
double QCborValueConstRef_ToDouble(const QCborValueConstRef* self) {
return self->toDouble();
}
struct miqt_string QCborValueConstRef_ToByteArray(const QCborValueConstRef* self) {
QByteArray _qb = self->toByteArray();
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
struct miqt_string QCborValueConstRef_ToString(const QCborValueConstRef* self) {
QString _ret = self->toString();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
QDateTime* QCborValueConstRef_ToDateTime(const QCborValueConstRef* self) {
return new QDateTime(self->toDateTime());
}
QUrl* QCborValueConstRef_ToUrl(const QCborValueConstRef* self) {
return new QUrl(self->toUrl());
}
QRegularExpression* QCborValueConstRef_ToRegularExpression(const QCborValueConstRef* self) {
return new QRegularExpression(self->toRegularExpression());
}
QUuid* QCborValueConstRef_ToUuid(const QCborValueConstRef* self) {
return new QUuid(self->toUuid());
}
QCborArray* QCborValueConstRef_ToArray(const QCborValueConstRef* self) {
return new QCborArray(self->toArray());
}
QCborArray* QCborValueConstRef_ToArrayWithQCborArray(const QCborValueConstRef* self, QCborArray* a) {
return new QCborArray(self->toArray(*a));
}
QCborMap* QCborValueConstRef_ToMap(const QCborValueConstRef* self) {
return new QCborMap(self->toMap());
}
QCborMap* QCborValueConstRef_ToMapWithQCborMap(const QCborValueConstRef* self, QCborMap* m) {
return new QCborMap(self->toMap(*m));
}
QCborValue* QCborValueConstRef_OperatorSubscript(const QCborValueConstRef* self, struct miqt_string key) {
QString key_QString = QString::fromUtf8(key.data, key.len);
return new QCborValue(self->operator[](key_QString));
}
QCborValue* QCborValueConstRef_OperatorSubscript2(const QCborValueConstRef* self, long long key) {
return new QCborValue(self->operator[](static_cast<qint64>(key)));
}
int QCborValueConstRef_Compare(const QCborValueConstRef* self, QCborValue* other) {
return self->compare(*other);
}
bool QCborValueConstRef_OperatorEqual(const QCborValueConstRef* self, QCborValue* other) {
return self->operator==(*other);
}
bool QCborValueConstRef_OperatorNotEqual(const QCborValueConstRef* self, QCborValue* other) {
return self->operator!=(*other);
}
bool QCborValueConstRef_OperatorLesser(const QCborValueConstRef* self, QCborValue* other) {
return self->operator<(*other);
}
QVariant* QCborValueConstRef_ToVariant(const QCborValueConstRef* self) {
return new QVariant(self->toVariant());
}
QJsonValue* QCborValueConstRef_ToJsonValue(const QCborValueConstRef* self) {
return new QJsonValue(self->toJsonValue());
}
struct miqt_string QCborValueConstRef_ToCbor(const QCborValueConstRef* self) {
QByteArray _qb = self->toCbor();
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
void QCborValueConstRef_ToCborWithWriter(const QCborValueConstRef* self, QCborStreamWriter* writer) {
self->toCbor(*writer);
}
struct miqt_string QCborValueConstRef_ToDiagnosticNotation(const QCborValueConstRef* self) {
QString _ret = self->toDiagnosticNotation();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
uint8_t QCborValueConstRef_ToSimpleType1(const QCborValueConstRef* self, uint8_t defaultValue) {
QCborSimpleType _ret = self->toSimpleType(static_cast<QCborSimpleType>(defaultValue));
return static_cast<uint8_t>(_ret);
}
uint64_t QCborValueConstRef_Tag1(const QCborValueConstRef* self, uint64_t defaultValue) {
QCborTag _ret = self->tag(static_cast<QCborTag>(defaultValue));
return static_cast<uint64_t>(_ret);
}
QCborValue* QCborValueConstRef_TaggedValue1(const QCborValueConstRef* self, QCborValue* defaultValue) {
return new QCborValue(self->taggedValue(*defaultValue));
}
long long QCborValueConstRef_ToInteger1(const QCborValueConstRef* self, long long defaultValue) {
qint64 _ret = self->toInteger(static_cast<qint64>(defaultValue));
return static_cast<long long>(_ret);
}
bool QCborValueConstRef_ToBool1(const QCborValueConstRef* self, bool defaultValue) {
return self->toBool(defaultValue);
}
double QCborValueConstRef_ToDouble1(const QCborValueConstRef* self, double defaultValue) {
return self->toDouble(static_cast<double>(defaultValue));
}
struct miqt_string QCborValueConstRef_ToByteArray1(const QCborValueConstRef* self, struct miqt_string defaultValue) {
QByteArray defaultValue_QByteArray(defaultValue.data, defaultValue.len);
QByteArray _qb = self->toByteArray(defaultValue_QByteArray);
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
struct miqt_string QCborValueConstRef_ToString1(const QCborValueConstRef* self, struct miqt_string defaultValue) {
QString defaultValue_QString = QString::fromUtf8(defaultValue.data, defaultValue.len);
QString _ret = self->toString(defaultValue_QString);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
QDateTime* QCborValueConstRef_ToDateTime1(const QCborValueConstRef* self, QDateTime* defaultValue) {
return new QDateTime(self->toDateTime(*defaultValue));
}
QUrl* QCborValueConstRef_ToUrl1(const QCborValueConstRef* self, QUrl* defaultValue) {
return new QUrl(self->toUrl(*defaultValue));
}
QRegularExpression* QCborValueConstRef_ToRegularExpression1(const QCborValueConstRef* self, QRegularExpression* defaultValue) {
return new QRegularExpression(self->toRegularExpression(*defaultValue));
}
QUuid* QCborValueConstRef_ToUuid1(const QCborValueConstRef* self, QUuid* defaultValue) {
return new QUuid(self->toUuid(*defaultValue));
}
struct miqt_string QCborValueConstRef_ToCbor1(const QCborValueConstRef* self, int opt) {
QByteArray _qb = self->toCbor(static_cast<QCborValue::EncodingOptions>(opt));
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
void QCborValueConstRef_ToCbor2(const QCborValueConstRef* self, QCborStreamWriter* writer, int opt) {
self->toCbor(*writer, static_cast<QCborValue::EncodingOptions>(opt));
}
struct miqt_string QCborValueConstRef_ToDiagnosticNotation1(const QCborValueConstRef* self, int opt) {
QString _ret = self->toDiagnosticNotation(static_cast<QCborValue::DiagnosticNotationOptions>(opt));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
void QCborValueConstRef_Delete(QCborValueConstRef* self) {
delete self;
}
QCborValueRef* QCborValueRef_new(QCborValueRef* param1) { QCborValueRef* QCborValueRef_new(QCborValueRef* param1) {
return new QCborValueRef(*param1); return new QCborValueRef(*param1);
} }
@ -505,6 +824,15 @@ void QCborValueRef_OperatorAssignWithOther(QCborValueRef* self, QCborValueRef* o
self->operator=(*other); self->operator=(*other);
} }
QCborValueRef* QCborValueRef_OperatorSubscript(QCborValueRef* self, long long key) {
return new QCborValueRef(self->operator[](static_cast<qint64>(key)));
}
QCborValueRef* QCborValueRef_OperatorSubscript2(QCborValueRef* self, struct miqt_string key) {
QString key_QString = QString::fromUtf8(key.data, key.len);
return new QCborValueRef(self->operator[](key_QString));
}
int QCborValueRef_Type(const QCborValueRef* self) { int QCborValueRef_Type(const QCborValueRef* self) {
QCborValue::Type _ret = self->type(); QCborValue::Type _ret = self->type();
return static_cast<int>(_ret); return static_cast<int>(_ret);
@ -590,6 +918,11 @@ bool QCborValueRef_IsSimpleTypeWithSt(const QCborValueRef* self, uint8_t st) {
return self->isSimpleType(static_cast<QCborSimpleType>(st)); return self->isSimpleType(static_cast<QCborSimpleType>(st));
} }
uint8_t QCborValueRef_ToSimpleType(const QCborValueRef* self) {
QCborSimpleType _ret = self->toSimpleType();
return static_cast<uint8_t>(_ret);
}
uint64_t QCborValueRef_Tag(const QCborValueRef* self) { uint64_t QCborValueRef_Tag(const QCborValueRef* self) {
QCborTag _ret = self->tag(); QCborTag _ret = self->tag();
return static_cast<uint64_t>(_ret); return static_cast<uint64_t>(_ret);
@ -664,24 +997,15 @@ QCborMap* QCborValueRef_ToMapWithQCborMap(const QCborValueRef* self, QCborMap* m
return new QCborMap(self->toMap(*m)); return new QCborMap(self->toMap(*m));
} }
QCborValue* QCborValueRef_OperatorSubscript(const QCborValueRef* self, struct miqt_string key) { QCborValue* QCborValueRef_OperatorSubscript3(const QCborValueRef* self, struct miqt_string key) {
QString key_QString = QString::fromUtf8(key.data, key.len); QString key_QString = QString::fromUtf8(key.data, key.len);
return new QCborValue(self->operator[](key_QString)); return new QCborValue(self->operator[](key_QString));
} }
QCborValue* QCborValueRef_OperatorSubscript2(const QCborValueRef* self, long long key) { QCborValue* QCborValueRef_OperatorSubscript5(const QCborValueRef* self, long long key) {
return new QCborValue(self->operator[](static_cast<qint64>(key))); return new QCborValue(self->operator[](static_cast<qint64>(key)));
} }
QCborValueRef* QCborValueRef_OperatorSubscript3(QCborValueRef* self, long long key) {
return new QCborValueRef(self->operator[](static_cast<qint64>(key)));
}
QCborValueRef* QCborValueRef_OperatorSubscript5(QCborValueRef* self, struct miqt_string key) {
QString key_QString = QString::fromUtf8(key.data, key.len);
return new QCborValueRef(self->operator[](key_QString));
}
int QCborValueRef_Compare(const QCborValueRef* self, QCborValue* other) { int QCborValueRef_Compare(const QCborValueRef* self, QCborValue* other) {
return self->compare(*other); return self->compare(*other);
} }
@ -730,6 +1054,11 @@ struct miqt_string QCborValueRef_ToDiagnosticNotation(QCborValueRef* self) {
return _ms; return _ms;
} }
uint8_t QCborValueRef_ToSimpleType1(const QCborValueRef* self, uint8_t defaultValue) {
QCborSimpleType _ret = self->toSimpleType(static_cast<QCborSimpleType>(defaultValue));
return static_cast<uint8_t>(_ret);
}
uint64_t QCborValueRef_Tag1(const QCborValueRef* self, uint64_t defaultValue) { uint64_t QCborValueRef_Tag1(const QCborValueRef* self, uint64_t defaultValue) {
QCborTag _ret = self->tag(static_cast<QCborTag>(defaultValue)); QCborTag _ret = self->tag(static_cast<QCborTag>(defaultValue));
return static_cast<uint64_t>(_ret); return static_cast<uint64_t>(_ret);

445
qt6/cbor/gen_qcborvalue.go
View File

@ -728,8 +728,399 @@ func (this *QCborValue) GoGC() {
}) })
} }
type QCborValueConstRef struct {
h *C.QCborValueConstRef
}
func (this *QCborValueConstRef) cPointer() *C.QCborValueConstRef {
if this == nil {
return nil
}
return this.h
}
func (this *QCborValueConstRef) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
func newQCborValueConstRef(h *C.QCborValueConstRef) *QCborValueConstRef {
if h == nil {
return nil
}
return &QCborValueConstRef{h: h}
}
func UnsafeNewQCborValueConstRef(h unsafe.Pointer) *QCborValueConstRef {
return newQCborValueConstRef((*C.QCborValueConstRef)(h))
}
// NewQCborValueConstRef constructs a new QCborValueConstRef object.
func NewQCborValueConstRef(param1 *QCborValueConstRef) *QCborValueConstRef {
ret := C.QCborValueConstRef_new(param1.cPointer())
return newQCborValueConstRef(ret)
}
func (this *QCborValueConstRef) Type() QCborValue__Type {
return (QCborValue__Type)(C.QCborValueConstRef_Type(this.h))
}
func (this *QCborValueConstRef) IsInteger() bool {
return (bool)(C.QCborValueConstRef_IsInteger(this.h))
}
func (this *QCborValueConstRef) IsByteArray() bool {
return (bool)(C.QCborValueConstRef_IsByteArray(this.h))
}
func (this *QCborValueConstRef) IsString() bool {
return (bool)(C.QCborValueConstRef_IsString(this.h))
}
func (this *QCborValueConstRef) IsArray() bool {
return (bool)(C.QCborValueConstRef_IsArray(this.h))
}
func (this *QCborValueConstRef) IsMap() bool {
return (bool)(C.QCborValueConstRef_IsMap(this.h))
}
func (this *QCborValueConstRef) IsTag() bool {
return (bool)(C.QCborValueConstRef_IsTag(this.h))
}
func (this *QCborValueConstRef) IsFalse() bool {
return (bool)(C.QCborValueConstRef_IsFalse(this.h))
}
func (this *QCborValueConstRef) IsTrue() bool {
return (bool)(C.QCborValueConstRef_IsTrue(this.h))
}
func (this *QCborValueConstRef) IsBool() bool {
return (bool)(C.QCborValueConstRef_IsBool(this.h))
}
func (this *QCborValueConstRef) IsNull() bool {
return (bool)(C.QCborValueConstRef_IsNull(this.h))
}
func (this *QCborValueConstRef) IsUndefined() bool {
return (bool)(C.QCborValueConstRef_IsUndefined(this.h))
}
func (this *QCborValueConstRef) IsDouble() bool {
return (bool)(C.QCborValueConstRef_IsDouble(this.h))
}
func (this *QCborValueConstRef) IsDateTime() bool {
return (bool)(C.QCborValueConstRef_IsDateTime(this.h))
}
func (this *QCborValueConstRef) IsUrl() bool {
return (bool)(C.QCborValueConstRef_IsUrl(this.h))
}
func (this *QCborValueConstRef) IsRegularExpression() bool {
return (bool)(C.QCborValueConstRef_IsRegularExpression(this.h))
}
func (this *QCborValueConstRef) IsUuid() bool {
return (bool)(C.QCborValueConstRef_IsUuid(this.h))
}
func (this *QCborValueConstRef) IsInvalid() bool {
return (bool)(C.QCborValueConstRef_IsInvalid(this.h))
}
func (this *QCborValueConstRef) IsContainer() bool {
return (bool)(C.QCborValueConstRef_IsContainer(this.h))
}
func (this *QCborValueConstRef) IsSimpleType() bool {
return (bool)(C.QCborValueConstRef_IsSimpleType(this.h))
}
func (this *QCborValueConstRef) IsSimpleTypeWithSt(st QCborSimpleType) bool {
return (bool)(C.QCborValueConstRef_IsSimpleTypeWithSt(this.h, (C.uint8_t)(st)))
}
func (this *QCborValueConstRef) ToSimpleType() QCborSimpleType {
return (QCborSimpleType)(C.QCborValueConstRef_ToSimpleType(this.h))
}
func (this *QCborValueConstRef) Tag() QCborTag {
return (QCborTag)(C.QCborValueConstRef_Tag(this.h))
}
func (this *QCborValueConstRef) TaggedValue() *QCborValue {
_ret := C.QCborValueConstRef_TaggedValue(this.h)
_goptr := newQCborValue(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToInteger() int64 {
return (int64)(C.QCborValueConstRef_ToInteger(this.h))
}
func (this *QCborValueConstRef) ToBool() bool {
return (bool)(C.QCborValueConstRef_ToBool(this.h))
}
func (this *QCborValueConstRef) ToDouble() float64 {
return (float64)(C.QCborValueConstRef_ToDouble(this.h))
}
func (this *QCborValueConstRef) ToByteArray() []byte {
var _bytearray C.struct_miqt_string = C.QCborValueConstRef_ToByteArray(this.h)
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *QCborValueConstRef) ToString() string {
var _ms C.struct_miqt_string = C.QCborValueConstRef_ToString(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *QCborValueConstRef) ToDateTime() *qt6.QDateTime {
_ret := C.QCborValueConstRef_ToDateTime(this.h)
_goptr := qt6.UnsafeNewQDateTime(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToUrl() *qt6.QUrl {
_ret := C.QCborValueConstRef_ToUrl(this.h)
_goptr := qt6.UnsafeNewQUrl(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToRegularExpression() *qt6.QRegularExpression {
_ret := C.QCborValueConstRef_ToRegularExpression(this.h)
_goptr := qt6.UnsafeNewQRegularExpression(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToUuid() *qt6.QUuid {
_ret := C.QCborValueConstRef_ToUuid(this.h)
_goptr := qt6.UnsafeNewQUuid(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToArray() *QCborArray {
_ret := C.QCborValueConstRef_ToArray(this.h)
_goptr := newQCborArray(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToArrayWithQCborArray(a *QCborArray) *QCborArray {
_ret := C.QCborValueConstRef_ToArrayWithQCborArray(this.h, a.cPointer())
_goptr := newQCborArray(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToMap() *QCborMap {
_ret := C.QCborValueConstRef_ToMap(this.h)
_goptr := newQCborMap(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToMapWithQCborMap(m *QCborMap) *QCborMap {
_ret := C.QCborValueConstRef_ToMapWithQCborMap(this.h, m.cPointer())
_goptr := newQCborMap(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) OperatorSubscript(key string) *QCborValue {
key_ms := C.struct_miqt_string{}
key_ms.data = C.CString(key)
key_ms.len = C.size_t(len(key))
defer C.free(unsafe.Pointer(key_ms.data))
_ret := C.QCborValueConstRef_OperatorSubscript(this.h, key_ms)
_goptr := newQCborValue(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) OperatorSubscript2(key int64) *QCborValue {
_ret := C.QCborValueConstRef_OperatorSubscript2(this.h, (C.longlong)(key))
_goptr := newQCborValue(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) Compare(other *QCborValue) int {
return (int)(C.QCborValueConstRef_Compare(this.h, other.cPointer()))
}
func (this *QCborValueConstRef) OperatorEqual(other *QCborValue) bool {
return (bool)(C.QCborValueConstRef_OperatorEqual(this.h, other.cPointer()))
}
func (this *QCborValueConstRef) OperatorNotEqual(other *QCborValue) bool {
return (bool)(C.QCborValueConstRef_OperatorNotEqual(this.h, other.cPointer()))
}
func (this *QCborValueConstRef) OperatorLesser(other *QCborValue) bool {
return (bool)(C.QCborValueConstRef_OperatorLesser(this.h, other.cPointer()))
}
func (this *QCborValueConstRef) ToVariant() *qt6.QVariant {
_ret := C.QCborValueConstRef_ToVariant(this.h)
_goptr := qt6.UnsafeNewQVariant(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToJsonValue() *qt6.QJsonValue {
_ret := C.QCborValueConstRef_ToJsonValue(this.h)
_goptr := qt6.UnsafeNewQJsonValue(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToCbor() []byte {
var _bytearray C.struct_miqt_string = C.QCborValueConstRef_ToCbor(this.h)
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *QCborValueConstRef) ToCborWithWriter(writer *QCborStreamWriter) {
C.QCborValueConstRef_ToCborWithWriter(this.h, writer.cPointer())
}
func (this *QCborValueConstRef) ToDiagnosticNotation() string {
var _ms C.struct_miqt_string = C.QCborValueConstRef_ToDiagnosticNotation(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *QCborValueConstRef) ToSimpleType1(defaultValue QCborSimpleType) QCborSimpleType {
return (QCborSimpleType)(C.QCborValueConstRef_ToSimpleType1(this.h, (C.uint8_t)(defaultValue)))
}
func (this *QCborValueConstRef) Tag1(defaultValue QCborTag) QCborTag {
return (QCborTag)(C.QCborValueConstRef_Tag1(this.h, (C.uint64_t)(defaultValue)))
}
func (this *QCborValueConstRef) TaggedValue1(defaultValue *QCborValue) *QCborValue {
_ret := C.QCborValueConstRef_TaggedValue1(this.h, defaultValue.cPointer())
_goptr := newQCborValue(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToInteger1(defaultValue int64) int64 {
return (int64)(C.QCborValueConstRef_ToInteger1(this.h, (C.longlong)(defaultValue)))
}
func (this *QCborValueConstRef) ToBool1(defaultValue bool) bool {
return (bool)(C.QCborValueConstRef_ToBool1(this.h, (C.bool)(defaultValue)))
}
func (this *QCborValueConstRef) ToDouble1(defaultValue float64) float64 {
return (float64)(C.QCborValueConstRef_ToDouble1(this.h, (C.double)(defaultValue)))
}
func (this *QCborValueConstRef) ToByteArray1(defaultValue []byte) []byte {
defaultValue_alias := C.struct_miqt_string{}
defaultValue_alias.data = (*C.char)(unsafe.Pointer(&defaultValue[0]))
defaultValue_alias.len = C.size_t(len(defaultValue))
var _bytearray C.struct_miqt_string = C.QCborValueConstRef_ToByteArray1(this.h, defaultValue_alias)
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *QCborValueConstRef) ToString1(defaultValue string) string {
defaultValue_ms := C.struct_miqt_string{}
defaultValue_ms.data = C.CString(defaultValue)
defaultValue_ms.len = C.size_t(len(defaultValue))
defer C.free(unsafe.Pointer(defaultValue_ms.data))
var _ms C.struct_miqt_string = C.QCborValueConstRef_ToString1(this.h, defaultValue_ms)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *QCborValueConstRef) ToDateTime1(defaultValue *qt6.QDateTime) *qt6.QDateTime {
_ret := C.QCborValueConstRef_ToDateTime1(this.h, (*C.QDateTime)(defaultValue.UnsafePointer()))
_goptr := qt6.UnsafeNewQDateTime(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToUrl1(defaultValue *qt6.QUrl) *qt6.QUrl {
_ret := C.QCborValueConstRef_ToUrl1(this.h, (*C.QUrl)(defaultValue.UnsafePointer()))
_goptr := qt6.UnsafeNewQUrl(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToRegularExpression1(defaultValue *qt6.QRegularExpression) *qt6.QRegularExpression {
_ret := C.QCborValueConstRef_ToRegularExpression1(this.h, (*C.QRegularExpression)(defaultValue.UnsafePointer()))
_goptr := qt6.UnsafeNewQRegularExpression(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToUuid1(defaultValue *qt6.QUuid) *qt6.QUuid {
_ret := C.QCborValueConstRef_ToUuid1(this.h, (*C.QUuid)(defaultValue.UnsafePointer()))
_goptr := qt6.UnsafeNewQUuid(unsafe.Pointer(_ret))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueConstRef) ToCbor1(opt QCborValue__EncodingOption) []byte {
var _bytearray C.struct_miqt_string = C.QCborValueConstRef_ToCbor1(this.h, (C.int)(opt))
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *QCborValueConstRef) ToCbor2(writer *QCborStreamWriter, opt QCborValue__EncodingOption) {
C.QCborValueConstRef_ToCbor2(this.h, writer.cPointer(), (C.int)(opt))
}
func (this *QCborValueConstRef) ToDiagnosticNotation1(opt QCborValue__DiagnosticNotationOption) string {
var _ms C.struct_miqt_string = C.QCborValueConstRef_ToDiagnosticNotation1(this.h, (C.int)(opt))
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
// Delete this object from C++ memory.
func (this *QCborValueConstRef) Delete() {
C.QCborValueConstRef_Delete(this.h)
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QCborValueConstRef) GoGC() {
runtime.SetFinalizer(this, func(this *QCborValueConstRef) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type QCborValueRef struct { type QCborValueRef struct {
h *C.QCborValueRef h *C.QCborValueRef
*QCborValueConstRef
} }
func (this *QCborValueRef) cPointer() *C.QCborValueRef { func (this *QCborValueRef) cPointer() *C.QCborValueRef {
@ -750,7 +1141,7 @@ func newQCborValueRef(h *C.QCborValueRef) *QCborValueRef {
if h == nil { if h == nil {
return nil return nil
} }
return &QCborValueRef{h: h} return &QCborValueRef{h: h, QCborValueConstRef: UnsafeNewQCborValueConstRef(unsafe.Pointer(h))}
} }
func UnsafeNewQCborValueRef(h unsafe.Pointer) *QCborValueRef { func UnsafeNewQCborValueRef(h unsafe.Pointer) *QCborValueRef {
@ -771,6 +1162,24 @@ func (this *QCborValueRef) OperatorAssignWithOther(other *QCborValueRef) {
C.QCborValueRef_OperatorAssignWithOther(this.h, other.cPointer()) C.QCborValueRef_OperatorAssignWithOther(this.h, other.cPointer())
} }
func (this *QCborValueRef) OperatorSubscript(key int64) *QCborValueRef {
_ret := C.QCborValueRef_OperatorSubscript(this.h, (C.longlong)(key))
_goptr := newQCborValueRef(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueRef) OperatorSubscript2(key string) *QCborValueRef {
key_ms := C.struct_miqt_string{}
key_ms.data = C.CString(key)
key_ms.len = C.size_t(len(key))
defer C.free(unsafe.Pointer(key_ms.data))
_ret := C.QCborValueRef_OperatorSubscript2(this.h, key_ms)
_goptr := newQCborValueRef(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueRef) Type() QCborValue__Type { func (this *QCborValueRef) Type() QCborValue__Type {
return (QCborValue__Type)(C.QCborValueRef_Type(this.h)) return (QCborValue__Type)(C.QCborValueRef_Type(this.h))
} }
@ -855,6 +1264,10 @@ func (this *QCborValueRef) IsSimpleTypeWithSt(st QCborSimpleType) bool {
return (bool)(C.QCborValueRef_IsSimpleTypeWithSt(this.h, (C.uint8_t)(st))) return (bool)(C.QCborValueRef_IsSimpleTypeWithSt(this.h, (C.uint8_t)(st)))
} }
func (this *QCborValueRef) ToSimpleType() QCborSimpleType {
return (QCborSimpleType)(C.QCborValueRef_ToSimpleType(this.h))
}
func (this *QCborValueRef) Tag() QCborTag { func (this *QCborValueRef) Tag() QCborTag {
return (QCborTag)(C.QCborValueRef_Tag(this.h)) return (QCborTag)(C.QCborValueRef_Tag(this.h))
} }
@ -948,42 +1361,24 @@ func (this *QCborValueRef) ToMapWithQCborMap(m *QCborMap) *QCborMap {
return _goptr return _goptr
} }
func (this *QCborValueRef) OperatorSubscript(key string) *QCborValue { func (this *QCborValueRef) OperatorSubscript3(key string) *QCborValue {
key_ms := C.struct_miqt_string{} key_ms := C.struct_miqt_string{}
key_ms.data = C.CString(key) key_ms.data = C.CString(key)
key_ms.len = C.size_t(len(key)) key_ms.len = C.size_t(len(key))
defer C.free(unsafe.Pointer(key_ms.data)) defer C.free(unsafe.Pointer(key_ms.data))
_ret := C.QCborValueRef_OperatorSubscript(this.h, key_ms) _ret := C.QCborValueRef_OperatorSubscript3(this.h, key_ms)
_goptr := newQCborValue(_ret) _goptr := newQCborValue(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr return _goptr
} }
func (this *QCborValueRef) OperatorSubscript2(key int64) *QCborValue { func (this *QCborValueRef) OperatorSubscript5(key int64) *QCborValue {
_ret := C.QCborValueRef_OperatorSubscript2(this.h, (C.longlong)(key)) _ret := C.QCborValueRef_OperatorSubscript5(this.h, (C.longlong)(key))
_goptr := newQCborValue(_ret) _goptr := newQCborValue(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer _goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr return _goptr
} }
func (this *QCborValueRef) OperatorSubscript3(key int64) *QCborValueRef {
_ret := C.QCborValueRef_OperatorSubscript3(this.h, (C.longlong)(key))
_goptr := newQCborValueRef(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueRef) OperatorSubscript5(key string) *QCborValueRef {
key_ms := C.struct_miqt_string{}
key_ms.data = C.CString(key)
key_ms.len = C.size_t(len(key))
defer C.free(unsafe.Pointer(key_ms.data))
_ret := C.QCborValueRef_OperatorSubscript5(this.h, key_ms)
_goptr := newQCborValueRef(_ret)
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QCborValueRef) Compare(other *QCborValue) int { func (this *QCborValueRef) Compare(other *QCborValue) int {
return (int)(C.QCborValueRef_Compare(this.h, other.cPointer())) return (int)(C.QCborValueRef_Compare(this.h, other.cPointer()))
} }
@ -1032,6 +1427,10 @@ func (this *QCborValueRef) ToDiagnosticNotation() string {
return _ret return _ret
} }
func (this *QCborValueRef) ToSimpleType1(defaultValue QCborSimpleType) QCborSimpleType {
return (QCborSimpleType)(C.QCborValueRef_ToSimpleType1(this.h, (C.uint8_t)(defaultValue)))
}
func (this *QCborValueRef) Tag1(defaultValue QCborTag) QCborTag { func (this *QCborValueRef) Tag1(defaultValue QCborTag) QCborTag {
return (QCborTag)(C.QCborValueRef_Tag1(this.h, (C.uint64_t)(defaultValue))) return (QCborTag)(C.QCborValueRef_Tag1(this.h, (C.uint64_t)(defaultValue)))
} }

86
qt6/cbor/gen_qcborvalue.h
View File

@ -22,6 +22,7 @@ class QCborParserError;
class QCborStreamReader; class QCborStreamReader;
class QCborStreamWriter; class QCborStreamWriter;
class QCborValue; class QCborValue;
class QCborValueConstRef;
class QCborValueRef; class QCborValueRef;
class QDateTime; class QDateTime;
class QJsonValue; class QJsonValue;
@ -37,6 +38,7 @@ typedef struct QCborParserError QCborParserError;
typedef struct QCborStreamReader QCborStreamReader; typedef struct QCborStreamReader QCborStreamReader;
typedef struct QCborStreamWriter QCborStreamWriter; typedef struct QCborStreamWriter QCborStreamWriter;
typedef struct QCborValue QCborValue; typedef struct QCborValue QCborValue;
typedef struct QCborValueConstRef QCborValueConstRef;
typedef struct QCborValueRef QCborValueRef; typedef struct QCborValueRef QCborValueRef;
typedef struct QDateTime QDateTime; typedef struct QDateTime QDateTime;
typedef struct QJsonValue QJsonValue; typedef struct QJsonValue QJsonValue;
@ -126,8 +128,8 @@ QCborValue* QCborValue_FromCbor(QCborStreamReader* reader);
QCborValue* QCborValue_FromCborWithBa(struct miqt_string ba); QCborValue* QCborValue_FromCborWithBa(struct miqt_string ba);
QCborValue* QCborValue_FromCbor2(const char* data, ptrdiff_t lenVal); QCborValue* QCborValue_FromCbor2(const char* data, ptrdiff_t lenVal);
QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal); QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal);
struct miqt_string QCborValue_ToCbor(QCborValue* self); struct miqt_string QCborValue_ToCbor(const QCborValue* self);
void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer); void QCborValue_ToCborWithWriter(const QCborValue* self, QCborStreamWriter* writer);
struct miqt_string QCborValue_ToDiagnosticNotation(const QCborValue* self); struct miqt_string QCborValue_ToDiagnosticNotation(const QCborValue* self);
uint8_t QCborValue_ToSimpleType1(const QCborValue* self, uint8_t defaultValue); uint8_t QCborValue_ToSimpleType1(const QCborValue* self, uint8_t defaultValue);
long long QCborValue_ToInteger1(const QCborValue* self, long long defaultValue); long long QCborValue_ToInteger1(const QCborValue* self, long long defaultValue);
@ -144,14 +146,82 @@ QUuid* QCborValue_ToUuid1(const QCborValue* self, QUuid* defaultValue);
QCborValue* QCborValue_FromCbor22(struct miqt_string ba, QCborParserError* error); QCborValue* QCborValue_FromCbor22(struct miqt_string ba, QCborParserError* error);
QCborValue* QCborValue_FromCbor32(const char* data, ptrdiff_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); QCborValue* QCborValue_FromCbor33(const unsigned char* data, ptrdiff_t lenVal, QCborParserError* error);
struct miqt_string QCborValue_ToCbor1(QCborValue* self, int opt); struct miqt_string QCborValue_ToCbor1(const QCborValue* self, int opt);
void QCborValue_ToCbor2(QCborValue* self, QCborStreamWriter* writer, int opt); void QCborValue_ToCbor2(const QCborValue* self, QCborStreamWriter* writer, int opt);
struct miqt_string QCborValue_ToDiagnosticNotation1(const QCborValue* self, int opts); struct miqt_string QCborValue_ToDiagnosticNotation1(const QCborValue* self, int opts);
void QCborValue_Delete(QCborValue* self); void QCborValue_Delete(QCborValue* self);
QCborValueConstRef* QCborValueConstRef_new(QCborValueConstRef* param1);
int QCborValueConstRef_Type(const QCborValueConstRef* self);
bool QCborValueConstRef_IsInteger(const QCborValueConstRef* self);
bool QCborValueConstRef_IsByteArray(const QCborValueConstRef* self);
bool QCborValueConstRef_IsString(const QCborValueConstRef* self);
bool QCborValueConstRef_IsArray(const QCborValueConstRef* self);
bool QCborValueConstRef_IsMap(const QCborValueConstRef* self);
bool QCborValueConstRef_IsTag(const QCborValueConstRef* self);
bool QCborValueConstRef_IsFalse(const QCborValueConstRef* self);
bool QCborValueConstRef_IsTrue(const QCborValueConstRef* self);
bool QCborValueConstRef_IsBool(const QCborValueConstRef* self);
bool QCborValueConstRef_IsNull(const QCborValueConstRef* self);
bool QCborValueConstRef_IsUndefined(const QCborValueConstRef* self);
bool QCborValueConstRef_IsDouble(const QCborValueConstRef* self);
bool QCborValueConstRef_IsDateTime(const QCborValueConstRef* self);
bool QCborValueConstRef_IsUrl(const QCborValueConstRef* self);
bool QCborValueConstRef_IsRegularExpression(const QCborValueConstRef* self);
bool QCborValueConstRef_IsUuid(const QCborValueConstRef* self);
bool QCborValueConstRef_IsInvalid(const QCborValueConstRef* self);
bool QCborValueConstRef_IsContainer(const QCborValueConstRef* self);
bool QCborValueConstRef_IsSimpleType(const QCborValueConstRef* self);
bool QCborValueConstRef_IsSimpleTypeWithSt(const QCborValueConstRef* self, uint8_t st);
uint8_t QCborValueConstRef_ToSimpleType(const QCborValueConstRef* self);
uint64_t QCborValueConstRef_Tag(const QCborValueConstRef* self);
QCborValue* QCborValueConstRef_TaggedValue(const QCborValueConstRef* self);
long long QCborValueConstRef_ToInteger(const QCborValueConstRef* self);
bool QCborValueConstRef_ToBool(const QCborValueConstRef* self);
double QCborValueConstRef_ToDouble(const QCborValueConstRef* self);
struct miqt_string QCborValueConstRef_ToByteArray(const QCborValueConstRef* self);
struct miqt_string QCborValueConstRef_ToString(const QCborValueConstRef* self);
QDateTime* QCborValueConstRef_ToDateTime(const QCborValueConstRef* self);
QUrl* QCborValueConstRef_ToUrl(const QCborValueConstRef* self);
QRegularExpression* QCborValueConstRef_ToRegularExpression(const QCborValueConstRef* self);
QUuid* QCborValueConstRef_ToUuid(const QCborValueConstRef* self);
QCborArray* QCborValueConstRef_ToArray(const QCborValueConstRef* self);
QCborArray* QCborValueConstRef_ToArrayWithQCborArray(const QCborValueConstRef* self, QCborArray* a);
QCborMap* QCborValueConstRef_ToMap(const QCborValueConstRef* self);
QCborMap* QCborValueConstRef_ToMapWithQCborMap(const QCborValueConstRef* self, QCborMap* m);
QCborValue* QCborValueConstRef_OperatorSubscript(const QCborValueConstRef* self, struct miqt_string key);
QCborValue* QCborValueConstRef_OperatorSubscript2(const QCborValueConstRef* self, long long key);
int QCborValueConstRef_Compare(const QCborValueConstRef* self, QCborValue* other);
bool QCborValueConstRef_OperatorEqual(const QCborValueConstRef* self, QCborValue* other);
bool QCborValueConstRef_OperatorNotEqual(const QCborValueConstRef* self, QCborValue* other);
bool QCborValueConstRef_OperatorLesser(const QCborValueConstRef* self, QCborValue* other);
QVariant* QCborValueConstRef_ToVariant(const QCborValueConstRef* self);
QJsonValue* QCborValueConstRef_ToJsonValue(const QCborValueConstRef* self);
struct miqt_string QCborValueConstRef_ToCbor(const QCborValueConstRef* self);
void QCborValueConstRef_ToCborWithWriter(const QCborValueConstRef* self, QCborStreamWriter* writer);
struct miqt_string QCborValueConstRef_ToDiagnosticNotation(const QCborValueConstRef* self);
uint8_t QCborValueConstRef_ToSimpleType1(const QCborValueConstRef* self, uint8_t defaultValue);
uint64_t QCborValueConstRef_Tag1(const QCborValueConstRef* self, uint64_t defaultValue);
QCborValue* QCborValueConstRef_TaggedValue1(const QCborValueConstRef* self, QCborValue* defaultValue);
long long QCborValueConstRef_ToInteger1(const QCborValueConstRef* self, long long defaultValue);
bool QCborValueConstRef_ToBool1(const QCborValueConstRef* self, bool defaultValue);
double QCborValueConstRef_ToDouble1(const QCborValueConstRef* self, double defaultValue);
struct miqt_string QCborValueConstRef_ToByteArray1(const QCborValueConstRef* self, struct miqt_string defaultValue);
struct miqt_string QCborValueConstRef_ToString1(const QCborValueConstRef* self, struct miqt_string defaultValue);
QDateTime* QCborValueConstRef_ToDateTime1(const QCborValueConstRef* self, QDateTime* defaultValue);
QUrl* QCborValueConstRef_ToUrl1(const QCborValueConstRef* self, QUrl* defaultValue);
QRegularExpression* QCborValueConstRef_ToRegularExpression1(const QCborValueConstRef* self, QRegularExpression* defaultValue);
QUuid* QCborValueConstRef_ToUuid1(const QCborValueConstRef* self, QUuid* defaultValue);
struct miqt_string QCborValueConstRef_ToCbor1(const QCborValueConstRef* self, int opt);
void QCborValueConstRef_ToCbor2(const QCborValueConstRef* self, QCborStreamWriter* writer, int opt);
struct miqt_string QCborValueConstRef_ToDiagnosticNotation1(const QCborValueConstRef* self, int opt);
void QCborValueConstRef_Delete(QCborValueConstRef* self);
QCborValueRef* QCborValueRef_new(QCborValueRef* param1); QCborValueRef* QCborValueRef_new(QCborValueRef* param1);
void QCborValueRef_OperatorAssign(QCborValueRef* self, QCborValue* other); void QCborValueRef_OperatorAssign(QCborValueRef* self, QCborValue* other);
void QCborValueRef_OperatorAssignWithOther(QCborValueRef* self, QCborValueRef* other); void QCborValueRef_OperatorAssignWithOther(QCborValueRef* self, QCborValueRef* other);
QCborValueRef* QCborValueRef_OperatorSubscript(QCborValueRef* self, long long key);
QCborValueRef* QCborValueRef_OperatorSubscript2(QCborValueRef* self, struct miqt_string key);
int QCborValueRef_Type(const QCborValueRef* self); int QCborValueRef_Type(const QCborValueRef* self);
bool QCborValueRef_IsInteger(const QCborValueRef* self); bool QCborValueRef_IsInteger(const QCborValueRef* self);
bool QCborValueRef_IsByteArray(const QCborValueRef* self); bool QCborValueRef_IsByteArray(const QCborValueRef* self);
@ -173,6 +243,7 @@ bool QCborValueRef_IsInvalid(const QCborValueRef* self);
bool QCborValueRef_IsContainer(const QCborValueRef* self); bool QCborValueRef_IsContainer(const QCborValueRef* self);
bool QCborValueRef_IsSimpleType(const QCborValueRef* self); bool QCborValueRef_IsSimpleType(const QCborValueRef* self);
bool QCborValueRef_IsSimpleTypeWithSt(const QCborValueRef* self, uint8_t st); bool QCborValueRef_IsSimpleTypeWithSt(const QCborValueRef* self, uint8_t st);
uint8_t QCborValueRef_ToSimpleType(const QCborValueRef* self);
uint64_t QCborValueRef_Tag(const QCborValueRef* self); uint64_t QCborValueRef_Tag(const QCborValueRef* self);
QCborValue* QCborValueRef_TaggedValue(const QCborValueRef* self); QCborValue* QCborValueRef_TaggedValue(const QCborValueRef* self);
long long QCborValueRef_ToInteger(const QCborValueRef* self); long long QCborValueRef_ToInteger(const QCborValueRef* self);
@ -188,10 +259,8 @@ QCborArray* QCborValueRef_ToArray(const QCborValueRef* self);
QCborArray* QCborValueRef_ToArrayWithQCborArray(const QCborValueRef* self, QCborArray* a); QCborArray* QCborValueRef_ToArrayWithQCborArray(const QCborValueRef* self, QCborArray* a);
QCborMap* QCborValueRef_ToMap(const QCborValueRef* self); QCborMap* QCborValueRef_ToMap(const QCborValueRef* self);
QCborMap* QCborValueRef_ToMapWithQCborMap(const QCborValueRef* self, QCborMap* m); QCborMap* QCborValueRef_ToMapWithQCborMap(const QCborValueRef* self, QCborMap* m);
QCborValue* QCborValueRef_OperatorSubscript(const QCborValueRef* self, struct miqt_string key); QCborValue* QCborValueRef_OperatorSubscript3(const QCborValueRef* self, struct miqt_string key);
QCborValue* QCborValueRef_OperatorSubscript2(const QCborValueRef* self, long long key); QCborValue* QCborValueRef_OperatorSubscript5(const QCborValueRef* self, long long key);
QCborValueRef* QCborValueRef_OperatorSubscript3(QCborValueRef* self, long long key);
QCborValueRef* QCborValueRef_OperatorSubscript5(QCborValueRef* self, struct miqt_string key);
int QCborValueRef_Compare(const QCborValueRef* self, QCborValue* other); int QCborValueRef_Compare(const QCborValueRef* self, QCborValue* other);
bool QCborValueRef_OperatorEqual(const QCborValueRef* self, QCborValue* other); bool QCborValueRef_OperatorEqual(const QCborValueRef* self, QCborValue* other);
bool QCborValueRef_OperatorNotEqual(const QCborValueRef* self, QCborValue* other); bool QCborValueRef_OperatorNotEqual(const QCborValueRef* self, QCborValue* other);
@ -201,6 +270,7 @@ QJsonValue* QCborValueRef_ToJsonValue(const QCborValueRef* self);
struct miqt_string QCborValueRef_ToCbor(QCborValueRef* self); struct miqt_string QCborValueRef_ToCbor(QCborValueRef* self);
void QCborValueRef_ToCborWithWriter(QCborValueRef* self, QCborStreamWriter* writer); void QCborValueRef_ToCborWithWriter(QCborValueRef* self, QCborStreamWriter* writer);
struct miqt_string QCborValueRef_ToDiagnosticNotation(QCborValueRef* self); struct miqt_string QCborValueRef_ToDiagnosticNotation(QCborValueRef* self);
uint8_t QCborValueRef_ToSimpleType1(const QCborValueRef* self, uint8_t defaultValue);
uint64_t QCborValueRef_Tag1(const QCborValueRef* self, uint64_t defaultValue); uint64_t QCborValueRef_Tag1(const QCborValueRef* self, uint64_t defaultValue);
QCborValue* QCborValueRef_TaggedValue1(const QCborValueRef* self, QCborValue* defaultValue); QCborValue* QCborValueRef_TaggedValue1(const QCborValueRef* self, QCborValue* defaultValue);
long long QCborValueRef_ToInteger1(const QCborValueRef* self, long long defaultValue); long long QCborValueRef_ToInteger1(const QCborValueRef* self, long long defaultValue);