mirror of
https://github.com/mappu/miqt.git
synced 2024-12-22 00:48:38 +00:00
Merge pull request #82 from rcalixte/qt6_cbor
Modify qt6/cbor for proper builds
This commit is contained in:
GitHub
commit
30c6cb4f07
@ -147,7 +147,7 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
|
||||
generate(
|
||||
"qt6/cbor",
|
||||
[]string{
|
||||
"/usr/include/x86_64-linux-gnu/qt5/QtCore",
|
||||
"/usr/include/x86_64-linux-gnu/qt6/QtCore",
|
||||
},
|
||||
func(fullpath string) bool {
|
||||
// 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")
|
||||
},
|
||||
clangBin,
|
||||
pkgConfigCflags("Qt6Core"),
|
||||
"--std=c++20 "+pkgConfigCflags("Qt6Core"),
|
||||
outDir,
|
||||
ClangMatchSameHeaderDefinitionOnly,
|
||||
)
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__ConstIterator
|
||||
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborArray__Iterator
|
||||
#include <QCborValue>
|
||||
#include <QCborValueConstRef>
|
||||
#include <QCborValueRef>
|
||||
#include <QJsonArray>
|
||||
#include <QList>
|
||||
@ -260,11 +261,15 @@ QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator*
|
||||
return new QCborValueRef(self->operator*());
|
||||
}
|
||||
|
||||
QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Iterator* self) {
|
||||
QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(QCborArray__Iterator* self) {
|
||||
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)));
|
||||
}
|
||||
|
||||
@ -377,16 +382,16 @@ void QCborArray__ConstIterator_OperatorAssign(QCborArray__ConstIterator* self, Q
|
||||
self->operator=(*other);
|
||||
}
|
||||
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self) {
|
||||
return new QCborValueRef(self->operator*());
|
||||
QCborValueConstRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self) {
|
||||
return new QCborValueConstRef(self->operator*());
|
||||
}
|
||||
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self) {
|
||||
return (QCborValueRef*) self->operator->();
|
||||
QCborValueConstRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self) {
|
||||
return (QCborValueConstRef*) self->operator->();
|
||||
}
|
||||
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j) {
|
||||
return new QCborValueRef(self->operator[]((qsizetype)(j)));
|
||||
QCborValueConstRef* QCborArray__ConstIterator_OperatorSubscript(const QCborArray__ConstIterator* self, ptrdiff_t j) {
|
||||
return new QCborValueConstRef(self->operator[]((qsizetype)(j)));
|
||||
}
|
||||
|
||||
bool QCborArray__ConstIterator_OperatorEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o) {
|
||||
|
||||
@ -430,6 +430,10 @@ func (this *QCborArray__Iterator) OperatorMinusGreater() *QCborValueRef {
|
||||
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 {
|
||||
_ret := C.QCborArray__Iterator_OperatorSubscript(this.h, (C.ptrdiff_t)(j))
|
||||
_goptr := newQCborValueRef(_ret)
|
||||
@ -592,20 +596,20 @@ func (this *QCborArray__ConstIterator) OperatorAssign(other *QCborArray__ConstIt
|
||||
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)
|
||||
_goptr := newQCborValueRef(_ret)
|
||||
_goptr := newQCborValueConstRef(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborArray__ConstIterator) OperatorMinusGreater() *QCborValueRef {
|
||||
return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborArray__ConstIterator_OperatorMinusGreater(this.h)))
|
||||
func (this *QCborArray__ConstIterator) OperatorMinusGreater() *QCborValueConstRef {
|
||||
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))
|
||||
_goptr := newQCborValueRef(_ret)
|
||||
_goptr := newQCborValueConstRef(_ret)
|
||||
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
return _goptr
|
||||
}
|
||||
|
||||
@ -27,6 +27,7 @@ typedef QCborArray::Iterator QCborArray__Iterator;
|
||||
class QCborArray__Iterator;
|
||||
#endif
|
||||
class QCborValue;
|
||||
class QCborValueConstRef;
|
||||
class QCborValueRef;
|
||||
class QJsonArray;
|
||||
#else
|
||||
@ -34,6 +35,7 @@ typedef struct QCborArray QCborArray;
|
||||
typedef struct QCborArray__ConstIterator QCborArray__ConstIterator;
|
||||
typedef struct QCborArray__Iterator QCborArray__Iterator;
|
||||
typedef struct QCborValue QCborValue;
|
||||
typedef struct QCborValueConstRef QCborValueConstRef;
|
||||
typedef struct QCborValueRef QCborValueRef;
|
||||
typedef struct QJsonArray QJsonArray;
|
||||
#endif
|
||||
@ -98,8 +100,9 @@ QCborArray__Iterator* QCborArray__Iterator_new();
|
||||
QCborArray__Iterator* QCborArray__Iterator_new2(QCborArray__Iterator* param1);
|
||||
void QCborArray__Iterator_OperatorAssign(QCborArray__Iterator* self, QCborArray__Iterator* other);
|
||||
QCborValueRef* QCborArray__Iterator_OperatorMultiply(const QCborArray__Iterator* self);
|
||||
QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(const QCborArray__Iterator* self);
|
||||
QCborValueRef* QCborArray__Iterator_OperatorSubscript(QCborArray__Iterator* self, ptrdiff_t j);
|
||||
QCborValueRef* QCborArray__Iterator_OperatorMinusGreater(QCborArray__Iterator* self);
|
||||
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_OperatorNotEqual(const QCborArray__Iterator* self, QCborArray__Iterator* o);
|
||||
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_new2(QCborArray__ConstIterator* param1);
|
||||
void QCborArray__ConstIterator_OperatorAssign(QCborArray__ConstIterator* self, QCborArray__ConstIterator* other);
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self);
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self);
|
||||
QCborValueRef* QCborArray__ConstIterator_OperatorSubscript(QCborArray__ConstIterator* self, ptrdiff_t j);
|
||||
QCborValueConstRef* QCborArray__ConstIterator_OperatorMultiply(const QCborArray__ConstIterator* self);
|
||||
QCborValueConstRef* QCborArray__ConstIterator_OperatorMinusGreater(const QCborArray__ConstIterator* self);
|
||||
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_OperatorNotEqual(const QCborArray__ConstIterator* self, QCborArray__Iterator* o);
|
||||
bool QCborArray__ConstIterator_OperatorLesser(const QCborArray__ConstIterator* self, QCborArray__Iterator* other);
|
||||
|
||||
@ -2,6 +2,7 @@
|
||||
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborMap__ConstIterator
|
||||
#define WORKAROUND_INNER_CLASS_DEFINITION_QCborMap__Iterator
|
||||
#include <QCborValue>
|
||||
#include <QCborValueConstRef>
|
||||
#include <QCborValueRef>
|
||||
#include <QJsonObject>
|
||||
#include <QList>
|
||||
@ -48,7 +49,7 @@ void QCborMap_Clear(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
|
||||
QCborValue** _arr = static_cast<QCborValue**>(malloc(sizeof(QCborValue*) * _ret.length()));
|
||||
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);
|
||||
}
|
||||
|
||||
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*();
|
||||
// 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*)));
|
||||
_first_arr[0] = new QCborValueRef(_ret.first);
|
||||
_first_arr[0] = new QCborValueConstRef(_ret.first);
|
||||
_second_arr[0] = new QCborValueRef(_ret.second);
|
||||
struct miqt_map _out;
|
||||
_out.len = 1;
|
||||
@ -378,10 +379,28 @@ struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */ QCborMap__Iter
|
||||
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->();
|
||||
}
|
||||
|
||||
QCborValueConstRef* QCborMap__Iterator_OperatorMinusGreater2(const QCborMap__Iterator* self) {
|
||||
return (QCborValueConstRef*) self->operator->();
|
||||
}
|
||||
|
||||
QCborValue* QCborMap__Iterator_Key(const QCborMap__Iterator* self) {
|
||||
return new QCborValue(self->key());
|
||||
}
|
||||
@ -499,13 +518,13 @@ void QCborMap__ConstIterator_OperatorAssign(QCborMap__ConstIterator* self, QCbor
|
||||
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*();
|
||||
// Convert QPair<> from C++ memory to manually-managed C memory
|
||||
QCborValueRef** _first_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
|
||||
QCborValueRef** _second_arr = static_cast<QCborValueRef**>(malloc(sizeof(QCborValueRef*)));
|
||||
_first_arr[0] = new QCborValueRef(_ret.first);
|
||||
_second_arr[0] = new QCborValueRef(_ret.second);
|
||||
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);
|
||||
@ -513,16 +532,30 @@ struct miqt_map /* tuple of QCborValueRef* and QCborValueRef* */ QCborMap__Cons
|
||||
return _out;
|
||||
}
|
||||
|
||||
QCborValueRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self) {
|
||||
return (QCborValueRef*) self->operator->();
|
||||
struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCborMap__ConstIterator_OperatorSubscript(const QCborMap__ConstIterator* self, ptrdiff_t j) {
|
||||
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) {
|
||||
return new QCborValue(self->key());
|
||||
}
|
||||
|
||||
QCborValueRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self) {
|
||||
return new QCborValueRef(self->value());
|
||||
QCborValueConstRef* QCborMap__ConstIterator_Value(const QCborMap__ConstIterator* self) {
|
||||
return new QCborValueConstRef(self->value());
|
||||
}
|
||||
|
||||
bool QCborMap__ConstIterator_OperatorEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o) {
|
||||
|
||||
@ -87,10 +87,10 @@ func (this *QCborMap) Keys() []QCborValue {
|
||||
_ret := make([]QCborValue, int(_ma.len))
|
||||
_outCast := (*[0xffff]*C.QCborValue)(unsafe.Pointer(_ma.data)) // hey ya
|
||||
for i := 0; i < int(_ma.len); i++ {
|
||||
_vv_ret := _outCast[i]
|
||||
_vv_goptr := newQCborValue(_vv_ret)
|
||||
_vv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
_ret[i] = *_vv_goptr
|
||||
_lv_ret := _outCast[i]
|
||||
_lv_goptr := newQCborValue(_lv_ret)
|
||||
_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
||||
_ret[i] = *_lv_goptr
|
||||
}
|
||||
return _ret
|
||||
}
|
||||
@ -618,14 +618,14 @@ func (this *QCborMap__Iterator) OperatorAssign(other *QCborMap__Iterator) {
|
||||
}
|
||||
|
||||
func (this *QCborMap__Iterator) OperatorMultiply() struct {
|
||||
First QCborValueRef
|
||||
First QCborValueConstRef
|
||||
Second QCborValueRef
|
||||
} {
|
||||
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))
|
||||
_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
|
||||
_entry_First := *_first_goptr
|
||||
|
||||
@ -635,7 +635,30 @@ func (this *QCborMap__Iterator) OperatorMultiply() struct {
|
||||
_entry_Second := *_second_goptr
|
||||
|
||||
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
|
||||
}{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)))
|
||||
}
|
||||
|
||||
func (this *QCborMap__Iterator) OperatorMinusGreater2() *QCborValueConstRef {
|
||||
return UnsafeNewQCborValueConstRef(unsafe.Pointer(C.QCborMap__Iterator_OperatorMinusGreater2(this.h)))
|
||||
}
|
||||
|
||||
func (this *QCborMap__Iterator) Key() *QCborValue {
|
||||
_ret := C.QCborMap__Iterator_Key(this.h)
|
||||
_goptr := newQCborValue(_ret)
|
||||
@ -814,30 +841,53 @@ func (this *QCborMap__ConstIterator) OperatorAssign(other *QCborMap__ConstIterat
|
||||
}
|
||||
|
||||
func (this *QCborMap__ConstIterator) OperatorMultiply() struct {
|
||||
First QCborValueRef
|
||||
Second QCborValueRef
|
||||
First QCborValueConstRef
|
||||
Second QCborValueConstRef
|
||||
} {
|
||||
var _mm C.struct_miqt_map = C.QCborMap__ConstIterator_OperatorMultiply(this.h)
|
||||
_First_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.keys))
|
||||
_Second_CArray := (*[0xffff]*C.QCborValueRef)(unsafe.Pointer(_mm.values))
|
||||
_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 := newQCborValueRef(_first_ret)
|
||||
_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 := 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 QCborValueRef
|
||||
Second QCborValueRef
|
||||
First QCborValueConstRef
|
||||
Second QCborValueConstRef
|
||||
}{First: _entry_First, Second: _entry_Second}
|
||||
}
|
||||
|
||||
func (this *QCborMap__ConstIterator) OperatorMinusGreater() *QCborValueRef {
|
||||
return UnsafeNewQCborValueRef(unsafe.Pointer(C.QCborMap__ConstIterator_OperatorMinusGreater(this.h)))
|
||||
func (this *QCborMap__ConstIterator) OperatorSubscript(j int64) struct {
|
||||
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 {
|
||||
@ -847,9 +897,9 @@ func (this *QCborMap__ConstIterator) Key() *QCborValue {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborMap__ConstIterator) Value() *QCborValueRef {
|
||||
func (this *QCborMap__ConstIterator) Value() *QCborValueConstRef {
|
||||
_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
|
||||
return _goptr
|
||||
}
|
||||
|
||||
@ -27,6 +27,7 @@ typedef QCborMap::Iterator QCborMap__Iterator;
|
||||
class QCborMap__Iterator;
|
||||
#endif
|
||||
class QCborValue;
|
||||
class QCborValueConstRef;
|
||||
class QCborValueRef;
|
||||
class QJsonObject;
|
||||
class QVariant;
|
||||
@ -35,6 +36,7 @@ typedef struct QCborMap QCborMap;
|
||||
typedef struct QCborMap__ConstIterator QCborMap__ConstIterator;
|
||||
typedef struct QCborMap__Iterator QCborMap__Iterator;
|
||||
typedef struct QCborValue QCborValue;
|
||||
typedef struct QCborValueConstRef QCborValueConstRef;
|
||||
typedef struct QCborValueRef QCborValueRef;
|
||||
typedef struct QJsonObject QJsonObject;
|
||||
typedef struct QVariant QVariant;
|
||||
@ -108,8 +110,10 @@ void QCborMap_Delete(QCborMap* self);
|
||||
QCborMap__Iterator* QCborMap__Iterator_new();
|
||||
QCborMap__Iterator* QCborMap__Iterator_new2(QCborMap__Iterator* param1);
|
||||
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);
|
||||
QCborValueRef* QCborMap__Iterator_OperatorMinusGreater(const QCborMap__Iterator* self);
|
||||
struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */ QCborMap__Iterator_OperatorMultiply(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);
|
||||
QCborValueRef* QCborMap__Iterator_Value(const QCborMap__Iterator* self);
|
||||
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_new2(QCborMap__ConstIterator* param1);
|
||||
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);
|
||||
QCborValueRef* QCborMap__ConstIterator_OperatorMinusGreater(const QCborMap__ConstIterator* self);
|
||||
struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCborMap__ConstIterator_OperatorMultiply(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);
|
||||
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_OperatorNotEqual(const QCborMap__ConstIterator* self, QCborMap__Iterator* o);
|
||||
bool QCborMap__ConstIterator_OperatorLesser(const QCborMap__ConstIterator* self, QCborMap__Iterator* other);
|
||||
|
||||
@ -5,6 +5,7 @@
|
||||
#include <QCborStreamReader>
|
||||
#include <QCborStreamWriter>
|
||||
#include <QCborValue>
|
||||
#include <QCborValueConstRef>
|
||||
#include <QCborValueRef>
|
||||
#include <QDateTime>
|
||||
#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)));
|
||||
}
|
||||
|
||||
struct miqt_string QCborValue_ToCbor(QCborValue* self) {
|
||||
struct miqt_string QCborValue_ToCbor(const QCborValue* self) {
|
||||
QByteArray _qb = self->toCbor();
|
||||
struct miqt_string _ms;
|
||||
_ms.len = _qb.length();
|
||||
@ -372,7 +373,7 @@ struct miqt_string QCborValue_ToCbor(QCborValue* self) {
|
||||
return _ms;
|
||||
}
|
||||
|
||||
void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer) {
|
||||
void QCborValue_ToCborWithWriter(const QCborValue* self, QCborStreamWriter* 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));
|
||||
}
|
||||
|
||||
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));
|
||||
struct miqt_string _ms;
|
||||
_ms.len = _qb.length();
|
||||
@ -474,7 +475,7 @@ struct miqt_string QCborValue_ToCbor1(QCborValue* self, int opt) {
|
||||
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));
|
||||
}
|
||||
|
||||
@ -493,6 +494,324 @@ void QCborValue_Delete(QCborValue* 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) {
|
||||
return new QCborValueRef(*param1);
|
||||
}
|
||||
@ -505,6 +824,15 @@ void QCborValueRef_OperatorAssignWithOther(QCborValueRef* self, QCborValueRef* o
|
||||
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) {
|
||||
QCborValue::Type _ret = self->type();
|
||||
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));
|
||||
}
|
||||
|
||||
uint8_t QCborValueRef_ToSimpleType(const QCborValueRef* self) {
|
||||
QCborSimpleType _ret = self->toSimpleType();
|
||||
return static_cast<uint8_t>(_ret);
|
||||
}
|
||||
|
||||
uint64_t QCborValueRef_Tag(const QCborValueRef* self) {
|
||||
QCborTag _ret = self->tag();
|
||||
return static_cast<uint64_t>(_ret);
|
||||
@ -664,24 +997,15 @@ QCborMap* QCborValueRef_ToMapWithQCborMap(const QCborValueRef* self, QCborMap* 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);
|
||||
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)));
|
||||
}
|
||||
|
||||
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) {
|
||||
return self->compare(*other);
|
||||
}
|
||||
@ -730,6 +1054,11 @@ struct miqt_string QCborValueRef_ToDiagnosticNotation(QCborValueRef* self) {
|
||||
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) {
|
||||
QCborTag _ret = self->tag(static_cast<QCborTag>(defaultValue));
|
||||
return static_cast<uint64_t>(_ret);
|
||||
|
||||
@ -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 {
|
||||
h *C.QCborValueRef
|
||||
*QCborValueConstRef
|
||||
}
|
||||
|
||||
func (this *QCborValueRef) cPointer() *C.QCborValueRef {
|
||||
@ -750,7 +1141,7 @@ func newQCborValueRef(h *C.QCborValueRef) *QCborValueRef {
|
||||
if h == nil {
|
||||
return nil
|
||||
}
|
||||
return &QCborValueRef{h: h}
|
||||
return &QCborValueRef{h: h, QCborValueConstRef: UnsafeNewQCborValueConstRef(unsafe.Pointer(h))}
|
||||
}
|
||||
|
||||
func UnsafeNewQCborValueRef(h unsafe.Pointer) *QCborValueRef {
|
||||
@ -771,6 +1162,24 @@ func (this *QCborValueRef) OperatorAssignWithOther(other *QCborValueRef) {
|
||||
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 {
|
||||
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)))
|
||||
}
|
||||
|
||||
func (this *QCborValueRef) ToSimpleType() QCborSimpleType {
|
||||
return (QCborSimpleType)(C.QCborValueRef_ToSimpleType(this.h))
|
||||
}
|
||||
|
||||
func (this *QCborValueRef) Tag() QCborTag {
|
||||
return (QCborTag)(C.QCborValueRef_Tag(this.h))
|
||||
}
|
||||
@ -948,42 +1361,24 @@ func (this *QCborValueRef) ToMapWithQCborMap(m *QCborMap) *QCborMap {
|
||||
return _goptr
|
||||
}
|
||||
|
||||
func (this *QCborValueRef) OperatorSubscript(key string) *QCborValue {
|
||||
func (this *QCborValueRef) OperatorSubscript3(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.QCborValueRef_OperatorSubscript(this.h, key_ms)
|
||||
_ret := C.QCborValueRef_OperatorSubscript3(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 *QCborValueRef) OperatorSubscript2(key int64) *QCborValue {
|
||||
_ret := C.QCborValueRef_OperatorSubscript2(this.h, (C.longlong)(key))
|
||||
func (this *QCborValueRef) OperatorSubscript5(key int64) *QCborValue {
|
||||
_ret := C.QCborValueRef_OperatorSubscript5(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 *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 {
|
||||
return (int)(C.QCborValueRef_Compare(this.h, other.cPointer()))
|
||||
}
|
||||
@ -1032,6 +1427,10 @@ func (this *QCborValueRef) ToDiagnosticNotation() string {
|
||||
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 {
|
||||
return (QCborTag)(C.QCborValueRef_Tag1(this.h, (C.uint64_t)(defaultValue)))
|
||||
}
|
||||
|
||||
@ -22,6 +22,7 @@ class QCborParserError;
|
||||
class QCborStreamReader;
|
||||
class QCborStreamWriter;
|
||||
class QCborValue;
|
||||
class QCborValueConstRef;
|
||||
class QCborValueRef;
|
||||
class QDateTime;
|
||||
class QJsonValue;
|
||||
@ -37,6 +38,7 @@ typedef struct QCborParserError QCborParserError;
|
||||
typedef struct QCborStreamReader QCborStreamReader;
|
||||
typedef struct QCborStreamWriter QCborStreamWriter;
|
||||
typedef struct QCborValue QCborValue;
|
||||
typedef struct QCborValueConstRef QCborValueConstRef;
|
||||
typedef struct QCborValueRef QCborValueRef;
|
||||
typedef struct QDateTime QDateTime;
|
||||
typedef struct QJsonValue QJsonValue;
|
||||
@ -126,8 +128,8 @@ QCborValue* QCborValue_FromCbor(QCborStreamReader* reader);
|
||||
QCborValue* QCborValue_FromCborWithBa(struct miqt_string ba);
|
||||
QCborValue* QCborValue_FromCbor2(const char* data, ptrdiff_t lenVal);
|
||||
QCborValue* QCborValue_FromCbor3(const unsigned char* data, ptrdiff_t lenVal);
|
||||
struct miqt_string QCborValue_ToCbor(QCborValue* self);
|
||||
void QCborValue_ToCborWithWriter(QCborValue* self, QCborStreamWriter* writer);
|
||||
struct miqt_string QCborValue_ToCbor(const QCborValue* self);
|
||||
void QCborValue_ToCborWithWriter(const QCborValue* self, QCborStreamWriter* writer);
|
||||
struct miqt_string QCborValue_ToDiagnosticNotation(const QCborValue* self);
|
||||
uint8_t QCborValue_ToSimpleType1(const QCborValue* self, uint8_t 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_FromCbor32(const 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);
|
||||
void QCborValue_ToCbor2(QCborValue* self, QCborStreamWriter* writer, int opt);
|
||||
struct miqt_string QCborValue_ToCbor1(const QCborValue* self, int opt);
|
||||
void QCborValue_ToCbor2(const QCborValue* self, QCborStreamWriter* writer, int opt);
|
||||
struct miqt_string QCborValue_ToDiagnosticNotation1(const QCborValue* self, int opts);
|
||||
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);
|
||||
void QCborValueRef_OperatorAssign(QCborValueRef* self, QCborValue* 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);
|
||||
bool QCborValueRef_IsInteger(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_IsSimpleType(const QCborValueRef* self);
|
||||
bool QCborValueRef_IsSimpleTypeWithSt(const QCborValueRef* self, uint8_t st);
|
||||
uint8_t QCborValueRef_ToSimpleType(const QCborValueRef* self);
|
||||
uint64_t QCborValueRef_Tag(const QCborValueRef* self);
|
||||
QCborValue* QCborValueRef_TaggedValue(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);
|
||||
QCborMap* QCborValueRef_ToMap(const QCborValueRef* self);
|
||||
QCborMap* QCborValueRef_ToMapWithQCborMap(const QCborValueRef* self, QCborMap* m);
|
||||
QCborValue* QCborValueRef_OperatorSubscript(const QCborValueRef* self, struct miqt_string key);
|
||||
QCborValue* QCborValueRef_OperatorSubscript2(const QCborValueRef* self, long long key);
|
||||
QCborValueRef* QCborValueRef_OperatorSubscript3(QCborValueRef* self, long long key);
|
||||
QCborValueRef* QCborValueRef_OperatorSubscript5(QCborValueRef* self, struct miqt_string key);
|
||||
QCborValue* QCborValueRef_OperatorSubscript3(const QCborValueRef* self, struct miqt_string key);
|
||||
QCborValue* QCborValueRef_OperatorSubscript5(const QCborValueRef* self, long long key);
|
||||
int QCborValueRef_Compare(const QCborValueRef* self, QCborValue* other);
|
||||
bool QCborValueRef_OperatorEqual(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);
|
||||
void QCborValueRef_ToCborWithWriter(QCborValueRef* self, QCborStreamWriter* writer);
|
||||
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);
|
||||
QCborValue* QCborValueRef_TaggedValue1(const QCborValueRef* self, QCborValue* defaultValue);
|
||||
long long QCborValueRef_ToInteger1(const QCborValueRef* self, long long defaultValue);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user