Qt 4.8
Classes | Public Functions | Private Types | Private Functions | Properties | List of all members
QDBusMetaObjectGenerator Class Reference

Classes

struct  Method
 
struct  Property
 
struct  Type
 

Public Functions

 QDBusMetaObjectGenerator (const QString &interface, const QDBusIntrospection::Interface *parsedData)
 
void write (QDBusMetaObject *obj)
 
void writeWithoutXml (QDBusMetaObject *obj)
 

Private Types

enum  MethodFlags {
  AccessPrivate = 0x00, AccessProtected = 0x01, AccessPublic = 0x02, AccessMask = 0x03,
  MethodMethod = 0x00, MethodSignal = 0x04, MethodSlot = 0x08, MethodTypeMask = 0x0c,
  MethodCompatibility = 0x10, MethodCloned = 0x20, MethodScriptable = 0x40
}
 
enum  PropertyFlags {
  Invalid = 0x00000000, Readable = 0x00000001, Writable = 0x00000002, Resettable = 0x00000004,
  EnumOrFlag = 0x00000008, StdCppSet = 0x00000100, Designable = 0x00001000, ResolveDesignable = 0x00002000,
  Scriptable = 0x00004000, ResolveScriptable = 0x00008000, Stored = 0x00010000, ResolveStored = 0x00020000,
  Editable = 0x00040000, ResolveEditable = 0x00080000, User = 0x00100000, ResolveUser = 0x00200000
}
 

Private Functions

Type findType (const QByteArray &signature, const QDBusIntrospection::Annotations &annotations, const char *direction="Out", int id=-1)
 
void parseMethods ()
 
void parseProperties ()
 
void parseSignals ()
 

Properties

const QDBusIntrospection::Interfacedata
 
QString interface
 
QMap< QByteArray, Methodmethods
 
QMap< QByteArray, Propertyproperties
 

Detailed Description

Definition at line 60 of file qdbusmetaobject.cpp.

Enumerations

◆ MethodFlags

◆ PropertyFlags

Enumerator
Invalid 
Readable 
Writable 
Resettable 
EnumOrFlag 
StdCppSet 
Designable 
ResolveDesignable 
Scriptable 
ResolveScriptable 
Stored 
ResolveStored 
Editable 
ResolveEditable 
User 
ResolveUser 

Definition at line 92 of file qdbusmetaobject.cpp.

92  {
93  Invalid = 0x00000000,
94  Readable = 0x00000001,
95  Writable = 0x00000002,
96  Resettable = 0x00000004,
97  EnumOrFlag = 0x00000008,
98  StdCppSet = 0x00000100,
99  // Override = 0x00000200,
100  Designable = 0x00001000,
101  ResolveDesignable = 0x00002000,
102  Scriptable = 0x00004000,
103  ResolveScriptable = 0x00008000,
104  Stored = 0x00010000,
105  ResolveStored = 0x00020000,
106  Editable = 0x00040000,
107  ResolveEditable = 0x00080000,
108  User = 0x00100000,
109  ResolveUser = 0x00200000
110  };

Constructors and Destructors

◆ QDBusMetaObjectGenerator()

QDBusMetaObjectGenerator::QDBusMetaObjectGenerator ( const QString interface,
const QDBusIntrospection::Interface parsedData 
)

Definition at line 161 of file qdbusmetaobject.cpp.

163  : data(parsedData), interface(interfaceName)
164 {
165  if (data) {
166  parseProperties();
167  parseSignals(); // call parseSignals first so that slots override signals
168  parseMethods();
169  }
170 }
const QDBusIntrospection::Interface * data

Functions

◆ findType()

QDBusMetaObjectGenerator::Type QDBusMetaObjectGenerator::findType ( const QByteArray signature,
const QDBusIntrospection::Annotations annotations,
const char *  direction = "Out",
int  id = -1 
)
private

Definition at line 175 of file qdbusmetaobject.cpp.

Referenced by parseMethods(), parseProperties(), and parseSignals().

178 {
179  Type result;
180  result.id = QVariant::Invalid;
181 
182  int type = QDBusMetaType::signatureToType(signature);
184  // it's not a type normally handled by our meta type system
185  // it must contain an annotation
186  QString annotationName = QString::fromLatin1("org.qtproject.QtDBus.QtTypeName");
187  if (id >= 0)
188  annotationName += QString::fromLatin1(".%1%2")
190  .arg(id);
191 
192  // extract from annotations:
193  QByteArray typeName = annotations.value(annotationName).toLatin1();
194 
195  // verify that it's a valid one
196  if (typeName.isEmpty()) {
197  // try the old annotation from Qt 4
198  annotationName = QString::fromLatin1("com.trolltech.QtDBus.QtTypeName");
199  if (id >= 0)
200  annotationName += QString::fromLatin1(".%1%2")
202  .arg(id);
203  typeName = annotations.value(annotationName).toLatin1();
204  }
205 
206  if (!typeName.isEmpty()) {
207  // type name found
208  type = QVariant::nameToType(typeName);
209  if (type == QVariant::UserType)
210  type = QMetaType::type(typeName);
211  }
212 
213  if (type == QVariant::Invalid || signature != QDBusMetaType::typeToSignature(type)) {
214  // type is still unknown or doesn't match back to the signature that it
215  // was expected to, so synthesize a fake type
216  type = QMetaType::VoidStar;
217  typeName = "QDBusRawType<0x" + signature.toHex() + ">*";
218  }
219 
220  result.name = typeName;
221  } else if (type == QVariant::Invalid) {
222  // this case is used only by the qdbus command-line tool
223  // invalid, let's create an impossible type that contains the signature
224 
225  if (signature == "av") {
226  result.name = "QVariantList";
227  type = QVariant::List;
228  } else if (signature == "a{sv}") {
229  result.name = "QVariantMap";
230  type = QVariant::Map;
231  } else {
232  result.name = "QDBusRawType::" + signature;
233  type = -1;
234  }
235  } else {
236  result.name = QVariant::typeToName( QVariant::Type(type) );
237  }
238 
239  result.id = type;
240  return result; // success
241 }
int type
Definition: qmetatype.cpp:239
static int signatureToType(const char *signature)
The QByteArray class provides an array of bytes.
Definition: qbytearray.h:135
QLatin1String(DBUS_INTERFACE_DBUS))) Q_GLOBAL_STATIC_WITH_ARGS(QString
Q_DBUS_EXPORT bool qt_dbus_metaobject_skip_annotations
The QString class provides a Unicode character string.
Definition: qstring.h:83
QByteArray toHex() const
Returns a hex encoded copy of the byte array.
static const char * typeToName(Type type)
Converts the enum representation of the storage type, typ, to its string representation.
Definition: qvariant.cpp:2008
static const char * typeToSignature(int type)
Returns the D-Bus signature equivalent to the supplied meta type id type.
const char * typeName
Definition: qmetatype.cpp:239
const T value(const Key &key) const
Returns the value associated with the key key.
Definition: qmap.h:499
Type
This enum type defines the types of variable that a QVariant can contain.
Definition: qvariant.h:95
QByteArray toLatin1() const Q_REQUIRED_RESULT
Returns a Latin-1 representation of the string as a QByteArray.
Definition: qstring.cpp:3993
static int type(const char *typeName)
Returns a handle to the type called typeName, or 0 if there is no such type.
Definition: qmetatype.cpp:607
QString arg(qlonglong a, int fieldwidth=0, int base=10, const QChar &fillChar=QLatin1Char(' ')) const Q_REQUIRED_RESULT
Definition: qstring.cpp:7186
static QString fromLatin1(const char *, int size=-1)
Returns a QString initialized with the first size characters of the Latin-1 string str...
Definition: qstring.cpp:4188
bool isEmpty() const
Returns true if the byte array has size 0; otherwise returns false.
Definition: qbytearray.h:421
static Type nameToType(const char *name)
Converts the string representation of the storage type given in name, to its enum representation...
Definition: qvariant.cpp:2026
Qt::LayoutDirection direction

◆ parseMethods()

void QDBusMetaObjectGenerator::parseMethods ( )
private

Definition at line 243 of file qdbusmetaobject.cpp.

Referenced by QDBusMetaObjectGenerator().

244 {
245  //
246  // TODO:
247  // Add cloned methods when the remote object has return types
248  //
249 
252  for ( ; method_it != method_end; ++method_it) {
253  const QDBusIntrospection::Method &m = *method_it;
254  Method mm;
255 
256  mm.name = m.name.toLatin1();
257  QByteArray prototype = mm.name;
258  prototype += '(';
259 
260  bool ok = true;
261 
262  // build the input argument list
263  for (int i = 0; i < m.inputArgs.count(); ++i) {
264  const QDBusIntrospection::Argument &arg = m.inputArgs.at(i);
265 
266  Type type = findType(arg.type.toLatin1(), m.annotations, "In", i);
267  if (type.id == QVariant::Invalid) {
268  ok = false;
269  break;
270  }
271 
272  mm.inputSignature += arg.type.toLatin1();
273  mm.inputTypes.append(type.id);
274 
275  mm.parameters.append(arg.name.toLatin1());
276  mm.parameters.append(',');
277 
278  prototype.append(type.name);
279  prototype.append(',');
280  }
281  if (!ok) continue;
282 
283  // build the output argument list:
284  for (int i = 0; i < m.outputArgs.count(); ++i) {
285  const QDBusIntrospection::Argument &arg = m.outputArgs.at(i);
286 
287  Type type = findType(arg.type.toLatin1(), m.annotations, "Out", i);
288  if (type.id == QVariant::Invalid) {
289  ok = false;
290  break;
291  }
292 
293  mm.outputSignature += arg.type.toLatin1();
294  mm.outputTypes.append(type.id);
295 
296  if (i == 0) {
297  // return value
298  mm.typeName = type.name;
299  } else {
300  // non-const ref parameter
301  mm.parameters.append(arg.name.toLatin1());
302  mm.parameters.append(',');
303 
304  prototype.append(type.name);
305  prototype.append("&,");
306  }
307  }
308  if (!ok) continue;
309 
310  // convert the last commas:
311  if (!mm.parameters.isEmpty()) {
312  mm.parameters.truncate(mm.parameters.length() - 1);
313  prototype[prototype.length() - 1] = ')';
314  } else {
315  prototype.append(')');
316  }
317 
318  // check the async tag
320  mm.tag = "Q_NOREPLY";
321 
322  // meta method flags
324 
325  // add
326  methods.insert(QMetaObject::normalizedSignature(prototype), mm);
327  }
328 }
int type
Definition: qmetatype.cpp:239
void truncate(int pos)
Truncates the byte array at index position pos.
QString name
The method&#39;s name.
static QByteArray normalizedSignature(const char *method)
Normalizes the signature of the given method.
QByteArray & append(char c)
Appends the character ch to this byte array.
Annotations annotations
The annotations associated with the method.
One argument to a D-Bus method or signal.
The QByteArray class provides an array of bytes.
Definition: qbytearray.h:135
QLatin1String(DBUS_INTERFACE_DBUS))) Q_GLOBAL_STATIC_WITH_ARGS(QString
int count(const T &t) const
Returns the number of occurrences of value in the list.
Definition: qlist.h:891
Type findType(const QByteArray &signature, const QDBusIntrospection::Annotations &annotations, const char *direction="Out", int id=-1)
Arguments outputArgs
A list of the method&#39;s output arguments (i.
Arguments inputArgs
A list of the method&#39;s input arguments.
#define ANNOTATION_NO_WAIT
const T value(const Key &key) const
Returns the value associated with the key key.
Definition: qmap.h:499
const T & at(int i) const
Returns the item at index position i in the list.
Definition: qlist.h:468
const QDBusIntrospection::Interface * data
The QLatin1String class provides a thin wrapper around an US-ASCII/Latin-1 encoded string literal...
Definition: qstring.h:654
QByteArray toLatin1() const Q_REQUIRED_RESULT
Returns a Latin-1 representation of the string as a QByteArray.
Definition: qstring.cpp:3993
QString type
The argument type.
const_iterator constBegin() const
Returns a const STL-style iterator pointing to the first item in the map.
Definition: qmap.h:374
QMap< QByteArray, Method > methods
int length() const
Same as size().
Definition: qbytearray.h:356
static QByteArray prototype(const QList< QByteArray > &parameterTypes, const QList< QByteArray > &parameterNames, bool *ok)
Definition: qaxserver.cpp:685
The QMap::const_iterator class provides an STL-style const iterator for QMap and QMultiMap.
Definition: qmap.h:301
const_iterator constEnd() const
Returns a const STL-style iterator pointing to the imaginary item after the last item in the map...
Definition: qmap.h:380
QString name
The argument name.
Methods methods
The methods available in this interface.
Information about one method.

◆ parseProperties()

void QDBusMetaObjectGenerator::parseProperties ( )
private

Definition at line 381 of file qdbusmetaobject.cpp.

Referenced by QDBusMetaObjectGenerator().

382 {
385  for ( ; prop_it != prop_end; ++prop_it) {
386  const QDBusIntrospection::Property &p = *prop_it;
387  Property mp;
389  if (type.id == QVariant::Invalid)
390  continue;
391 
393  mp.signature = p.type.toLatin1();
394  mp.type = type.id;
395  mp.typeName = type.name;
396 
397  // build the flags:
398  mp.flags = StdCppSet | Scriptable | Stored | Designable;
400  mp.flags |= Readable;
402  mp.flags |= Writable;
403 
404  if (mp.typeName == "QDBusVariant")
405  mp.flags |= 0xff << 24;
406  else if (mp.type < 0xff)
407  // encode the type in the flags
408  mp.flags |= mp.type << 24;
409 
410  // add the property:
411  properties.insert(name, mp);
412  }
413 }
int type
Definition: qmetatype.cpp:239
QString name
The property&#39;s name.
Information about one property.
The QByteArray class provides an array of bytes.
Definition: qbytearray.h:135
Type findType(const QByteArray &signature, const QDBusIntrospection::Annotations &annotations, const char *direction="Out", int id=-1)
Properties properties
The properties available in this interface.
const_iterator ConstIterator
Qt-style synonym for QMap::const_iterator.
Definition: qmap.h:389
const char * name
const QDBusIntrospection::Interface * data
QByteArray toLatin1() const Q_REQUIRED_RESULT
Returns a Latin-1 representation of the string as a QByteArray.
Definition: qstring.cpp:3993
const_iterator constBegin() const
Returns a const STL-style iterator pointing to the first item in the map.
Definition: qmap.h:374
QMap< QByteArray, Property > properties
const_iterator constEnd() const
Returns a const STL-style iterator pointing to the imaginary item after the last item in the map...
Definition: qmap.h:380
QString type
The property&#39;s type.
Access access
The property&#39;s access rights.
Annotations annotations
The annotations associated with the property.

◆ parseSignals()

void QDBusMetaObjectGenerator::parseSignals ( )
private

Definition at line 330 of file qdbusmetaobject.cpp.

Referenced by QDBusMetaObjectGenerator().

331 {
334  for ( ; signal_it != signal_end; ++signal_it) {
335  const QDBusIntrospection::Signal &s = *signal_it;
336  Method mm;
337 
338  mm.name = s.name.toLatin1();
339  QByteArray prototype = mm.name;
340  prototype += '(';
341 
342  bool ok = true;
343 
344  // build the output argument list
345  for (int i = 0; i < s.outputArgs.count(); ++i) {
346  const QDBusIntrospection::Argument &arg = s.outputArgs.at(i);
347 
348  Type type = findType(arg.type.toLatin1(), s.annotations, "Out", i);
349  if (type.id == QVariant::Invalid) {
350  ok = false;
351  break;
352  }
353 
354  mm.inputSignature += arg.type.toLatin1();
355  mm.inputTypes.append(type.id);
356 
357  mm.parameters.append(arg.name.toLatin1());
358  mm.parameters.append(',');
359 
360  prototype.append(type.name);
361  prototype.append(',');
362  }
363  if (!ok) continue;
364 
365  // convert the last commas:
366  if (!mm.parameters.isEmpty()) {
367  mm.parameters.truncate(mm.parameters.length() - 1);
368  prototype[prototype.length() - 1] = ')';
369  } else {
370  prototype.append(')');
371  }
372 
373  // meta method flags
375 
376  // add
377  methods.insert(QMetaObject::normalizedSignature(prototype), mm);
378  }
379 }
int type
Definition: qmetatype.cpp:239
void truncate(int pos)
Truncates the byte array at index position pos.
static QByteArray normalizedSignature(const char *method)
Normalizes the signature of the given method.
Arguments outputArgs
A list of the signal&#39;s arguments.
QByteArray & append(char c)
Appends the character ch to this byte array.
One argument to a D-Bus method or signal.
Signals signals_
The signals available in this interface.
The QByteArray class provides an array of bytes.
Definition: qbytearray.h:135
int count(const T &t) const
Returns the number of occurrences of value in the list.
Definition: qlist.h:891
Type findType(const QByteArray &signature, const QDBusIntrospection::Annotations &annotations, const char *direction="Out", int id=-1)
const T & at(int i) const
Returns the item at index position i in the list.
Definition: qlist.h:468
const QDBusIntrospection::Interface * data
Annotations annotations
The annotations associated with the signal.
QByteArray toLatin1() const Q_REQUIRED_RESULT
Returns a Latin-1 representation of the string as a QByteArray.
Definition: qstring.cpp:3993
QString type
The argument type.
const_iterator constBegin() const
Returns a const STL-style iterator pointing to the first item in the map.
Definition: qmap.h:374
Information about one signal.
QMap< QByteArray, Method > methods
int length() const
Same as size().
Definition: qbytearray.h:356
static QByteArray prototype(const QList< QByteArray > &parameterTypes, const QList< QByteArray > &parameterNames, bool *ok)
Definition: qaxserver.cpp:685
The QMap::const_iterator class provides an STL-style const iterator for QMap and QMultiMap.
Definition: qmap.h:301
const_iterator constEnd() const
Returns a const STL-style iterator pointing to the imaginary item after the last item in the map...
Definition: qmap.h:380
QString name
The argument name.
QString name
The signal&#39;s name.

◆ write()

void QDBusMetaObjectGenerator::write ( QDBusMetaObject obj)

Definition at line 415 of file qdbusmetaobject.cpp.

Referenced by QDBusMetaObject::createMetaObject().

416 {
417  // this code here is mostly copied from qaxbase.cpp
418  // with a few modifications to make it cleaner
419 
421  className.replace(QLatin1Char('.'), QLatin1String("::"));
422  if (className.isEmpty())
423  className = QLatin1String("QDBusInterface");
424 
425  QVarLengthArray<int> idata;
426  idata.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(int));
427 
428  QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(idata.data());
429  header->revision = 1;
430  header->className = 0;
431  header->classInfoCount = 0;
432  header->classInfoData = 0;
433  header->methodCount = methods.count();
434  header->methodData = idata.size();
435  header->propertyCount = properties.count();
436  header->propertyData = header->methodData + header->methodCount * 5;
437  header->enumeratorCount = 0;
438  header->enumeratorData = 0;
439  header->propertyDBusData = header->propertyData + header->propertyCount * 3;
440  header->methodDBusData = header->propertyDBusData + header->propertyCount * intsPerProperty;
441 
442  int data_size = idata.size() +
443  (header->methodCount * (5+intsPerMethod)) +
444  (header->propertyCount * (3+intsPerProperty));
445  foreach (const Method &mm, methods)
446  data_size += 2 + mm.inputTypes.count() + mm.outputTypes.count();
447  idata.resize(data_size + 1);
448 
449  char null('\0');
450  QByteArray stringdata = className.toLatin1();
451  stringdata += null;
452  stringdata.reserve(8192);
453 
454  int offset = header->methodData;
455  int signatureOffset = header->methodDBusData;
456  int typeidOffset = header->methodDBusData + header->methodCount * intsPerMethod;
457  idata[typeidOffset++] = 0; // eod
458 
459  // add each method:
461  it != methods.constEnd(); ++it) {
462  // form "prototype\0parameters\0typeName\0tag\0methodname\0inputSignature\0outputSignature"
463  const Method &mm = it.value();
464 
465  idata[offset++] = stringdata.length();
466  stringdata += it.key(); // prototype
467  stringdata += null;
468  idata[offset++] = stringdata.length();
469  stringdata += mm.parameters;
470  stringdata += null;
471  idata[offset++] = stringdata.length();
472  stringdata += mm.typeName;
473  stringdata += null;
474  idata[offset++] = stringdata.length();
475  stringdata += mm.tag;
476  stringdata += null;
477  idata[offset++] = mm.flags;
478 
479  idata[signatureOffset++] = stringdata.length();
480  stringdata += mm.name;
481  stringdata += null;
482  idata[signatureOffset++] = stringdata.length();
483  stringdata += mm.inputSignature;
484  stringdata += null;
485  idata[signatureOffset++] = stringdata.length();
486  stringdata += mm.outputSignature;
487  stringdata += null;
488 
489  idata[signatureOffset++] = typeidOffset;
490  idata[typeidOffset++] = mm.inputTypes.count();
491  memcpy(idata.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.count() * sizeof(int));
492  typeidOffset += mm.inputTypes.count();
493 
494  idata[signatureOffset++] = typeidOffset;
495  idata[typeidOffset++] = mm.outputTypes.count();
496  memcpy(idata.data() + typeidOffset, mm.outputTypes.data(), mm.outputTypes.count() * sizeof(int));
497  typeidOffset += mm.outputTypes.count();
498  }
499 
500  Q_ASSERT(offset == header->propertyData);
501  Q_ASSERT(signatureOffset == header->methodDBusData + header->methodCount * intsPerMethod);
502  Q_ASSERT(typeidOffset == idata.size());
503 
504  // add each property
505  signatureOffset = header->propertyDBusData;
507  it != properties.constEnd(); ++it) {
508  const Property &mp = it.value();
509 
510  // form is "name\0typeName\0signature\0"
511  idata[offset++] = stringdata.length();
512  stringdata += it.key(); // name
513  stringdata += null;
514  idata[offset++] = stringdata.length();
515  stringdata += mp.typeName;
516  stringdata += null;
517  idata[offset++] = mp.flags;
518 
519  idata[signatureOffset++] = stringdata.length();
520  stringdata += mp.signature;
521  stringdata += null;
522  idata[signatureOffset++] = mp.type;
523  }
524 
525  Q_ASSERT(offset == header->propertyDBusData);
526  Q_ASSERT(signatureOffset == header->methodDBusData);
527 
528  char *string_data = new char[stringdata.length()];
529  memcpy(string_data, stringdata, stringdata.length());
530 
531  uint *uint_data = new uint[idata.size()];
532  memcpy(uint_data, idata.data(), idata.size() * sizeof(int));
533 
534  // put the metaobject together
535  obj->d.data = uint_data;
536  obj->d.extradata = 0;
537  obj->d.stringdata = string_data;
539 }
void resize(int size)
const void * extradata
Definition: qobjectdefs.h:472
#define it(className, varName)
QString & replace(int i, int len, QChar after)
Definition: qstring.cpp:2005
The QByteArray class provides an array of bytes.
Definition: qbytearray.h:135
static const QMetaObject staticMetaObject
This variable stores the meta-object for the class.
Definition: qobject.h:128
static const int intsPerMethod
QLatin1String(DBUS_INTERFACE_DBUS))) Q_GLOBAL_STATIC_WITH_ARGS(QString
The QString class provides a Unicode character string.
Definition: qstring.h:83
const char * stringdata
Definition: qobjectdefs.h:470
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
const char * className
Definition: qwizard.cpp:137
bool isEmpty() const
Returns true if the string has no characters; otherwise returns false.
Definition: qstring.h:704
unsigned int uint
Definition: qglobal.h:996
QByteArray toLatin1() const Q_REQUIRED_RESULT
Returns a Latin-1 representation of the string as a QByteArray.
Definition: qstring.cpp:3993
int count() const
const uint * data
Definition: qobjectdefs.h:471
QMap< QByteArray, Method > methods
int length() const
Same as size().
Definition: qbytearray.h:356
static const int intsPerProperty
The QMap::const_iterator class provides an STL-style const iterator for QMap and QMultiMap.
Definition: qmap.h:301
QMap< QByteArray, Property > properties
const QMetaObject * superdata
Definition: qobjectdefs.h:469
struct QMetaObject::@38 d
void reserve(int size)
Attempts to allocate memory for at least size bytes.
Definition: qbytearray.h:449
The QLatin1Char class provides an 8-bit ASCII/Latin-1 character.
Definition: qchar.h:55
int size() const

◆ writeWithoutXml()

void QDBusMetaObjectGenerator::writeWithoutXml ( QDBusMetaObject obj)

Referenced by write().

Properties

◆ data

const QDBusIntrospection::Interface* QDBusMetaObjectGenerator::data
private

◆ interface

QString QDBusMetaObjectGenerator::interface
private

Definition at line 132 of file qdbusmetaobject.cpp.

Referenced by QDBusMetaObject::createMetaObject(), and write().

◆ methods

QMap<QByteArray, Method> QDBusMetaObjectGenerator::methods
private

Definition at line 128 of file qdbusmetaobject.cpp.

Referenced by parseMethods(), parseSignals(), and write().

◆ properties

QMap<QByteArray, Property> QDBusMetaObjectGenerator::properties
private

Definition at line 129 of file qdbusmetaobject.cpp.

Referenced by parseProperties(), and write().


The documentation for this class was generated from the following file: