class QMetaType#

The QMetaType class manages named types in the meta-object system. More…

Synopsis#

Methods#

Static functions#

Note

This documentation may contain snippets that were automatically translated from C++ to Python. We always welcome contributions to the snippet translation. If you see an issue with the translation, you can also let us know by creating a ticket on https:/bugreports.qt.io/projects/PYSIDE

Detailed Description#

Warning

This section contains snippets that were automatically translated from C++ to Python and may contain errors.

The class is used as a helper to marshall types in QVariant and in queued signals and slots connections. It associates a type name to a type so that it can be created and destructed dynamically at run-time.

Type names can be registered with QMetaType by using either qRegisterMetaType() or registerType() . Registration is not required for most operations; it’s only required for operations that attempt to resolve a type name in string form back to a QMetaType object or the type’s ID. Those include some old-style signal-slot connections using connect() , reading user-types from QDataStream to QVariant , or binding to other languages and IPC mechanisms, like QML, D-Bus, JavaScript, etc.

The following code allocates and destructs an instance of MyClass by its name, which requires that MyClass have been previously registered:

type = QMetaType.fromName("MyClass")
if type.isValid():
    myClassPtr = type.create()
    ...
    type.destroy(myClassPtr)
    myClassPtr = None

If we want the stream operators operator<<() and operator>>() to work on QVariant objects that store custom types, the custom type must provide operator<<() and operator>>() operators.

See also

Q_DECLARE_METATYPE() setValue() value() fromValue()

class Type#

(inherits enum.IntEnum) These are the built-in types supported by QMetaType :

Constant

Description

QMetaType.Void

void

QMetaType.Bool

bool

QMetaType.Int

int

QMetaType.UInt

unsigned int

QMetaType.Double

double

QMetaType.QChar

QChar

QMetaType.QString

QString

QMetaType.QByteArray

QByteArray

QMetaType.Nullptr

std::nullptr_t

QMetaType.VoidStar

void *

QMetaType.Long

long

QMetaType.LongLong

LongLong

QMetaType.Short

short

QMetaType.Char

char

QMetaType.Char16

char16_t

QMetaType.Char32

char32_t

QMetaType.ULong

unsigned long

QMetaType.ULongLong

ULongLong

QMetaType.UShort

unsigned short

QMetaType.SChar

signed char

QMetaType.UChar

unsigned char

QMetaType.Float

float

QMetaType.Float16

qfloat16

QMetaType.QObjectStar

QObject *

QMetaType.QCursor

QCursor

QMetaType.QDate

QDate

QMetaType.QSize

QSize

QMetaType.QTime

QTime

QMetaType.QVariantList

QVariantList

QMetaType.QPolygon

QPolygon

QMetaType.QPolygonF

QPolygonF

QMetaType.QColor

QColor

QMetaType.QColorSpace

QColorSpace (introduced in Qt 5.15)

QMetaType.QSizeF

QSizeF

QMetaType.QRectF

QRectF

QMetaType.QLine

QLine

QMetaType.QTextLength

QTextLength

QMetaType.QStringList

QStringList

QMetaType.QVariantMap

QVariantMap

QMetaType.QVariantHash

QVariantHash

QMetaType.QVariantPair

QVariantPair

QMetaType.QIcon

QIcon

QMetaType.QPen

QPen

QMetaType.QLineF

QLineF

QMetaType.QTextFormat

QTextFormat

QMetaType.QRect

QRect

QMetaType.QPoint

QPoint

QMetaType.QUrl

QUrl

QMetaType.QRegularExpression

QRegularExpression

QMetaType.QDateTime

QDateTime

QMetaType.QPointF

QPointF

QMetaType.QPalette

QPalette

QMetaType.QFont

QFont

QMetaType.QBrush

QBrush

QMetaType.QRegion

QRegion

QMetaType.QBitArray

QBitArray

QMetaType.QImage

QImage

QMetaType.QKeySequence

QKeySequence

QMetaType.QSizePolicy

QSizePolicy

QMetaType.QPixmap

QPixmap

QMetaType.QLocale

QLocale

QMetaType.QBitmap

QBitmap

QMetaType.QTransform

QTransform

QMetaType.QMatrix4x4

QMatrix4x4

QMetaType.QVector2D

QVector2D

QMetaType.QVector3D

QVector3D

QMetaType.QVector4D

QVector4D

QMetaType.QQuaternion

QQuaternion

QMetaType.QEasingCurve

QEasingCurve

QMetaType.QJsonValue

QJsonValue

QMetaType.QJsonObject

QJsonObject

QMetaType.QJsonArray

QJsonArray

QMetaType.QJsonDocument

QJsonDocument

QMetaType.QCborValue

QCborValue

QMetaType.QCborArray

QCborArray

QMetaType.QCborMap

QCborMap

QMetaType.QCborSimpleType

QCborSimpleType

QMetaType.QModelIndex

QModelIndex

QMetaType.QPersistentModelIndex

QPersistentModelIndex (introduced in Qt 5.5)

QMetaType.QUuid

QUuid

QMetaType.QByteArrayList

QByteArrayList

QMetaType.QVariant

QVariant

QMetaType.User

Base value for user types

QMetaType.UnknownType

This is an invalid type id. It is returned from QMetaType for types that are not registered

Additional types can be registered using qRegisterMetaType() or by calling registerType() .

See also

type() typeName()

class TypeFlag#

(inherits enum.Flag) The enum describes attributes of a type supported by QMetaType .

Constant

Description

QMetaType.NeedsConstruction

This type has a default constructor. If the flag is not set, instances can be safely initialized with memset to 0.

QMetaType.NeedsCopyConstruction

(since 6.5) This type has a non-trivial copy constructor. If the flag is not set, instances can be copied with memcpy.

QMetaType.NeedsMoveConstruction

(since 6.5) This type has a non-trivial move constructor. If the flag is not set, instances can be moved with memcpy.

QMetaType.NeedsDestruction

This type has a non-trivial destructor. If the flag is not set, calls to the destructor are not necessary before discarding objects.

QMetaType.RelocatableType

An instance of a type having this attribute can be safely moved to a different memory location using memcpy.

QMetaType.IsEnumeration

This type is an enumeration.

QMetaType.IsUnsignedEnumeration

If the type is an Enumeration, its underlying type is unsigned.

QMetaType.PointerToQObject

This type is a pointer to a class derived from QObject .

QMetaType.IsPointer

This type is a pointer to another type.

QMetaType.IsConst

Indicates that values of this type are immutable; for instance, because they are pointers to const objects.

Note

Before Qt 6.5, both the NeedsConstruction and NeedsDestruction flags were incorrectly set if the either copy construtor or destructor were non-trivial (that is, if the type was not trivial).

Note that the Needs flags may be set but the meta type may not have a publicly-accessible constructor of the relevant type or a publicly-accessible destructor.

__init__(arg__1)#
Parameters:

arg__1 – PyTypeObject

__init__()

Constructs a default, invalid, QMetaType object.

__init__(type)
Parameters:

type – int

Constructs a QMetaType object that contains all information about type typeId.

__init__(arg__1)
Parameters:

arg__1 – Type

alignOf()#
Return type:

int

Returns the alignment of the type in bytes (i.e. alignof(T), where T is the actual type for which this QMetaType instance was constructed for).

This function is typically used together with construct() to perform low-level management of the memory used by a type.

static canConvert(fromType, toType)#
Parameters:
Return type:

bool

Returns true if convert can convert from fromType to toType.

The following conversions are supported by Qt:

Type

Automatically Cast To

Bool

QChar , Double , Int , LongLong , QString , UInt , ULongLong

QByteArray

Double , Int , LongLong , QString , UInt , ULongLong , QUuid

QChar

Bool , Int , UInt , LongLong , ULongLong

QColor

QString

QDate

QDateTime , QString

QDateTime

QDate , QString , QTime

Double

Bool , Int , LongLong , QString , UInt , ULongLong

QFont

QString

Int

Bool , QChar , Double , LongLong , QString , UInt , ULongLong

QKeySequence

Int , QString

QVariantList

QStringList (if the list’s items can be converted to QStrings)

LongLong

Bool , QByteArray , QChar , Double , Int , QString , UInt , ULongLong

QPoint

QPointF

QRect

QRectF

QString

Bool , QByteArray , QChar , QColor , QDate , QDateTime , Double , QFont , Int , QKeySequence , LongLong , QStringList , QTime , UInt , ULongLong , QUuid

QStringList

QVariantList , QString (if the list contains exactly one item)

QTime

QString

UInt

Bool , QChar , Double , Int , LongLong , QString , ULongLong

ULongLong

Bool , QChar , Double , Int , LongLong , QString , UInt

QUuid

QByteArray , QString

Casting between primitive type (int, float, bool etc.) is supported.

Converting between pointers of types derived from QObject will also return true for this function if a qobject_cast from the type described by fromType to the type described by toType would succeed.

A cast from a sequential container will also return true for this function if the toType is QVariantList .

Similarly, a cast from an associative container will also return true for this function the toType is QVariantHash or QVariantMap .

See also

convert() QSequentialIterable Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE() QAssociativeIterable Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE()

static canView(fromType, toType)#
Parameters:
Return type:

bool

Returns true if view can create a mutable view of type toType on type fromType.

Converting between pointers of types derived from QObject will return true for this function if a qobject_cast from the type described by fromType to the type described by toType would succeed.

You can create a mutable view of type QSequentialIterable on any container registered with Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE() .

Similarly you can create a mutable view of type QAssociativeIterable on any container registered with Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE() .

See also

convert() QSequentialIterable Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE() QAssociativeIterable Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE()

static compare(lhs, rhs, typeId, result)#
Parameters:

  • lhs – void

  • rhs – void

  • typeId – int

  • result – int

Return type:

bool

Note

This function is deprecated.

Use the non-static compare method instead

Compares the objects at lhs and rhs. Both objects need to be of type typeId. result is set to less than, equal to or greater than zero, if lhs is less than, equal to or greater than rhs. Returns true, if the comparison succeeded, otherwise false.

static construct(type, where, copy)#
Parameters:

  • type – int

  • where – void

  • copy – void

Return type:

void

Note

This function is deprecated.

Constructs a value of the given type in the existing memory addressed by where, that is a copy of copy, and returns where. If copy is zero, the value is default constructed.

This is a low-level function for explicitly managing the memory used to store the type. Consider calling create() if you don’t need this level of control (that is, use “new” rather than “placement new”).

You must ensure that where points to a location that can store a value of type type, and that where is suitably aligned. The type’s size can be queried by calling sizeOf() .

The rule of thumb for alignment is that a type is aligned to its natural boundary, which is the smallest power of 2 that is bigger than the type, unless that alignment is larger than the maximum useful alignment for the platform. For practical purposes, alignment larger than 2 * sizeof(void*) is only necessary for special hardware instructions (e.g., aligned SSE loads and stores on x86).

See also

destruct() sizeOf()

construct(where[, copy=None])
Parameters:

  • where – void

  • copy – void

Return type:

void

Constructs a value of the type that this QMetaType instance was constructed for in the existing memory addressed by where, that is a copy of copy, and returns where. If copy is zero, the value is default constructed.

This is a low-level function for explicitly managing the memory used to store the type. Consider calling create() if you don’t need this level of control (that is, use “new” rather than “placement new”).

You must ensure that where points to a location where the new value can be stored and that where is suitably aligned. The type’s size can be queried by calling sizeOf() .

The rule of thumb for alignment is that a type is aligned to its natural boundary, which is the smallest power of 2 that is bigger than the type, unless that alignment is larger than the maximum useful alignment for the platform. For practical purposes, alignment larger than 2 * sizeof(void*) is only necessary for special hardware instructions (e.g., aligned SSE loads and stores on x86).

static convert(fromType, from, toType, to)#
Parameters:
Return type:

bool

Converts the object at from from fromType to the preallocated space at to typed toType. Returns true, if the conversion succeeded, otherwise false.

Both from and to have to be valid pointers.

static convert(from, fromTypeId, to, toTypeId)
Parameters:

  • from – void

  • fromTypeId – int

  • to – void

  • toTypeId – int

Return type:

bool

Note

This function is deprecated.

Converts the object at from from fromTypeId to the preallocated space at to typed toTypeId. Returns true, if the conversion succeeded, otherwise false.

Both from and to have to be valid pointers.

create([copy=None])#
Parameters:

copy – void

Return type:

void

Returns a copy of copy, assuming it is of the type that this QMetaType instance was created for. If copy is None, creates a default constructed instance.

See also

destroy()

static create(type[, copy=None])
Parameters:

  • type – int

  • copy – void

Return type:

void

Note

This function is deprecated.

Returns a copy of copy, assuming it is of type type. If copy is zero, creates a default constructed instance.

static destroy(type, data)#
Parameters:

  • type – int

  • data – void

Note

This function is deprecated.

Destroys the data, assuming it is of the type given.

destroy(data)
Parameters:

data – void

Destroys the data, assuming it is of the type that this QMetaType instance was created for.

See also

create()

static destruct(type, where)#
Parameters:

  • type – int

  • where – void

Note

This function is deprecated.

Destructs the value of the given type, located at where.

Unlike destroy() , this function only invokes the type’s destructor, it doesn’t invoke the delete operator.

See also

construct()

destruct(data)
Parameters:

data – void

Destructs the value, located at data, assuming that it is of the type for which this QMetaType instance was constructed for.

Unlike destroy(), this function only invokes the type’s destructor, it doesn’t invoke the delete operator.

See also

construct()

equals(lhs, rhs)#
Parameters:

  • lhs – void

  • rhs – void

Return type:

bool

Compares the objects at lhs and rhs for equality.

Both objects must be of the type described by this metatype. Can only compare the two objects if a less than or equality operator for the type was visible to the metatype declaration. Otherwise, the metatype never considers values equal. When an equality operator was visible to the metatype declaration, it is authoritative; otherwise, if less than is visible, when neither value is less than the other, the two are considered equal. If values are unordered (see compare() for details) they are not equal.

Returns true if the two objects compare equal, otherwise false.

static equals(lhs, rhs, typeId, result)
Parameters:

  • lhs – void

  • rhs – void

  • typeId – int

  • result – int

Return type:

bool

Note

This function is deprecated.

flags()#
Return type:

Combination of TypeFlag

Returns flags of the type for which this QMetaType instance was constructed. To inspect specific type traits, prefer using one of the “is-” functions rather than the flags directly.

static fromName(name)#
Parameters:

name – QByteArrayView

Return type:

QMetaType

Returns a QMetaType matching typeName. The returned object is not valid if the typeName is not known to QMetaType

static hasRegisteredConverterFunction(fromType, toType)#
Parameters:
Return type:

bool

Returns true, if the meta type system has a registered conversion from meta type id fromType to toType

hasRegisteredDataStreamOperators()#
Return type:

bool

Returns true, if the meta type system has registered data stream operators for this meta type.

hasRegisteredDebugStreamOperator()#
Return type:

bool

Returns true, if the meta type system has a registered debug stream operator for this meta type.

static hasRegisteredDebugStreamOperator(typeId)
Parameters:

typeId – int

Return type:

bool

Note

This function is deprecated.

Use hasRegisteredDebugStreamOperator() instead.

Returns true, if the meta type system has a registered debug stream operator for type id typeId.

static hasRegisteredMutableViewFunction(fromType, toType)#
Parameters:
Return type:

bool

Returns true, if the meta type system has a registered mutable view on meta type id fromType of meta type id toType.

id([arg__1=0])#
Parameters:

arg__1 – int

Return type:

int

isCopyConstructible()#
Return type:

bool

Returns true if this type can be copy-constructed. If it can be, then construct() and create() can be used with a copy parameter that is not null.

isDefaultConstructible()#
Return type:

bool

Returns true if this type can be default-constructed. If it can be, then construct() and create() can be used with a copy parameter that is null.

isDestructible()#
Return type:

bool

Returns true if this type can be destroyed. If it can be, then destroy() and destruct() can be called.

isEqualityComparable()#
Return type:

bool

Returns true if a less than or equality operator for the type described by this metatype was visible to the metatype declaration, otherwise false.

isMoveConstructible()#
Return type:

bool

Returns true if this type can be move-constructed. QMetaType currently does not have an API to make use of this trait.

isOrdered()#
Return type:

bool

Returns true if a less than operator for the type described by this metatype was visible to the metatype declaration, otherwise false.

isRegistered()#
Return type:

bool

Returns true if this QMetaType object has been registered with the Qt global metatype registry. Registration allows the type to be found by its name (using fromName() ) or by its ID (using the constructor).

See also

qRegisterMetaType() isValid()

static isRegistered(type)
Parameters:

type – int

Return type:

bool

Returns true if the datatype with ID type is registered; otherwise returns false.

isValid()#
Return type:

bool

Returns true if this QMetaType object contains valid information about a type, false otherwise.

See also

isRegistered()

static load(stream, type, data)#
Parameters:
Return type:

bool

Note

This function is deprecated.

This is an overloaded function.

load(stream, data)
Parameters:
Return type:

bool

Reads the object of this type from the given stream into data. Returns true if the object is loaded successfully; otherwise returns false.

Normally, you should not need to call this function directly. Instead, use QVariant ‘s operator>>(), which relies on load() to stream custom types.

See also

save()

static metaObjectForType(type)#
Parameters:

type – int

Return type:

QMetaObject

Note

This function is deprecated.

returns metaObject for type

See also

metaObject()

name()#
Return type:

str

Returns the type name associated with this QMetaType , or a null pointer if no matching type was found. The returned pointer must not be deleted.

See also

typeName()

__ne__(b)#
Parameters:

b – QMetaType

Return type:

bool

This is an overloaded function.

Returns true if the QMetaType a represents a different type than the QMetaType b, otherwise returns false.

__eq__(b)#
Parameters:

b – QMetaType

Return type:

bool

This is an overloaded function.

Returns true if the QMetaType a represents the same type as the QMetaType b, otherwise returns false.

static registerNormalizedTypedef(normalizedTypeName, type)#
Parameters:
registerType()#

Registers this QMetaType with the type registry so it can be found by name, using fromName() .

See also

qRegisterMetaType()

save(stream, data)#
Parameters:
Return type:

bool

Writes the object pointed to by data to the given stream. Returns true if the object is saved successfully; otherwise returns false.

Normally, you should not need to call this function directly. Instead, use QVariant ‘s operator<<(), which relies on save() to stream custom types.

See also

load()

static save(stream, type, data)
Parameters:
Return type:

bool

Note

This function is deprecated.

This is an overloaded function.

sizeOf()#
Return type:

int

Returns the size of the type in bytes (i.e. sizeof(T), where T is the actual type for which this QMetaType instance was constructed for).

This function is typically used together with construct() to perform low-level management of the memory used by a type.

static sizeOf(type)
Parameters:

type – int

Return type:

int

Note

This function is deprecated.

Returns the size of the given type in bytes (i.e. sizeof(T), where T is the actual type identified by the type argument).

This function is typically used together with construct() to perform low-level management of the memory used by a type.

static type(typeName)#
Parameters:

typeName – QByteArray

Return type:

int

Note

This function is deprecated.

This is an overloaded function.

Returns a handle to the type called typeName, or 0 if there is no such type.

static type(typeName)
Parameters:

typeName – str

Return type:

int

Note

This function is deprecated.

Returns a handle to the type called typeName, or UnknownType if there is no such type.

static typeFlags(type)#
Parameters:

type – int

Return type:

Combination of TypeFlag

Note

This function is deprecated.

Returns flags of the given type.

See also

TypeFlags

static typeName(type)#
Parameters:

type – int

Return type:

str

Note

This function is deprecated.

Returns the type name associated with the given typeId, or a null pointer if no matching type was found. The returned pointer must not be deleted.

underlyingType()#
Return type:

QMetaType

If this metatype represents an enumeration, this method returns a metatype of a numeric class of the same signedness and size as the enums underlying type. If it represents a QFlags type, it returns Int . In all other cases an invalid QMetaType is returned.

static unregisterConverterFunction(from, to)#
Parameters:
static unregisterMetaType(type)#
Parameters:

type – QMetaType

static unregisterMutableViewFunction(from, to)#
Parameters:
static view(fromType, from, toType, to)#
Parameters:
Return type:

bool

Creates a mutable view on the object at from of fromType in the preallocated space at to typed toType. Returns true if the conversion succeeded, otherwise false.