cxx-qt-lib 0.10.0

Qt types for integrating `cxx-qt` crate with `cxx`
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// SPDX-FileCopyrightText: 2026 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
// SPDX-FileContributor: Yuri Knigavko <yuri.knigavko@qt.io>
//
// SPDX-License-Identifier: MIT OR Apache-2.0

use crate::{QJsonValue, QString};
use std::fmt;
use std::mem::MaybeUninit;

#[cxx::bridge]
mod ffi {
    unsafe extern "C++" {
        include!("cxx-qt-lib/qjsonobject.h");
        type QJsonObject = super::QJsonObject;

        include!("cxx-qt-lib/qjsonvalue.h");
        type QJsonValue = crate::QJsonValue;

        include!("cxx-qt-lib/qstring.h");
        type QString = crate::QString;

        include!("cxx-qt-lib/qstringlist.h");
        type QStringList = crate::QStringList;

        /// Returns `true` if the object is empty.
        #[rust_name = "is_empty"]
        fn isEmpty(self: &QJsonObject) -> bool;

        /// Returns `true` if the object contains `key`.
        fn contains(self: &QJsonObject, key: &QString) -> bool;

        /// Returns the value for `key`, or an undefined [`QJsonValue`] if the key is absent.
        fn value(self: &QJsonObject, key: &QString) -> QJsonValue;

        /// Removes `key` from the object.
        fn remove(self: &mut QJsonObject, key: &QString);

        /// Returns all keys in the object.
        fn keys(self: &QJsonObject) -> QStringList;
    }

    #[namespace = "rust::cxxqtlib1"]
    unsafe extern "C++" {
        include!("cxx-qt-lib/common.h");

        #[doc(hidden)]
        #[rust_name = "qjsonobject_drop"]
        fn drop(object: &mut QJsonObject);

        #[doc(hidden)]
        #[rust_name = "qjsonobject_init_default"]
        fn construct() -> QJsonObject;

        #[doc(hidden)]
        #[rust_name = "qjsonobject_init_from_qjsonobject"]
        fn construct(object: &QJsonObject) -> QJsonObject;

        #[doc(hidden)]
        #[rust_name = "qjsonobject_eq"]
        fn operatorEq(a: &QJsonObject, b: &QJsonObject) -> bool;

        #[doc(hidden)]
        #[rust_name = "qjsonobject_to_debug_qstring"]
        fn toDebugQString(object: &QJsonObject) -> QString;

        #[doc(hidden)]
        #[rust_name = "qjsonobject_len"]
        fn qjsonobjectLen(object: &QJsonObject) -> isize;

        #[doc(hidden)]
        #[rust_name = "qjsonobject_insert"]
        fn qjsonobjectInsert(object: &mut QJsonObject, key: &QString, value: &QJsonValue);
    }
}

/// The `QJsonObject` class encapsulates a JSON object.
///
/// Qt Documentation: [QJsonObject](https://doc.qt.io/qt/qjsonobject.html#details)
#[repr(C)]
pub struct QJsonObject {
    #[cfg(cxxqt_qt_version_major = "5")]
    _d: MaybeUninit<usize>,
    _o: MaybeUninit<usize>,
}

impl Default for QJsonObject {
    fn default() -> Self {
        ffi::qjsonobject_init_default()
    }
}

impl Drop for QJsonObject {
    fn drop(&mut self) {
        ffi::qjsonobject_drop(self);
    }
}

impl Clone for QJsonObject {
    fn clone(&self) -> Self {
        ffi::qjsonobject_init_from_qjsonobject(self)
    }
}

impl PartialEq for QJsonObject {
    fn eq(&self, other: &Self) -> bool {
        ffi::qjsonobject_eq(self, other)
    }
}

impl fmt::Debug for QJsonObject {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        ffi::qjsonobject_to_debug_qstring(self).fmt(f)
    }
}

// Safety:
//
// Static checks on the C++ side ensure that QJsonObject is trivial.
unsafe impl cxx::ExternType for QJsonObject {
    type Id = cxx::type_id!("QJsonObject");
    type Kind = cxx::kind::Trivial;
}

impl QJsonObject {
    /// Returns the number of key-value pairs in the object.
    pub fn len(&self) -> isize {
        ffi::qjsonobject_len(self)
    }

    /// Inserts or replaces the value for `key`.
    pub fn insert(&mut self, key: &QString, value: &QJsonValue) {
        ffi::qjsonobject_insert(self, key, value);
    }
}