QList<ListDigraph::Node> ProcessModel::topolSortReachableFrom(const QList<ListDigraph::Node>& s) {
ListDigraph::NodeMap<bool > nodevisited(graph, false);
QList<ListDigraph::Node> res;
QStack<ListDigraph::Node> stack;
ListDigraph::Node curnode;
ListDigraph::Node pnode;
ListDigraph::Node snode;
QList<ListDigraph::Node> reachable = reachableFrom(s);
// Reserve memory
res.reserve(countNodes(graph));
stack.reserve(countNodes(graph));
for (int i = 0; i < s.size(); i++) {
if (s[i] != INVALID) {
stack.push(s[i]);
}
}
bool psched;
while (!stack.empty()) {
curnode = stack.pop();
if (!nodevisited[curnode]) { // This node has not been visited yet
// Check whether all predecessors in reachable are scheduled
psched = true;
for (ListDigraph::InArcIt iait(graph, curnode); iait != INVALID; ++iait) {
pnode = graph.source(iait);
if (reachable.contains(pnode)) { // Consider only nodes which can be reached from s
if (!nodevisited[pnode]) {
psched = false;
break;
}
}
}
if (psched) { // All predecessors have been visited
res.append(curnode);
nodevisited[curnode] = true;
// Push the succeeding nodes
for (ListDigraph::OutArcIt oait(graph, curnode); oait != INVALID; ++oait) {
snode = graph.target(oait);
if (!nodevisited[snode]) {
stack.push(snode);
}
}
} else {
stack.prepend(curnode);
}
} // Else ignore the visited node
}
return res;
}
QList<Section> QsCodeMarker::sections( const InnerNode *inner, SynopsisStyle style, Status status )
{
QList<Section> sections;
if (inner->type() != Node::Class)
return sections;
const ClassNode *classe = static_cast<const ClassNode *>(inner);
if ( style == Summary ) {
FastSection enums(classe, "Enums", "", "enum", "enums");
FastSection functions(classe, "Functions", "", "function", "functions");
FastSection readOnlyProperties(classe, "", "Read-Only Properties", "property", "properties");
FastSection signalz(classe, "Signals", "", "signal", "signals");
FastSection writableProperties(classe, "", "Writable Properties", "property", "properties");
QStack<const ClassNode *> stack;
stack.push( classe );
while ( !stack.isEmpty() ) {
const ClassNode *ancestorClass = stack.pop();
NodeList::ConstIterator c = ancestorClass->childNodes().begin();
while ( c != ancestorClass->childNodes().end() ) {
if ( (*c)->access() == Node::Public ) {
if ( (*c)->type() == Node::Enum ) {
insert( enums, *c, style, status );
} else if ( (*c)->type() == Node::Function ) {
const FunctionNode *func = (const FunctionNode *) *c;
if ( func->metaness() == FunctionNode::Signal ) {
insert( signalz, *c, style, status );
} else {
insert( functions, *c, style, status );
}
} else if ( (*c)->type() == Node::Property ) {
const PropertyNode *property =
(const PropertyNode *) *c;
if ( property->setters().isEmpty() ) {
insert( readOnlyProperties, *c, style, status );
} else {
insert( writableProperties, *c, style, status );
}
}
}
++c;
}
QList<RelatedClass>::ConstIterator r = ancestorClass->baseClasses().begin();
while ( r != ancestorClass->baseClasses().end() ) {
stack.prepend( (*r).node );
++r;
}
}
append( sections, enums );
append( sections, writableProperties );
append( sections, readOnlyProperties );
append( sections, functions );
append( sections, signalz );
} else if ( style == Detailed ) {
FastSection enums( classe, "Enum Documentation", "", "member", "members");
FastSection functionsAndSignals( classe, "Function and Signal Documentation", "", "member", "members");
FastSection properties( classe, "Property Documentation", "", "member", "members");
NodeList::ConstIterator c = classe->childNodes().begin();
while ( c != classe->childNodes().end() ) {
if ( (*c)->access() == Node::Public ) {
if ( (*c)->type() == Node::Enum ) {
insert( enums, *c, style, status );
} else if ( (*c)->type() == Node::Function ) {
insert( functionsAndSignals, *c, style, status );
} else if ( (*c)->type() == Node::Property ) {
insert( properties, *c, style, status );
}
}
++c;
}
append( sections, enums );
append( sections, properties );
append( sections, functionsAndSignals );
} else { // ( style == SeparateList )
FastSection all(classe, "", "", "member", "members");
QStack<const ClassNode *> stack;
stack.push( classe );
while ( !stack.isEmpty() ) {
const ClassNode *ancestorClass = stack.pop();
NodeList::ConstIterator c = ancestorClass->childNodes().begin();
while ( c != ancestorClass->childNodes().end() ) {
if ( (*c)->access() == Node::Public )
insert( all, *c, style, status );
++c;
}
QList<RelatedClass>::ConstIterator r = ancestorClass->baseClasses().begin();
while ( r != ancestorClass->baseClasses().end() ) {
stack.prepend( (*r).node );
++r;
}
}
append( sections, all );
}
return sections;
}
