QMetaType Class

Documentation des fonctions membres

[constexpr noexcept default, since 6.0] QMetaType::QMetaType()

Crée un objet QMetaType par défaut, non valide.

Cette fonction a été introduite dans Qt 6.0.

[explicit] QMetaType::QMetaType(int typeId)

Crée un objet QMetaType contenant toutes les informations relatives à l'typeId du type.

[constexpr, since 6.0] qsizetype QMetaType::alignOf() const

Renvoie l'alignement du type en octets (c'est-à-dire `alignof(T)`, où `T` est le type réel pour lequel cette instance de ` QMetaType ` a été construite).

Cette fonction est généralement utilisée conjointement avec ` construct()` pour effectuer une gestion de bas niveau de la mémoire utilisée par un type.

Cette fonction a été introduite dans Qt 6.0.

Voir également ` QMetaType::construct()` et ` QMetaType::sizeOf()`.

[static] bool QMetaType::canConvert(QMetaType fromType, QMetaType toType)

Renvoie ` true ` si ` QMetaType::convert ` peut effectuer la conversion de ` fromType ` vers ` toType`. Notez qu’il s’agit principalement de la capacité à exécuter la conversion, alors que la conversion elle-même peut échouer lors de sa tentative (par exemple, lors de la conversion d’une valeur à virgule flottante en un entier hors de sa plage).

La fonction ` registerConverter()` permet d’enregistrer des conversions supplémentaires, soit entre un type intégré et un type non intégré, soit entre deux types non intégrés. Cette fonction renvoie ` true ` si le chemin de conversion est enregistré.

Les conversions suivantes sont prises en charge par Qt :

Les autres conversions prises en charge incluent celles entre tous les types primitifs (int, float, bool, etc., y compris toutes les énumérations) et entre n'importe quel type de pointeur et std::nullptr_t. Les énumérations peuvent également être converties en QString et QByteArray.

Si fromType et toType sont tous deux des types dérivés de QObject (ou des pointeurs vers ceux-ci), cette fonction renverra également true si l’un des types est dérivé de l’autre. Autrement dit, elle renvoie vrai si la conversion static_cast<> du type décrit par fromType vers le type décrit par toType pouvait être compilée. La fonction convert() fonctionne comme qobject_cast() et vérifie le type dynamique de l’objet pointé par QVariant.

Un transtypage à partir d’un conteneur séquentiel renverra également « true » pour cette fonction si toType est QVariantList.

De même, une conversion à partir d’un conteneur associatif renverra également « true » à cette fonction si le toType est de type QVariantHash ou QVariantMap.

Voir également convert(), QMetaSequence::Iterable, Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(), QMetaAssociation::Iterable et Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE().

[static] bool QMetaType::canView(QMetaType fromType, QMetaType toType)

Renvoie ` true ` si ` QMetaType::view ` peut créer une vue modifiable de type ` toType ` sur le type ` fromType`.

La conversion entre des pointeurs de types dérivés de QObject renverra « true » pour cette fonction si une conversion de qobject_cast du type décrit par fromType vers le type décrit par toType aboutissait.

Vous pouvez créer une vue modifiable de type QMetaSequence::Iterable sur n'importe quel conteneur enregistré avec Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE().

De même, vous pouvez créer une vue modifiable de type QMetaAssociation::Iterable sur n'importe quel conteneur enregistré avec Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE().

Voir également convert(), QMetaSequence::Iterable, Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(), QMetaAssociation::Iterable et Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE().

[since 6.0] QPartialOrdering QMetaType::compare(const void *lhs, const void *rhs) const

Compare les objets disponibles à l'adresse lhs et rhs afin de déterminer leur ordre.

Renvoie QPartialOrdering::Unordered si la comparaison n’est pas prise en charge ou si les valeurs ne sont pas ordonnées. Sinon, renvoie QPartialOrdering::Less, QPartialOrdering::Equivalent ou QPartialOrdering::Greater si lhs est respectivement inférieur à, égal à ou supérieur à rhs.

Les deux objets doivent être du type décrit par ce métatype. Si l’un des deux, lhs ou rhs, est de type nullptr, les valeurs ne sont pas ordonnées. La comparaison n’est prise en charge que si l’opérateur « inférieur à » du type était visible lors de la déclaration du métatype.

Si l’opérateur d’égalité du type était également visible, les valeurs ne seront considérées comme égales que si l’opérateur d’égalité indique qu’elles le sont. En l’absence d’opérateur d’égalité, lorsque aucune des deux valeurs n’est inférieure à l’autre, les valeurs sont considérées comme égales ; si l’égalité est également disponible et que ces deux valeurs ne sont pas égales, elles sont considérées comme non ordonnées, tout comme les valeurs NaN (not a number) d’un type à virgule flottante qui ne s’inscrivent pas dans son ordre.

Cette fonction a été introduite dans Qt 6.0.

Voir également equals() et isOrdered().

void *QMetaType::construct(void *where, const void *copy = nullptr) const

Construit une valeur du type pour lequel cette instance de ` QMetaType ` a été créée dans la mémoire existante adressée par ` where`, c'est-à-dire une copie de ` copy`, et renvoie ` where`. Si ` copy ` est égal à zéro, la valeur est construite par défaut.

Il s'agit d'une fonction de bas niveau permettant de gérer explicitement la mémoire utilisée pour stocker le type. Envisagez d'appeler ` create()` si vous n'avez pas besoin de ce niveau de contrôle (c'est-à-dire utilisez « new » plutôt que « placement new »).

Vous devez vous assurer que where pointe vers un emplacement où la nouvelle valeur peut être stockée et que where est correctement aligné. La taille du type peut être interrogée en appelant sizeOf().

La règle générale en matière d’alignement est qu’un type est aligné sur sa limite naturelle, c’est-à-dire la plus petite puissance de 2 supérieure au type, à moins que cet alignement ne soit supérieur à l’alignement utile maximal pour la plate-forme. D’un point de vue pratique, un alignement supérieur à 2 * sizeof(void*) n’est nécessaire que pour des instructions matérielles spécifiques (par exemple, les chargements et stockages SSE alignés sur x86).

[static] bool QMetaType::convert(QMetaType fromType, const void *from, QMetaType toType, void *to)

Convertit l'objet situé à l'adresse from, provenant de fromType, vers l'espace préalloué à l'adresse to, de type toType. Renvoie true si la conversion a réussi, sinon false.

from et to doivent tous deux être des pointeurs valides.

void *QMetaType::create(const void *copy = nullptr) const

Renvoie une copie de ` copy`, en supposant qu'elle soit du type pour lequel cette instance de ` QMetaType ` a été créée. Si ` copy ` est de type ` nullptr`, crée une instance construite par défaut.

Voir également QMetaType::destroy().

bool QMetaType::debugStream(QDebug &dbg, const void *rhs)

Diffuse l'objet situé à l'adresse rhs vers le flux de débogage dbg. Renvoie true en cas de réussite, sinon false.

void QMetaType::destroy(void *data) const

Détruit l'data, à condition qu'il s'agisse du type pour lequel cette instance QMetaType a été créée.

Voir également QMetaType::create().

void QMetaType::destruct(void *data) const

Détruit la valeur située à l'adresse data, en supposant qu'elle soit du type pour lequel cette instance de ` QMetaType ` a été construite.

Contrairement à ` destroy()`, cette fonction n'appelle que le destructeur du type ; elle n'appelle pas l'opérateur `delete`.

Voir aussi QMetaType::construct().

[since 6.0] bool QMetaType::equals(const void *lhs, const void *rhs) const

Compare les objets situés à l'adresse lhs et rhs pour vérifier s'ils sont égaux.

Les deux objets doivent être du type décrit par ce métatype. La comparaison des deux objets n’est possible que si un opérateur « inférieur à » ou d’égalité pour ce type était visible dans la déclaration du métatype. Dans le cas contraire, le métatype ne considère jamais les valeurs comme égales. Lorsqu’un opérateur d’égalité était visible lors de la déclaration du métatype, c’est lui qui fait autorité ; sinon, si l’opérateur « inférieur à » est visible, et qu’aucune des deux valeurs n’est inférieure à l’autre, les deux sont considérées comme égales. Si les valeurs ne sont pas ordonnées (voir compare() pour plus de détails), elles ne sont pas égales.

Renvoie « true » si les deux objets sont égaux, sinon « false ».

Cette fonction a été introduite dans Qt 6.0.

Voir également isEqualityComparable() et compare().

[constexpr] QMetaType::TypeFlags QMetaType::flags() const

Renvoie les indicateurs du type pour lequel cette instance de ` QMetaType ` a été construite. Pour examiner les traits spécifiques d'un type, il est préférable d'utiliser l'une des fonctions « is- » plutôt que les indicateurs directement.

Voir également QMetaType::TypeFlags, isDefaultConstructible(), isCopyConstructible(), isMoveConstructible(), isDestructible(), isEqualityComparable() et isOrdered().

[static] QMetaType QMetaType::fromName(QByteArrayView typeName)

Renvoie un objet de type « QMetaType » correspondant à « typeName ». L'objet renvoyé n'est pas valide si le typeName n'est pas reconnu par QMetaType

[static constexpr] template <typename T> QMetaType QMetaType::fromType()

Renvoie l'QMetaType e correspondant au type spécifié dans le paramètre de modèle.

[static] bool QMetaType::hasRegisteredConverterFunction(QMetaType fromType, QMetaType toType)

Renvoie true si le système de méta-types dispose d'une conversion enregistrée entre l'identifiant de méta-type fromType et toType

[static] template <typename From, typename To> bool QMetaType::hasRegisteredConverterFunction()

Renvoie ` true` si le système de méta-types dispose d'une conversion enregistrée du type `From` vers le type `To`.

[since 6.1] bool QMetaType::hasRegisteredDataStreamOperators() const

Renvoie « true » si le système de méta-types a enregistré des opérateurs de flux de données pour ce méta-type.

Cette fonction a été introduite dans Qt 6.1.

[since 6.0] bool QMetaType::hasRegisteredDebugStreamOperator() const

Renvoie ` true` si le système de méta-types dispose d’un opérateur de flux de débogage enregistré pour ce méta-type.

Cette fonction a été introduite dans Qt 6.0.

[static] bool QMetaType::hasRegisteredMutableViewFunction(QMetaType fromType, QMetaType toType)

Renvoie « true » si le système de méta-types dispose d'une vue modifiable enregistrée, portant l'identifiant « fromType », du méta-type dont l'identifiant est « toType ».

[static, since 6.0] template <typename From, typename To> bool QMetaType::hasRegisteredMutableViewFunction()

Renvoie ` true` si le système de méta-types dispose d'une vue modifiable enregistrée sur le type `From` de type `To`.

Cette fonction a été introduite dans Qt 6.0.

int QMetaType::id() const

Renvoie le type d'identifiant associé à cette instance d'QMetaType.

[noexcept, since 6.5] bool QMetaType::isCopyConstructible() const

Renvoie « true » si ce type peut être instancié par copie. Si c'est le cas, les fonctions ` construct()` et ` create()` peuvent être utilisées avec un paramètre ` copy ` non nul.

Cette fonction a été introduite dans Qt 6.5.

Voir également flags(), isDefaultConstructible(), isMoveConstructible() et isDestructible().

[noexcept, since 6.5] bool QMetaType::isDefaultConstructible() const

Renvoie « true » si ce type peut faire l'objet d'une construction par défaut. Si c'est le cas, les fonctions ` construct()` et ` create()` peuvent être utilisées avec un paramètre ` copy ` de type null.

Cette fonction a été introduite dans Qt 6.5.

Voir également flags(), isCopyConstructible(), isMoveConstructible() et isDestructible().

[noexcept, since 6.5] bool QMetaType::isDestructible() const

Renvoie « true » si ce type peut être détruit. Si c'est le cas, les fonctions ` destroy()` et ` destruct()` peuvent être appelées.

Cette fonction a été introduite dans Qt 6.5.

Voir également flags(), isDefaultConstructible(), isCopyConstructible() et isMoveConstructible().

bool QMetaType::isEqualityComparable() const

Renvoie « true » si un opérateur « inférieur ou égal à » pour le type décrit par ce métatype était visible au moment de la déclaration du métatype ; sinon, renvoie « false ».

Voir également equals() et isOrdered().

[noexcept, since 6.5] bool QMetaType::isMoveConstructible() const

Renvoie « true » si ce type peut faire l'objet d'une construction par déplacement. QMetaType ne dispose actuellement pas d'une API permettant d'utiliser ce trait.

Cette fonction a été introduite dans Qt 6.5.

Voir également flags(), isDefaultConstructible(), isCopyConstructible() et isDestructible().

bool QMetaType::isOrdered() const

Renvoie « true » si un opérateur « inférieur à » pour le type décrit par ce métatype était visible au moment de la déclaration du métatype ; sinon, renvoie « false ».

Voir également compare() et isEqualityComparable().

[noexcept] bool QMetaType::isRegistered() const

Renvoie ` true ` si cet objet ` QMetaType ` a été enregistré dans le registre global des métatypes de Qt. L'enregistrement permet de retrouver le type par son nom (à l'aide de ` QMetaType::fromName()`) ou par son identifiant (à l'aide du constructeur).

Voir également qRegisterMetaType() et isValid().

[static] bool QMetaType::isRegistered(int type)

Renvoie « true » si le type de données dont l'ID est « type » est enregistré ; sinon, renvoie « false ».

Voir également type() et Type.

[constexpr noexcept] bool QMetaType::isValid() const

Renvoie « true » si cet objet « QMetaType » contient des informations valides sur un type, « false » dans le cas contraire.

Voir également isRegistered().

bool QMetaType::load(QDataStream &stream, void *data) const

Lit l'objet de ce type à partir du fichier stream et le stocke dans data. Renvoie true si l'objet a été chargé avec succès ; sinon, renvoie false.

En règle générale, vous ne devriez pas avoir besoin d’appeler cette fonction directement. Utilisez plutôt la méthode operator>>() de QVariant, qui s’appuie sur load() pour charger les types personnalisés.

Voir également save().

[constexpr] const QMetaObject *QMetaType::metaObject() const

Renvoie une classe « QMetaObject » associée à ce type.

Si le type est un type de pointeur vers une sous-classe de ` QObject`, ` flags()` contient ` QMetaType::PointerToQObject ` et cette fonction renvoie le ` QMetaObject` correspondant. Cela peut être utilisé en combinaison avec ` QMetaObject::newInstance()` pour créer des `QObject` de ce type.

Si le type est un Q_GADGET, flags() contient QMetaType::IsGadget. Si le type est un pointeur vers un Q_GADGET, flags() contient QMetaType::PointerToGadget. Dans les deux cas, cette fonction renvoie son QMetaObject. Cela peut être utilisé pour récupérer QMetaMethod et QMetaProperty et les utiliser sur un pointeur de ce type, par exemple, comme indiqué par QVariant::data().

Si le type est une énumération, flags() contient QMetaType::IsEnumeration. Dans ce cas, cette fonction renvoie l’ QMetaObject de l’objet englobant si l’énumération a été enregistrée en tant que Q_ENUM ou nullptr dans le cas contraire.

Voir également QMetaType::flags().

[constexpr] const char *QMetaType::name() const

Renvoie le nom du type associé à cette QMetaType, ou un pointeur nul si aucun type correspondant n'a été trouvé. Le pointeur renvoyé ne doit pas être supprimé.

Voir aussi typeName().

[static] template <typename From, typename To> bool QMetaType::registerConverter()

Enregistre la possibilité d'une conversion implicite du type « From » vers le type « To » dans le système de méta-types. Renvoie « true » si l'enregistrement a abouti, sinon « false ».

class Counter {
  int number = 0;
public:
  int value() const { return number; }
  operator int() const { return value(); }
  void increment() {++number;}
};
QMetaType::registerConverter<Counter, int>();

[static] template <typename From, typename To> bool QMetaType::registerConverter(To (From::*function)() const)

Enregistre une méthode function de la forme To From::function() const en tant que convertisseur du type From vers le type To dans le système de méta-types. Renvoie true si l'enregistrement a réussi, sinon false.

struct Coordinates {
  int x;
  int y;
  int z;

  QString toString() const { return u"[x: %1; y: %2, z: %3]"_s.arg(QString::number(x),
    QString::number(y),
    QString::number(z)); }
};
QMetaType::registerConverter<Coordinates, QString>(&Coordinates::toString);

[static] template <typename From, typename To> bool QMetaType::registerConverter(To (From::*function)(bool *) const)

Enregistre une méthode de type « function » telle que `To From::function(bool *ok) const` en tant que convertisseur du type `From` vers le type `To` dans le système de méta-types. Renvoie ` true ` si l'enregistrement a réussi, sinon `false`.

Le pointeur ok peut être utilisé par la fonction pour indiquer si la conversion a réussi.

struct BigNumber {
    long long l;

    int toInt(bool *ok = nullptr) const {
      const bool canConvertSafely = l < std::numeric_limits<int>::max();
      if (ok)
        *ok = canConvertSafely;
      return l;
    }
};
QMetaType::registerConverter<BigNumber, int>(&BigNumber::toInt);

[static] template < typename From, typename To, typename UnaryFunction > bool QMetaType::registerConverter(UnaryFunction function)

Enregistre un objet de fonction unaire function en tant que convertisseur du type From vers le type To dans le système de méta-types. Renvoie true si l'enregistrement a réussi, sinon false.

function Doit prendre une instance de type From et renvoyer une instance de To. Il peut s’agir d’un pointeur de fonction, d’un lambda ou d’un objet functor. Depuis Qt 6.5, l’ function peut également renvoyer une instance de std::optional<To> afin de pouvoir signaler les conversions ayant échoué.

QMetaType::registerConverter<CustomStringType, QString>([](const CustomStringType &str) {
    return QString::fromUtf8(str.data());
});
QMetaType::registerConverter<QJsonValue, CustomPointType>(
          [](const QJsonValue &value) -> std::optional<CustomPointType> {
    const auto object = value.toObject();
    if (!object.contains("x") || !object.contains("y"))
        return std::nullopt;  // The conversion fails if the required properties are missing
    return CustomPointType{object["x"].toDouble(), object["y"].toDouble()};
});

[static, since 6.0] template <typename From, typename To> bool QMetaType::registerMutableView(To (From::*function)())

Enregistre une méthode function, telle que To From::function(), en tant que vue modifiable de type To sur le type From dans le système de méta-types. Renvoie true si l'enregistrement a réussi, sinon false.

Cette fonction a été introduite dans Qt 6.0.

[static, since 6.0] template < typename From, typename To, typename UnaryFunction > bool QMetaType::registerMutableView(UnaryFunction function)

Enregistre un objet de fonction unaire function en tant que vue modifiable de type To sur le type From dans le système de méta-types. Renvoie true si l'enregistrement a réussi, sinon false.

Cette fonction a été introduite dans Qt 6.0.

[since 6.5] void QMetaType::registerType() const

Enregistre cette QMetaType dans le registre des types afin qu'elle puisse être retrouvée par son nom, à l'aide de la fonction QMetaType::fromName().

Cette fonction a été introduite dans Qt 6.5.

Voir également qRegisterMetaType().

bool QMetaType::save(QDataStream &stream, const void *data) const

Enregistre l'objet pointé par ` data ` dans le fichier ` stream` indiqué. Renvoie ` true ` si l'objet est enregistré avec succès ; sinon, renvoie ` false`.

En règle générale, vous ne devriez pas avoir besoin d’appeler cette fonction directement. Utilisez plutôt la méthode ` operator<<()` de ` QVariant`, qui s’appuie sur `save()` pour enregistrer les types personnalisés.

Voir également load().

[constexpr] qsizetype QMetaType::sizeOf() const

Renvoie la taille du type en octets (c'est-à-dire `sizeof(T)`, où `T` est le type réel pour lequel cette instance de ` QMetaType ` a été construite).

Cette fonction est généralement utilisée conjointement avec ` construct()` pour assurer la gestion de bas niveau de la mémoire utilisée par un type.

Voir également ` QMetaType::construct()` et ` QMetaType::alignOf()`.

[since 6.6] QMetaType QMetaType::underlyingType() const

Si ce métatype représente une énumération, cette méthode renvoie un métatype de classe numérique ayant le même signe et la même taille que le type sous-jacent de l'énumération. S'il représente un type de type « QFlags », elle renvoie QMetaType::Int. Dans tous les autres cas, une exception QMetaType est renvoyée.

Cette fonction a été introduite dans Qt 6.6.

[static, since 6.0] bool QMetaType::view(QMetaType fromType, void *from, QMetaType toType, void *to)

Crée une vue modifiable de l'objet situé à l'adresse from de type fromType dans l'espace préalloué à l'adresse to de type toType. Renvoie true si la conversion a réussi, sinon false.

Cette fonction a été introduite dans Qt 6.0.