[−][src]Struct qt_core::QVariant

#[repr(C)]
pub struct QVariant { /* fields omitted */ }

The QVariant class acts like a union for the most common Qt data types.

C++ class: QVariant.

C++ documentation:

The QVariant class acts like a union for the most common Qt data types.

Because C++ forbids unions from including types that have non-default constructors or destructors, most interesting Qt classes cannot be used in unions. Without QVariant, this would be a problem for QObject::property() and for database work, etc.

A QVariant object holds a single value of a single type() at a time. (Some type()s are multi-valued, for example a string list.) You can find out what type, T, the variant holds, convert it to a different type using convert(), get its value using one of the toT() functions (e.g., toSize()) and check whether the type can be converted to a particular type using canConvert().

The methods named toT() (e.g., toInt(), toString()) are const. If you ask for the stored type, they return a copy of the stored object. If you ask for a type that can be generated from the stored type, toT() copies and converts and leaves the object itself unchanged. If you ask for a type that cannot be generated from the stored type, the result depends on the type; see the function documentation for details.

Here is some example code to demonstrate the use of QVariant:

QDataStream out(...);
QVariant v(123);                // The variant now contains an int
int x = v.toInt();              // x = 123
out << v;                       // Writes a type tag and an int to out
v = QVariant("hello");          // The variant now contains a QByteArray
v = QVariant(tr("hello"));      // The variant now contains a QString
int y = v.toInt();              // y = 0 since v cannot be converted to an int
QString s = v.toString();       // s = tr("hello")  (see QObject::tr())
out << v;                       // Writes a type tag and a QString to out
...
QDataStream in(...);            // (opening the previously written stream)
in >> v;                        // Reads an Int variant
int z = v.toInt();              // z = 123
qDebug("Type is %s",            // prints "Type is int"
          v.typeName());
v = v.toInt() + 100;            // The variant now hold the value 223
v = QVariant(QStringList());

You can even store QList<QVariant> and QMap<QString, QVariant> values in a variant, so you can easily construct arbitrarily complex data structures of arbitrary types. This is very powerful and versatile, but may prove less memory and speed efficient than storing specific types in standard data structures.

QVariant also supports the notion of null values, where you can have a defined type with no value set. However, note that QVariant types can only be cast when they have had a value set.

QVariant x, y(QString()), z(QString(""));
x.convert(QVariant::Int);
// x.isNull() == true
// y.isNull() == true, z.isNull() == false

QVariant can be extended to support other types than those mentioned in the Type enum. See Creating Custom Qt Types for details.

Methods

impl QVariant[src]

pub unsafe fn can_convert(&self, target_type_id: c_int) -> bool[src]

Returns true if the variant's type can be cast to the requested type, targetTypeId. Such casting is done automatically when calling the toInt(), toBool(), ... methods.

Calls C++ function: bool QVariant::canConvert(int targetTypeId) const.

C++ documentation:

Returns true if the variant's type can be cast to the requested type, targetTypeId. Such casting is done automatically when calling the toInt(), toBool(), ... methods.

The following casts are done automatically:

TypeAutomatically Cast To
QMetaType::BoolQMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong
QMetaType::QByteArrayQMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong, QMetaType::QUuid
QMetaType::QCharQMetaType::Bool, QMetaType::Int, QMetaType::UInt, QMetaType::LongLong, QMetaType::ULongLong
QMetaType::QColorQMetaType::QString
QMetaType::QDateQMetaType::QDateTime, QMetaType::QString
QMetaType::QDateTimeQMetaType::QDate, QMetaType::QString, QMetaType::QTime
QMetaType::DoubleQMetaType::Bool, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong
QMetaType::QFontQMetaType::QString
QMetaType::IntQMetaType::Bool, QMetaType::QChar, QMetaType::Double, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong
QMetaType::QKeySequenceQMetaType::Int, QMetaType::QString
QMetaType::QVariantListQMetaType::QStringList (if the list's items can be converted to QStrings)
QMetaType::LongLongQMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::QString, QMetaType::UInt, QMetaType::ULongLong
QMetaType::QPointQMetaType::QPointF
QMetaType::QRectQMetaType::QRectF
QMetaType::QStringQMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::QColor, QMetaType::QDate, QMetaType::QDateTime, QMetaType::Double, QMetaType::QFont, QMetaType::Int, QMetaType::QKeySequence, QMetaType::LongLong, QMetaType::QStringList, QMetaType::QTime, QMetaType::UInt, QMetaType::ULongLong, QMetaType::QUuid
QMetaType::QStringListQMetaType::QVariantList, QMetaType::QString (if the list contains exactly one item)
QMetaType::QTimeQMetaType::QString
QMetaType::UIntQMetaType::Bool, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::ULongLong
QMetaType::ULongLongQMetaType::Bool, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt
QMetaType::QUuidQMetaType::QByteArray, QMetaType::QString

A QVariant containing a pointer to a type derived from QObject will also return true for this function if a qobject_cast to the type described by targetTypeId would succeed. Note that this only works for QObject subclasses which use the Q_OBJECT macro.

A QVariant containing a sequential container will also return true for this function if the targetTypeId is QVariantList. It is possible to iterate over the contents of the container without extracting it as a (copied) QVariantList:

QList<int> intList = {7, 11, 42};


QVariant variant = QVariant::fromValue(intList);
if (variant.canConvert<QVariantList>()) {
      QSequentialIterable iterable = variant.value<QSequentialIterable>();
      // Can use foreach:
      foreach (const QVariant &v, iterable) {
          qDebug() << v;
      }
      // Can use C++11 range-for:
      for (const QVariant &v : iterable) {
          qDebug() << v;
      }
      // Can use iterators:
      QSequentialIterable::const_iterator it = iterable.begin();
      const QSequentialIterable::const_iterator end = iterable.end();
      for ( ; it != end; ++it) {
          qDebug() << *it;
      }
}

This requires that the value_type of the container is itself a metatype.

Similarly, a QVariant containing a sequential container will also return true for this function the targetTypeId is QVariantHash or QVariantMap. It is possible to iterate over the contents of the container without extracting it as a (copied) QVariantHash or QVariantMap:

QHash<int, QString> mapping;
mapping.insert(7, "Seven");
mapping.insert(11, "Eleven");
mapping.insert(42, "Forty-two");


QVariant variant = QVariant::fromValue(mapping);
if (variant.canConvert<QVariantHash>()) {
      QAssociativeIterable iterable = variant.value<QAssociativeIterable>();
      // Can use foreach over the values:
      foreach (const QVariant &v, iterable) {
          qDebug() << v;
      }
      // Can use C++11 range-for over the values:
      for (const QVariant &v : iterable) {
          qDebug() << v;
      }
      // Can use iterators:
      QAssociativeIterable::const_iterator it = iterable.begin();
      const QAssociativeIterable::const_iterator end = iterable.end();
      for ( ; it != end; ++it) {
          qDebug() << *it; // The current value
          qDebug() << it.key();
          qDebug() << it.value();
      }
}

See also convert(), QSequentialIterable, Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(), QAssociativeIterable, and Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE().

pub unsafe fn clear(&mut self)[src]

Convert this variant to type QMetaType::UnknownType and free up any resources used.

Calls C++ function: void QVariant::clear().

C++ documentation:

Convert this variant to type QMetaType::UnknownType and free up any resources used.

pub unsafe fn const_data(&self) -> Ptr<c_void>[src]

Calls C++ function: const void* QVariant::constData() const.

pub unsafe fn convert(&mut self, target_type_id: c_int) -> bool[src]

Casts the variant to the requested type, targetTypeId. If the cast cannot be done, the variant is cleared. Returns true if the current type of the variant was successfully cast; otherwise returns false.

Calls C++ function: bool QVariant::convert(int targetTypeId).

C++ documentation:

Casts the variant to the requested type, targetTypeId. If the cast cannot be done, the variant is cleared. Returns true if the current type of the variant was successfully cast; otherwise returns false.

A QVariant containing a pointer to a type derived from QObject will also convert and return true for this function if a qobject_cast to the type described by targetTypeId would succeed. Note that this only works for QObject subclasses which use the Q_OBJECT macro.

Warning: For historical reasons, converting a null QVariant results in a null value of the desired type (e.g., an empty string for QString) and a result of false.

See also canConvert() and clear().

pub unsafe fn copy_from(
    &mut self,
    other: impl CastInto<Ref<QVariant>>
) -> MutRef<QVariant>[src]

Assigns the value of the variant variant to this variant.

Calls C++ function: QVariant& QVariant::operator=(const QVariant& other).

C++ documentation:

Assigns the value of the variant variant to this variant.

pub unsafe fn data_mut(&mut self) -> MutPtr<c_void>[src]

Calls C++ function: void* QVariant::data().

pub unsafe fn data(&self) -> Ptr<c_void>[src]

Calls C++ function: const void* QVariant::data() const.

pub unsafe fn detach(&mut self)[src]

Calls C++ function: void QVariant::detach().

pub unsafe fn is_detached(&self) -> bool[src]

Calls C++ function: bool QVariant::isDetached() const.

pub unsafe fn is_null(&self) -> bool[src]

Returns true if this is a null variant, false otherwise. A variant is considered null if it contains a default constructed value or a built-in type instance that has an isNull method, in which case the result would be the same as calling isNull on the wrapped object.

Calls C++ function: bool QVariant::isNull() const.

C++ documentation:

Returns true if this is a null variant, false otherwise. A variant is considered null if it contains a default constructed value or a built-in type instance that has an isNull method, in which case the result would be the same as calling isNull on the wrapped object.

Warning: The result of the function doesn't affect == operator, which means that two values can be equal even if one of them is null and another is not.

pub unsafe fn is_valid(&self) -> bool[src]

Returns true if the storage type of this variant is not QMetaType::UnknownType; otherwise returns false.

Calls C++ function: bool QVariant::isValid() const.

C++ documentation:

Returns true if the storage type of this variant is not QMetaType::UnknownType; otherwise returns false.

pub unsafe fn load(&mut self, ds: impl CastInto<MutRef<QDataStream>>)[src]

Calls C++ function: void QVariant::load(QDataStream& ds).

pub unsafe fn name_to_type(name: impl CastInto<Ptr<c_char>>) -> Type[src]

Converts the string representation of the storage type given in name, to its enum representation.

Calls C++ function: static QVariant::Type QVariant::nameToType(const char* name).

C++ documentation:

Converts the string representation of the storage type given in name, to its enum representation.

If the string representation cannot be converted to any enum representation, the variant is set to Invalid.

pub unsafe fn new() -> CppBox<QVariant>[src]

Constructs an invalid variant.

Calls C++ function: [constructor] void QVariant::QVariant().

C++ documentation:

Constructs an invalid variant.

pub unsafe fn from_type(type_: Type) -> CppBox<QVariant>[src]

Constructs a null variant of type type.

Calls C++ function: [constructor] void QVariant::QVariant(QVariant::Type type).

C++ documentation:

Constructs a null variant of type type.

pub unsafe fn from_int_void(
    type_id: c_int,
    copy: impl CastInto<Ptr<c_void>>
) -> CppBox<QVariant>[src]

Constructs variant of type typeId, and initializes with copy if copy is not 0.

Calls C++ function: [constructor] void QVariant::QVariant(int typeId, const void* copy).

C++ documentation:

Constructs variant of type typeId, and initializes with copy if copy is not 0.

Note that you have to pass the address of the variable you want stored.

Usually, you never have to use this constructor, use QVariant::fromValue() instead to construct variants from the pointer types represented by QMetaType::VoidStar, and QMetaType::QObjectStar.

See also QVariant::fromValue() and QMetaType::Type.

pub unsafe fn from_int_void_uint(
    type_id: c_int,
    copy: impl CastInto<Ptr<c_void>>,
    flags: c_uint
) -> CppBox<QVariant>[src]

Calls C++ function: [constructor] void QVariant::QVariant(int typeId, const void* copy, unsigned int flags).

pub unsafe fn from_q_data_stream(
    s: impl CastInto<MutRef<QDataStream>>
) -> CppBox<QVariant>[src]

Reads the variant from the data stream, s.

Calls C++ function: [constructor] void QVariant::QVariant(QDataStream& s).

C++ documentation:

Reads the variant from the data stream, s.

pub unsafe fn from_int(i: c_int) -> CppBox<QVariant>[src]

Constructs a new variant with an integer value, val.

Calls C++ function: [constructor] void QVariant::QVariant(int i).

C++ documentation:

Constructs a new variant with an integer value, val.

pub unsafe fn from_uint(ui: c_uint) -> CppBox<QVariant>[src]

Constructs a new variant with an unsigned integer value, val.

Calls C++ function: [constructor] void QVariant::QVariant(unsigned int ui).

C++ documentation:

Constructs a new variant with an unsigned integer value, val.

pub unsafe fn from_i64(ll: i64) -> CppBox<QVariant>[src]

Constructs a new variant with a long long integer value, val.

Calls C++ function: [constructor] void QVariant::QVariant(qlonglong ll).

C++ documentation:

Constructs a new variant with a long long integer value, val.

pub unsafe fn from_u64(ull: u64) -> CppBox<QVariant>[src]

Constructs a new variant with an unsigned long long integer value, val.

Calls C++ function: [constructor] void QVariant::QVariant(qulonglong ull).

C++ documentation:

Constructs a new variant with an unsigned long long integer value, val.

pub unsafe fn from_bool(b: bool) -> CppBox<QVariant>[src]

Constructs a new variant with a boolean value, val.

Calls C++ function: [constructor] void QVariant::QVariant(bool b).

C++ documentation:

Constructs a new variant with a boolean value, val.

pub unsafe fn from_double(d: c_double) -> CppBox<QVariant>[src]

Constructs a new variant with a floating point value, val.

Calls C++ function: [constructor] void QVariant::QVariant(double d).

C++ documentation:

Constructs a new variant with a floating point value, val.

pub unsafe fn from_float(f: c_float) -> CppBox<QVariant>[src]

Constructs a new variant with a floating point value, val.

Calls C++ function: [constructor] void QVariant::QVariant(float f).

C++ documentation:

Constructs a new variant with a floating point value, val.

This function was introduced in Qt 4.6.

pub unsafe fn from_char(str: impl CastInto<Ptr<c_char>>) -> CppBox<QVariant>[src]

Constructs a new variant with a string value of val. The variant creates a deep copy of val into a QString assuming UTF-8 encoding on the input val.

Calls C++ function: [constructor] void QVariant::QVariant(const char* str).

C++ documentation:

Constructs a new variant with a string value of val. The variant creates a deep copy of val into a QString assuming UTF-8 encoding on the input val.

Note that val is converted to a QString for storing in the variant and QVariant::userType() will return QMetaType::QString for the variant.

You can disable this operator by defining QT_NO_CAST_FROM_ASCII when you compile your applications.

pub unsafe fn from_q_byte_array(
    bytearray: impl CastInto<Ref<QByteArray>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a bytearray value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QByteArray& bytearray).

C++ documentation:

Constructs a new variant with a bytearray value, val.

pub unsafe fn from_q_bit_array(
    bitarray: impl CastInto<Ref<QBitArray>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a bitarray value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QBitArray& bitarray).

C++ documentation:

Constructs a new variant with a bitarray value, val.

pub unsafe fn from_q_string(
    string: impl CastInto<Ref<QString>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a string value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QString& string).

C++ documentation:

Constructs a new variant with a string value, val.

pub unsafe fn from_q_latin1_string(
    string: impl CastInto<Ref<QLatin1String>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a string value, val.

Calls C++ function: [constructor] void QVariant::QVariant(QLatin1String string).

C++ documentation:

Constructs a new variant with a string value, val.

pub unsafe fn from_q_string_list(
    stringlist: impl CastInto<Ref<QStringList>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a string list value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QStringList& stringlist).

C++ documentation:

Constructs a new variant with a string list value, val.

pub unsafe fn from_q_char(qchar: impl CastInto<Ref<QChar>>) -> CppBox<QVariant>[src]

Constructs a new variant with a char value, c.

Calls C++ function: [constructor] void QVariant::QVariant(QChar qchar).

C++ documentation:

Constructs a new variant with a char value, c.

pub unsafe fn from_q_date(date: impl CastInto<Ref<QDate>>) -> CppBox<QVariant>[src]

Constructs a new variant with a date value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QDate& date).

C++ documentation:

Constructs a new variant with a date value, val.

pub unsafe fn from_q_time(time: impl CastInto<Ref<QTime>>) -> CppBox<QVariant>[src]

Constructs a new variant with a time value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QTime& time).

C++ documentation:

Constructs a new variant with a time value, val.

pub unsafe fn from_q_date_time(
    datetime: impl CastInto<Ref<QDateTime>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a date/time value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QDateTime& datetime).

C++ documentation:

Constructs a new variant with a date/time value, val.

pub unsafe fn from_q_list_of_q_variant(
    list: impl CastInto<Ref<QListOfQVariant>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a list value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QList<QVariant>& list).

C++ documentation:

Constructs a new variant with a list value, val.

pub unsafe fn from_q_map_of_q_string_q_variant(
    map: impl CastInto<Ref<QMapOfQStringQVariant>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a map of QVariants, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QMap<QString, QVariant>& map).

C++ documentation:

Constructs a new variant with a map of QVariants, val.

pub unsafe fn from_q_hash_of_q_string_q_variant(
    hash: impl CastInto<Ref<QHashOfQStringQVariant>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a hash of QVariants, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QHash<QString, QVariant>& hash).

C++ documentation:

Constructs a new variant with a hash of QVariants, val.

pub unsafe fn from_q_size(size: impl CastInto<Ref<QSize>>) -> CppBox<QVariant>[src]

Constructs a new variant with a size value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QSize& size).

C++ documentation:

Constructs a new variant with a size value of val.

pub unsafe fn from_q_size_f(
    size: impl CastInto<Ref<QSizeF>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a size value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QSizeF& size).

C++ documentation:

Constructs a new variant with a size value of val.

pub unsafe fn from_q_point(pt: impl CastInto<Ref<QPoint>>) -> CppBox<QVariant>[src]

Constructs a new variant with a point value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QPoint& pt).

C++ documentation:

Constructs a new variant with a point value of val.

pub unsafe fn from_q_point_f(
    pt: impl CastInto<Ref<QPointF>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a point value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QPointF& pt).

C++ documentation:

Constructs a new variant with a point value of val.

pub unsafe fn from_q_line(line: impl CastInto<Ref<QLine>>) -> CppBox<QVariant>[src]

Constructs a new variant with a line value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QLine& line).

C++ documentation:

Constructs a new variant with a line value of val.

pub unsafe fn from_q_line_f(
    line: impl CastInto<Ref<QLineF>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a line value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QLineF& line).

C++ documentation:

Constructs a new variant with a line value of val.

pub unsafe fn from_q_rect(rect: impl CastInto<Ref<QRect>>) -> CppBox<QVariant>[src]

Constructs a new variant with a rect value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QRect& rect).

C++ documentation:

Constructs a new variant with a rect value of val.

pub unsafe fn from_q_rect_f(
    rect: impl CastInto<Ref<QRectF>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a rect value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QRectF& rect).

C++ documentation:

Constructs a new variant with a rect value of val.

pub unsafe fn from_q_locale(
    locale: impl CastInto<Ref<QLocale>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a locale value, l.

Calls C++ function: [constructor] void QVariant::QVariant(const QLocale& locale).

C++ documentation:

Constructs a new variant with a locale value, l.

pub unsafe fn from_q_reg_exp(
    reg_exp: impl CastInto<Ref<QRegExp>>
) -> CppBox<QVariant>[src]

Constructs a new variant with the regexp value regExp.

Calls C++ function: [constructor] void QVariant::QVariant(const QRegExp& regExp).

C++ documentation:

Constructs a new variant with the regexp value regExp.

pub unsafe fn from_q_regular_expression(
    re: impl CastInto<Ref<QRegularExpression>>
) -> CppBox<QVariant>[src]

Constructs a new variant with the regular expression value re.

Calls C++ function: [constructor] void QVariant::QVariant(const QRegularExpression& re).

C++ documentation:

Constructs a new variant with the regular expression value re.

This function was introduced in Qt 5.0.

pub unsafe fn from_q_url(url: impl CastInto<Ref<QUrl>>) -> CppBox<QVariant>[src]

Constructs a new variant with a url value of val.

Calls C++ function: [constructor] void QVariant::QVariant(const QUrl& url).

C++ documentation:

Constructs a new variant with a url value of val.

pub unsafe fn from_q_easing_curve(
    easing: impl CastInto<Ref<QEasingCurve>>
) -> CppBox<QVariant>[src]

Constructs a new variant with an easing curve value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QEasingCurve& easing).

C++ documentation:

Constructs a new variant with an easing curve value, val.

This function was introduced in Qt 4.7.

pub unsafe fn from_q_uuid(uuid: impl CastInto<Ref<QUuid>>) -> CppBox<QVariant>[src]

Constructs a new variant with an uuid value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QUuid& uuid).

C++ documentation:

Constructs a new variant with an uuid value, val.

This function was introduced in Qt 5.0.

pub unsafe fn from_q_model_index(
    model_index: impl CastInto<Ref<QModelIndex>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a QModelIndex value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QModelIndex& modelIndex).

C++ documentation:

Constructs a new variant with a QModelIndex value, val.

This function was introduced in Qt 5.0.

pub unsafe fn from_q_persistent_model_index(
    model_index: impl CastInto<Ref<QPersistentModelIndex>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a QPersistentModelIndex value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QPersistentModelIndex& modelIndex).

C++ documentation:

Constructs a new variant with a QPersistentModelIndex value, val.

This function was introduced in Qt 5.5.

pub unsafe fn from_q_json_value(
    json_value: impl CastInto<Ref<QJsonValue>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a json value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QJsonValue& jsonValue).

C++ documentation:

Constructs a new variant with a json value, val.

This function was introduced in Qt 5.0.

pub unsafe fn from_q_json_object(
    json_object: impl CastInto<Ref<QJsonObject>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a json object value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QJsonObject& jsonObject).

C++ documentation:

Constructs a new variant with a json object value, val.

This function was introduced in Qt 5.0.

pub unsafe fn from_q_json_array(
    json_array: impl CastInto<Ref<QJsonArray>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a json array value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QJsonArray& jsonArray).

C++ documentation:

Constructs a new variant with a json array value, val.

This function was introduced in Qt 5.0.

pub unsafe fn from_q_json_document(
    json_document: impl CastInto<Ref<QJsonDocument>>
) -> CppBox<QVariant>[src]

Constructs a new variant with a json document value, val.

Calls C++ function: [constructor] void QVariant::QVariant(const QJsonDocument& jsonDocument).

C++ documentation:

Constructs a new variant with a json document value, val.

This function was introduced in Qt 5.0.

pub unsafe fn new_copy(other: impl CastInto<Ref<QVariant>>) -> CppBox<QVariant>[src]

Constructs a copy of the variant, p, passed as the argument to this constructor.

Calls C++ function: [constructor] void QVariant::QVariant(const QVariant& other).

C++ documentation:

Constructs a copy of the variant, p, passed as the argument to this constructor.

pub unsafe fn save(&self, ds: impl CastInto<MutRef<QDataStream>>)[src]

Calls C++ function: void QVariant::save(QDataStream& ds) const.

pub unsafe fn swap(&mut self, other: impl CastInto<MutRef<QVariant>>)[src]

Swaps variant other with this variant. This operation is very fast and never fails.

Calls C++ function: void QVariant::swap(QVariant& other).

C++ documentation:

Swaps variant other with this variant. This operation is very fast and never fails.

This function was introduced in Qt 4.8.

pub unsafe fn to_bit_array(&self) -> CppBox<QBitArray>[src]

Returns the variant as a QBitArray if the variant has userType() QMetaType::QBitArray; otherwise returns an empty bit array.

Calls C++ function: QBitArray QVariant::toBitArray() const.

C++ documentation:

Returns the variant as a QBitArray if the variant has userType() QMetaType::QBitArray; otherwise returns an empty bit array.

See also canConvert() and convert().

pub unsafe fn to_bool(&self) -> bool[src]

Returns the variant as a bool if the variant has userType() Bool.

Calls C++ function: bool QVariant::toBool() const.

C++ documentation:

Returns the variant as a bool if the variant has userType() Bool.

Returns true if the variant has userType() QMetaType::Bool, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::UInt, or QMetaType::ULongLong and the value is non-zero, or if the variant has type QMetaType::QString or QMetaType::QByteArray and its lower-case content is not one of the following: empty, "0" or "false"; otherwise returns false.

See also canConvert() and convert().

pub unsafe fn to_byte_array(&self) -> CppBox<QByteArray>[src]

Returns the variant as a QByteArray if the variant has userType() QMetaType::QByteArray or QMetaType::QString (converted using QString::fromUtf8()); otherwise returns an empty byte array.

Calls C++ function: QByteArray QVariant::toByteArray() const.

C++ documentation:

Returns the variant as a QByteArray if the variant has userType() QMetaType::QByteArray or QMetaType::QString (converted using QString::fromUtf8()); otherwise returns an empty byte array.

See also canConvert() and convert().

pub unsafe fn to_char(&self) -> CppBox<QChar>[src]

Returns the variant as a QChar if the variant has userType() QMetaType::QChar, QMetaType::Int, or QMetaType::UInt; otherwise returns an invalid QChar.

Calls C++ function: QChar QVariant::toChar() const.

C++ documentation:

Returns the variant as a QChar if the variant has userType() QMetaType::QChar, QMetaType::Int, or QMetaType::UInt; otherwise returns an invalid QChar.

See also canConvert() and convert().

pub unsafe fn to_date(&self) -> CppBox<QDate>[src]

Returns the variant as a QDate if the variant has userType() QMetaType::QDate, QMetaType::QDateTime, or QMetaType::QString; otherwise returns an invalid date.

Calls C++ function: QDate QVariant::toDate() const.

C++ documentation:

Returns the variant as a QDate if the variant has userType() QMetaType::QDate, QMetaType::QDateTime, or QMetaType::QString; otherwise returns an invalid date.

If the type() is QMetaType::QString, an invalid date will be returned if the string cannot be parsed as a Qt::ISODate format date.

See also canConvert() and convert().

pub unsafe fn to_date_time(&self) -> CppBox<QDateTime>[src]

Returns the variant as a QDateTime if the variant has userType() QMetaType::QDateTime, QMetaType::QDate, or QMetaType::QString; otherwise returns an invalid date/time.

Calls C++ function: QDateTime QVariant::toDateTime() const.

C++ documentation:

Returns the variant as a QDateTime if the variant has userType() QMetaType::QDateTime, QMetaType::QDate, or QMetaType::QString; otherwise returns an invalid date/time.

If the type() is QMetaType::QString, an invalid date/time will be returned if the string cannot be parsed as a Qt::ISODate format date/time.

See also canConvert() and convert().

pub unsafe fn to_double_1a(&self, ok: impl CastInto<MutPtr<bool>>) -> c_double[src]

Returns the variant as a double if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

Calls C++ function: double QVariant::toDouble(bool* ok = …) const.

C++ documentation:

Returns the variant as a double if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

If ok is non-null: *ok is set to true if the value could be converted to a double; otherwise *ok is set to false.

See also canConvert() and convert().

pub unsafe fn to_double_0a(&self) -> c_double[src]

Returns the variant as a double if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

Calls C++ function: double QVariant::toDouble() const.

C++ documentation:

Returns the variant as a double if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

If ok is non-null: *ok is set to true if the value could be converted to a double; otherwise *ok is set to false.

See also canConvert() and convert().

pub unsafe fn to_easing_curve(&self) -> CppBox<QEasingCurve>[src]

Returns the variant as a QEasingCurve if the variant has userType() QMetaType::QEasingCurve; otherwise returns a default easing curve.

Calls C++ function: QEasingCurve QVariant::toEasingCurve() const.

C++ documentation:

Returns the variant as a QEasingCurve if the variant has userType() QMetaType::QEasingCurve; otherwise returns a default easing curve.

This function was introduced in Qt 4.7.

See also canConvert() and convert().

pub unsafe fn to_float_1a(&self, ok: impl CastInto<MutPtr<bool>>) -> c_float[src]

Returns the variant as a float if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

Calls C++ function: float QVariant::toFloat(bool* ok = …) const.

C++ documentation:

Returns the variant as a float if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

If ok is non-null: *ok is set to true if the value could be converted to a double; otherwise *ok is set to false.

This function was introduced in Qt 4.6.

See also canConvert() and convert().

pub unsafe fn to_float_0a(&self) -> c_float[src]

Returns the variant as a float if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

Calls C++ function: float QVariant::toFloat() const.

C++ documentation:

Returns the variant as a float if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

If ok is non-null: *ok is set to true if the value could be converted to a double; otherwise *ok is set to false.

This function was introduced in Qt 4.6.

See also canConvert() and convert().

pub unsafe fn to_hash(&self) -> CppBox<QHashOfQStringQVariant>[src]

Returns the variant as a QHash<QString, QVariant> if the variant has type() QMetaType::QVariantHash; otherwise returns an empty map.

Calls C++ function: QHash<QString, QVariant> QVariant::toHash() const.

C++ documentation:

Returns the variant as a QHash<QString, QVariant> if the variant has type() QMetaType::QVariantHash; otherwise returns an empty map.

See also canConvert() and convert().

pub unsafe fn to_int_1a(&self, ok: impl CastInto<MutPtr<bool>>) -> c_int[src]

Returns the variant as an int if the variant has userType() QMetaType::Int, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.

Calls C++ function: int QVariant::toInt(bool* ok = …) const.

C++ documentation:

Returns the variant as an int if the variant has userType() QMetaType::Int, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.

If ok is non-null: *ok is set to true if the value could be converted to an int; otherwise *ok is set to false.

Warning: If the value is convertible to a QMetaType::LongLong but is too large to be represented in an int, the resulting arithmetic overflow will not be reflected in ok. A simple workaround is to use QString::toInt().

See also canConvert() and convert().

pub unsafe fn to_int_0a(&self) -> c_int[src]

Returns the variant as an int if the variant has userType() QMetaType::Int, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.

Calls C++ function: int QVariant::toInt() const.

C++ documentation:

Returns the variant as an int if the variant has userType() QMetaType::Int, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.

If ok is non-null: *ok is set to true if the value could be converted to an int; otherwise *ok is set to false.

Warning: If the value is convertible to a QMetaType::LongLong but is too large to be represented in an int, the resulting arithmetic overflow will not be reflected in ok. A simple workaround is to use QString::toInt().

See also canConvert() and convert().

pub unsafe fn to_json_array(&self) -> CppBox<QJsonArray>[src]

Returns the variant as a QJsonArray if the variant has userType() QJsonArray; otherwise returns a default constructed QJsonArray.

Calls C++ function: QJsonArray QVariant::toJsonArray() const.

C++ documentation:

Returns the variant as a QJsonArray if the variant has userType() QJsonArray; otherwise returns a default constructed QJsonArray.

This function was introduced in Qt 5.0.

See also canConvert() and convert().

pub unsafe fn to_json_document(&self) -> CppBox<QJsonDocument>[src]

Returns the variant as a QJsonDocument if the variant has userType() QJsonDocument; otherwise returns a default constructed QJsonDocument.

Calls C++ function: QJsonDocument QVariant::toJsonDocument() const.

C++ documentation:

Returns the variant as a QJsonDocument if the variant has userType() QJsonDocument; otherwise returns a default constructed QJsonDocument.

This function was introduced in Qt 5.0.

See also canConvert() and convert().

pub unsafe fn to_json_object(&self) -> CppBox<QJsonObject>[src]

Returns the variant as a QJsonObject if the variant has userType() QJsonObject; otherwise returns a default constructed QJsonObject.

Calls C++ function: QJsonObject QVariant::toJsonObject() const.

C++ documentation:

Returns the variant as a QJsonObject if the variant has userType() QJsonObject; otherwise returns a default constructed QJsonObject.

This function was introduced in Qt 5.0.

See also canConvert() and convert().

pub unsafe fn to_json_value(&self) -> CppBox<QJsonValue>[src]

Returns the variant as a QJsonValue if the variant has userType() QJsonValue; otherwise returns a default constructed QJsonValue.

Calls C++ function: QJsonValue QVariant::toJsonValue() const.

C++ documentation:

Returns the variant as a QJsonValue if the variant has userType() QJsonValue; otherwise returns a default constructed QJsonValue.

This function was introduced in Qt 5.0.

See also canConvert() and convert().

pub unsafe fn to_line(&self) -> CppBox<QLine>[src]

Returns the variant as a QLine if the variant has userType() QMetaType::QLine; otherwise returns an invalid QLine.

Calls C++ function: QLine QVariant::toLine() const.

C++ documentation:

Returns the variant as a QLine if the variant has userType() QMetaType::QLine; otherwise returns an invalid QLine.

See also canConvert() and convert().

pub unsafe fn to_line_f(&self) -> CppBox<QLineF>[src]

Returns the variant as a QLineF if the variant has userType() QMetaType::QLineF; otherwise returns an invalid QLineF.

Calls C++ function: QLineF QVariant::toLineF() const.

C++ documentation:

Returns the variant as a QLineF if the variant has userType() QMetaType::QLineF; otherwise returns an invalid QLineF.

See also canConvert() and convert().

pub unsafe fn to_list(&self) -> CppBox<QListOfQVariant>[src]

Returns the variant as a QVariantList if the variant has userType() QMetaType::QVariantList or QMetaType::QStringList; otherwise returns an empty list.

Calls C++ function: QList<QVariant> QVariant::toList() const.

C++ documentation:

Returns the variant as a QVariantList if the variant has userType() QMetaType::QVariantList or QMetaType::QStringList; otherwise returns an empty list.

See also canConvert() and convert().

pub unsafe fn to_locale(&self) -> CppBox<QLocale>[src]

Returns the variant as a QLocale if the variant has userType() QMetaType::QLocale; otherwise returns an invalid QLocale.

Calls C++ function: QLocale QVariant::toLocale() const.

C++ documentation:

Returns the variant as a QLocale if the variant has userType() QMetaType::QLocale; otherwise returns an invalid QLocale.

See also canConvert() and convert().

pub unsafe fn to_long_long_1a(&self, ok: impl CastInto<MutPtr<bool>>) -> i64[src]

Returns the variant as a long long int if the variant has userType() QMetaType::LongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.

Calls C++ function: qlonglong QVariant::toLongLong(bool* ok = …) const.

C++ documentation:

Returns the variant as a long long int if the variant has userType() QMetaType::LongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.

If ok is non-null: *ok is set to true if the value could be converted to an int; otherwise *ok is set to false.

See also canConvert() and convert().

pub unsafe fn to_long_long_0a(&self) -> i64[src]

Returns the variant as a long long int if the variant has userType() QMetaType::LongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.

Calls C++ function: qlonglong QVariant::toLongLong() const.

C++ documentation:

Returns the variant as a long long int if the variant has userType() QMetaType::LongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.

If ok is non-null: *ok is set to true if the value could be converted to an int; otherwise *ok is set to false.

See also canConvert() and convert().

pub unsafe fn to_map(&self) -> CppBox<QMapOfQStringQVariant>[src]

Returns the variant as a QMap<QString, QVariant> if the variant has type() QMetaType::QVariantMap; otherwise returns an empty map.

Calls C++ function: QMap<QString, QVariant> QVariant::toMap() const.

C++ documentation:

Returns the variant as a QMap<QString, QVariant> if the variant has type() QMetaType::QVariantMap; otherwise returns an empty map.

See also canConvert() and convert().

pub unsafe fn to_model_index(&self) -> CppBox<QModelIndex>[src]

Returns the variant as a QModelIndex if the variant has userType() QModelIndex; otherwise returns a default constructed QModelIndex.

Calls C++ function: QModelIndex QVariant::toModelIndex() const.

C++ documentation:

Returns the variant as a QModelIndex if the variant has userType() QModelIndex; otherwise returns a default constructed QModelIndex.

This function was introduced in Qt 5.0.

See also canConvert(), convert(), and toPersistentModelIndex().

pub unsafe fn to_persistent_model_index(&self) -> CppBox<QPersistentModelIndex>[src]

Returns the variant as a QPersistentModelIndex if the variant has userType() QPersistentModelIndex; otherwise returns a default constructed QPersistentModelIndex.

Calls C++ function: QPersistentModelIndex QVariant::toPersistentModelIndex() const.

C++ documentation:

Returns the variant as a QPersistentModelIndex if the variant has userType() QPersistentModelIndex; otherwise returns a default constructed QPersistentModelIndex.

This function was introduced in Qt 5.5.

See also canConvert(), convert(), and toModelIndex().

pub unsafe fn to_point(&self) -> CppBox<QPoint>[src]

Returns the variant as a QPoint if the variant has userType() QMetaType::QPoint or QMetaType::QPointF; otherwise returns a null QPoint.

Calls C++ function: QPoint QVariant::toPoint() const.

C++ documentation:

Returns the variant as a QPoint if the variant has userType() QMetaType::QPoint or QMetaType::QPointF; otherwise returns a null QPoint.

See also canConvert() and convert().

pub unsafe fn to_point_f(&self) -> CppBox<QPointF>[src]

Returns the variant as a QPointF if the variant has userType() QMetaType::QPoint or QMetaType::QPointF; otherwise returns a null QPointF.

Calls C++ function: QPointF QVariant::toPointF() const.

C++ documentation:

Returns the variant as a QPointF if the variant has userType() QMetaType::QPoint or QMetaType::QPointF; otherwise returns a null QPointF.

See also canConvert() and convert().

pub unsafe fn to_real_1a(&self, ok: impl CastInto<MutPtr<bool>>) -> c_double[src]

Returns the variant as a qreal if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

Calls C++ function: double QVariant::toReal(bool* ok = …) const.

C++ documentation:

Returns the variant as a qreal if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

If ok is non-null: *ok is set to true if the value could be converted to a double; otherwise *ok is set to false.

This function was introduced in Qt 4.6.

See also canConvert() and convert().

pub unsafe fn to_real_0a(&self) -> c_double[src]

Returns the variant as a qreal if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

Calls C++ function: double QVariant::toReal() const.

C++ documentation:

Returns the variant as a qreal if the variant has userType() QMetaType::Double, QMetaType::Float, QMetaType::Bool, QMetaType::QByteArray, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns 0.0.

If ok is non-null: *ok is set to true if the value could be converted to a double; otherwise *ok is set to false.

This function was introduced in Qt 4.6.

See also canConvert() and convert().

pub unsafe fn to_rect(&self) -> CppBox<QRect>[src]

Returns the variant as a QRect if the variant has userType() QMetaType::QRect; otherwise returns an invalid QRect.

Calls C++ function: QRect QVariant::toRect() const.

C++ documentation:

Returns the variant as a QRect if the variant has userType() QMetaType::QRect; otherwise returns an invalid QRect.

See also canConvert() and convert().

pub unsafe fn to_rect_f(&self) -> CppBox<QRectF>[src]

Returns the variant as a QRectF if the variant has userType() QMetaType::QRect or QMetaType::QRectF; otherwise returns an invalid QRectF.

Calls C++ function: QRectF QVariant::toRectF() const.

C++ documentation:

Returns the variant as a QRectF if the variant has userType() QMetaType::QRect or QMetaType::QRectF; otherwise returns an invalid QRectF.

See also canConvert() and convert().

pub unsafe fn to_reg_exp(&self) -> CppBox<QRegExp>[src]

Returns the variant as a QRegExp if the variant has userType() QMetaType::QRegExp; otherwise returns an empty QRegExp.

Calls C++ function: QRegExp QVariant::toRegExp() const.

C++ documentation:

Returns the variant as a QRegExp if the variant has userType() QMetaType::QRegExp; otherwise returns an empty QRegExp.

This function was introduced in Qt 4.1.

See also canConvert() and convert().

pub unsafe fn to_regular_expression(&self) -> CppBox<QRegularExpression>[src]

Returns the variant as a QRegularExpression if the variant has userType() QRegularExpression; otherwise returns an empty QRegularExpression.

Calls C++ function: QRegularExpression QVariant::toRegularExpression() const.

C++ documentation:

Returns the variant as a QRegularExpression if the variant has userType() QRegularExpression; otherwise returns an empty QRegularExpression.

This function was introduced in Qt 5.0.

See also canConvert() and convert().

pub unsafe fn to_size(&self) -> CppBox<QSize>[src]

Returns the variant as a QSize if the variant has userType() QMetaType::QSize; otherwise returns an invalid QSize.

Calls C++ function: QSize QVariant::toSize() const.

C++ documentation:

Returns the variant as a QSize if the variant has userType() QMetaType::QSize; otherwise returns an invalid QSize.

See also canConvert() and convert().

pub unsafe fn to_size_f(&self) -> CppBox<QSizeF>[src]

Returns the variant as a QSizeF if the variant has userType() QMetaType::QSizeF; otherwise returns an invalid QSizeF.

Calls C++ function: QSizeF QVariant::toSizeF() const.

C++ documentation:

Returns the variant as a QSizeF if the variant has userType() QMetaType::QSizeF; otherwise returns an invalid QSizeF.

See also canConvert() and convert().

pub unsafe fn to_string(&self) -> CppBox<QString>[src]

Returns the variant as a QString if the variant has userType() QMetaType::QString, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::QDate, QMetaType::QDateTime, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QStringList, QMetaType::QTime, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns an empty string.

Calls C++ function: QString QVariant::toString() const.

C++ documentation:

Returns the variant as a QString if the variant has userType() QMetaType::QString, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::QDate, QMetaType::QDateTime, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QStringList, QMetaType::QTime, QMetaType::UInt, or QMetaType::ULongLong; otherwise returns an empty string.

See also canConvert() and convert().

pub unsafe fn to_string_list(&self) -> CppBox<QStringList>[src]

Returns the variant as a QStringList if the variant has userType() QMetaType::QStringList, QMetaType::QString, or QMetaType::QVariantList of a type that can be converted to QString; otherwise returns an empty list.

Calls C++ function: QStringList QVariant::toStringList() const.

C++ documentation:

Returns the variant as a QStringList if the variant has userType() QMetaType::QStringList, QMetaType::QString, or QMetaType::QVariantList of a type that can be converted to QString; otherwise returns an empty list.

See also canConvert() and convert().

pub unsafe fn to_time(&self) -> CppBox<QTime>[src]

Returns the variant as a QTime if the variant has userType() QMetaType::QTime, QMetaType::QDateTime, or QMetaType::QString; otherwise returns an invalid time.

Calls C++ function: QTime QVariant::toTime() const.

C++ documentation:

Returns the variant as a QTime if the variant has userType() QMetaType::QTime, QMetaType::QDateTime, or QMetaType::QString; otherwise returns an invalid time.

If the type() is QMetaType::QString, an invalid time will be returned if the string cannot be parsed as a Qt::ISODate format time.

See also canConvert() and convert().

pub unsafe fn to_u_int_1a(&self, ok: impl CastInto<MutPtr<bool>>) -> c_uint[src]

Returns the variant as an unsigned int if the variant has userType() QMetaType::UInt, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, or QMetaType::ULongLong; otherwise returns 0.

Calls C++ function: unsigned int QVariant::toUInt(bool* ok = …) const.

C++ documentation:

Returns the variant as an unsigned int if the variant has userType() QMetaType::UInt, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, or QMetaType::ULongLong; otherwise returns 0.

If ok is non-null: *ok is set to true if the value could be converted to an unsigned int; otherwise *ok is set to false.

Warning: If the value is convertible to a QMetaType::ULongLong but is too large to be represented in an unsigned int, the resulting arithmetic overflow will not be reflected in ok. A simple workaround is to use QString::toUInt().

See also canConvert() and convert().

pub unsafe fn to_u_int_0a(&self) -> c_uint[src]

Returns the variant as an unsigned int if the variant has userType() QMetaType::UInt, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, or QMetaType::ULongLong; otherwise returns 0.

Calls C++ function: unsigned int QVariant::toUInt() const.

C++ documentation:

Returns the variant as an unsigned int if the variant has userType() QMetaType::UInt, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, or QMetaType::ULongLong; otherwise returns 0.

If ok is non-null: *ok is set to true if the value could be converted to an unsigned int; otherwise *ok is set to false.

Warning: If the value is convertible to a QMetaType::ULongLong but is too large to be represented in an unsigned int, the resulting arithmetic overflow will not be reflected in ok. A simple workaround is to use QString::toUInt().

See also canConvert() and convert().

pub unsafe fn to_u_long_long_1a(&self, ok: impl CastInto<MutPtr<bool>>) -> u64[src]

Returns the variant as an unsigned long long int if the variant has type() QMetaType::ULongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, or QMetaType::UInt; otherwise returns 0.

Calls C++ function: qulonglong QVariant::toULongLong(bool* ok = …) const.

C++ documentation:

Returns the variant as an unsigned long long int if the variant has type() QMetaType::ULongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, or QMetaType::UInt; otherwise returns 0.

If ok is non-null: *ok is set to true if the value could be converted to an int; otherwise *ok is set to false.

See also canConvert() and convert().

pub unsafe fn to_u_long_long_0a(&self) -> u64[src]

Returns the variant as an unsigned long long int if the variant has type() QMetaType::ULongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, or QMetaType::UInt; otherwise returns 0.

Calls C++ function: qulonglong QVariant::toULongLong() const.

C++ documentation:

Returns the variant as an unsigned long long int if the variant has type() QMetaType::ULongLong, QMetaType::Bool, QMetaType::QByteArray, QMetaType::QChar, QMetaType::Double, QMetaType::Int, QMetaType::LongLong, QMetaType::QString, or QMetaType::UInt; otherwise returns 0.

If ok is non-null: *ok is set to true if the value could be converted to an int; otherwise *ok is set to false.

See also canConvert() and convert().

pub unsafe fn to_url(&self) -> CppBox<QUrl>[src]

Returns the variant as a QUrl if the variant has userType() QMetaType::QUrl; otherwise returns an invalid QUrl.

Calls C++ function: QUrl QVariant::toUrl() const.

C++ documentation:

Returns the variant as a QUrl if the variant has userType() QMetaType::QUrl; otherwise returns an invalid QUrl.

See also canConvert() and convert().

pub unsafe fn to_uuid(&self) -> CppBox<QUuid>[src]

Returns the variant as a QUuid if the variant has type() QMetaType::QUuid, QMetaType::QByteArray or QMetaType::QString; otherwise returns a default-constructed QUuid.

Calls C++ function: QUuid QVariant::toUuid() const.

C++ documentation:

Returns the variant as a QUuid if the variant has type() QMetaType::QUuid, QMetaType::QByteArray or QMetaType::QString; otherwise returns a default-constructed QUuid.

This function was introduced in Qt 5.0.

See also canConvert() and convert().

pub unsafe fn type_(&self) -> Type[src]

Returns the storage type of the value stored in the variant. Although this function is declared as returning QVariant::Type, the return value should be interpreted as QMetaType::Type. In particular, QVariant::UserType is returned here only if the value is equal or greater than QMetaType::User.

Calls C++ function: QVariant::Type QVariant::type() const.

C++ documentation:

Returns the storage type of the value stored in the variant. Although this function is declared as returning QVariant::Type, the return value should be interpreted as QMetaType::Type. In particular, QVariant::UserType is returned here only if the value is equal or greater than QMetaType::User.

Note that return values in the ranges QVariant::Char through QVariant::RegExp and QVariant::Font through QVariant::Transform correspond to the values in the ranges QMetaType::QChar through QMetaType::QRegExp and QMetaType::QFont through QMetaType::QQuaternion.

Pay particular attention when working with char and QChar variants. Note that there is no QVariant constructor specifically for type char, but there is one for QChar. For a variant of type QChar, this function returns QVariant::Char, which is the same as QMetaType::QChar, but for a variant of type char, this function returns QMetaType::Char, which is not the same as QVariant::Char.

Also note that the types void*, long, short, unsigned long, unsigned short, unsigned char, float, QObject*, and QWidget* are represented in QMetaType::Type but not in QVariant::Type, and they can be returned by this function. However, they are considered to be user defined types when tested against QVariant::Type.

To test whether an instance of QVariant contains a data type that is compatible with the data type you are interested in, use canConvert().

pub unsafe fn type_name(&self) -> Ptr<c_char>[src]

Returns the name of the type stored in the variant. The returned strings describe the C++ datatype used to store the data: for example, "QFont", "QString", or "QVariantList". An Invalid variant returns 0.

Calls C++ function: const char* QVariant::typeName() const.

C++ documentation:

Returns the name of the type stored in the variant. The returned strings describe the C++ datatype used to store the data: for example, "QFont", "QString", or "QVariantList". An Invalid variant returns 0.

pub unsafe fn type_to_name(type_id: c_int) -> Ptr<c_char>[src]

Converts the int representation of the storage type, typeId, to its string representation.

Calls C++ function: static const char* QVariant::typeToName(int typeId).

C++ documentation:

Converts the int representation of the storage type, typeId, to its string representation.

Returns a null pointer if the type is QMetaType::UnknownType or doesn't exist.

pub unsafe fn user_type(&self) -> c_int[src]

Returns the storage type of the value stored in the variant. For non-user types, this is the same as type().

Calls C++ function: int QVariant::userType() const.

C++ documentation:

Returns the storage type of the value stored in the variant. For non-user types, this is the same as type().

See also type().

Trait Implementations

impl PartialEq<Ref<QVariant>> for QVariant[src]

fn eq(&self, v: &Ref<QVariant>) -> bool[src]

Compares this QVariant with v and returns true if they are equal; otherwise returns false.

Calls C++ function: bool QVariant::operator==(const QVariant& v) const.

C++ documentation:

Compares this QVariant with v and returns true if they are equal; otherwise returns false.

QVariant uses the equality operator of the type() it contains to check for equality. QVariant will try to convert() v if its type is not the same as this variant's type. See canConvert() for a list of possible conversions.

Warning: To make this function work with a custom type registered with qRegisterMetaType(), its comparison operator must be registered using QMetaType::registerComparators().

impl Lt<Ref<QVariant>> for QVariant[src]

unsafe fn lt(&self, v: &Ref<QVariant>) -> bool[src]

Compares this QVariant with v and returns true if this is less than v.

Calls C++ function: bool QVariant::operator<(const QVariant& v) const.

C++ documentation:

Compares this QVariant with v and returns true if this is less than v.

Note: Comparability might not be availabe for the type stored in this QVariant or in v.

Warning: To make this function work with a custom type registered with qRegisterMetaType(), its comparison operator must be registered using QMetaType::registerComparators().

impl Le<Ref<QVariant>> for QVariant[src]

unsafe fn le(&self, v: &Ref<QVariant>) -> bool[src]

Compares this QVariant with v and returns true if this is less or equal than v.

Calls C++ function: bool QVariant::operator<=(const QVariant& v) const.

C++ documentation:

Compares this QVariant with v and returns true if this is less or equal than v.

Note: Comparability might not be available for the type stored in this QVariant or in v.

Warning: To make this function work with a custom type registered with qRegisterMetaType(), its comparison operator must be registered using QMetaType::registerComparators().

impl Gt<Ref<QVariant>> for QVariant[src]

unsafe fn gt(&self, v: &Ref<QVariant>) -> bool[src]

Compares this QVariant with v and returns true if this is larger than v.

Calls C++ function: bool QVariant::operator>(const QVariant& v) const.

C++ documentation:

Compares this QVariant with v and returns true if this is larger than v.

Note: Comparability might not be available for the type stored in this QVariant or in v.

Warning: To make this function work with a custom type registered with qRegisterMetaType(), its comparison operator must be registered using QMetaType::registerComparators().

impl Ge<Ref<QVariant>> for QVariant[src]

unsafe fn ge(&self, v: &Ref<QVariant>) -> bool[src]

Compares this QVariant with v and returns true if this is larger or equal than v.

Calls C++ function: bool QVariant::operator>=(const QVariant& v) const.

C++ documentation:

Compares this QVariant with v and returns true if this is larger or equal than v.

Note: Comparability might not be available for the type stored in this QVariant or in v.

Warning: To make this function work with a custom type registered with qRegisterMetaType(), its comparison operator must be registered using QMetaType::registerComparators().

impl CppDeletable for QVariant[src]

unsafe fn delete(&mut self)[src]

Destroys the QVariant and the contained object.

Calls C++ function: [destructor] void QVariant::~QVariant().

C++ documentation:

Destroys the QVariant and the contained object.

Note that subclasses that reimplement clear() should reimplement the destructor to call clear(). This destructor calls clear(), but because it is the destructor, QVariant::clear() is called rather than a subclass's clear().

impl Data for QVariant[src]

type Output = Ptr<c_void>

unsafe fn data(&self) -> Ptr<c_void>[src]

Calls C++ function: const void* QVariant::data() const.

impl DataMut for QVariant[src]

type Output = MutPtr<c_void>

unsafe fn data_mut(&mut self) -> MutPtr<c_void>[src]

Calls C++ function: void* QVariant::data().

Auto Trait Implementations

Blanket Implementations

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> From<T> for T[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> Any for T where
    T: 'static + ?Sized, [src]

impl<T> StaticUpcast<T> for T[src]

impl<T, U> CastInto<U> for T where
    U: CastFrom<T>, [src]