FCL/sf/mw/qt: comparison tools/qdoc3/node.cpp

equal deleted inserted replaced

-:5dc02b23752f
+:3e2da88830cd
 /*
 node.cpp
 */
 #include "node.h"
+#include "tree.h"
+#include "codemarker.h"
 #include <qdebug.h>
 QT_BEGIN_NAMESPACE
 /*!
 rel(0),
 nam(name)
 {
 if (par)
 par->addChild(this);
+//uuid = QUuid::createUuid();
 }
 /*!
 Returns the node's URL.
 */
 linkPair.second = desc;
 linkMap[linkType] = linkPair;
 }
 /*!
+Returns a string representing the access specifier.
+*/
+QString Node::accessString() const
+{
+switch (acc) {
+case Protected:
+return "protected";
+case Private:
+return "private";
+case Public:
+default:
+break;
+}
+return "public";
+}
+/*!
+Extract a class name from the type \a string and return it.
+*/
+QString Node::extractClassName(const QString &string) const
+{
+QString result;
+for (int i=0; i<=string.size(); ++i) {
+QChar ch;
+if (i != string.size())
+ch = string.at(i);
+QChar lower = ch.toLower();
+if ((lower >= QLatin1Char('a') && lower <= QLatin1Char('z')) ||
+ch.digitValue() >= 0 ||
+ch == QLatin1Char('_') ||
+ch == QLatin1Char(':')) {
+result += ch;
+}
+else if (!result.isEmpty()) {
+if (result != QLatin1String("const"))
+return result;
+result.clear();
+}
+}
+return result;
+}
+/*!
+Returns a string representing the access specifier.
+*/
+QString RelatedClass::accessString() const
+{
+switch (access) {
+case Node::Protected:
+return "protected";
+case Node::Private:
+return "private";
+case Node::Public:
+default:
+break;
+}
+return "public";
+}
+/*!
 */
 Node::Status Node::inheritedStatus() const
 {
 Status parentStatus = Commendable;
 if (par)
 parentStatus = par->inheritedStatus();
 return (Status)qMin((int)sta, (int)parentStatus);
 }
 /*!
+Returns the thread safeness value for whatever this node
+represents. But if this node has a parent and the thread
+safeness value of the parent is the same as the thread
+safeness value of this node, what is returned is the
+value \c{UnspecifiedSafeness}. Why?
 */
 Node::ThreadSafeness Node::threadSafeness() const
 {
 if (par && saf == par->inheritedThreadSafeness())
 return UnspecifiedSafeness;
 return saf;
 }
 /*!
+If this node has a parent, the parent's thread safeness
+value is returned. Otherwise, this node's thread safeness
+value is returned. Why?
 */
 Node::ThreadSafeness Node::inheritedThreadSafeness() const
 {
 if (par && saf == UnspecifiedSafeness)
 return par->inheritedThreadSafeness();
 return saf;
 }
 /*!
+Returns the sanitized file name without the path.
+If the the file is an html file, the html suffix
+is removed. Why?
 */
 QString Node::fileBase() const
 {
 QString base = name();
 if (base.endsWith(".html"))
 base.replace(" ", "-");
 return base.toLower();
 }
 /*!
+Returns this node's Universally Unique IDentifier.
+If its UUID has not yet been created, it is created
+first.
+*/
+QUuid Node::guid() const
+{
+if (uuid.isNull())
+uuid = QUuid::createUuid();
+return uuid;
+}
+/*!
+Composes a string to be used as an href attribute in DITA
+XML. It is composed of the file name and the UUID separated
+by a '#'. If this node is a class node, the file name is
+taken from this node; if this node is a function node, the
+file name is taken from the parent node of this node.
+*/
+QString Node::ditaXmlHref()
+{
+QString href;
+if ((type() == Function) ||
+(type() == Property) ||
+(type() == Variable)) {
+href = parent()->fileBase();
+}
+else {
+href = fileBase();
+}
+if (!href.endsWith(".xml"))
+href += ".xml";
+return href + "#" + guid();
+}
+/*!
 \class InnerNode
 */
 /*!
+The inner node destructor deletes the children and removes
+this node from its related nodes.
 */
 InnerNode::~InnerNode()
 {
 deleteChildren();
 removeFromRelated();
 group nodes. Return the matching node or 0.
 */
 Node *InnerNode::findNode(const QString& name)
 {
 Node *node = childMap.value(name);
-if (node)
+if (node && node->subType() != QmlPropertyGroup)
 return node;
 if ((type() == Fake) && (subType() == QmlClass)) {
 for (int i=0; i<children.size(); ++i) {
 Node* n = children.at(i);
 if (n->subType() == QmlPropertyGroup) {
 	}
 }
 }
 /*!
+Mark all child nodes that have no documentation as having
+private access and internal status. qdoc will then ignore
+them for documentation purposes.
 */
 void InnerNode::makeUndocumentedChildrenInternal()
 {
 foreach (Node *child, childNodes()) {
 if (child->doc().isEmpty()) {
 if (type == Class)
 setPageType(ApiPage);
 }
 /*!
+Appends an \a include file to the list of include files.
 */
 void InnerNode::addInclude(const QString& include)
 {
 inc.append(include);
 }
 /*!
+Sets the list of include files to \a includes.
 */
 void InnerNode::setIncludes(const QStringList& includes)
 {
 inc = includes;
 }
 enumChildren.removeAll(child);
 if (child->type() == Function) {
 	QMap<QString, Node *>::Iterator prim =
 		primaryFunctionMap.find(child->name());
 	NodeList& secs = secondaryFunctionMap[child->name()];
-	if (*prim == child) {
+	if (prim != primaryFunctionMap.end() && *prim == child) {
 	    if (secs.isEmpty()) {
 		primaryFunctionMap.remove(child->name());
 	    }
 else {
 		primaryFunctionMap.insert(child->name(), secs.takeFirst());
 	}
 else {
 	    secs.removeAll(child);
 	}
 QMap<QString, Node *>::Iterator ent = childMap.find( child->name() );
-if ( *ent == child )
+if (ent != childMap.end() && *ent == child)
 childMap.erase( ent );
 }
 else {
 	QMap<QString, Node *>::Iterator ent = childMap.find(child->name());
-	if (*ent == child)
+	if (ent != childMap.end() && *ent == child)
 	    childMap.erase(ent);
 }
 }
 /*!
 setPageType(ApiPage);
 }
 /*!
 \class ClassNode
+\brief This class represents a C++ class.
 */
 /*!
 Constructs a class node. A class node will generate an API page.
 */
 ClassNode::ClassNode(InnerNode *parent, const QString& name)
 : InnerNode(Class, parent, name)
 {
 hidden = false;
+abstract = false;
 setPageType(ApiPage);
 }
 /*!
 */
 void ClassNode::addBaseClass(Access access,
 ClassNode *node,
 const QString &dataTypeWithTemplateArgs)
 {
-bas.append(RelatedClass(access, node, dataTypeWithTemplateArgs));
+bases.append(RelatedClass(access, node, dataTypeWithTemplateArgs));
-node->der.append(RelatedClass(access, this));
+node->derived.append(RelatedClass(access, this));
 }
 /*!
 */
 void ClassNode::fixBaseClasses()
 {
 int i;
 i = 0;
-while (i < bas.size()) {
+while (i < bases.size()) {
-ClassNode *baseClass = bas.at(i).node;
+ClassNode* bc = bases.at(i).node;
-if (baseClass->access() == Node::Private) {
+if (bc->access() == Node::Private) {
-bas.removeAt(i);
+RelatedClass rc = bases.at(i);
+bases.removeAt(i);
-const QList<RelatedClass> &basesBases = baseClass->baseClasses();
+ignoredBases.append(rc);
-for (int j = basesBases.size() - 1; j >= 0; --j)
+const QList<RelatedClass> &bb = bc->baseClasses();
-bas.insert(i, basesBases.at(j));
+for (int j = bb.size() - 1; j >= 0; --j)
+bases.insert(i, bb.at(j));
 }
 else {
 ++i;
 }
 }
 i = 0;
-while (i < der.size()) {
+while (i < derived.size()) {
-ClassNode *derivedClass = der.at(i).node;
+ClassNode* dc = derived.at(i).node;
-if (derivedClass->access() == Node::Private) {
+if (dc->access() == Node::Private) {
-der.removeAt(i);
+derived.removeAt(i);
+const QList<RelatedClass> &dd = dc->derivedClasses();
-const QList<RelatedClass> &dersDers =
+for (int j = dd.size() - 1; j >= 0; --j)
-derivedClass->derivedClasses();
+derived.insert(i, dd.at(j));
-for (int j = dersDers.size() - 1; j >= 0; --j)
-der.insert(i, dersDers.at(j));
 }
 else {
 ++i;
 }
 }
+}
+/*!
+Search the child list to find the property node with the
+specified \a name.
+*/
+const PropertyNode* ClassNode::findPropertyNode(const QString& name) const
+{
+const Node* n = findNode(name,Node::Property);
+return (n ? static_cast<const PropertyNode*>(n) : 0);
 }
 /*!
 \class FakeNode
 */
 break;
 }
 }
 /*!
+Returns the fake node's title. This is used for the page title.
+*/
+QString FakeNode::title() const
+{
+return tle;
+}
+/*!
 Returns the fake node's full title, which is usually
 just title(), but for some SubType values is different
 from title()
 */
 QString FakeNode::fullTitle() const
 /*!
 \class EnumNode
 */
 /*!
+The constructor for the node representing an enum type
+has a \a parent class and an enum type \a name.
 */
 EnumNode::EnumNode(InnerNode *parent, const QString& name)
 : LeafNode(Enum, parent, name), ft(0)
 {
 }
 /*!
+Add \a item to the enum type's item list.
 */
 void EnumNode::addItem(const EnumItem& item)
 {
 itms.append(item);
 names.insert(item.name());
 }
 /*!
+Returns the access level of the enumeration item named \a name.
+Apparently it is private if it has been omitted by qdoc's
+omitvalue command. Otherwise it is public.
 */
 Node::Access EnumNode::itemAccess(const QString &name) const
 {
-if (doc().omitEnumItemNames().contains(name)) {
+if (doc().omitEnumItemNames().contains(name))
 return Private;
-}
+return Public;
-else {
-return Public;
-}
 }
 /*!
 Returns the enum value associated with the enum \a name.
 */
 {
 // nothing.
 }
 /*!
+Sets the \a virtualness of this function. If the \a virtualness
+is PureVirtual, and if the parent() is a ClassNode, set the parent's
+\e abstract flag to true.
+*/
+void FunctionNode::setVirtualness(Virtualness virtualness)
+{
+vir = virtualness;
+if ((virtualness == PureVirtual) && parent() &&
+(parent()->type() == Node::Class))
+parent()->setAbstract(true);
+}
+/*!
 */
 void FunctionNode::setOverload(bool overlode)
 {
 parent()->setOverload(this, overlode);
 ove = overlode;
 while (p != parameters().end()) {
 names << (*p).name();
 ++p;
 }
 return names;
+}
+/*!
+Returns a raw list of parameters. If \a names is true, the
+names are included. If \a values is true, the default values
+are included, if any are present.
+*/
+QString FunctionNode::rawParameters(bool names, bool values) const
+{
+QString raw;
+foreach (const Parameter &parameter, parameters()) {
+raw += parameter.leftType() + parameter.rightType();
+if (names)
+raw += parameter.name();
+if (values)
+raw += parameter.defaultValue();
+}
+return raw;
 }
 /*!
 Returns the list of reconstructed parameters. If \a values
 is true, the default values are included, if any are present.
 qPrintable(name()), qPrintable(rt), qPrintable(pp.join(" ")));
 }
 /*!
 \class PropertyNode
-*/
+This class describes one instance of using the Q_PROPERTY macro.
-/*!
+*/
+/*!
+The constructor sets the \a parent and the \a name, but
+everything else is set to default values.
 */
 PropertyNode::PropertyNode(InnerNode *parent, const QString& name)
 : LeafNode(Property, parent, name),
 sto(Trool_Default),
 des(Trool_Default),
+scr(Trool_Default),
+wri(Trool_Default),
+usr(Trool_Default),
+cst(false),
+fnl(false),
 overrides(0)
 {
-}
+// nothing.
+}
-/*!
-*/
+/*!
-void PropertyNode::setOverriddenFrom(const PropertyNode *baseProperty)
+Sets this property's \e {overridden from} property to
+\a baseProperty, which indicates that this property
+overrides \a baseProperty. To begin with, all the values
+in this property are set to the corresponding values in
+\a baseProperty.
+We probably should ensure that the constant and final
+attributes are not being overridden improperly.
+*/
+void PropertyNode::setOverriddenFrom(const PropertyNode* baseProperty)
 {
 for (int i = 0; i < NumFunctionRoles; ++i) {
 if (funcs[i].isEmpty())
 funcs[i] = baseProperty->funcs[i];
 }
 if (sto == Trool_Default)
 sto = baseProperty->sto;
 if (des == Trool_Default)
 des = baseProperty->des;
+if (scr == Trool_Default)
+scr = baseProperty->scr;
+if (wri == Trool_Default)
+wri = baseProperty->wri;
+if (usr == Trool_Default)
+usr = baseProperty->usr;
 overrides = baseProperty;
 }
 /*!
 */
 else {
 return dt;
 }
 }
-/*!
+/*! Converts the \a boolean value to an enum representation
+of the boolean type, which includes an enum  value for the
+\e {default value} of the item, i.e. true, false, or default.
 */
 PropertyNode::Trool PropertyNode::toTrool(bool boolean)
 {
 return boolean ? Trool_True : Trool_False;
 }
 /*!
+Converts the enum \a troolean back to a boolean value.
+If \a troolean is neither the true enum value nor the
+false enum value, the boolean value returned is
+\a defaultValue.
+Note that runtimeDesignabilityFunction() should be called
+first. If that function returns the name of a function, it
+means the function must be called at runtime to determine
+whether the property is Designable.
 */
 bool PropertyNode::fromTrool(Trool troolean, bool defaultValue)
 {
 switch (troolean) {
 case Trool_True:
 QmlClassNode::QmlClassNode(InnerNode *parent,
 const QString& name,
 const ClassNode* cn)
 : FakeNode(parent, name, QmlClass), cnode(cn)
 {
-setTitle((qmlOnly ? "" : "QML ") + name + " Element");
+if (name.startsWith(QLatin1String("QML:")))
+setTitle((qmlOnly ? QLatin1String("") : QLatin1String("QML ")) + name.mid(4) + QLatin1String(" Element"));
+else
+setTitle((qmlOnly ? QLatin1String("") : QLatin1String("QML ")) + name + QLatin1String(" Element"));
 }
 /*!
 I made this so I could print a debug message here.
 */
 return false;
 default:
 return defaultValue;
 }
 }
+static QString valueType(const QString& n)
+{
+if (n == "QPoint")
+return "QDeclarativePointValueType";
+if (n == "QPointF")
+return "QDeclarativePointFValueType";
+if (n == "QSize")
+return "QDeclarativeSizeValueType";
+if (n == "QSizeF")
+return "QDeclarativeSizeFValueType";
+if (n == "QRect")
+return "QDeclarativeRectValueType";
+if (n == "QRectF")
+return "QDeclarativeRectFValueType";
+if (n == "QVector2D")
+return "QDeclarativeVector2DValueType";
+if (n == "QVector3D")
+return "QDeclarativeVector3DValueType";
+if (n == "QVector4D")
+return "QDeclarativeVector4DValueType";
+if (n == "QQuaternion")
+return "QDeclarativeQuaternionValueType";
+if (n == "QMatrix4x4")
+return "QDeclarativeMatrix4x4ValueType";
+if (n == "QEasingCurve")
+return "QDeclarativeEasingValueType";
+if (n == "QFont")
+return "QDeclarativeFontValueType";
+return QString();
+}
+/*!
+Returns true if a QML property or attached property is
+read-only. The algorithm for figuring this out is long
+amd tedious and almost certainly will break. It currently
+doesn't work for qmlproperty bool PropertyChanges::explicit,
+because the tokenized gets confused on "explicit" .
+*/
+bool QmlPropertyNode::isWritable(const Tree* tree) const
+{
+Node* n = parent();
+while (n && n->subType() != Node::QmlClass)
+n = n->parent();
+if (n) {
+const QmlClassNode* qcn = static_cast<const QmlClassNode*>(n);
+const ClassNode* cn = qcn->classNode();
+if (cn) {
+QStringList dotSplit = name().split(QChar('.'));
+const PropertyNode* pn = cn->findPropertyNode(dotSplit[0]);
+if (pn) {
+if (dotSplit.size() > 1) {
+QStringList path(extractClassName(pn->qualifiedDataType()));
+const Node* nn = tree->findNode(path,Class);
+if (nn) {
+const ClassNode* cn = static_cast<const ClassNode*>(nn);
+pn = cn->findPropertyNode(dotSplit[1]);
+if (pn) {
+return pn->isWritable();
+}
+else {
+const QList<RelatedClass>& bases = cn->baseClasses();
+if (!bases.isEmpty()) {
+for (int i=0; i<bases.size(); ++i) {
+const ClassNode* cn = bases[i].node;
+pn = cn->findPropertyNode(dotSplit[1]);
+if (pn) {
+return pn->isWritable();
+}
+}
+}
+const QList<RelatedClass>& ignoredBases = cn->ignoredBaseClasses();
+if (!ignoredBases.isEmpty()) {
+for (int i=0; i<ignoredBases.size(); ++i) {
+const ClassNode* cn = ignoredBases[i].node;
+pn = cn->findPropertyNode(dotSplit[1]);
+if (pn) {
+return pn->isWritable();
+}
+}
+}
+QString vt = valueType(cn->name());
+if (!vt.isEmpty()) {
+QStringList path(vt);
+const Node* vtn = tree->findNode(path,Class);
+if (vtn) {
+const ClassNode* cn = static_cast<const ClassNode*>(vtn);
+pn = cn->findPropertyNode(dotSplit[1]);
+if (pn) {
+return pn->isWritable();
+}
+}
+}
+}
+}
+}
+else {
+return pn->isWritable();
+}
+}
+else {
+const QList<RelatedClass>& bases = cn->baseClasses();
+if (!bases.isEmpty()) {
+for (int i=0; i<bases.size(); ++i) {
+const ClassNode* cn = bases[i].node;
+pn = cn->findPropertyNode(dotSplit[0]);
+if (pn) {
+return pn->isWritable();
+}
+}
+}
+const QList<RelatedClass>& ignoredBases = cn->ignoredBaseClasses();
+if (!ignoredBases.isEmpty()) {
+for (int i=0; i<ignoredBases.size(); ++i) {
+const ClassNode* cn = ignoredBases[i].node;
+pn = cn->findPropertyNode(dotSplit[0]);
+if (pn) {
+return pn->isWritable();
+}
+}
+}
+if (isAttached()) {
+QString classNameAttached = cn->name() + "Attached";
+QStringList path(classNameAttached);
+const Node* nn = tree->findNode(path,Class);
+const ClassNode* acn = static_cast<const ClassNode*>(nn);
+pn = acn->findPropertyNode(dotSplit[0]);
+if (pn) {
+return pn->isWritable();
+}
+}
+}
+}
+}
+location().warning(tr("Can't determine read-only status of QML property %1; writable assumed.").arg(name()));
+return true;
+}
 #endif
 QT_END_NAMESPACE

changeset 33	3e2da88830cd
parent 30	5dc02b23752f
child 37	758a864f9613