QMetaType Class

Documentation des fonctions membres

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

Construit un objet QMetaType invalide par défaut.

Cette fonction a été introduite dans Qt 6.0.

[explicit] QMetaType::QMetaType(int typeId)

Construit un objet QMetaType qui contient toutes les informations sur le type typeId.

[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 QMetaType a été construite).

Cette fonction est généralement utilisée 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 aussi QMetaType::construct() et QMetaType::sizeOf().

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

Renvoie true si QMetaType::convert peut convertir fromType en toType. Notez qu'il s'agit principalement de la capacité à exécuter la conversion, alors que la conversion réelle peut échouer lorsqu'elle est tentée (par exemple, la conversion d'une valeur à virgule flottante en un entier en dehors de sa plage).

La fonction registerConverter() peut être utilisée pour 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 :

D'autres conversions sont possibles entre tous les types primitifs (int, float, bool, etc., y compris tous les enums) 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 eux), cette fonction renvoie également true si l'un des types est dérivé de l'autre. En d'autres termes, elle renvoie vrai si static_cast<> du type décrit par fromType vers le type décrit par toType se compile. La fonction convert() fonctionne comme qobject_cast() et vérifie le type dynamique de l'objet pointé par QVariant.

Un cast à partir d'un conteneur séquentiel renverra également un vrai pour cette fonction si le toType est QVariantList.

De même, un cast à partir d'un conteneur associatif retournera également vrai pour cette fonction si toType est QVariantHash ou QVariantMap.

Voir aussi 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 mutable du type toType sur le type fromType.

La conversion entre pointeurs de types dérivés de QObject renverra vrai pour cette fonction si un qobject_cast du type décrit par fromType vers le type décrit par toType réussirait.

Vous pouvez créer une vue mutable 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 mutable de type QMetaAssociation::Iterable sur n'importe quel conteneur enregistré avec Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE().

Voir aussi 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 à lhs et rhs pour l'ordre.

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

Les deux objets doivent être du type décrit par ce métatype. Si lhs ou rhs est nullptr, les valeurs ne sont pas ordonnées. La comparaison n'est prise en charge que si l'opérateur "less than" du type était visible dans la déclaration du métatype.

Si l'opérateur d'égalité du type était également visible, les valeurs ne seront comparées que si l'opérateur d'égalité indique qu'elles sont égales. En l'absence d'opérateur d'égalité, lorsque aucune valeur n'est inférieure à l'autre, les valeurs sont considérées comme égales ; si l'opérateur d'égalité est également disponible et que deux valeurs de ce type 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 se situent en dehors de son ordre.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi equals() et isOrdered().

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

Construit une valeur du type pour lequel cette instance QMetaType a été construite dans la mémoire existante adressée par where, qui est 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. Pensez à 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 demandée en appelant sizeOf().

La règle empirique en matière d'alignement est qu'un type est aligné sur sa limite naturelle, qui est la plus petite puissance de 2 plus grande que le type, à moins que cet alignement ne soit supérieur à l'alignement maximal utile pour la plate-forme. En pratique, un alignement supérieur à 2 * sizeof(void*) n'est nécessaire que pour les instructions matérielles spéciales (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 à from de fromType en l'espace préalloué à to typé toType. Retourne true, si la conversion a réussi, sinon false.

from et to doivent être des pointeurs valides.

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

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

Voir aussi QMetaType::destroy().

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

Transmet l'objet à rhs au flux de débogage dbg. Retourne true en cas de succès, sinon false.

void QMetaType::destroy(void *data) const

Détruit l'instance data, en supposant qu'elle soit du type pour lequel cette instance QMetaType a été créée.

Voir aussi 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 QMetaType a été construite.

Contrairement à destroy(), cette fonction n'invoque que le destructeur du type, elle n'invoque pas l'opérateur de suppression.

Voir également QMetaType::construct().

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

Compare les objets à lhs et rhs pour vérifier leur égalité.

Les deux objets doivent être du type décrit par ce métatype. Il ne peut comparer les deux objets que si un opérateur inférieur ou un opérateur d'égalité pour le 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 dans la déclaration du métatype, il fait autorité ; sinon, si less than est visible, lorsqu'aucune valeur 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.

Retourne true si les deux objets se comparent, sinon false.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi isEqualityComparable() et compare().

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

Renvoie les drapeaux du type pour lequel cette instance QMetaType a été construite. Pour inspecter les caractéristiques d'un type spécifique, il est préférable d'utiliser l'une des fonctions "is-" plutôt que les drapeaux directement.

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

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

Renvoie un QMetaType correspondant à typeName. L'objet retourné n'est pas valide si le typeName n'est pas connu de QMetaType

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

Renvoie l'adresse QMetaType correspondant au type indiqué dans le paramètre du modèle.

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

Renvoie true, si le système de méta types a enregistré une conversion de l'identifiant de méta types fromType en toType

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

Renvoie true, si le système de méta types a 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 types.

Cette fonction a été introduite dans Qt 6.1.

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

Retourne true, si le système de méta types a 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 a une vue mutable enregistrée sur l'identifiant de méta types fromType de l'identifiant de méta types toType.

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

Renvoie true, si le système de méta types a une vue mutable enregistrée sur le type From du type To.

Cette fonction a été introduite dans Qt 6.0.

int QMetaType::id() const

Renvoie le type d'identifiant détenu par cette instance QMetaType.

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

Retourne vrai si ce type peut être construit par copie. Si c'est le cas, alors construct() et create() peuvent être utilisés avec un paramètre copy qui n'est pas nul.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi flags(), isDefaultConstructible(), isMoveConstructible(), et isDestructible().

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

Retourne vrai si ce type peut être construit par défaut. Si c'est le cas, alors construct() et create() peuvent être utilisés avec un paramètre copy qui est nul.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi flags(), isCopyConstructible(), isMoveConstructible() et isDestructible().

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

Retourne vrai si ce type peut être détruit. Si c'est le cas, alors destroy() et destruct() peuvent être appelés.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi flags(), isDefaultConstructible(), isCopyConstructible() et isMoveConstructible().

bool QMetaType::isEqualityComparable() const

Renvoie true si un opérateur "moins que" ou "égalité" pour le type décrit par ce métatype était visible dans la déclaration du métatype, sinon false.

Voir également equals() et isOrdered().

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

Retourne vrai si ce type peut être construit par déplacement. QMetaType n'a actuellement pas d'API pour utiliser ce trait.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi flags(), isDefaultConstructible(), isCopyConstructible(), et isDestructible().

bool QMetaType::isOrdered() const

Renvoie true si un opérateur moins que pour le type décrit par ce métatype était visible dans la déclaration du métatype, sinon 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 trouver le type par son nom (en utilisant QMetaType::fromName()) ou par son ID (en utilisant le constructeur).

Voir aussi qRegisterMetaType() et isValid().

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

Renvoie true si le type de données portant l'ID 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 sinon.

Voir aussi isRegistered().

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

Lit l'objet de ce type à partir de l'adresse stream dans data. Renvoie true si l'objet est chargé avec succès ; sinon, renvoie false.

Normalement, vous ne devriez pas avoir besoin d'appeler cette fonction directement. Utilisez plutôt QVariant's operator>>(), qui s'appuie sur la fonction load() pour transmettre les types personnalisés.

Voir aussi save().

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

Renvoie un QMetaObject relatif à ce type.

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

Si le type est un Q_GADGET, flags() contient QMetaType::IsGadget. Si le type est un pointeur sur 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'adresse 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 adresse QMetaType, ou un pointeur nul si aucun type correspondant n'a été trouvé. Le pointeur retourné 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. Retourne true si l'enregistrement a réussi, 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::*)() const function)

Enregistre une méthode function comme To From::function() const en tant que convertisseur du type From vers le type To dans le système de méta types. Retourne 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::*)(bool *) const function)

Enregistre une méthode function comme To From::function(bool *ok) const comme convertisseur du type From au type To dans le système de méta types. Retourne 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 fonction unaire function en tant que convertisseur du type From au type To dans le système de méta types. Retourne true si l'enregistrement a réussi, sinon false.

function doit prendre une instance du type From et retourner une instance de To. Il peut s'agir d'un pointeur de fonction, d'un lambda ou d'un objet foncteur. Depuis Qt XML 6.5, function peut également renvoyer une instance de std::optional<To> pour pouvoir indiquer les échecs de conversion.

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 comme To From::function() en tant que vue mutable du type To sur le type From dans le système de méta types. Retourne 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 mutable du type To sur le type From dans le système de méta types. Retourne 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 ce QMetaType dans le registre des types afin qu'il puisse être trouvé par son nom, en utilisant QMetaType::fromName().

Cette fonction a été introduite dans Qt 6.5.

Voir aussi qRegisterMetaType().

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

Écrit l'objet pointé par data sur le site stream. Renvoie true si l'objet est sauvegardé avec succès ; sinon, renvoie false.

Normalement, vous ne devriez pas avoir besoin d'appeler cette fonction directement. Utilisez plutôt QVariant's operator<<(), qui s'appuie sur save() pour diffuser les types personnalisés.

Voir aussi 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 QMetaType a été construite).

Cette fonction est généralement utilisée avec construct() pour effectuer une 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 d'une classe numérique ayant la même signature et la même taille que le type sous-jacent de l'énumération. S'il représente un type QFlags, elle renvoie QMetaType::Int. Dans tous les autres cas, elle renvoie une adresse QMetaType invalide.

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 mutable sur l'objet à from de fromType dans l'espace préalloué à to typé toType. Retourne true si la conversion a réussi, sinon false.

Cette fonction a été introduite dans Qt 6.0.