diff options
Diffstat (limited to 'src/tools/qdoc/node.cpp')
| -rw-r--r-- | src/tools/qdoc/node.cpp | 624 |
1 files changed, 335 insertions, 289 deletions
diff --git a/src/tools/qdoc/node.cpp b/src/tools/qdoc/node.cpp index 37bc0c5fef..f20020cd15 100644 --- a/src/tools/qdoc/node.cpp +++ b/src/tools/qdoc/node.cpp @@ -44,16 +44,16 @@ QT_BEGIN_NAMESPACE int Node::propertyGroupCount_ = 0; QStringMap Node::operators_; -QMap<QString,Node::Type> Node::goals_; +QMap<QString,Node::NodeType> Node::goals_; /*! Initialize the map of search goals. This is called once by QDocDatabase::initializeDB(). The map key is a string - representing a value in the enum Node::Type. The map value + representing a value in the enum Node::NodeType. The map value is the enum value. There should be an entry in the map for each value in the - Type enum. + NodeType enum. */ void Node::initialize() { @@ -160,8 +160,8 @@ QString Node::fullName(const Node* relative) const match is found, return false. \a types is a list of type/subtype pairs, where the first - value in the pair is a Node::Type, and the second value is - a Node::SubType. The second value is used in the match if + value in the pair is a Node::NodeType, and the second value is + a Node::DocSubtype. The second value is used in the match if this node's type is Node::Document. */ bool Node::match(const NodeTypeList& types) const @@ -169,7 +169,7 @@ bool Node::match(const NodeTypeList& types) const for (int i=0; i<types.size(); ++i) { if (type() == types.at(i).first) { if (type() == Node::Document) { - if (subType() == types.at(i).second) + if (docSubtype() == types.at(i).second) return true; } else @@ -200,12 +200,12 @@ void Node::setDoc(const Doc& doc, bool replace) given \a parent and \a name. The new node is added to the parent's child list. */ -Node::Node(Type type, InnerNode *parent, const QString& name) +Node::Node(NodeType type, Aggregate *parent, const QString& name) : nodeType_((unsigned char) type), access_((unsigned char) Public), safeness_((unsigned char) UnspecifiedSafeness), pageType_((unsigned char) NoPageType), - status_((unsigned char) Commendable), + status_((unsigned char) Active), indexNodeFlag_(false), parent_(parent), relatesTo_(0), @@ -320,7 +320,7 @@ QString Node::nodeTypeString() const */ QString Node::nodeTypeString(unsigned char t) { - switch ((Type)t) { + switch ((NodeType)t) { case Namespace: return "namespace"; case Class: @@ -370,7 +370,7 @@ QString Node::nodeTypeString(unsigned char t) */ QString Node::nodeSubtypeString() const { - return nodeSubtypeString(subType()); + return nodeSubtypeString(docSubtype()); } /*! @@ -380,7 +380,7 @@ QString Node::nodeSubtypeString() const */ QString Node::nodeSubtypeString(unsigned char t) { - switch ((SubType)t) { + switch ((DocSubtype)t) { case Example: return "example"; case HeaderFile: @@ -395,7 +395,7 @@ QString Node::nodeSubtypeString(unsigned char t) return "external page"; case DitaMap: return "ditamap"; - case NoSubType: + case NoSubtype: default: break; } @@ -460,7 +460,7 @@ bool Node::fromFlagValue(FlagValue fv, bool defaultValue) /*! Sets the pointer to the node that this node relates to. */ -void Node::setRelates(InnerNode *pseudoParent) +void Node::setRelates(Aggregate *pseudoParent) { if (relatesTo_) { relatesTo_->removeRelated(this); @@ -558,7 +558,7 @@ QString RelatedClass::accessString() const */ Node::Status Node::inheritedStatus() const { - Status parentStatus = Commendable; + Status parentStatus = Active; if (parent_) parentStatus = parent_->inheritedStatus(); return (Status)qMin((int)status_, (int)parentStatus); @@ -606,7 +606,6 @@ QString Node::fileBase() const base.replace(QLatin1Char(' '), QLatin1Char('-')); return base.toLower(); } -#endif /*! Returns this node's Universally Unique IDentifier as a QString. Creates the UUID first, if it has not been created. @@ -617,6 +616,7 @@ QString Node::guid() const uuid_ = idForNode(); return uuid_; } +#endif /*! If this node is a QML or JS type node, return a pointer to @@ -683,14 +683,32 @@ const Node* Node::root() const } /*! - \class InnerNode + Sets the node's declaration location, its definition + location, or both, depending on the suffix of the file + name from the file path in location \a t. + */ +void Node::setLocation(const Location& t) +{ + QString suffix = t.fileSuffix(); + if (suffix == "h") + declLocation_ = t; + else if (suffix == "cpp") + defLocation_ = t; + else { + declLocation_ = t; + defLocation_ = t; + } +} + +/*! + \class Aggregate */ /*! The inner node destructor deletes the children and removes this node from its related nodes. */ -InnerNode::~InnerNode() +Aggregate::~Aggregate() { deleteChildren(); removeFromRelated(); @@ -706,17 +724,17 @@ InnerNode::~InnerNode() find all this node's children that have the given \a name, and return the one that satisfies the \a genus requirement. */ -Node *InnerNode::findChildNode(const QString& name, Node::Genus genus) const +Node *Aggregate::findChildNode(const QString& name, Node::Genus genus) const { if (genus == Node::DontCare) { - Node *node = childMap.value(name); + Node *node = childMap_.value(name); if (node && !node->isQmlPropertyGroup()) // mws asks: Why not property group? return node; if (isQmlType() || isJsType()) { for (int i=0; i<children_.size(); ++i) { Node* n = children_.at(i); if (n->isQmlPropertyGroup() || isJsPropertyGroup()) { - node = static_cast<InnerNode*>(n)->findChildNode(name, genus); + node = static_cast<Aggregate*>(n)->findChildNode(name, genus); if (node) return node; } @@ -724,7 +742,7 @@ Node *InnerNode::findChildNode(const QString& name, Node::Genus genus) const } } else { - NodeList nodes = childMap.values(name); + NodeList nodes = childMap_.values(name); if (!nodes.isEmpty()) { for (int i=0; i<nodes.size(); ++i) { Node* node = nodes.at(i); @@ -733,20 +751,20 @@ Node *InnerNode::findChildNode(const QString& name, Node::Genus genus) const } } } - return primaryFunctionMap.value(name); + return primaryFunctionMap_.value(name); } /*! Find all the child nodes of this node that are named \a name and return them in \a nodes. */ -void InnerNode::findChildren(const QString& name, NodeList& nodes) const +void Aggregate::findChildren(const QString& name, NodeList& nodes) const { - nodes = childMap.values(name); - Node* n = primaryFunctionMap.value(name); + nodes = childMap_.values(name); + Node* n = primaryFunctionMap_.value(name); if (n) { nodes.append(n); - NodeList t = secondaryFunctionMap.value(name); + NodeList t = secondaryFunctionMap_.value(name); if (!t.isEmpty()) nodes.append(t); } @@ -756,7 +774,7 @@ void InnerNode::findChildren(const QString& name, NodeList& nodes) const if (i < 0) return; QString qmlPropGroup = name.left(i); - NodeList t = childMap.values(qmlPropGroup); + NodeList t = childMap_.values(qmlPropGroup); if (t.isEmpty()) return; foreach (Node* n, t) { @@ -773,12 +791,12 @@ void InnerNode::findChildren(const QString& name, NodeList& nodes) const with the specified \a name is found but it is not of the specified \a type, 0 is returned. */ -Node* InnerNode::findChildNode(const QString& name, Type type) +Node* Aggregate::findChildNode(const QString& name, NodeType type) { if (type == Function) - return primaryFunctionMap.value(name); + return primaryFunctionMap_.value(name); else { - NodeList nodes = childMap.values(name); + NodeList nodes = childMap_.values(name); for (int i=0; i<nodes.size(); ++i) { Node* node = nodes.at(i); if (node->type() == type) @@ -792,9 +810,9 @@ Node* InnerNode::findChildNode(const QString& name, Type type) Find a function node that is a child of this nose, such that the function node has the specified \a name. */ -FunctionNode *InnerNode::findFunctionNode(const QString& name) const +FunctionNode *Aggregate::findFunctionNode(const QString& name) const { - return static_cast<FunctionNode *>(primaryFunctionMap.value(name)); + return static_cast<FunctionNode *>(primaryFunctionMap_.value(name)); } /*! @@ -802,15 +820,15 @@ FunctionNode *InnerNode::findFunctionNode(const QString& name) const that the function has the same name and signature as the \a clone node. */ -FunctionNode *InnerNode::findFunctionNode(const FunctionNode *clone) const +FunctionNode *Aggregate::findFunctionNode(const FunctionNode *clone) const { - QMap<QString,Node*>::ConstIterator c = primaryFunctionMap.constFind(clone->name()); - if (c != primaryFunctionMap.constEnd()) { + QMap<QString,Node*>::ConstIterator c = primaryFunctionMap_.constFind(clone->name()); + if (c != primaryFunctionMap_.constEnd()) { if (isSameSignature(clone, (FunctionNode *) *c)) { return (FunctionNode *) *c; } - else if (secondaryFunctionMap.contains(clone->name())) { - const NodeList& secs = secondaryFunctionMap[clone->name()]; + else if (secondaryFunctionMap_.contains(clone->name())) { + const NodeList& secs = secondaryFunctionMap_[clone->name()]; NodeList::ConstIterator s = secs.constBegin(); while (s != secs.constEnd()) { if (isSameSignature(clone, (FunctionNode *) *s)) @@ -825,11 +843,11 @@ FunctionNode *InnerNode::findFunctionNode(const FunctionNode *clone) const /*! Returns the list of keys from the primary function map. */ -QStringList InnerNode::primaryKeys() +QStringList Aggregate::primaryKeys() { QStringList t; - QMap<QString, Node*>::iterator i = primaryFunctionMap.begin(); - while (i != primaryFunctionMap.end()) { + QMap<QString, Node*>::iterator i = primaryFunctionMap_.begin(); + while (i != primaryFunctionMap_.end()) { t.append(i.key()); ++i; } @@ -839,11 +857,11 @@ QStringList InnerNode::primaryKeys() /*! Returns the list of keys from the secondary function map. */ -QStringList InnerNode::secondaryKeys() +QStringList Aggregate::secondaryKeys() { QStringList t; - QMap<QString, NodeList>::iterator i = secondaryFunctionMap.begin(); - while (i != secondaryFunctionMap.end()) { + QMap<QString, NodeList>::iterator i = secondaryFunctionMap_.begin(); + while (i != secondaryFunctionMap_.end()) { t.append(i.key()); ++i; } @@ -851,43 +869,13 @@ QStringList InnerNode::secondaryKeys() } /*! - */ -void InnerNode::setOverload(FunctionNode *func, bool overlode) -{ - Node *node = (Node *) func; - Node *&primary = primaryFunctionMap[func->name()]; - - if (secondaryFunctionMap.contains(func->name())) { - NodeList& secs = secondaryFunctionMap[func->name()]; - if (overlode) { - if (primary == node) { - primary = secs.first(); - secs.erase(secs.begin()); - secs.append(node); - } - else { - secs.removeAll(node); - secs.append(node); - } - } - else { - if (primary != node) { - secs.removeAll(node); - secs.prepend(primary); - primary = node; - } - } - } -} - -/*! Mark all child nodes that have no documentation as having private access and internal status. qdoc will then ignore them for documentation purposes. Some nodes have an Intermediate status, meaning that they should be ignored, but not their children. */ -void InnerNode::makeUndocumentedChildrenInternal() +void Aggregate::makeUndocumentedChildrenInternal() { foreach (Node *child, childNodes()) { if (child->doc().isEmpty() && child->status() != Node::Intermediate) { @@ -898,68 +886,109 @@ void InnerNode::makeUndocumentedChildrenInternal() } /*! + This is where we should set the overload numbers, including + the related non-members. */ -void InnerNode::normalizeOverloads() +void Aggregate::normalizeOverloads() { - QMap<QString, Node *>::Iterator p1 = primaryFunctionMap.begin(); - while (p1 != primaryFunctionMap.end()) { + QMap<QString, Node *>::Iterator p1 = primaryFunctionMap_.begin(); + while (p1 != primaryFunctionMap_.end()) { FunctionNode *primaryFunc = (FunctionNode *) *p1; - if (secondaryFunctionMap.contains(primaryFunc->name()) && - (primaryFunc->status() != Commendable || - primaryFunc->access() == Private)) { - - NodeList& secs = secondaryFunctionMap[primaryFunc->name()]; - NodeList::ConstIterator s = secs.constBegin(); - while (s != secs.constEnd()) { - FunctionNode *secondaryFunc = (FunctionNode *) *s; - - // Any non-obsolete, non-compatibility, non-private functions - // (i.e, visible functions) are preferable to the primary - // function. - - if (secondaryFunc->status() == Commendable && - secondaryFunc->access() != Private) { - - *p1 = secondaryFunc; - int index = secondaryFunctionMap[primaryFunc->name()].indexOf(secondaryFunc); - secondaryFunctionMap[primaryFunc->name()].replace(index, primaryFunc); - break; + if (primaryFunc->status() != Active || primaryFunc->access() == Private) { + if (secondaryFunctionMap_.contains(primaryFunc->name())) { + /* + Either the primary function is not active or it is private. + It therefore can't be the primary function. Search the list + of overloads to find one that can be the primary function. + */ + NodeList& overloads = secondaryFunctionMap_[primaryFunc->name()]; + NodeList::ConstIterator s = overloads.constBegin(); + while (s != overloads.constEnd()) { + FunctionNode *overloadFunc = (FunctionNode *) *s; + /* + Any non-obsolete, non-private function (i.e., visible function) + is preferable to the current primary function. Swap the primary + and overload functions. + */ + if (overloadFunc->status() == Active && overloadFunc->access() != Private) { + primaryFunc->setOverloadNumber(overloadFunc->overloadNumber()); + overloads.replace(overloads.indexOf(overloadFunc), primaryFunc); + *p1 = overloadFunc; + overloadFunc->setOverloadFlag(false); + overloadFunc->setOverloadNumber(0); + break; + } + ++s; } - ++s; } } ++p1; } - - QMap<QString, Node *>::ConstIterator p = primaryFunctionMap.constBegin(); - while (p != primaryFunctionMap.constEnd()) { + /* + Ensure that none of the primary functions is marked with \overload. + */ + QMap<QString, Node *>::Iterator p = primaryFunctionMap_.begin(); + while (p != primaryFunctionMap_.end()) { FunctionNode *primaryFunc = (FunctionNode *) *p; - if (primaryFunc->isOverload()) - primaryFunc->ove = false; - if (secondaryFunctionMap.contains(primaryFunc->name())) { - NodeList& secs = secondaryFunctionMap[primaryFunc->name()]; - NodeList::ConstIterator s = secs.constBegin(); - while (s != secs.constEnd()) { - FunctionNode *secondaryFunc = (FunctionNode *) *s; - if (!secondaryFunc->isOverload()) - secondaryFunc->ove = true; - ++s; + if (primaryFunc->isOverload()) { + if (secondaryFunctionMap_.contains(primaryFunc->name())) { + /* + The primary function is marked with \overload. Find an + overload in the secondary function map that is not marked + with \overload but that is active and not private. Then + swap it with the primary function. + */ + NodeList& overloads = secondaryFunctionMap_[primaryFunc->name()]; + NodeList::ConstIterator s = overloads.constBegin(); + while (s != overloads.constEnd()) { + FunctionNode *overloadFunc = (FunctionNode *) *s; + if (!overloadFunc->isOverload()) { + if (overloadFunc->status() == Active && overloadFunc->access() != Private) { + primaryFunc->setOverloadNumber(overloadFunc->overloadNumber()); + overloads.replace(overloads.indexOf(overloadFunc), primaryFunc); + *p = overloadFunc; + overloadFunc->setOverloadFlag(false); + overloadFunc->setOverloadNumber(0); + break; + } + } + ++s; + } } } ++p; } - + /* + Add the related non-members here. + */ + if (!related_.isEmpty()) { + foreach (Node* n, related_) { + if (n->isFunction()) { + FunctionNode* fn = static_cast<FunctionNode*>(n); + QMap<QString, Node *>::Iterator p = primaryFunctionMap_.find(fn->name()); + if (p != primaryFunctionMap_.end()) { + secondaryFunctionMap_[fn->name()].append(fn); + fn->setOverloadNumber(secondaryFunctionMap_[fn->name()].size()); + } + else + fn->setOverloadNumber(0); + } + } + } + /* + Recursive part. + */ NodeList::ConstIterator c = childNodes().constBegin(); while (c != childNodes().constEnd()) { - if ((*c)->isInnerNode()) - ((InnerNode *) *c)->normalizeOverloads(); + if ((*c)->isAggregate()) + ((Aggregate *) *c)->normalizeOverloads(); ++c; } } /*! */ -void InnerNode::removeFromRelated() +void Aggregate::removeFromRelated() { while (!related_.isEmpty()) { Node *p = static_cast<Node *>(related_.takeFirst()); @@ -971,13 +1000,13 @@ void InnerNode::removeFromRelated() /*! Deletes all this node's children. */ -void InnerNode::deleteChildren() +void Aggregate::deleteChildren() { NodeList childrenCopy = children_; // `children_` will be changed in ~Node() qDeleteAll(childrenCopy); } -/*! \fn bool InnerNode::isInnerNode() const +/*! \fn bool Aggregate::isAggregate() const Returns \c true because this is an inner node. */ @@ -997,7 +1026,7 @@ bool Node::isWrapper() const no enum type node is found that has \a enumValue as one of its values. */ -const EnumNode *InnerNode::findEnumNodeForValue(const QString &enumValue) const +const EnumNode *Aggregate::findEnumNodeForValue(const QString &enumValue) const { foreach (const Node *node, enumChildren_) { const EnumNode *en = static_cast<const EnumNode *>(node); @@ -1008,32 +1037,16 @@ const EnumNode *InnerNode::findEnumNodeForValue(const QString &enumValue) const } /*! - Returnds the sequence number of the function node \a func - in the list of overloaded functions for a class, such that - all the functions have the same name as the \a func. - */ -int InnerNode::overloadNumber(const FunctionNode *func) const -{ - Node *node = const_cast<FunctionNode *>(func); - if (primaryFunctionMap[func->name()] == node) { - return 1; - } - else { - return secondaryFunctionMap[func->name()].indexOf(node) + 2; - } -} - -/*! Returns a node list containing all the member functions of some class such that the functions overload the name \a funcName. */ -NodeList InnerNode::overloads(const QString &funcName) const +NodeList Aggregate::overloads(const QString &funcName) const { NodeList result; - Node *primary = primaryFunctionMap.value(funcName); + Node *primary = primaryFunctionMap_.value(funcName); if (primary) { result << primary; - result += secondaryFunctionMap[funcName]; + result += secondaryFunctionMap_[funcName]; } return result; } @@ -1042,7 +1055,7 @@ NodeList InnerNode::overloads(const QString &funcName) const Construct an inner node (i.e., not a leaf node) of the given \a type and having the given \a parent and \a name. */ -InnerNode::InnerNode(Type type, InnerNode *parent, const QString& name) +Aggregate::Aggregate(NodeType type, Aggregate *parent, const QString& name) : Node(type, parent, name) { switch (type) { @@ -1059,7 +1072,7 @@ InnerNode::InnerNode(Type type, InnerNode *parent, const QString& name) /*! Appends an \a include file to the list of include files. */ -void InnerNode::addInclude(const QString& include) +void Aggregate::addInclude(const QString& include) { includes_.append(include); } @@ -1067,7 +1080,7 @@ void InnerNode::addInclude(const QString& include) /*! Sets the list of include files to \a includes. */ -void InnerNode::setIncludes(const QStringList& includes) +void Aggregate::setIncludes(const QStringList& includes) { includes_ = includes; } @@ -1075,7 +1088,7 @@ void InnerNode::setIncludes(const QStringList& includes) /*! f1 is always the clone */ -bool InnerNode::isSameSignature(const FunctionNode *f1, const FunctionNode *f2) +bool Aggregate::isSameSignature(const FunctionNode *f1, const FunctionNode *f2) { if (f1->parameters().count() != f2->parameters().count()) return false; @@ -1113,23 +1126,26 @@ bool InnerNode::isSameSignature(const FunctionNode *f1, const FunctionNode *f2) be necessary to update this node's internal collections and the child's parent pointer and output subdirectory. */ -void InnerNode::addChild(Node *child) +void Aggregate::addChild(Node *child) { children_.append(child); if ((child->type() == Function) || (child->type() == QmlMethod)) { - FunctionNode *func = (FunctionNode *) child; - if (!primaryFunctionMap.contains(func->name())) { - primaryFunctionMap.insert(func->name(), func); + FunctionNode *func = static_cast<FunctionNode*>(child); + QString name = func->name(); + if (!primaryFunctionMap_.contains(name)) { + primaryFunctionMap_.insert(name, func); + func->setOverloadNumber(0); } else { - NodeList &secs = secondaryFunctionMap[func->name()]; - secs.append(func); + NodeList &overloads = secondaryFunctionMap_[name]; + overloads.append(func); + func->setOverloadNumber(overloads.size()); } } else { if (child->type() == Enum) enumChildren_.append(child); - childMap.insertMulti(child->name(), child); + childMap_.insertMulti(child->name(), child); } if (child->parent() == 0) { child->setParent(this); @@ -1143,9 +1159,9 @@ void InnerNode::addChild(Node *child) again, because it is presumed to already be there. We just want to be able to find the child by its \a title. */ -void InnerNode::addChild(Node* child, const QString& title) +void Aggregate::addChild(Node* child, const QString& title) { - childMap.insertMulti(title, child); + childMap_.insertMulti(title, child); } /*! @@ -1154,40 +1170,38 @@ void InnerNode::addChild(Node* child, const QString& title) pointer is set to 0, but its output subdirectory is not changed. */ -void InnerNode::removeChild(Node *child) +void Aggregate::removeChild(Node *child) { children_.removeAll(child); enumChildren_.removeAll(child); if (child->type() == Function) { - QMap<QString, Node *>::Iterator prim = - primaryFunctionMap.find(child->name()); - NodeList& secs = secondaryFunctionMap[child->name()]; - if (prim != primaryFunctionMap.end() && *prim == child) { - if (secs.isEmpty()) { - primaryFunctionMap.remove(child->name()); - } - else { - primaryFunctionMap.insert(child->name(), secs.takeFirst()); + QMap<QString, Node *>::Iterator primary = primaryFunctionMap_.find(child->name()); + NodeList& overloads = secondaryFunctionMap_[child->name()]; + if (primary != primaryFunctionMap_.end() && *primary == child) { + primaryFunctionMap_.erase(primary); + if (!overloads.isEmpty()) { + FunctionNode* fn = static_cast<FunctionNode*>(overloads.takeFirst()); + fn->setOverloadNumber(0); + primaryFunctionMap_.insert(child->name(), fn); } } - else { - secs.removeAll(child); - } + else + overloads.removeAll(child); } - QMap<QString, Node *>::Iterator ent = childMap.find(child->name()); - while (ent != childMap.end() && ent.key() == child->name()) { + QMap<QString, Node *>::Iterator ent = childMap_.find(child->name()); + while (ent != childMap_.end() && ent.key() == child->name()) { if (*ent == child) { - childMap.erase(ent); + childMap_.erase(ent); break; } ++ent; } if (child->title().isEmpty()) return; - ent = childMap.find(child->title()); - while (ent != childMap.end() && ent.key() == child->title()) { + ent = childMap_.find(child->title()); + while (ent != childMap_.end() && ent.key() == child->title()) { if (*ent == child) { - childMap.erase(ent); + childMap_.erase(ent); break; } ++ent; @@ -1198,7 +1212,7 @@ void InnerNode::removeChild(Node *child) /*! Recursively sets the output subdirectory for children */ -void InnerNode::setOutputSubdirectory(const QString &t) +void Aggregate::setOutputSubdirectory(const QString &t) { Node::setOutputSubdirectory(t); for (int i = 0; i < childNodes().size(); ++i) @@ -1261,7 +1275,7 @@ QString Node::physicalModuleName() const /*! */ -void InnerNode::removeRelated(Node *pseudoChild) +void Aggregate::removeRelated(Node *pseudoChild) { related_.removeAll(pseudoChild); } @@ -1270,7 +1284,7 @@ void InnerNode::removeRelated(Node *pseudoChild) If this node has a child that is a QML property named \a n, return the pointer to that child. */ -QmlPropertyNode* InnerNode::hasQmlProperty(const QString& n) const +QmlPropertyNode* Aggregate::hasQmlProperty(const QString& n) const { foreach (Node* child, childNodes()) { if (child->type() == Node::QmlProperty) { @@ -1291,7 +1305,7 @@ QmlPropertyNode* InnerNode::hasQmlProperty(const QString& n) const whose type (attached or normal property) matches \a attached, return the pointer to that child. */ -QmlPropertyNode* InnerNode::hasQmlProperty(const QString& n, bool attached) const +QmlPropertyNode* Aggregate::hasQmlProperty(const QString& n, bool attached) const { foreach (Node* child, childNodes()) { if (child->type() == Node::QmlProperty) { @@ -1311,7 +1325,7 @@ QmlPropertyNode* InnerNode::hasQmlProperty(const QString& n, bool attached) cons \class LeafNode */ -/*! \fn bool LeafNode::isInnerNode() const +/*! \fn bool LeafNode::isAggregate() const Returns \c false because this is a LeafNode. */ @@ -1319,7 +1333,7 @@ QmlPropertyNode* InnerNode::hasQmlProperty(const QString& n, bool attached) cons Constructs a leaf node named \a name of the specified \a type. The new leaf node becomes a child of \a parent. */ -LeafNode::LeafNode(Type type, InnerNode *parent, const QString& name) +LeafNode::LeafNode(NodeType type, Aggregate *parent, const QString& name) : Node(type, parent, name) { switch (type) { @@ -1346,7 +1360,7 @@ LeafNode::LeafNode(Type type, InnerNode *parent, const QString& name) documentation case where a \e{qmlproperty} command is used to override the QML definition of a QML property. */ -LeafNode::LeafNode(InnerNode* parent, Type type, const QString& name) +LeafNode::LeafNode(Aggregate* parent, NodeType type, const QString& name) : Node(type, 0, name) { setParent(parent); @@ -1374,8 +1388,8 @@ LeafNode::LeafNode(InnerNode* parent, Type type, const QString& name) /*! Constructs a namespace node. */ -NamespaceNode::NamespaceNode(InnerNode *parent, const QString& name) - : InnerNode(Namespace, parent, name), seen_(false), tree_(0) +NamespaceNode::NamespaceNode(Aggregate *parent, const QString& name) + : Aggregate(Namespace, parent, name), seen_(false), tree_(0) { setGenus(Node::CPP); setPageType(ApiPage); @@ -1389,8 +1403,8 @@ NamespaceNode::NamespaceNode(InnerNode *parent, const QString& name) /*! Constructs a class node. A class node will generate an API page. */ -ClassNode::ClassNode(InnerNode *parent, const QString& name) - : InnerNode(Class, parent, name) +ClassNode::ClassNode(Aggregate *parent, const QString& name) + : Aggregate(Class, parent, name) { abstract_ = false; wrapper_ = false; @@ -1584,8 +1598,8 @@ QmlTypeNode* ClassNode::findQmlBaseNode() which specifies the type of DocumentNode. The page type for the page index is set here. */ -DocumentNode::DocumentNode(InnerNode* parent, const QString& name, SubType subtype, Node::PageType ptype) - : InnerNode(Document, parent, name), nodeSubtype_(subtype) +DocumentNode::DocumentNode(Aggregate* parent, const QString& name, DocSubtype subtype, Node::PageType ptype) + : Aggregate(Document, parent, name), nodeSubtype_(subtype) { setGenus(Node::DOC); switch (subtype) { @@ -1618,7 +1632,7 @@ void DocumentNode::setTitle(const QString &title) /*! Returns the document node's full title, which is usually - just title(), but for some SubType values is different + just title(), but for some DocSubtype values is different from title() */ QString DocumentNode::fullTitle() const @@ -1669,8 +1683,8 @@ QString DocumentNode::subTitle() const 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) +EnumNode::EnumNode(Aggregate *parent, const QString& name) + : LeafNode(Enum, parent, name), flagsType_(0) { setGenus(Node::CPP); } @@ -1680,8 +1694,8 @@ EnumNode::EnumNode(InnerNode *parent, const QString& name) */ void EnumNode::addItem(const EnumItem& item) { - itms.append(item); - names.insert(item.name()); + items_.append(item); + names_.insert(item.name()); } /*! @@ -1701,7 +1715,7 @@ Node::Access EnumNode::itemAccess(const QString &name) const */ QString EnumNode::itemValue(const QString &name) const { - foreach (const EnumItem &item, itms) { + foreach (const EnumItem &item, items_) { if (item.name() == name) return item.value(); } @@ -1714,8 +1728,8 @@ QString EnumNode::itemValue(const QString &name) const /*! */ -TypedefNode::TypedefNode(InnerNode *parent, const QString& name) - : LeafNode(Typedef, parent, name), ae(0) +TypedefNode::TypedefNode(Aggregate *parent, const QString& name) + : LeafNode(Typedef, parent, name), associatedEnum_(0) { setGenus(Node::CPP); } @@ -1724,7 +1738,7 @@ TypedefNode::TypedefNode(InnerNode *parent, const QString& name) */ void TypedefNode::setAssociatedEnum(const EnumNode *enume) { - ae = enume; + associatedEnum_ = enume; } /*! @@ -1745,7 +1759,7 @@ Parameter::Parameter(const QString& leftType, const QString& rightType, const QString& name, const QString& defaultValue) - : lef(leftType), rig(rightType), nam(name), def(defaultValue) + : leftType_(leftType), rightType_(rightType), name_(name), defaultValue_(defaultValue) { } @@ -1753,7 +1767,7 @@ Parameter::Parameter(const QString& leftType, The standard copy constructor copies the strings from \a p. */ Parameter::Parameter(const Parameter& p) - : lef(p.lef), rig(p.rig), nam(p.nam), def(p.def) + : leftType_(p.leftType_), rightType_(p.rightType_), name_(p.name_), defaultValue_(p.defaultValue_) { } @@ -1763,10 +1777,10 @@ Parameter::Parameter(const Parameter& p) */ Parameter& Parameter::operator=(const Parameter& p) { - lef = p.lef; - rig = p.rig; - nam = p.nam; - def = p.def; + leftType_ = p.leftType_; + rightType_ = p.rightType_; + name_ = p.name_; + defaultValue_ = p.defaultValue_; return *this; } @@ -1777,12 +1791,12 @@ Parameter& Parameter::operator=(const Parameter& p) */ QString Parameter::reconstruct(bool value) const { - QString p = lef + rig; + QString p = leftType_ + rightType_; if (!p.endsWith(QChar('*')) && !p.endsWith(QChar('&')) && !p.endsWith(QChar(' '))) p += QLatin1Char(' '); - p += nam; - if (value && !def.isEmpty()) - p += " = " + def; + p += name_; + if (value && !defaultValue_.isEmpty()) + p += " = " + defaultValue_; return p; } @@ -1794,19 +1808,21 @@ QString Parameter::reconstruct(bool value) const /*! Construct a function node for a C++ function. It's parent is \a parent, and it's name is \a name. + + Do not set overloadNumber_ in the initializer list because it + is set by addChild() in the Node base class. */ -FunctionNode::FunctionNode(InnerNode *parent, const QString& name) +FunctionNode::FunctionNode(Aggregate *parent, const QString& name) : LeafNode(Function, parent, name), - met(Plain), - vir(NonVirtual), - con(false), - sta(false), - ove(false), - reimp(false), + metaness_(Plain), + virtualness_(NonVirtual), + const_(false), + static_(false), + reimplemented_(false), attached_(false), privateSignal_(false), - rf(0), - ap(0) + overload_(false), + reimplementedFrom_(0) { setGenus(Node::CPP); } @@ -1815,19 +1831,21 @@ FunctionNode::FunctionNode(InnerNode *parent, const QString& name) Construct a function node for a QML method or signal, specified by \a type. It's parent is \a parent, and it's name is \a name. If \a attached is true, it is an attached method or signal. + + Do not set overloadNumber_ in the initializer list because it + is set by addChild() in the Node base class. */ -FunctionNode::FunctionNode(Type type, InnerNode *parent, const QString& name, bool attached) +FunctionNode::FunctionNode(NodeType type, Aggregate *parent, const QString& name, bool attached) : LeafNode(type, parent, name), - met(Plain), - vir(NonVirtual), - con(false), - sta(false), - ove(false), - reimp(false), + metaness_(Plain), + virtualness_(NonVirtual), + const_(false), + static_(false), + reimplemented_(false), attached_(attached), privateSignal_(false), - rf(0), - ap(0) + overload_(false), + reimplementedFrom_(0) { setGenus(Node::QML); if (type == QmlMethod || type == QmlSignal) { @@ -1843,32 +1861,33 @@ FunctionNode::FunctionNode(Type type, InnerNode *parent, const QString& name, bo is PureVirtual, and if the parent() is a ClassNode, set the parent's \e abstract flag to true. */ -void FunctionNode::setVirtualness(Virtualness virtualness) +void FunctionNode::setVirtualness(Virtualness v) { - vir = virtualness; - if ((virtualness == PureVirtual) && parent() && - (parent()->type() == Node::Class)) + virtualness_ = v; + if ((v == PureVirtual) && parent() && (parent()->type() == Node::Class)) parent()->setAbstract(true); } -/*! +/*! \fn void FunctionNode::setOverloadFlag(bool b) + Sets this function node's overload flag to \a b. + It does not set the overload number. + */ + +/*! \fn void FunctionNode::setOverloadNumber(unsigned char n) + Sets this function node's overload number to \a n. + It does not set the overload flag. */ -void FunctionNode::setOverload(bool overlode) -{ - parent()->setOverload(this, overlode); - ove = overlode; -} /*! - Sets the function node's reimplementation flag to \a r. - When \a r is true, it is supposed to mean that this function + Sets the function node's reimplementation flag to \a b. + When \a b is true, it is supposed to mean that this function is a reimplementation of a virtual function in a base class, - but it really just means the \e reimp command was seen in the - qdoc comment. + but it really just means the \e {\\reimp} command was seen in + the qdoc comment. */ -void FunctionNode::setReimp(bool r) +void FunctionNode::setReimplemented(bool b) { - reimp = r; + reimplemented_ = b; } /*! @@ -1876,16 +1895,16 @@ void FunctionNode::setReimp(bool r) */ void FunctionNode::addParameter(const Parameter& parameter) { - params.append(parameter); + parameters_.append(parameter); } /*! */ void FunctionNode::borrowParameterNames(const FunctionNode *source) { - QList<Parameter>::Iterator t = params.begin(); - QList<Parameter>::ConstIterator s = source->params.constBegin(); - while (s != source->params.constEnd() && t != params.end()) { + QList<Parameter>::Iterator t = parameters_.begin(); + QList<Parameter>::ConstIterator s = source->parameters_.constBegin(); + while (s != source->parameters_.constEnd() && t != parameters_.end()) { if (!(*s).name().isEmpty()) (*t).setName((*s).name()); ++s; @@ -1897,30 +1916,42 @@ void FunctionNode::borrowParameterNames(const FunctionNode *source) If this function is a reimplementation, \a from points to the FunctionNode of the function being reimplemented. */ -void FunctionNode::setReimplementedFrom(FunctionNode *from) +void FunctionNode::setReimplementedFrom(FunctionNode *f) { - rf = from; - from->rb.append(this); + reimplementedFrom_ = f; + f->reimplementedBy_.append(this); } /*! - Sets the "associated" property to \a property. The function - might be the setter or getter for a property, for example. + Adds the "associated" property \a p to this function node. + The function might be the setter or getter for a property, + for example. */ -void FunctionNode::setAssociatedProperty(PropertyNode *property) +void FunctionNode::addAssociatedProperty(PropertyNode *p) { - ap = property; + associatedProperties_.append(p); } /*! - Returns the overload number for this function obtained - from the parent. + Returns true if this function has at least one property + that is active, i.e. at least one property that is not + obsolete. */ -int FunctionNode::overloadNumber() const +bool FunctionNode::hasActiveAssociatedProperty() const { - return parent()->overloadNumber(this); + if (associatedProperties_.isEmpty()) + return false; + foreach (const PropertyNode* p, associatedProperties_) { + if (!p->isObsolete()) + return true; + } + return false; } +/*! \fn unsigned char FunctionNode::overloadNumber() const + Returns the overload number for this function. + */ + /*! Returns the list of parameter names. */ @@ -1957,15 +1988,15 @@ QString FunctionNode::rawParameters(bool names, bool values) const Returns the list of reconstructed parameters. If \a values is true, the default values are included, if any are present. */ -QStringList FunctionNode::reconstructParams(bool values) const +QStringList FunctionNode::reconstructParameters(bool values) const { - QStringList params; + QStringList reconstructedParameters; QList<Parameter>::ConstIterator p = parameters().constBegin(); while (p != parameters().constEnd()) { - params << (*p).reconstruct(values); + reconstructedParameters << (*p).reconstruct(values); ++p; } - return params; + return reconstructedParameters; } /*! @@ -1979,11 +2010,11 @@ QString FunctionNode::signature(bool values) const if (!returnType().isEmpty()) s = returnType() + QLatin1Char(' '); s += name() + QLatin1Char('('); - QStringList params = reconstructParams(values); - int p = params.size(); + QStringList reconstructedParameters = reconstructParameters(values); + int p = reconstructedParameters.size(); if (p > 0) { for (int i=0; i<p; i++) { - s += params[i]; + s += reconstructedParameters[i]; if (i < (p-1)) s += ", "; } @@ -1993,12 +2024,25 @@ QString FunctionNode::signature(bool values) const } /*! + Returns true if function \a fn has role \a r for this + property. + */ +PropertyNode::FunctionRole PropertyNode::role(const FunctionNode* fn) const +{ + for (int i=0; i<4; i++) { + if (functions_[i].contains((Node*)fn)) + return (FunctionRole) i; + } + return Notifier; +} + +/*! Print some debugging stuff. */ void FunctionNode::debug() const { - qDebug("QML METHOD %s rt %s pp %s", - qPrintable(name()), qPrintable(rt), qPrintable(pp.join(' '))); + qDebug("QML METHOD %s returnType_ %s parentPath_ %s", + qPrintable(name()), qPrintable(returnType_), qPrintable(parentPath_.join(' '))); } /*! @@ -2011,17 +2055,17 @@ void FunctionNode::debug() const 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) +PropertyNode::PropertyNode(Aggregate *parent, const QString& name) : LeafNode(Property, parent, name), stored_(FlagValueDefault), designable_(FlagValueDefault), scriptable_(FlagValueDefault), writable_(FlagValueDefault), user_(FlagValueDefault), - cst(false), - fnl(false), - rev(-1), - overrides(0) + const_(false), + final_(false), + revision_(-1), + overrides_(0) { setGenus(Node::CPP); } @@ -2039,8 +2083,8 @@ PropertyNode::PropertyNode(InnerNode *parent, const QString& name) void PropertyNode::setOverriddenFrom(const PropertyNode* baseProperty) { for (int i = 0; i < NumFunctionRoles; ++i) { - if (funcs[i].isEmpty()) - funcs[i] = baseProperty->funcs[i]; + if (functions_[i].isEmpty()) + functions_[i] = baseProperty->functions_[i]; } if (stored_ == FlagValueDefault) stored_ = baseProperty->stored_; @@ -2052,7 +2096,7 @@ void PropertyNode::setOverriddenFrom(const PropertyNode* baseProperty) writable_ = baseProperty->writable_; if (user_ == FlagValueDefault) user_ = baseProperty->user_; - overrides = baseProperty; + overrides_ = baseProperty; } /*! @@ -2084,8 +2128,8 @@ QMultiMap<QString,Node*> QmlTypeNode::inheritedBy; Constructs a Qml class node. The new node has the given \a parent and \a name. */ -QmlTypeNode::QmlTypeNode(InnerNode *parent, const QString& name) - : InnerNode(QmlType, parent, name), +QmlTypeNode::QmlTypeNode(Aggregate *parent, const QString& name) + : Aggregate(QmlType, parent, name), abstract_(false), cnodeRequired_(false), wrapper_(false), @@ -2199,9 +2243,9 @@ QString QmlTypeNode::logicalModuleIdentifier() const Constructs a Qml basic type node. The new node has the given \a parent and \a name. */ -QmlBasicTypeNode::QmlBasicTypeNode(InnerNode *parent, +QmlBasicTypeNode::QmlBasicTypeNode(Aggregate *parent, const QString& name) - : InnerNode(QmlBasicType, parent, name) + : Aggregate(QmlBasicType, parent, name) { setTitle(name); setGenus(Node::QML); @@ -2212,7 +2256,7 @@ QmlBasicTypeNode::QmlBasicTypeNode(InnerNode *parent, always a QmlTypeNode. */ QmlPropertyGroupNode::QmlPropertyGroupNode(QmlTypeNode* parent, const QString& name) - : InnerNode(QmlPropertyGroup, parent, name) + : Aggregate(QmlPropertyGroup, parent, name) { idNumber_ = -1; setGenus(Node::QML); @@ -2235,7 +2279,7 @@ QString QmlPropertyGroupNode::idNumber() /*! Constructor for the QML property node. */ -QmlPropertyNode::QmlPropertyNode(InnerNode* parent, +QmlPropertyNode::QmlPropertyNode(Aggregate* parent, const QString& name, const QString& type, bool attached) @@ -2281,16 +2325,16 @@ bool QmlPropertyNode::isWritable() if (pn) return pn->isWritable(); else - location().warning(tr("No Q_PROPERTY for QML property %1::%2::%3 " - "in C++ class documented as QML type: " - "(property not found in the C++ class or its base classes)") - .arg(logicalModuleName()).arg(qmlTypeName()).arg(name())); + defLocation().warning(tr("No Q_PROPERTY for QML property %1::%2::%3 " + "in C++ class documented as QML type: " + "(property not found in the C++ class or its base classes)") + .arg(logicalModuleName()).arg(qmlTypeName()).arg(name())); } else - location().warning(tr("No Q_PROPERTY for QML property %1::%2::%3 " - "in C++ class documented as QML type: " - "(C++ class not specified or not found).") - .arg(logicalModuleName()).arg(qmlTypeName()).arg(name())); + defLocation().warning(tr("No Q_PROPERTY for QML property %1::%2::%3 " + "in C++ class documented as QML type: " + "(C++ class not specified or not found).") + .arg(logicalModuleName()).arg(qmlTypeName()).arg(name())); } } return true; @@ -2477,6 +2521,7 @@ QString Node::cleanId(const QString &str) return clean; } +#if 0 /*! Creates a string that can be used as a UUID for the node, depending on the type and subtype of the node. Uniquenss @@ -2574,14 +2619,14 @@ QString Node::idForNode() const str = "js-method-" + parent_->name().toLower() + "-" + func->name(); else if (parent_->type() == Document) { qDebug() << "qdoc internal error: Node subtype not handled:" - << parent_->subType() << func->name(); + << parent_->docSubtype() << func->name(); } else qDebug() << "qdoc internal error: Node type not handled:" << parent_->type() << func->name(); } - if (func->overloadNumber() != 1) + if (func->overloadNumber() != 0) str += QLatin1Char('-') + QString::number(func->overloadNumber()); } break; @@ -2599,7 +2644,7 @@ QString Node::idForNode() const break; case Node::Document: { - switch (subType()) { + switch (docSubtype()) { case Node::Page: case Node::HeaderFile: str = title(); @@ -2620,7 +2665,7 @@ QString Node::idForNode() const break; default: qDebug() << "ERROR: A case was not handled in Node::idForNode():" - << "subType():" << subType() << "type():" << type(); + << "docSubtype():" << docSubtype() << "type():" << type(); break; } } @@ -2682,7 +2727,7 @@ QString Node::idForNode() const else str = "js-method-"; str += parent_->name().toLower() + "-" + func->name(); - if (func->overloadNumber() != 1) + if (func->overloadNumber() != 0) str += QLatin1Char('-') + QString::number(func->overloadNumber()); break; case Node::Variable: @@ -2690,12 +2735,12 @@ QString Node::idForNode() const break; default: qDebug() << "ERROR: A case was not handled in Node::idForNode():" - << "type():" << type() << "subType():" << subType(); + << "type():" << type() << "docSubtype():" << docSubtype(); break; } if (str.isEmpty()) { qDebug() << "ERROR: A link text was empty in Node::idForNode():" - << "type():" << type() << "subType():" << subType() + << "type():" << type() << "docSubtype():" << docSubtype() << "name():" << name() << "title():" << title(); } @@ -2704,12 +2749,13 @@ QString Node::idForNode() const } return str; } +#endif /*! Prints the inner node's list of children. For debugging only. */ -void InnerNode::printChildren(const QString& title) +void Aggregate::printChildren(const QString& title) { qDebug() << title << name() << children_.size(); if (children_.size() > 0) { |