mirror of
https://github.com/mappu/miqt.git
synced 2024-12-22 17:08:38 +00:00
692 lines
23 KiB
Go
692 lines
23 KiB
Go
package qt6
|
|
|
|
/*
|
|
|
|
#include "gen_qmetacontainer.h"
|
|
#include <stdlib.h>
|
|
|
|
*/
|
|
import "C"
|
|
|
|
import (
|
|
"runtime"
|
|
"unsafe"
|
|
)
|
|
|
|
type QtMetaContainerPrivate__IteratorCapability byte
|
|
|
|
const (
|
|
QtMetaContainerPrivate__InputCapability QtMetaContainerPrivate__IteratorCapability = 1
|
|
QtMetaContainerPrivate__ForwardCapability QtMetaContainerPrivate__IteratorCapability = 2
|
|
QtMetaContainerPrivate__BiDirectionalCapability QtMetaContainerPrivate__IteratorCapability = 4
|
|
QtMetaContainerPrivate__RandomAccessCapability QtMetaContainerPrivate__IteratorCapability = 8
|
|
)
|
|
|
|
type QtMetaContainerPrivate__AddRemoveCapability byte
|
|
|
|
const (
|
|
QtMetaContainerPrivate__CanAddAtBegin QtMetaContainerPrivate__AddRemoveCapability = 1
|
|
QtMetaContainerPrivate__CanRemoveAtBegin QtMetaContainerPrivate__AddRemoveCapability = 2
|
|
QtMetaContainerPrivate__CanAddAtEnd QtMetaContainerPrivate__AddRemoveCapability = 4
|
|
QtMetaContainerPrivate__CanRemoveAtEnd QtMetaContainerPrivate__AddRemoveCapability = 8
|
|
)
|
|
|
|
type QtMetaContainerPrivate__QMetaContainerInterface__Position byte
|
|
|
|
const (
|
|
QtMetaContainerPrivate__QMetaContainerInterface__AtBegin QtMetaContainerPrivate__QMetaContainerInterface__Position = 0
|
|
QtMetaContainerPrivate__QMetaContainerInterface__AtEnd QtMetaContainerPrivate__QMetaContainerInterface__Position = 1
|
|
QtMetaContainerPrivate__QMetaContainerInterface__Unspecified QtMetaContainerPrivate__QMetaContainerInterface__Position = 2
|
|
)
|
|
|
|
type QtMetaContainerPrivate__QMetaContainerInterface struct {
|
|
h *C.QtMetaContainerPrivate__QMetaContainerInterface
|
|
}
|
|
|
|
func (this *QtMetaContainerPrivate__QMetaContainerInterface) cPointer() *C.QtMetaContainerPrivate__QMetaContainerInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QtMetaContainerPrivate__QMetaContainerInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
func newQtMetaContainerPrivate__QMetaContainerInterface(h *C.QtMetaContainerPrivate__QMetaContainerInterface) *QtMetaContainerPrivate__QMetaContainerInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QtMetaContainerPrivate__QMetaContainerInterface{h: h}
|
|
}
|
|
|
|
func UnsafeNewQtMetaContainerPrivate__QMetaContainerInterface(h unsafe.Pointer) *QtMetaContainerPrivate__QMetaContainerInterface {
|
|
return newQtMetaContainerPrivate__QMetaContainerInterface((*C.QtMetaContainerPrivate__QMetaContainerInterface)(h))
|
|
}
|
|
|
|
// NewQtMetaContainerPrivate__QMetaContainerInterface constructs a new QtMetaContainerPrivate::QMetaContainerInterface object.
|
|
func NewQtMetaContainerPrivate__QMetaContainerInterface() *QtMetaContainerPrivate__QMetaContainerInterface {
|
|
ret := C.QtMetaContainerPrivate__QMetaContainerInterface_new()
|
|
return newQtMetaContainerPrivate__QMetaContainerInterface(ret)
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QtMetaContainerPrivate__QMetaContainerInterface) Delete() {
|
|
C.QtMetaContainerPrivate__QMetaContainerInterface_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 *QtMetaContainerPrivate__QMetaContainerInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QtMetaContainerPrivate__QMetaContainerInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QtMetaContainerPrivate__QMetaSequenceInterface struct {
|
|
h *C.QtMetaContainerPrivate__QMetaSequenceInterface
|
|
*QtMetaContainerPrivate__QMetaContainerInterface
|
|
}
|
|
|
|
func (this *QtMetaContainerPrivate__QMetaSequenceInterface) cPointer() *C.QtMetaContainerPrivate__QMetaSequenceInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QtMetaContainerPrivate__QMetaSequenceInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
func newQtMetaContainerPrivate__QMetaSequenceInterface(h *C.QtMetaContainerPrivate__QMetaSequenceInterface) *QtMetaContainerPrivate__QMetaSequenceInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QtMetaContainerPrivate__QMetaSequenceInterface{h: h, QtMetaContainerPrivate__QMetaContainerInterface: UnsafeNewQtMetaContainerPrivate__QMetaContainerInterface(unsafe.Pointer(h))}
|
|
}
|
|
|
|
func UnsafeNewQtMetaContainerPrivate__QMetaSequenceInterface(h unsafe.Pointer) *QtMetaContainerPrivate__QMetaSequenceInterface {
|
|
return newQtMetaContainerPrivate__QMetaSequenceInterface((*C.QtMetaContainerPrivate__QMetaSequenceInterface)(h))
|
|
}
|
|
|
|
// NewQtMetaContainerPrivate__QMetaSequenceInterface constructs a new QtMetaContainerPrivate::QMetaSequenceInterface object.
|
|
func NewQtMetaContainerPrivate__QMetaSequenceInterface() *QtMetaContainerPrivate__QMetaSequenceInterface {
|
|
ret := C.QtMetaContainerPrivate__QMetaSequenceInterface_new()
|
|
return newQtMetaContainerPrivate__QMetaSequenceInterface(ret)
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QtMetaContainerPrivate__QMetaSequenceInterface) Delete() {
|
|
C.QtMetaContainerPrivate__QMetaSequenceInterface_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 *QtMetaContainerPrivate__QMetaSequenceInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QtMetaContainerPrivate__QMetaSequenceInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QtMetaContainerPrivate__QMetaAssociationInterface struct {
|
|
h *C.QtMetaContainerPrivate__QMetaAssociationInterface
|
|
*QtMetaContainerPrivate__QMetaContainerInterface
|
|
}
|
|
|
|
func (this *QtMetaContainerPrivate__QMetaAssociationInterface) cPointer() *C.QtMetaContainerPrivate__QMetaAssociationInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QtMetaContainerPrivate__QMetaAssociationInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
func newQtMetaContainerPrivate__QMetaAssociationInterface(h *C.QtMetaContainerPrivate__QMetaAssociationInterface) *QtMetaContainerPrivate__QMetaAssociationInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QtMetaContainerPrivate__QMetaAssociationInterface{h: h, QtMetaContainerPrivate__QMetaContainerInterface: UnsafeNewQtMetaContainerPrivate__QMetaContainerInterface(unsafe.Pointer(h))}
|
|
}
|
|
|
|
func UnsafeNewQtMetaContainerPrivate__QMetaAssociationInterface(h unsafe.Pointer) *QtMetaContainerPrivate__QMetaAssociationInterface {
|
|
return newQtMetaContainerPrivate__QMetaAssociationInterface((*C.QtMetaContainerPrivate__QMetaAssociationInterface)(h))
|
|
}
|
|
|
|
// NewQtMetaContainerPrivate__QMetaAssociationInterface constructs a new QtMetaContainerPrivate::QMetaAssociationInterface object.
|
|
func NewQtMetaContainerPrivate__QMetaAssociationInterface() *QtMetaContainerPrivate__QMetaAssociationInterface {
|
|
ret := C.QtMetaContainerPrivate__QMetaAssociationInterface_new()
|
|
return newQtMetaContainerPrivate__QMetaAssociationInterface(ret)
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QtMetaContainerPrivate__QMetaAssociationInterface) Delete() {
|
|
C.QtMetaContainerPrivate__QMetaAssociationInterface_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 *QtMetaContainerPrivate__QMetaAssociationInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QtMetaContainerPrivate__QMetaAssociationInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMetaContainer struct {
|
|
h *C.QMetaContainer
|
|
}
|
|
|
|
func (this *QMetaContainer) cPointer() *C.QMetaContainer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMetaContainer) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
func newQMetaContainer(h *C.QMetaContainer) *QMetaContainer {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMetaContainer{h: h}
|
|
}
|
|
|
|
func UnsafeNewQMetaContainer(h unsafe.Pointer) *QMetaContainer {
|
|
return newQMetaContainer((*C.QMetaContainer)(h))
|
|
}
|
|
|
|
// NewQMetaContainer constructs a new QMetaContainer object.
|
|
func NewQMetaContainer() *QMetaContainer {
|
|
ret := C.QMetaContainer_new()
|
|
return newQMetaContainer(ret)
|
|
}
|
|
|
|
// NewQMetaContainer2 constructs a new QMetaContainer object.
|
|
func NewQMetaContainer2(d *QtMetaContainerPrivate__QMetaContainerInterface) *QMetaContainer {
|
|
ret := C.QMetaContainer_new2(d.cPointer())
|
|
return newQMetaContainer(ret)
|
|
}
|
|
|
|
// NewQMetaContainer3 constructs a new QMetaContainer object.
|
|
func NewQMetaContainer3(param1 *QMetaContainer) *QMetaContainer {
|
|
ret := C.QMetaContainer_new3(param1.cPointer())
|
|
return newQMetaContainer(ret)
|
|
}
|
|
|
|
func (this *QMetaContainer) HasInputIterator() bool {
|
|
return (bool)(C.QMetaContainer_HasInputIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaContainer) HasForwardIterator() bool {
|
|
return (bool)(C.QMetaContainer_HasForwardIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaContainer) HasBidirectionalIterator() bool {
|
|
return (bool)(C.QMetaContainer_HasBidirectionalIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaContainer) HasRandomAccessIterator() bool {
|
|
return (bool)(C.QMetaContainer_HasRandomAccessIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaContainer) HasSize() bool {
|
|
return (bool)(C.QMetaContainer_HasSize(this.h))
|
|
}
|
|
|
|
func (this *QMetaContainer) Size(container unsafe.Pointer) int64 {
|
|
return (int64)(C.QMetaContainer_Size(this.h, container))
|
|
}
|
|
|
|
func (this *QMetaContainer) CanClear() bool {
|
|
return (bool)(C.QMetaContainer_CanClear(this.h))
|
|
}
|
|
|
|
func (this *QMetaContainer) Clear(container unsafe.Pointer) {
|
|
C.QMetaContainer_Clear(this.h, container)
|
|
}
|
|
|
|
func (this *QMetaContainer) HasIterator() bool {
|
|
return (bool)(C.QMetaContainer_HasIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaContainer) Begin(container unsafe.Pointer) unsafe.Pointer {
|
|
return (unsafe.Pointer)(C.QMetaContainer_Begin(this.h, container))
|
|
}
|
|
|
|
func (this *QMetaContainer) End(container unsafe.Pointer) unsafe.Pointer {
|
|
return (unsafe.Pointer)(C.QMetaContainer_End(this.h, container))
|
|
}
|
|
|
|
func (this *QMetaContainer) DestroyIterator(iterator unsafe.Pointer) {
|
|
C.QMetaContainer_DestroyIterator(this.h, iterator)
|
|
}
|
|
|
|
func (this *QMetaContainer) CompareIterator(i unsafe.Pointer, j unsafe.Pointer) bool {
|
|
return (bool)(C.QMetaContainer_CompareIterator(this.h, i, j))
|
|
}
|
|
|
|
func (this *QMetaContainer) CopyIterator(target unsafe.Pointer, source unsafe.Pointer) {
|
|
C.QMetaContainer_CopyIterator(this.h, target, source)
|
|
}
|
|
|
|
func (this *QMetaContainer) AdvanceIterator(iterator unsafe.Pointer, step int64) {
|
|
C.QMetaContainer_AdvanceIterator(this.h, iterator, (C.ptrdiff_t)(step))
|
|
}
|
|
|
|
func (this *QMetaContainer) DiffIterator(i unsafe.Pointer, j unsafe.Pointer) int64 {
|
|
return (int64)(C.QMetaContainer_DiffIterator(this.h, i, j))
|
|
}
|
|
|
|
func (this *QMetaContainer) HasConstIterator() bool {
|
|
return (bool)(C.QMetaContainer_HasConstIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaContainer) ConstBegin(container unsafe.Pointer) unsafe.Pointer {
|
|
return (unsafe.Pointer)(C.QMetaContainer_ConstBegin(this.h, container))
|
|
}
|
|
|
|
func (this *QMetaContainer) ConstEnd(container unsafe.Pointer) unsafe.Pointer {
|
|
return (unsafe.Pointer)(C.QMetaContainer_ConstEnd(this.h, container))
|
|
}
|
|
|
|
func (this *QMetaContainer) DestroyConstIterator(iterator unsafe.Pointer) {
|
|
C.QMetaContainer_DestroyConstIterator(this.h, iterator)
|
|
}
|
|
|
|
func (this *QMetaContainer) CompareConstIterator(i unsafe.Pointer, j unsafe.Pointer) bool {
|
|
return (bool)(C.QMetaContainer_CompareConstIterator(this.h, i, j))
|
|
}
|
|
|
|
func (this *QMetaContainer) CopyConstIterator(target unsafe.Pointer, source unsafe.Pointer) {
|
|
C.QMetaContainer_CopyConstIterator(this.h, target, source)
|
|
}
|
|
|
|
func (this *QMetaContainer) AdvanceConstIterator(iterator unsafe.Pointer, step int64) {
|
|
C.QMetaContainer_AdvanceConstIterator(this.h, iterator, (C.ptrdiff_t)(step))
|
|
}
|
|
|
|
func (this *QMetaContainer) DiffConstIterator(i unsafe.Pointer, j unsafe.Pointer) int64 {
|
|
return (int64)(C.QMetaContainer_DiffConstIterator(this.h, i, j))
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMetaContainer) Delete() {
|
|
C.QMetaContainer_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 *QMetaContainer) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMetaContainer) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMetaSequence struct {
|
|
h *C.QMetaSequence
|
|
*QMetaContainer
|
|
}
|
|
|
|
func (this *QMetaSequence) cPointer() *C.QMetaSequence {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMetaSequence) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
func newQMetaSequence(h *C.QMetaSequence) *QMetaSequence {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMetaSequence{h: h, QMetaContainer: UnsafeNewQMetaContainer(unsafe.Pointer(h))}
|
|
}
|
|
|
|
func UnsafeNewQMetaSequence(h unsafe.Pointer) *QMetaSequence {
|
|
return newQMetaSequence((*C.QMetaSequence)(h))
|
|
}
|
|
|
|
// NewQMetaSequence constructs a new QMetaSequence object.
|
|
func NewQMetaSequence() *QMetaSequence {
|
|
ret := C.QMetaSequence_new()
|
|
return newQMetaSequence(ret)
|
|
}
|
|
|
|
// NewQMetaSequence2 constructs a new QMetaSequence object.
|
|
func NewQMetaSequence2(d *QtMetaContainerPrivate__QMetaSequenceInterface) *QMetaSequence {
|
|
ret := C.QMetaSequence_new2(d.cPointer())
|
|
return newQMetaSequence(ret)
|
|
}
|
|
|
|
func (this *QMetaSequence) ValueMetaType() *QMetaType {
|
|
_ret := C.QMetaSequence_ValueMetaType(this.h)
|
|
_goptr := newQMetaType(_ret)
|
|
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
return _goptr
|
|
}
|
|
|
|
func (this *QMetaSequence) IsSortable() bool {
|
|
return (bool)(C.QMetaSequence_IsSortable(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) CanAddValueAtBegin() bool {
|
|
return (bool)(C.QMetaSequence_CanAddValueAtBegin(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) AddValueAtBegin(container unsafe.Pointer, value unsafe.Pointer) {
|
|
C.QMetaSequence_AddValueAtBegin(this.h, container, value)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanAddValueAtEnd() bool {
|
|
return (bool)(C.QMetaSequence_CanAddValueAtEnd(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) AddValueAtEnd(container unsafe.Pointer, value unsafe.Pointer) {
|
|
C.QMetaSequence_AddValueAtEnd(this.h, container, value)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanRemoveValueAtBegin() bool {
|
|
return (bool)(C.QMetaSequence_CanRemoveValueAtBegin(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) RemoveValueAtBegin(container unsafe.Pointer) {
|
|
C.QMetaSequence_RemoveValueAtBegin(this.h, container)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanRemoveValueAtEnd() bool {
|
|
return (bool)(C.QMetaSequence_CanRemoveValueAtEnd(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) RemoveValueAtEnd(container unsafe.Pointer) {
|
|
C.QMetaSequence_RemoveValueAtEnd(this.h, container)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanGetValueAtIndex() bool {
|
|
return (bool)(C.QMetaSequence_CanGetValueAtIndex(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) ValueAtIndex(container unsafe.Pointer, index int64, result unsafe.Pointer) {
|
|
C.QMetaSequence_ValueAtIndex(this.h, container, (C.ptrdiff_t)(index), result)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanSetValueAtIndex() bool {
|
|
return (bool)(C.QMetaSequence_CanSetValueAtIndex(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) SetValueAtIndex(container unsafe.Pointer, index int64, value unsafe.Pointer) {
|
|
C.QMetaSequence_SetValueAtIndex(this.h, container, (C.ptrdiff_t)(index), value)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanAddValue() bool {
|
|
return (bool)(C.QMetaSequence_CanAddValue(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) AddValue(container unsafe.Pointer, value unsafe.Pointer) {
|
|
C.QMetaSequence_AddValue(this.h, container, value)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanRemoveValue() bool {
|
|
return (bool)(C.QMetaSequence_CanRemoveValue(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) RemoveValue(container unsafe.Pointer) {
|
|
C.QMetaSequence_RemoveValue(this.h, container)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanGetValueAtIterator() bool {
|
|
return (bool)(C.QMetaSequence_CanGetValueAtIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) ValueAtIterator(iterator unsafe.Pointer, result unsafe.Pointer) {
|
|
C.QMetaSequence_ValueAtIterator(this.h, iterator, result)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanSetValueAtIterator() bool {
|
|
return (bool)(C.QMetaSequence_CanSetValueAtIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) SetValueAtIterator(iterator unsafe.Pointer, value unsafe.Pointer) {
|
|
C.QMetaSequence_SetValueAtIterator(this.h, iterator, value)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanInsertValueAtIterator() bool {
|
|
return (bool)(C.QMetaSequence_CanInsertValueAtIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) InsertValueAtIterator(container unsafe.Pointer, iterator unsafe.Pointer, value unsafe.Pointer) {
|
|
C.QMetaSequence_InsertValueAtIterator(this.h, container, iterator, value)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanEraseValueAtIterator() bool {
|
|
return (bool)(C.QMetaSequence_CanEraseValueAtIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) EraseValueAtIterator(container unsafe.Pointer, iterator unsafe.Pointer) {
|
|
C.QMetaSequence_EraseValueAtIterator(this.h, container, iterator)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanEraseRangeAtIterator() bool {
|
|
return (bool)(C.QMetaSequence_CanEraseRangeAtIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) EraseRangeAtIterator(container unsafe.Pointer, iterator1 unsafe.Pointer, iterator2 unsafe.Pointer) {
|
|
C.QMetaSequence_EraseRangeAtIterator(this.h, container, iterator1, iterator2)
|
|
}
|
|
|
|
func (this *QMetaSequence) CanGetValueAtConstIterator() bool {
|
|
return (bool)(C.QMetaSequence_CanGetValueAtConstIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaSequence) ValueAtConstIterator(iterator unsafe.Pointer, result unsafe.Pointer) {
|
|
C.QMetaSequence_ValueAtConstIterator(this.h, iterator, result)
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMetaSequence) Delete() {
|
|
C.QMetaSequence_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 *QMetaSequence) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMetaSequence) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMetaAssociation struct {
|
|
h *C.QMetaAssociation
|
|
*QMetaContainer
|
|
}
|
|
|
|
func (this *QMetaAssociation) cPointer() *C.QMetaAssociation {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMetaAssociation) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
func newQMetaAssociation(h *C.QMetaAssociation) *QMetaAssociation {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMetaAssociation{h: h, QMetaContainer: UnsafeNewQMetaContainer(unsafe.Pointer(h))}
|
|
}
|
|
|
|
func UnsafeNewQMetaAssociation(h unsafe.Pointer) *QMetaAssociation {
|
|
return newQMetaAssociation((*C.QMetaAssociation)(h))
|
|
}
|
|
|
|
// NewQMetaAssociation constructs a new QMetaAssociation object.
|
|
func NewQMetaAssociation() *QMetaAssociation {
|
|
ret := C.QMetaAssociation_new()
|
|
return newQMetaAssociation(ret)
|
|
}
|
|
|
|
// NewQMetaAssociation2 constructs a new QMetaAssociation object.
|
|
func NewQMetaAssociation2(d *QtMetaContainerPrivate__QMetaAssociationInterface) *QMetaAssociation {
|
|
ret := C.QMetaAssociation_new2(d.cPointer())
|
|
return newQMetaAssociation(ret)
|
|
}
|
|
|
|
func (this *QMetaAssociation) KeyMetaType() *QMetaType {
|
|
_ret := C.QMetaAssociation_KeyMetaType(this.h)
|
|
_goptr := newQMetaType(_ret)
|
|
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
return _goptr
|
|
}
|
|
|
|
func (this *QMetaAssociation) MappedMetaType() *QMetaType {
|
|
_ret := C.QMetaAssociation_MappedMetaType(this.h)
|
|
_goptr := newQMetaType(_ret)
|
|
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
return _goptr
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanInsertKey() bool {
|
|
return (bool)(C.QMetaAssociation_CanInsertKey(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) InsertKey(container unsafe.Pointer, key unsafe.Pointer) {
|
|
C.QMetaAssociation_InsertKey(this.h, container, key)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanRemoveKey() bool {
|
|
return (bool)(C.QMetaAssociation_CanRemoveKey(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) RemoveKey(container unsafe.Pointer, key unsafe.Pointer) {
|
|
C.QMetaAssociation_RemoveKey(this.h, container, key)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanContainsKey() bool {
|
|
return (bool)(C.QMetaAssociation_CanContainsKey(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) ContainsKey(container unsafe.Pointer, key unsafe.Pointer) bool {
|
|
return (bool)(C.QMetaAssociation_ContainsKey(this.h, container, key))
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanGetMappedAtKey() bool {
|
|
return (bool)(C.QMetaAssociation_CanGetMappedAtKey(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) MappedAtKey(container unsafe.Pointer, key unsafe.Pointer, mapped unsafe.Pointer) {
|
|
C.QMetaAssociation_MappedAtKey(this.h, container, key, mapped)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanSetMappedAtKey() bool {
|
|
return (bool)(C.QMetaAssociation_CanSetMappedAtKey(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) SetMappedAtKey(container unsafe.Pointer, key unsafe.Pointer, mapped unsafe.Pointer) {
|
|
C.QMetaAssociation_SetMappedAtKey(this.h, container, key, mapped)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanGetKeyAtIterator() bool {
|
|
return (bool)(C.QMetaAssociation_CanGetKeyAtIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) KeyAtIterator(iterator unsafe.Pointer, key unsafe.Pointer) {
|
|
C.QMetaAssociation_KeyAtIterator(this.h, iterator, key)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanGetKeyAtConstIterator() bool {
|
|
return (bool)(C.QMetaAssociation_CanGetKeyAtConstIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) KeyAtConstIterator(iterator unsafe.Pointer, key unsafe.Pointer) {
|
|
C.QMetaAssociation_KeyAtConstIterator(this.h, iterator, key)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanGetMappedAtIterator() bool {
|
|
return (bool)(C.QMetaAssociation_CanGetMappedAtIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) MappedAtIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
|
|
C.QMetaAssociation_MappedAtIterator(this.h, iterator, mapped)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanGetMappedAtConstIterator() bool {
|
|
return (bool)(C.QMetaAssociation_CanGetMappedAtConstIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) MappedAtConstIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
|
|
C.QMetaAssociation_MappedAtConstIterator(this.h, iterator, mapped)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanSetMappedAtIterator() bool {
|
|
return (bool)(C.QMetaAssociation_CanSetMappedAtIterator(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) SetMappedAtIterator(iterator unsafe.Pointer, mapped unsafe.Pointer) {
|
|
C.QMetaAssociation_SetMappedAtIterator(this.h, iterator, mapped)
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanCreateIteratorAtKey() bool {
|
|
return (bool)(C.QMetaAssociation_CanCreateIteratorAtKey(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) CreateIteratorAtKey(container unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
|
|
return (unsafe.Pointer)(C.QMetaAssociation_CreateIteratorAtKey(this.h, container, key))
|
|
}
|
|
|
|
func (this *QMetaAssociation) CanCreateConstIteratorAtKey() bool {
|
|
return (bool)(C.QMetaAssociation_CanCreateConstIteratorAtKey(this.h))
|
|
}
|
|
|
|
func (this *QMetaAssociation) CreateConstIteratorAtKey(container unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
|
|
return (unsafe.Pointer)(C.QMetaAssociation_CreateConstIteratorAtKey(this.h, container, key))
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMetaAssociation) Delete() {
|
|
C.QMetaAssociation_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 *QMetaAssociation) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMetaAssociation) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|