xref: /openbmc/qemu/include/qapi/qmp/qobject.h (revision 05548400)
1 /*
2  * QEMU Object Model.
3  *
4  * Based on ideas by Avi Kivity <avi@redhat.com>
5  *
6  * Copyright (C) 2009, 2015 Red Hat Inc.
7  *
8  * Authors:
9  *  Luiz Capitulino <lcapitulino@redhat.com>
10  *
11  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
12  * See the COPYING.LIB file in the top-level directory.
13  *
14  * QObject Reference Counts Terminology
15  * ------------------------------------
16  *
17  *  - Returning references: A function that returns an object may
18  *  return it as either a weak or a strong reference.  If the
19  *  reference is strong, you are responsible for calling
20  *  qobject_unref() on the reference when you are done.
21  *
22  *  If the reference is weak, the owner of the reference may free it at
23  *  any time in the future.  Before storing the reference anywhere, you
24  *  should call qobject_ref() to make the reference strong.
25  *
26  *  - Transferring ownership: when you transfer ownership of a reference
27  *  by calling a function, you are no longer responsible for calling
28  *  qobject_unref() when the reference is no longer needed.  In other words,
29  *  when the function returns you must behave as if the reference to the
30  *  passed object was weak.
31  */
32 #ifndef QOBJECT_H
33 #define QOBJECT_H
34 
35 #include "qapi/qapi-builtin-types.h"
36 
37 /* Not for use outside include/qapi/qmp/ */
38 struct QObjectBase_ {
39     QType type;
40     size_t refcnt;
41 };
42 
43 /* this struct must have no other members than base */
44 struct QObject {
45     struct QObjectBase_ base;
46 };
47 
48 /*
49  * Preprocessor sorcery ahead: use a different identifier for the
50  * local variable in each expansion, so we can nest macro calls
51  * without shadowing variables.
52  */
53 #define QOBJECT_INTERNAL(obj, _obj) ({                          \
54     typeof(obj) _obj = (obj);                                   \
55     _obj ? container_of(&_obj->base, QObject, base) : NULL;     \
56 })
57 #define QOBJECT(obj) QOBJECT_INTERNAL((obj), MAKE_IDENTIFIER(_obj))
58 
59 /* Required for qobject_to() */
60 #define QTYPE_CAST_TO_QNull     QTYPE_QNULL
61 #define QTYPE_CAST_TO_QNum      QTYPE_QNUM
62 #define QTYPE_CAST_TO_QString   QTYPE_QSTRING
63 #define QTYPE_CAST_TO_QDict     QTYPE_QDICT
64 #define QTYPE_CAST_TO_QList     QTYPE_QLIST
65 #define QTYPE_CAST_TO_QBool     QTYPE_QBOOL
66 
67 QEMU_BUILD_BUG_MSG(QTYPE__MAX != 7,
68                    "The QTYPE_CAST_TO_* list needs to be extended");
69 
70 #define qobject_to(type, obj)                                       \
71     ((type *)qobject_check_type(obj, glue(QTYPE_CAST_TO_, type)))
72 
qobject_ref_impl(QObject * obj)73 static inline void qobject_ref_impl(QObject *obj)
74 {
75     if (obj) {
76         obj->base.refcnt++;
77     }
78 }
79 
80 /**
81  * qobject_is_equal(): Return whether the two objects are equal.
82  *
83  * Any of the pointers may be NULL; return true if both are.  Always
84  * return false if only one is (therefore a QNull object is not
85  * considered equal to a NULL pointer).
86  */
87 bool qobject_is_equal(const QObject *x, const QObject *y);
88 
89 /**
90  * qobject_destroy(): Free resources used by the object
91  * For use via qobject_unref() only!
92  */
93 void qobject_destroy(QObject *obj);
94 
qobject_unref_impl(QObject * obj)95 static inline void qobject_unref_impl(QObject *obj)
96 {
97     assert(!obj || obj->base.refcnt);
98     if (obj && --obj->base.refcnt == 0) {
99         qobject_destroy(obj);
100     }
101 }
102 
103 /**
104  * qobject_ref(): Increment QObject's reference count
105  *
106  * Returns: the same @obj. The type of @obj will be propagated to the
107  * return type.
108  */
109 #define qobject_ref(obj) ({                     \
110     typeof(obj) _o = (obj);                     \
111     qobject_ref_impl(QOBJECT(_o));              \
112     _o;                                         \
113 })
114 
115 /**
116  * qobject_unref(): Decrement QObject's reference count, deallocate
117  * when it reaches zero
118  */
119 #define qobject_unref(obj) qobject_unref_impl(QOBJECT(obj))
120 
121 /**
122  * qobject_type(): Return the QObject's type
123  */
qobject_type(const QObject * obj)124 static inline QType qobject_type(const QObject *obj)
125 {
126     assert(QTYPE_NONE < obj->base.type && obj->base.type < QTYPE__MAX);
127     return obj->base.type;
128 }
129 
130 /**
131  * qobject_check_type(): Helper function for the qobject_to() macro.
132  * Return @obj, but only if @obj is not NULL and @type is equal to
133  * @obj's type.  Return NULL otherwise.
134  */
qobject_check_type(const QObject * obj,QType type)135 static inline QObject *qobject_check_type(const QObject *obj, QType type)
136 {
137     if (obj && qobject_type(obj) == type) {
138         return (QObject *)obj;
139     } else {
140         return NULL;
141     }
142 }
143 
144 #endif /* QOBJECT_H */
145