unicorn/qemu/include/qapi/qmp/qobject.h
Max Reitz dbdba16732
qapi: Add qobject_to()
This is a dynamic casting macro that, given a QObject type, returns an
object as that type or NULL if the object is of a different type (or
NULL itself).

The macro uses lower-case letters because:
1. There does not seem to be a hard rule on whether qemu macros have to
be upper-cased,
2. The current situation in qapi/qmp is inconsistent (compare e.g.
QINCREF() vs. qdict_put()),
3. qobject_to() will evaluate its @obj parameter only once, thus it is
generally not important to the caller whether it is a macro or not,
4. I prefer it aesthetically.

The macro parameter order is chosen with typename first for
consistency with other QAPI macros like QAPI_CLONE(), as well as
for legibility (read it as "qobject to" type "applied to" obj).

Backports commit 1a56b1e2ab5e9d6d89386ca953b4afb419e15abe from qemu
2018-03-20 10:45:59 -04:00

139 lines
3.8 KiB
C

/*
* QEMU Object Model.
*
* Based on ideas by Avi Kivity <avi@redhat.com>
*
* Copyright (C) 2009, 2015 Red Hat Inc.
*
* Authors:
* Luiz Capitulino <lcapitulino@redhat.com>
*
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
* See the COPYING.LIB file in the top-level directory.
*
* QObject Reference Counts Terminology
* ------------------------------------
*
* - Returning references: A function that returns an object may
* return it as either a weak or a strong reference. If the reference
* is strong, you are responsible for calling QDECREF() on the reference
* when you are done.
*
* If the reference is weak, the owner of the reference may free it at
* any time in the future. Before storing the reference anywhere, you
* should call QINCREF() to make the reference strong.
*
* - Transferring ownership: when you transfer ownership of a reference
* by calling a function, you are no longer responsible for calling
* QDECREF() when the reference is no longer needed. In other words,
* when the function returns you must behave as if the reference to the
* passed object was weak.
*/
#ifndef QOBJECT_H
#define QOBJECT_H
#include "qapi/qapi-builtin-types.h"
struct QObject {
QType type;
size_t refcnt;
};
/* Objects definitions must include this */
#define QObject_HEAD \
QObject base
/* Get the 'base' part of an object */
#define QOBJECT(obj) (&(obj)->base)
/* High-level interface for qobject_incref() */
#define QINCREF(obj) \
qobject_incref(QOBJECT(obj))
/* High-level interface for qobject_decref() */
#define QDECREF(obj) \
qobject_decref(obj ? QOBJECT(obj) : NULL)
/* Required for qobject_to() */
#define QTYPE_CAST_TO_QNull QTYPE_QNULL
#define QTYPE_CAST_TO_QNum QTYPE_QNUM
#define QTYPE_CAST_TO_QString QTYPE_QSTRING
#define QTYPE_CAST_TO_QDict QTYPE_QDICT
#define QTYPE_CAST_TO_QList QTYPE_QLIST
#define QTYPE_CAST_TO_QBool QTYPE_QBOOL
QEMU_BUILD_BUG_MSG(QTYPE__MAX != 7,
"The QTYPE_CAST_TO_* list needs to be extended");
#define qobject_to(type, obj) ({ \
QObject *_tmp = qobject_check_type(obj, glue(QTYPE_CAST_TO_, type)); \
_tmp ? container_of(_tmp, type, base) : (type *)NULL; })
/* Initialize an object to default values */
static inline void qobject_init(QObject *obj, QType type)
{
assert(QTYPE_NONE < type && type < QTYPE__MAX);
obj->refcnt = 1;
obj->type = type;
}
/**
* qobject_incref(): Increment QObject's reference count
*/
static inline void qobject_incref(QObject *obj)
{
if (obj)
obj->refcnt++;
}
/**
* qobject_is_equal(): Return whether the two objects are equal.
*
* Any of the pointers may be NULL; return true if both are. Always
* return false if only one is (therefore a QNull object is not
* considered equal to a NULL pointer).
*/
bool qobject_is_equal(const QObject *x, const QObject *y);
/**
* qobject_destroy(): Free resources used by the object
*/
void qobject_destroy(QObject *obj);
/**
* qobject_decref(): Decrement QObject's reference count, deallocate
* when it reaches zero
*/
static inline void qobject_decref(QObject *obj)
{
assert(!obj || obj->refcnt);
if (obj && --obj->refcnt == 0) {
qobject_destroy(obj);
}
}
/**
* qobject_type(): Return the QObject's type
*/
static inline QType qobject_type(const QObject *obj)
{
assert(QTYPE_NONE < obj->type && obj->type < QTYPE__MAX);
return obj->type;
}
/**
* qobject_check_type(): Helper function for the qobject_to() macro.
* Return @obj, but only if @obj is not NULL and @type is equal to
* @obj's type. Return NULL otherwise.
*/
static inline QObject *qobject_check_type(const QObject *obj, QType type)
{
if (obj && qobject_type(obj) == type) {
return (QObject *)obj;
} else {
return NULL;
}
}
#endif /* QOBJECT_H */