void Monitor::MonitorDataStorage::manageTransportLink( TreeNode* node, int transport_id, bool& create ) { // Start by finding the participant node. TreeNode* processNode = node->parent(); if( processNode) { // And follow it to the actual process node. processNode = processNode->parent(); } else { // Horribly corrupt model, something oughta been done about it! ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: MonitorDataStorage::manageTransportLink() - ") ACE_TEXT("unable to locate the ancestor process node!\n") )); return; } // Then finds its key in the maps. ProcessKey processKey; std::pair< bool, ProcessKey> pResult = this->findKey( this->processToTreeMap_, processNode); if( pResult.first) { processKey = pResult.second; } else { // Horribly corrupt model, something oughta been done about it! ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ERROR: MonitorDataStorage::manageTransportLink() - ") ACE_TEXT("unable to locate the process node in the maps!\n") )); return; } // Now we have enough information to build a TransportKey and find or // create a transport node for our Id value. TransportKey transportKey( processKey.host, processKey.pid, transport_id ); TreeNode* transportNode = this->getTransportNode( transportKey, create); if( !node) { return; } // Transport Id display. QString label( QObject::tr( "Transport")); int row = node->indexOf( 0, label); if( row == -1) { // New entry, add a reference to the actual transport node. QList<QVariant> list; list << label << QString( QObject::tr("<error>"));; TreeNode* idNode = new TreeNode( list, node); idNode->setColor( 1, QColor("#bfbfff")); node->append( idNode); transportNode->addValueRef( idNode); transportNode->setColor( 1, QColor("#bfffbf")); create = true; } }
// ----------------------------------------------------------------------------- TreeNode* bTree::TreeInsert(HTTPCSTR str, TreeNode *ParentItem) { if (ParentItem == NULL) { if (root == NULL) { TreeNode *newnode = new TreeNode(str, NULL); newnode->SetTreeNodeParentTree(this); root = newnode; count++; return (root); } else { TreeNode *y = NULL; TreeNode *x = root; while (x != NULL) { if (_tcscmp(x->GetTreeNodeName(), str) == 0) { /* already Exists */ return (x); } y = x; if (_tcscmp(str, x->GetTreeNodeName()) < 0) x = x->GetTreeNodeLeft(); else x = x->GetTreeNodeRight(); } /* str doesn't yet exist in tree - add it in */ TreeNode *newnode = new TreeNode(str, y); newnode->SetTreeNodeParentTree(this); if (_tcscmp(str, y->GetTreeNodeName()) < 0) { y->SetTreeNodeLeft(newnode); } else { y->SetTreeNodeRight(newnode); } this->count++; /* Add an additional element to the tree counter */ return (newnode); } } else { TreeNode*newnode = ParentItem->GetTreeNodeChildTree()->TreeInsert(str, NULL); return (newnode); } }
void TreeDustGridStructure::setupSelfBefore() { GenDustGridStructure::setupSelfBefore(); Log* log = find<Log>(); // Validate attribute values if (_xmax <= 0.0 || _ymax <= 0.0 || _zmax <= 0.0) throw FATALERROR("The maximum extent should be positive"); if (_minlevel < 0) throw FATALERROR("The minimum tree level should be at least 0"); if (_maxlevel < 2) throw FATALERROR("The maximum tree level should be at least 2"); if (_maxlevel <= _minlevel) throw FATALERROR("Maximum tree level should be larger than minimum tree level"); if (_Nrandom < 1) throw FATALERROR("Number of random samples must be at least 1"); if (_maxOpticalDepth < 0.0) throw FATALERROR("The maximum mean optical depth should be positive"); if (_maxMassFraction < 0.0) throw FATALERROR("The maximum mass fraction should be positive"); if (_maxDensDispFraction < 0.0) throw FATALERROR("The maximum density dispersion fraction should be positive"); // If no assigner was set, use an IdenticalAssigner as default (each process builds the entire tree) if (!_assigner) setAssigner(new IdenticalAssigner(this)); // Cache some often used values // A Parallel instance is created with a limited amount of threads (4) for performance reasons _parallel = find<ParallelFactory>()->parallel(4); _dd = find<DustDistribution>(); _dmib = _dd->interface<DustMassInBoxInterface>(); _useDmibForSubdivide = _dmib && !_maxDensDispFraction; _totalmass = _dd->mass(); _eps = 1e-12 * extent().widths().norm(); // Create the root node _tree.push_back(createRoot(extent())); // Recursively subdivide the root node until all nodes satisfy the // necessary criteria. When finished, set the number _Nnodes. int currentlevel = -1; unsigned int l = 0; while (true) { TreeNode* node = _tree[l]; int level = node->level(); if (level>currentlevel) { log->info("Starting subdivision of level " + QString::number(level) + "..."); currentlevel = level; } if (l%50000 == 0) log->info("Subdividing node number " + QString::number(l) + "..."); if (node->ynchildless()) subdivide(node); l++; if (l>=_tree.size()) break; } _Nnodes = _tree.size(); // Construction of a vector _idv that contains the node IDs of all // leaves. This is the actual dust cell vector (only the leaves will // eventually become valid dust cells). We also create a vector // _cellnumberv with the cell numbers of all the nodes (i.e. the // rank m of the node in the vector _idv if the node is a leaf, and // -1 if the node is not a leaf). int m = 0; _cellnumberv.resize(_Nnodes,-1); for (int l=0; l<_Nnodes; l++) { if (_tree[l]->ynchildless()) { _idv.push_back(l); _cellnumberv[l] = m; m++; } } _Ncells = _idv.size(); // Log the number of cells log->info("Construction of the tree finished."); log->info(" Total number of nodes: " + QString::number(_Nnodes)); log->info(" Total number of leaves: " + QString::number(_Ncells)); vector<int> countv(_maxlevel+1); for (int m=0; m<_Ncells; m++) { TreeNode* node = _tree[_idv[m]]; int level = node->level(); countv[level]++; } log->info(" Number of leaf cells of each level:"); for (int level=0; level<=_maxlevel; level++) log->info(" Level " + QString::number(level) + ": " + QString::number(countv[level]) + " cells"); // Determine the number of levels to be included in 3D grid output (if such output is requested) if (writeGrid()) { int cumulativeCells = 0; for (_highestWriteLevel=0; _highestWriteLevel<=_maxlevel; _highestWriteLevel++) { cumulativeCells += countv[_highestWriteLevel]; if (cumulativeCells > 1500) break; // experimental number } if (_highestWriteLevel<_maxlevel) log->info("Will be outputting 3D grid data up to level " + QString::number(_highestWriteLevel) + ", i.e. " + QString::number(cumulativeCells) + " cells."); } // Add neighbors to the tree structure (but only if required for the search method) if (_search == Neighbor) { log->info("Adding neighbors to the tree nodes..."); for (int l=0; l<_Nnodes; l++) _tree[l]->addneighbors(); for (int l=0; l<_Nnodes; l++) _tree[l]->sortneighbors(); } }
void Monitor::NodeGenerator::generate(TreeNode *t, QGraphicsScene *nodeScene, int w, int h, Node* parent) { static int xpos = 0; static int ypos = 0; if (t == 0) { return; } Node *node = 0; QString text; if (isNodeValid(t, text)) { xpos = w * 100; ypos += 50; node = new Node(text, xpos, ypos, t); node->setParent(parent); // populate tooltips with the children TreeNode *c; std::ostringstream ttip; for (int i = 0; i < t->size(); ++i) { c = t->operator[](i); std::string k = c->column(0).toString().toLocal8Bit().constData(); std::string v = c->column(1).toString().toLocal8Bit().constData(); ttip << k << " : " << v << std::endl; } node->setToolTip(ttip.str().c_str()); // this takes ownership of the node so the nodeScene will // cleanup all nodes when it's destroyed // TODO: This make each nodes parent the nodeScene. change this // so parent is the actual parent node using setParent() nodeScene->addItem(node); // connect us to our parent with a dashed line // connect us to the parent if (parent && !nodeOpt_.hideParentChild()) { // give edge an actual parent so that z-order works Edge *edge = new Edge(parent, node, false, parent); nodeScene->addItem(edge); parent->addEdge(edge); node->addEdge(edge); } // store node if (parent && !nodeOpt_.hidePubSub()) { nMap_[t] = node; } } // draw the child nodes ++w; for (int i = 0; i < t->size(); ++i) { generate(t->operator[](i), nodeScene, w, ++h, node); } }
bool RamAi::GameMonteCarloTree::NodeNeedsExpanding(const TreeNode &node) const { return (node.GetNumberOfChildren() < ConsoleSettings::GetSpecs().GetNumberOfInputCombinations()) && PartialExpansion(node); }
int QueryParser::parseIt(int sessionId, string query, TreeNode *&qTree, string &tcResultString, bool toBeTypeChecked, bool toBeOptimized) { QueryParser::setStatEvalRun(0); ErrorConsole &ec(ErrorConsole::get_instance(EC_QUERY_PARSER)); try{ qTree = parser->parse(query).release(); debug_print(ec, "Query not parsed properly...\n"); debug_print(ec, (ErrQParser | ENotParsed)); } catch (LoximException &ex) { debug_print(ec, "Query parsed"); return (ErrQParser | ENotParsed); } Indexes::QueryOptimizer::optimizeWithIndexes(qTree); //Nothing more needs to be done, if this is an internal query. (no screen logging, typechecking, optimization) if (!toBeTypeChecked && !toBeOptimized) { return 0; } if (Deb::ugOn()) { cout << " Tree before optimization:"; cout << "\n--------------------------------------\n"; qTree->putToString(); cout << "\n--------------------------------------\n"; } if ((shouldTypeCheck || shouldOptimize) && !qTree->skipPreprocessing()) { TreeNode *nt = qTree->clone(); bool metadataCorrect = DataScheme::dScheme(sessionId)->getIsComplete(); bool metadataUpToDate = DataScheme::dScheme(sessionId)->getIsUpToDate(); if (!metadataCorrect || !metadataUpToDate) { debug_print(ec, "Data scheme is not complete or not up to date); optimization and typechecking blocked."); } int typeCheckErrCode = 0; if (shouldTypeCheck && toBeTypeChecked && metadataCorrect && metadataUpToDate) { if (isTcOffTmp()) { debug_print(ec, "Typechecking turned off temporarily"); tcResultString = "";} else { Deb::ug(" \n \n TYPECHECK BEGIN !!! \n \n"); TypeChecker *tc = new TypeCheck::TypeChecker(nt); typeCheckErrCode = tc->doTypeChecking(tcResultString); Deb::ug(" \n \n TYPECHECK DONE... \n "); if ((typeCheckErrCode != 0) && (typeCheckErrCode != (ErrTypeChecker | ETCNotApplicable))) { debug_print(ec, "TC, Parser: typeCheckErrorCode says general TC error, should return string to user.\n"); return typeCheckErrCode; } if (typeCheckErrCode == 0) { delete qTree; qTree = nt; } } } else { if (shouldTypeCheck && toBeTypeChecked && dmlIncompleteAction == DML_AC_RETURN_ERROR) { if (!metadataCorrect) return (ErrTypeChecker | EIncompleteMetadata); else return (ErrTypeChecker | EMetadataOutdated); } tcResultString = ""; Deb::ug("TypeChecking is disabled."); } if (shouldOptimize && toBeOptimized && metadataCorrect && metadataUpToDate) { Deb::ug(" optimisation is set ON !"); int optres = 0; int stat_ev_res; nt = qTree->clone(); if ((stat_ev_res = this->statEvaluate(sessionId, nt)) != 0) { Deb::ug("static evaluation did not work out ..."); optres = -1; } else { int optres = -2; DeathRmver *rmver = new DeathRmver(this); rmver->rmvDeath(nt); if (this->statEvaluate(sessionId, nt) != 0) optres = -1; /* The main optimisation loop - factor out single independent subqueries * * as long as ... such exist ! */ while (optres == -2) { optres = nt->optimizeTree(); while (nt->getParent() != NULL) nt = nt->getParent(); /*one more static eval, to make sure nodes have the right info.. */ fprintf (stderr, "one more stat eval..\n"); if (this->statEvaluate(sessionId, nt) != 0) optres = -1; } AuxRmver *auxRmver = new AuxRmver(this); auxRmver->rmvAux(nt); JoinRpcer *joinRpcer = new JoinRpcer(this); joinRpcer->replaceJoin(nt); } if (optres != -1) { Deb::ug("I'll return optimized tree\n"); qTree = nt; if (Deb::ugOn()) { cout << "Tree after optimization:\n--------------------------------------\n"; qTree->putToString(); cout << "\n--------------------------------------\n"; } } else { Deb::ug("I'll return the tree from before static eval..");} } else { if (shouldTypeCheck && toBeTypeChecked && dmlIncompleteAction == DML_AC_RETURN_ERROR) { if (!metadataCorrect) return (ErrTypeChecker | EIncompleteMetadata); else return (ErrTypeChecker | EMetadataOutdated); } Deb::ug(" optimisation is disabled. \n"); } } else { qTree->qpLocalAction(this); } Deb::ug(" ParseIt() ends successfully!"); /* cout << "td1------------------------------------------------------------\n"; testDeath("EMP.NAME"); cout << "td2------------------------------------------------------------\n"; testDeath("(EMP join (WORKS_IN.DEPT)).NAME;"); cout << "td3------------------------------------------------------------\n"; */ if (Deb::ugOn()) { cout << "===================================================================" << endl; cout << "P A R S E R R E T U R N S :" << endl; qTree->serialize(); cout << "\n===================================================================" << endl; } return 0; }
int main () { //create a binary tree first TreeNode * a = new TreeNode ("A"); TreeNode * b = new TreeNode ("B"); TreeNode * c = new TreeNode ("C"); TreeNode * d = new TreeNode ("D"); TreeNode * e = new TreeNode ("E"); TreeNode * f = new TreeNode ("F"); TreeNode * g = new TreeNode ("G"); TreeNode * h = new TreeNode ("H"); TreeNode * i = new TreeNode ("I"); a->setRight(c); a->setLeft(b); b->setRight(d); c->setRight(f); c->setLeft(e); e->setLeft(g); f->setLeft(h); f->setRight(i); vector <string> result = preorderTraversal(a); for(int i = 0; i < result.size(); i++ ) { cout << result[i] << endl; } return 0; }
int model::DbContainerModel::rowCount(const QModelIndex& parent /*= QModelIndex()*/) const { TreeNode* node = Index2Node(parent); // Check for root return (node == nullptr) ? m_rootNodes.size() : node->GetChildrenCount(); }
void ParticleTreeDustGridStructure::setupSelfBefore() { GenDustGridStructure::setupSelfBefore(); // Verify property values if (_xmax <= 0.0 || _ymax <= 0.0 || _zmax <= 0.0) throw FATALERROR("The maximum extent should be positive"); // Cache some often used values Log* log = find<Log>(); _eps = 1e-12 * extent().widths().norm(); DustDistribution* dd = find<DustDistribution>(); _dmib = dd->interface<DustMassInBoxInterface>(); DustParticleInterface* dpi = dd->interface<DustParticleInterface>(); if (!dpi) throw FATALERROR("Can't retrieve particle locations from this dust distribution"); int numParticles = dpi->numParticles(); log->info("Constructing tree for " + QString::number(numParticles) + " particles..."); // Create a list, used only during construction, that contains the index of the particle // contained in each leaf node so far created, or -1 if the node is empty // (the value is undefined for nonleaf nodes) vector<int> particlev; // Create the root node (which at this point is an empty leaf) using the requested type switch (_treeType) { default: case OctTree: _tree.push_back(new OctTreeNode(0,0,extent())); break; case BinTree: _tree.push_back(new BinTreeNode(0,0,extent())); break; } particlev.push_back(-1); int maxlevel = 0; // Add particles one by one, subdividing if the leaf node containing the new particle // already contains another particle for (int i=0; i<numParticles; i++) { if (i%50000 == 0) log->info("Adding particle number " + QString::number(i) + " (" + QString::number(i*100/numParticles) + "%)..."); int level = addParticleToNode(i, root(), dpi, particlev, _tree); maxlevel = max(maxlevel, level); } // Perform additional subdivisions as requested if (_extraLevels>0) { log->info("Performing additional subdivisions..."); maxlevel += _extraLevels; for (int e=0; e<_extraLevels; e++) { int Nnodes = _tree.size(); for (int l=0; l<Nnodes; l++) { TreeNode* node = _tree[l]; if (node->ynchildless()) { node->createchildren(_tree.size()); _tree.insert(_tree.end(), node->children().begin(), node->children().end()); } } } } // Construction of a vector _idv that contains the node IDs of all // leaves. This is the actual dust cell vector (only the leaves will // eventually become valid dust cells). We also create a vector // _cellnumberv with the cell numbers of all the nodes (i.e. the // rank m of the node in the vector _idv if the node is a leaf, and // -1 if the node is not a leaf). int Nnodes = _tree.size(); int m = 0; _cellnumberv.resize(Nnodes,-1); for (int l=0; l<Nnodes; l++) { if (_tree[l]->ynchildless()) { _idv.push_back(l); _cellnumberv[l] = m; m++; } } _Ncells = _idv.size(); // Log the number of cells log->info("Construction of the tree finished."); log->info(" Total number of nodes: " + QString::number(Nnodes)); log->info(" Total number of leaves: " + QString::number(_Ncells)); vector<int> countv(maxlevel+1); for (int m=0; m<_Ncells; m++) { TreeNode* node = _tree[_idv[m]]; int level = node->level(); countv[level]++; } log->info(" Number of leaf cells of each level:"); for (int level=0; level<=maxlevel; level++) log->info(" Level " + QString::number(level) + ": " + QString::number(countv[level]) + " cells"); // Determine the number of levels to be included in 3D grid output (if such output is requested) if (writeGrid()) { int cumulativeCells = 0; for (_highestWriteLevel=0; _highestWriteLevel<=maxlevel; _highestWriteLevel++) { cumulativeCells += countv[_highestWriteLevel]; if (cumulativeCells > 1500) break; // experimental number } if (_highestWriteLevel<maxlevel) log->info("Will be outputting 3D grid data up to level " + QString::number(_highestWriteLevel) + ", i.e. " + QString::number(cumulativeCells) + " cells."); } }
iterator begin(){ if (root) return iterator(root->leftMost()); else return iterator(NULL); }
void algorithm2(int n, int m, int k, AdjacencyList &Graph, int** &Groups) { Tree* T = new Tree; Tree* C = NULL; Tree* R_i = NULL; Tree* current_path = NULL; TreeNode* ptr = NULL; int current_weight, i, j, current_t_i, t_i, real_weight; long int d_i = 1000000000; int group = 1000; // Add vertex in Groups[0] to T // and mark as reached T->insert(Groups[0][2], 0); Groups[0][0] = 1; cout << "0\n"; while(1) { // check if there is at least one group that is unreached for(i = 0; i < k; i++) { if (!Groups[i][0]) // if there is a group unreached break; } if (i == k) // if i == k, then all groups are reached and we are done break; d_i = 1000000000; t_i = 1; group = 1000; for(i = 0; i < k; i++) { if (Groups[i][0] == 1) continue; // find a shortest path from vertex in g_i to vertex in T for (j = 2; j < Groups[i][1] + 2; j++) { // find a shortest path from vertex j in g_i to vertex in T current_path = Dijkstra(n, Groups[i][j], T, Graph); current_weight = current_path->get_last()->get_vertex_weight(); current_path->set_total_weight(current_weight);// path_into_tree sums them at the end! current_t_i = num_groups_in_path(current_path, Groups, k); // the number of "not reached" groups that current_path visits // now comapre based off of d_i/t_i if ((double)current_weight/current_t_i < (double)d_i/t_i) { R_i = current_path; d_i = current_weight; t_i = current_t_i; group = i; } else if ((double)current_weight/current_t_i == (double)d_i/t_i) { if (i < group) { R_i = current_path; d_i = current_weight; t_i = current_t_i; group = i; } else if (i == group) { // if the distances AND groups are equal, lexicographic if (!lexicographic(current_path, R_i)) { R_i = current_path; d_i = current_weight; group = i; } } } } } // add R_i to T and mark group as reached T->insert(R_i); // create C - a collection of all the groups visited by path R_i that are not currently reached C = groups_in_path(R_i, Groups, k); // mark all the groups in C as marked for (ptr = C->get_first(); ptr != NULL; ptr = ptr->get_next()) { Groups[ptr->get_vertex_id()][0] = 1; } // create array from nodes in C, then sort the array int* C_array = new int[C->get_tree_size()]; int* temp = new int[C->get_tree_size()]; int step = 0; TreeNode* array_c; for(array_c = C->get_first(); array_c != NULL; array_c = array_c->get_next()) { C_array[step] = array_c->get_vertex_id(); step++; } merge_sort(C_array, temp, 0, C->get_tree_size()-1); for (step = 0; step < C->get_tree_size(); step++) { cout << C_array[step] << "\n"; } delete[] C_array; delete[] temp; } // print all vertices in T from smallest values to largest per line // create array from nodes in T, then sort the array // print sum of the weight of all the endges in T in one line int* final_array = new int[T->get_tree_size()]; int* temp = new int[T->get_tree_size()]; int step = 0; TreeNode* final_p; for(final_p = T->get_first(); final_p != NULL; final_p = final_p->get_next()) { final_array[step] = final_p->get_vertex_id(); step++; } merge_sort(final_array, temp, 0, T->get_tree_size()-1); for (step = 0; step < T->get_tree_size(); step++) cout << final_array[step] << "\n"; cout << T->get_total_weight() << "\n"; }
int main(int argc, char *argv) { int i, j; float data[10]; float currData[2]; #if 0 int socket; /* Connect to MDSplus */ socket = MdsConnect (SERVER_ADDR); if ( socket == -1 ) { fprintf(stderr,"Error connecting to Atlas.\n"); return EXIT_FAILURE; } printf ("after MdsConnect\n"); #endif try { #if 0 Connection *conn = new Connection (SERVER_ADDR); if (!conn) { printf ("Connection failed \n"); } printf ("after Connection\n"); #endif /* Open pulse file, shot # */ Tree *t = new Tree(TREE_NAME, SHOT_NUM); printf ("after Tree\n"); /* Get node */ TreeNode *node = t->getNode(TAG_NAME); printf ("after getNode\n"); /* Make sure no data is contained */ // Segmentation fault => 3.0 library & header is ok node->deleteData(); //float stime = -5; float stime = -5; Data *start = new Float64(10.); Data *end = new Float64(11.); Data *rate = new Float64(0.1); Data *dimension = new Range(start, end, rate); memset (data, 0x00, sizeof(data)); Array *dataArray = new Float32Array(data, 2); for (i = 0; i < 5; i++) { start = new Float64(stime + i); end = new Float64(stime + 0.1 + i); rate = new Float64(0.1); dimension = new Range(start, end, rate); node->beginSegment (start, end, dimension, dataArray); for(j = 0; j < 2; j++) { currData[j] = i+1; } printf ("[%02d] putSegment ... \n", i); Array *subArr = new Float32Array(currData, 2); node->putSegment (subArr, -1); Event::setEvent (EVENT_NAME); cout << "Data (" << node->getNumSegments() << ") : " << node->getData() << endl; /* Free stuff */ //deleteData(start); //deleteData(end); //deleteData(rate); deleteData(dimension); delete(subArr); sleep (2); } delete(t); } catch(MdsException *exc) { cout << "Error appending segments: " << exc->what(); } }
void Monitor::MonitorDataStorage::displayNvp( TreeNode* parent, const OpenDDS::DCPS::NVPSeq& data, bool layoutChanged, bool dataChanged ) { // NAME / VALUE DATA int size = data.length(); for( int index = 0; index < size; ++index) { QString name( data[ index].name); int row = parent->indexOf( 0, name); if( row == -1) { // This is new data, insert it. QList<QVariant> list; list << name; switch( data[ index].value._d()) { case OpenDDS::DCPS::INTEGER_TYPE: list << QString::number( data[ index].value.integer_value()); break; case OpenDDS::DCPS::DOUBLE_TYPE: list << QString::number( data[ index].value.double_value()); break; case OpenDDS::DCPS::STRING_TYPE: list << QString( data[ index].value.string_value()); break; case OpenDDS::DCPS::STATISTICS_TYPE: case OpenDDS::DCPS::STRING_LIST_TYPE: list << QString( QObject::tr("<display unimplemented>")); break; } TreeNode* node = new TreeNode( list, parent); parent->append( node); layoutChanged = true; } else { // This is existing data, update the value. TreeNode* node = (*parent)[ row]; switch( data[ index].value._d()) { case OpenDDS::DCPS::INTEGER_TYPE: node->setData( 1, QString::number( data[ index].value.integer_value())); break; case OpenDDS::DCPS::DOUBLE_TYPE: node->setData( 1, QString::number( data[ index].value.double_value())); break; case OpenDDS::DCPS::STRING_TYPE: node->setData( 1, QString( data[ index].value.string_value())); break; case OpenDDS::DCPS::STATISTICS_TYPE: case OpenDDS::DCPS::STRING_LIST_TYPE: break; } dataChanged = true; } } // Notify the GUI if we have changed the underlying model. if( layoutChanged) { /// @TODO: Check that we really do not need to do updated here. this->model_->changed(); } else if( dataChanged) { this->model_->updated( parent, 1, (*parent)[ parent->size()-1], 1); } }
void Monitor::MonitorDataStorage::manageTopicLink( TreeNode* node, const OpenDDS::DCPS::GUID_t& dp_id, const OpenDDS::DCPS::GUID_t& topic_id, bool& create ) { // This gets a bit tedious. Here are the cases: // 1) We currently have no reference, and found a Topic node to // reference: // - attach a reference to the topic node; // 2) We currently have no reference, and found a Name node to // reference: // - attach a reference to the name node; // 3) We currently have a Topic node referenced, and found the same // topic node to reference: // - nothing to do; // 4) We currently have a Topic node referenced, and found a different // Topic node to reference: // - detach previous reference and reattach to new topic node; // 5) We currently have a Topic node referenced, but were able to find // a name node to reference: // - detach previous reference and reattach to new name node; // 6) We currently have a Name node referenced, and found the same name // node to reference: // - nothing to do; // 7) We currently have a Name node referenced, and found a different // name node to reference: // - detach previous reference and reattach to new name node; // 8) We currently have a Name node referenced, and found a different // Topic node to reference: // - detach previous reference and reattach to new topic node. // // Note that cases (4), (7), and (8) indicate inconsistent data reports // and are error conditions. We chose to not handle these cases. // Cases (3) and (6) require no action, so the only code paths we need // to consider are for cases (1), (2), and (5). // Find the actual topic. TreeNode* topicNode = this->getNode( std::string( "Topic"), dp_id, topic_id, create ); if( !topicNode) { return; } // Find the topic name to reference instead of the GUID value. TreeNode* nameNode = 0; QString nameLabel( QObject::tr( "Topic Name")); int row = topicNode->indexOf( 0, nameLabel); if( row != -1) { nameNode = (*topicNode)[ row]; } // Check for an existing Topic entry. QString topicLabel( QObject::tr( "Topic")); int topicRow = node->indexOf( 0, topicLabel); if( nameNode && topicRow != -1) { // Case 5: We have a topic reference and found a name reference, // remove the existing topic reference TreeNode* topicRef = (*node)[ topicRow]; if( topicRef && topicRef->valueSource()) { topicRef->valueSource()->removeValueRef( topicRef); } // node->removeChildren( topicRow, 1); // DEVELOPMENT: don't delete to show stale data. } // The node to install. TreeNode* refNode = nameNode; if( !refNode) { refNode = topicNode; } // Check to see if we need to create a name entry. int nameRow = node->indexOf( 0, nameLabel); if( nameRow == -1) { // New entry, add a reference to the topic or its name. QList<QVariant> list; list << topicLabel << QString( QObject::tr("<error>")); TreeNode* idNode = new TreeNode( list, node); idNode->setColor( 1, QColor("#bfbfff")); node->append( idNode); refNode->addValueRef( idNode); refNode->setColor( 1, QColor("#bfffbf")); create = true; } }
void print() { root->print(); }
void TreeNode::iterate(int action, int* curIndex, int* targetIndex) { Gwen::String name = Gwen::Utility::UnicodeToString(m_Title->GetText()); // int actualIndex = curIndex? *curIndex : -1; //printf("iterated over item %d with name = %s\n", actualIndex, name.c_str()); if (action==ITERATE_ACTION_SELECT) { if (curIndex && targetIndex) { if ((*curIndex)==(*targetIndex)) { SetSelected(true); *targetIndex=-1; } } } if (IsSelected()) { //printf("current selected: name = %s\n", name.c_str()); switch (action) { case ITERATE_ACTION_DESELECT_INDEX: { if (targetIndex && curIndex) { if (*targetIndex == *curIndex) SetSelected(false); } break; } case ITERATE_ACTION_FIND_SELECTED_INDEX: { if (targetIndex && curIndex) { *targetIndex = *curIndex; } break; } case ITERATE_ACTION_OPEN: { Open(); break; } case ITERATE_ACTION_CLOSE: { //either close or select parent if (this->GetChildren().size()) { if (m_ToggleButton && m_ToggleButton->GetToggleState()) { Close(); } else { TreeNode* pChild = (GetParent())->DynamicCastTreeNode(); TreeControl* pChild2 = (GetParent())->DynamicCastTreeControl(); if (pChild && !pChild2) { SetSelected(false); pChild->SetSelected(true); } } } else { TreeNode* pChild = (GetParent())->DynamicCastTreeNode(); TreeControl* pChild2 = (GetParent())->DynamicCastTreeControl(); if (pChild && !pChild2) { SetSelected(false); pChild->SetSelected(true); } } break; } default: { } }; } if (curIndex) (*curIndex)++; bool needsRecursion = true; if (action == ITERATE_ACTION_FIND_SELECTED_INDEX || action==ITERATE_ACTION_SELECT || action==ITERATE_ACTION_DESELECT_INDEX) { if (m_ToggleButton && !m_ToggleButton->GetToggleState()) { needsRecursion=false; } } if (needsRecursion) { Base::List& children = m_InnerPanel->GetChildren(); for ( Base::List::iterator iter = children.begin(); iter != children.end(); ++iter ) { TreeNode* pChild = (*iter)->DynamicCastTreeNode(); if ( !pChild ) continue; pChild->iterate(action , curIndex, targetIndex); } } }
Tree<_DATA>& Tree<_DATA>:: read_this(const char* dir) { char path[SIZEOF_PATH], * filename, line_str[SIZEOF_PATH], * filename_str; std::strcpy(path, dir); std::size_t dir_len = std::strlen(path); std::size_t file_len; if (dir_len > 0 && (path[dir_len - 1] != '/' && path[dir_len - 1] != '\\')) path[dir_len++] = '/'; filename = path + dir_len; file_len = SIZEOF_PATH - dir_len; std::strcpy(filename, "Tree"); std::ifstream file(path); if (!file.is_open()) { std::cerr << "\nFailed opening file: " << path << std::endl; return *this; } while(file.getline(line_str, SIZEOF_LINE) && !line_str[0]); if (!line_str[0]) { std::cerr << "\nFailed finding file for root." << std::endl; return *this; } file.close(); filename_str = strtostr(line_str); std::strcpy(filename, filename_str); file.open(path); if (!file.is_open()) { std::cerr << "\nFailed opening file: " << path << std::endl; return *this; } unsigned long node_num; _DATA* data; std::queue<unsigned long> node_name; std::queue<TreeNode*> node_parent_pointer; file.getline(line_str, SIZEOF_LINE); file.getline(line_str, SIZEOF_LINE); file.getline(line_str, SIZEOF_LINE); unsigned int n_child = strto<unsigned int>(line_str, 10); root_ = new TreeNode(NULL, NULL, n_child); for (unsigned int i = 0; i < n_child; ++i) { file.getline(line_str, SIZEOF_LINE); node_num = strto<unsigned long>(line_str, 10); node_name.push(node_num); node_parent_pointer.push(root_); } data = new _DATA(); file >> *data; file.close(); root_->pcontent(data); while (!node_name.empty()) { unsigned long name = node_name.front(); TreeNode* parent = node_parent_pointer.front(); std::snprintf(filename, file_len, "%016lu.node", name); file.open(path); if (!file.is_open()) { std::cerr << "\nFailed opening file: " << path << std::endl; node_name.pop(); node_parent_pointer.pop(); continue; } file.getline(line_str, SIZEOF_LINE); file.getline(line_str, SIZEOF_LINE); file.getline(line_str, SIZEOF_LINE); unsigned int n_child = strto<unsigned int>(line_str, 10); TreeNode* node = new TreeNode(NULL, parent, n_child); parent->attach_child(node); for (unsigned int i = 0; i < n_child; ++i) { file.getline(line_str, SIZEOF_LINE); node_num = strto<unsigned long>(line_str, 10); node_name.push(node_num); node_parent_pointer.push(node); } data = new _DATA(); file >> *data; file.close(); node->pcontent(data); node_name.pop(); node_parent_pointer.pop(); } return *this; }
TreeNode* Parser::Factor() { TreeNode* node; Token rememberedToken = currentToken; switch (currentToken.type) { case tokBraceOpen: matchToken(tokBraceOpen); node = Expression(); matchToken(tokBraceClose); break; case tokUnknown: node = getId(); if (learnedFunctionList.contains(rememberedToken.look) > 0) // is function call { delete node; node = FunctionCall(rememberedToken); node->setType(funcReturnNode); // expect returned value on stack } break; case tokString: node = new TreeNode(currentToken, constantNode); { // extra scope to localize the QString 'str' QString str = currentToken.look; if ( currentToken.look.endsWith("\"") ) { // cut off the quotes and store the value str.remove(0, 1).truncate( currentToken.look.length() - 2 ); } else // problems but we need to keep it moving { str.remove(0, 1); // cut off the first quote only Error(currentToken, i18n("String text not properly delimited with a ' \" ' (double quote)"), 1060); } node->setValue(str); } matchToken(tokString); break; case tokNumber: node = new TreeNode(currentToken, constantNode); node->setValue(currentToken.value); matchToken(tokNumber); break; case tokRun: node = ExternalRun(); break; case tokInputWindow: node = InputWindow(); break; case tokRandom: node = Random(); break; case tokEOL: node = new TreeNode(currentToken, Unknown); break; default: QString s = currentToken.look; if ( s.isEmpty() || currentToken.type == tokEOF ) { Error(currentToken, i18n("INTERNAL ERROR NR %1: please sent this Logo script to KTurtle developers").arg(1), 1020); // if this error occurs the see the Parser::Repeat for the good solution using 'preservedToken' } else { Error(currentToken, i18n("Cannot understand '%1', expected an expression after the '%2' command").arg(s).arg(preservedToken.look), 1020); } node = new TreeNode(currentToken, Unknown); getToken(); break; } return node; }
void AVLTree::Delete(TreeNode * &node, int x, QAnimationGroup *group) { if (node == NULL) return; if (group&& node->parent) group->addAnimation(node->parent->getTurnRedAnim()); TreePath *path; if (group && node->parent) { path = new TreePath(node->parent, node, view); group->addAnimation(path->getToSonAnim()); } TreeNode* parent = node->parent; if (x < node->data) { //如果x小于节点的值,就继续在节点的左子树中删除x Delete(node->Lson, x, group); if (group && node->parent) group->addAnimation(path->getToParentAnim()); if (2 == height(node->Rson) - height(node->Lson)) { if (node->Rson->Lson != NULL && (height(node->Rson->Lson)>height(node->Rson->Rson))) RL(node, group); else RR(node, group); } } else if (x > node->data) { Delete(node->Rson, x, group);//如果x大于节点的值,就继续在节点的右子树中删除x if (group && node->parent) group->addAnimation(path->getToParentAnim()); if (2 == height(node->Lson) - height(node->Rson)) { if (node->Lson->Rson != NULL && (height(node->Lson->Rson)>height(node->Lson->Lson))) LR(node, group); else LL(node, group); } } else//如果相等,此节点就是要删除的节点 { if (group) group->addAnimation(node->getPopAnim()); else node->getPopAnim()->start(QAbstractAnimation::DeleteWhenStopped); if (node->Lson && node->Rson)//此节点有两个儿子 { TreeNode* temp = node->Rson;//temp指向节点的右儿子 while (temp->Lson != NULL) temp = temp->Lson;//找到右子树中值最小的节点 //把右子树中最小节点的值赋值给本节点 if (group) group->addAnimation(node->getValueAnim(temp->data)); else node->data = temp->data; //node->freq = temp->freq; Delete(node->Rson, temp->data, group);//删除右子树中最小值的节点 if (group && node->parent) group->addAnimation(path->getToParentAnim()); if (2 == height(node->Lson) - height(node->Rson)) { if (node->Lson->Rson != NULL && (height(node->Lson->Rson)>height(node->Lson->Lson))) LR(node, group); else LL(node, group); } } else//此节点有1个或0个儿子 { TreeNode* temp = node; TreeNode* parent = node->parent; if (group && node->parent) group->addAnimation(path->getToParentAnim()); if (node->Lson == NULL)//有右儿子或者没有儿子 node = node->Rson; else if (node->Rson == NULL)//有左儿子 node = node->Lson; if (group) { QParallelAnimationGroup *anim = new QParallelAnimationGroup; anim->addAnimation(temp->getFadeOutAnim()); if (node) anim->addAnimation(node->setParent(parent)); group->addAnimation(anim); } else { temp->getFadeOutAnim()->start(QAbstractAnimation::DeleteWhenStopped); if (node) node->setParent(parent)->start(QAbstractAnimation::DeleteWhenStopped); } if (group) group->addAnimation(getPosAnim()); } } if (group && parent) group->addAnimation(parent->getTurnBlackAnim()); if (node == NULL) return; node->h = max(height(node->Lson), height(node->Rson)) + 1; return; }
/* Parse and Translate an Expression */ TreeNode* Parser::Expression() { TreeNode* retExp = Term(); // preset the base-TreeNode as it eventually will be returned TreeNode* pos = retExp; TreeNode* left = NULL; TreeNode* right = NULL; while ( isAddOp(currentToken) ) { left = pos; pos = new TreeNode(currentToken, Unknown); pos->appendChild(left); switch (currentToken.type) { case tokPlus: matchToken(tokPlus); right = Term(); pos->setType(addNode); break; case tokMinus: matchToken(tokMinus); right = Term(); pos->setType(subNode); break; case tokGt: matchToken(tokGt); right = Term(); pos->setType(nodeGT); break; case tokLt: matchToken(tokLt); right = Term(); pos->setType(nodeLT); break; case tokGe: matchToken(tokGe); right = Term(); pos->setType(nodeGE); break; case tokLe: matchToken(tokLe); right = Term(); pos->setType(nodeLE); break; case tokEq: matchToken(tokEq); right = Term(); pos->setType(nodeEQ); break; case tokNe: matchToken(tokNe); right = Term(); pos->setType(nodeNE); break; case tokOr: matchToken(tokOr); right = Term(); pos->setType(orNode); break; default: Error(currentToken, i18n("Expected '*' or '/'"), 1040); getToken(); return pos; break; } if (right != NULL) pos->appendChild(right); retExp = pos; } return retExp; }
void Qtilities::Testing::TestSubjectIterator::testIterationComplex() { TreeNode node; TreeNode* nodeA = node.addNode("A"); TreeNode* nodeB = node.addNode("B"); nodeA->addItem("1"); TreeItem* shared_item = nodeA->addItem("2"); nodeA->addItem("3"); nodeB->addItem("4"); nodeB->addItem("5"); nodeB->attachSubject(shared_item); nodeB->addItem("6"); // If we want to iterate through the subjects in nodeA: SubjectIterator<QObject> itrA(nodeA,SubjectIterator<QObject>::IterateChildren); QVERIFY(itrA.current() != 0); // In this case item1 will be skipped: QStringList testListA; testListA << itrA.current()->objectName(); while (itrA.hasNext()) { testListA << itrA.next()->objectName(); } QCOMPARE(testListA.count(), 3); QCOMPARE(testListA.at(0), QString("1")); QCOMPARE(testListA.at(1), QString("2")); QCOMPARE(testListA.at(2), QString("3")); // If we want to iterate through the subjects in nodeB: SubjectIterator<QObject> itrB(nodeB,SubjectIterator<QObject>::IterateChildren); // In this case item1 will be skipped: QStringList testListB; testListB << itrB.current()->objectName(); while (itrB.hasNext()) { testListB << itrB.next()->objectName(); } QCOMPARE(testListB.count(), 4); QCOMPARE(testListB.at(0), QString("4")); QCOMPARE(testListB.at(1), QString("5")); QCOMPARE(testListB.at(2), QString("2")); QCOMPARE(testListB.at(3), QString("6")); // If we want to iterate through the subjects in nodeB: SubjectIterator<QObject> itrC(shared_item,nodeB); // In this case item1 will be skipped: QStringList testListC; testListC << itrC.current()->objectName(); while (itrC.hasNext()) { testListC << itrC.next()->objectName(); } QCOMPARE(testListC.count(), 2); QCOMPARE(testListC.at(0), QString("2")); QCOMPARE(testListC.at(1), QString("6")); // If we want to iterate through the subjects in nodeB: SubjectIterator<QObject> itrD(shared_item,nodeA); // In this case item1 will be skipped: QStringList testListD; testListD << itrD.current()->objectName(); while (itrD.hasNext()) { testListD << itrD.next()->objectName(); } QCOMPARE(testListD.count(), 2); QCOMPARE(testListD.at(0), QString("2")); QCOMPARE(testListD.at(1), QString("3")); }
void output_standard_tag(Context& ctx, std::string *out, const TreeNode& tag) { if (!tag.mbIsText && tag.mName == "pre") ++ctx.pre_count; if (out && (tag.mbIsControl || !tag.mbIsText)) { if (ctx.holding_space && ctx.cdata_count) { if (!ctx.eat_next_space) { *out += ' '; } ctx.eat_next_space = false; ctx.holding_space = false; } } if (!ctx.construction_stack.empty()) { TreeNode *new_tag = ctx.mpDocument->AllocNode(); new_tag->mpLocation = tag.mpLocation; new_tag->mLineno = tag.mLineno; new_tag->mName = tag.mName; new_tag->mAttribs = tag.mAttribs; new_tag->mbIsText = tag.mbIsText; new_tag->mbIsControl = tag.mbIsControl; ctx.construction_stack.back()->mChildren.push_back(new_tag); ctx.construction_stack.push_back(new_tag); output_tag_contents(ctx, out, tag); ctx.construction_stack.pop_back(); } else if (tag.mbIsText) { if (out) { if (tag.mbIsControl) { *out += tag.mName; } else if (ctx.cdata_count) { if (ctx.pre_count) { *out += tag.mName; } else { std::string::const_iterator it(tag.mName.begin()), itEnd(tag.mName.end()); for(; it!=itEnd; ++it) { const char c = *it; if (isspace(c)) { ctx.holding_space = true; } else { if (ctx.eat_next_space) ctx.eat_next_space = false; else if (ctx.holding_space) *out += ' '; ctx.holding_space = false; *out += c; } } } } else { std::string::const_iterator it(tag.mName.begin()), itEnd(tag.mName.end()); for(; it!=itEnd; ++it) { const char c = *it; if (!isspace(c)) error(ctx, "inline text not allowed"); } } } } else { bool cdata = tag.SupportsCDATA(); if (cdata) { if (!ctx.cdata_count) { ctx.holding_space = false; ctx.eat_next_space = true; } ++ctx.cdata_count; } if (!out) { output_tag_contents(ctx, out, tag); } else if (tag.mChildren.empty()) { *out += '<'; *out += tag.mName; output_tag_attributes(*out, tag); *out += '>'; } else { *out += '<'; *out += tag.mName; output_tag_attributes(*out, tag); *out += '>'; output_tag_contents(ctx, out, tag); *out += "</"; *out += tag.mName; *out += '>'; } if (cdata) --ctx.cdata_count; } if (!tag.mbIsText && tag.mName == "pre") --ctx.pre_count; }
bool Monitor::NodeGenerator::isNodeValid(TreeNode *t, QString &text) { bool ret = false; // draw this node ? if (t != root_ && t->width() >= 2) { if (!honorDisplayFlag_ || (honorDisplayFlag_ && t->display())) { std::string key = t->column(0).toString().toLocal8Bit().constData(); std::string val = t->column(1).toString().toLocal8Bit().constData(); // host and process nodes // TODO: this is terribly ugly if ( (key == "Host" && !nodeOpt_.ignoreHosts()) || (key == "Process" && !nodeOpt_.ignoreProcs()) || (key == "DomainParticipant") || (key == "Publisher" && !nodeOpt_.ignorePubs()) || (key == "Subscriber" && !nodeOpt_.ignoreSubs()) || (key == "Topic" && !nodeOpt_.hideTopics()) || (key == "Transport" && !nodeOpt_.ignoreTransports()) || (key == "Reader" || key == "Writer") || (key == "Qos" && !nodeOpt_.ignoreQos()) ) { ret = true; // check for ignoreBuiltInTopics if (key == "Topic" && !nodeOpt_.hideTopics() && nodeOpt_.ignoreBuiltinTopics()) { ret = false; std::string tmp; TreeNode* c; for (int i = 0; i < t->size(); ++i) { c = t->operator[](i); tmp = c->column(0).toString().toLocal8Bit().constData(); if (tmp == "Topic Name") { tmp = c->column(1).toString().toLocal8Bit().constData(); if(tmp.substr(0, 4) != "DCPS") { ret = true; } } } } if (ret) { // yes, draw this node! if (nodeOpt_.abbrGUIDs()) { val = abbr(val); } text = key.c_str(); text += "\n"; text += val.c_str(); } } } } return ret; }
void output_special_tag(Context& ctx, std::string *out, const TreeNode& tag) { if (tag.mName == "lina:fireball") { const TreeAttribute *a1 = tag.Attrib("src"); const TreeAttribute *a2 = tag.Attrib("dst"); if (!a1 || !a2) error(ctx, "<lina:fireball> requires SRC and DST attributes"); g_fileCopies[a2->mValue] = a1->mValue; } else if (tag.mName == "lina:write") { const TreeAttribute *a = tag.Attrib("file"); if (!a) error(ctx, "<lina:write> must specify FILE"); std::string s; std::list<TreeNode *> tempStack; ctx.construction_stack.swap(tempStack); int cdataCount = ctx.cdata_count; int preCount = ctx.pre_count; ctx.cdata_count = 0; ctx.pre_count = 0; bool bHoldingSpace = ctx.holding_space; bool bEatNextSpace = ctx.eat_next_space; ctx.holding_space = false; ctx.eat_next_space = true; output_tag_contents(ctx, &s, tag); ctx.holding_space = bHoldingSpace; ctx.eat_next_space = bEatNextSpace; ctx.pre_count = cdataCount; ctx.cdata_count = preCount; ctx.construction_stack.swap(tempStack); std::string filename(create_output_filename(a->mValue)); FILE *f = fopen(filename.c_str(), "wb"); if (!f) error(ctx, "couldn't create \"%s\"", a->mValue.c_str()); fwrite(s.data(), s.length(), 1, f); fclose(f); printf("created file: %s\n", a->mValue.c_str()); } else if (tag.mName == "lina:body") { // printf("outputting:\n"); // dump_parse_tree(*ctx.invocation_stack.back(), 4); output_tag_contents(ctx, out, *ctx.invocation_stack.back()); } else if (tag.mName == "lina:tag") { const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:tag> must have NAME attribute"); ctx.construction_stack.push_back(ctx.mpDocument->AllocNode()); TreeNode *new_tag = ctx.construction_stack.back(); new_tag->mpLocation = tag.mpLocation; new_tag->mLineno = tag.mLineno; new_tag->mName = a->mValue; new_tag->mbIsText = false; new_tag->mbIsControl = false; // compatibility if (!new_tag->mName.compare(0, 2, "w:")) new_tag->mName.replace(0, 2, "lina:"); output_tag_contents(ctx, NULL, tag); ctx.construction_stack.pop_back(); output_tag(ctx, out, *new_tag); } else if (tag.mName == "lina:arg") { if (!out && ctx.construction_stack.empty()) error(ctx, "<lina:arg> can only be used in an output context"); const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:arg> must have NAME attribute"); if (ctx.invocation_stack.empty()) error(ctx, "<lina:arg> can only be used during macro expansion"); std::list<const TreeNode *>::const_iterator it(ctx.invocation_stack.end()); --it; int levels = 1; const char *name = a->mValue.c_str(); while(*name == '^') { ++levels; ++name; if (it == ctx.invocation_stack.begin()) error(ctx, "Number of up-scope markers in name exceeds macro nesting level"); --it; } const TreeNode& macrotag = **it; const TreeAttribute *a2 = macrotag.Attrib(name); if (!a2) error(ctx, "macro invocation <%s> does not have an attribute \"%s\"", macrotag.mName.c_str(), name); if (out) { *out += a2->mValue; ctx.eat_next_space = false; ctx.holding_space = false; } else { TreeNode *t = ctx.mpDocument->AllocNode(); t->mpLocation = tag.mpLocation; t->mLineno = tag.mLineno; t->mbIsControl = false; t->mbIsText = true; t->mName = a2->mValue; ctx.construction_stack.back()->mChildren.push_back(t); } } else if (tag.mName == "lina:if-arg") { const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:if-arg> must have NAME attribute"); if (ctx.invocation_stack.empty()) error(ctx, "<lina:if-arg> can only be used during macro expansion"); const TreeNode& macrotag = *ctx.invocation_stack.back(); const TreeAttribute *a2 = macrotag.Attrib(a->mValue); if (a2) output_tag_contents(ctx, out, tag); } else if (tag.mName == "lina:if-not-arg") { const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:if-not-arg> must have NAME attribute"); if (ctx.invocation_stack.empty()) error(ctx, "<lina:if-not-arg> can only be used during macro expansion"); const TreeNode& macrotag = *ctx.invocation_stack.back(); const TreeAttribute *a2 = macrotag.Attrib(a->mValue); if (!a2) output_tag_contents(ctx, out, tag); } else if (tag.mName == "lina:attrib") { if (ctx.construction_stack.empty()) error(ctx, "<lina:attrib> can only be used in a <lina:tag> element"); const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:attrib> must have NAME attribute"); std::string s; std::list<TreeNode *> tempStack; ctx.construction_stack.swap(tempStack); ++ctx.cdata_count; ++ctx.pre_count; bool bHoldingSpace = ctx.holding_space; bool bEatNextSpace = ctx.eat_next_space; ctx.holding_space = false; ctx.eat_next_space = true; output_tag_contents(ctx, &s, tag); ctx.holding_space = bHoldingSpace; ctx.eat_next_space = bEatNextSpace; --ctx.pre_count; --ctx.cdata_count; ctx.construction_stack.swap(tempStack); TreeNode *t = ctx.construction_stack.back(); TreeAttribute new_att; if (tag.Attrib("novalue")) { new_att.mbNoValue = true; } else { new_att.mbNoValue = false; new_att.mValue = s; } new_att.mName = a->mValue; t->mAttribs.push_back(new_att); } else if (tag.mName == "lina:pull") { if (ctx.invocation_stack.empty()) error(ctx, "<lina:pull> can only be used during macro expansion"); const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:pull> must have NAME attribute"); const TreeNode *t = ctx.find_tag(a->mValue); if (!t) error(ctx, "cannot find tag <%s> referenced in <lina:pull>", a->mValue.c_str()); output_tag_contents(ctx, out, *t); } else if (tag.mName == "lina:for-each") { const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:for-each> must have NAME attribute"); std::string node_name; const TreeNode *parent; if (ctx.invocation_stack.empty()) { if (!a->mValue.empty() && a->mValue[0] == '/') parent = ctx.mpDocument->mpRoot->ResolvePath(a->mValue.substr(1), node_name); else error(ctx, "path must be absolute if not in macro context"); } else { std::list<const TreeNode *>::reverse_iterator it(ctx.invocation_stack.rbegin()), itEnd(ctx.invocation_stack.rend()); for(; it!=itEnd; ++it) { parent = (*it)->ResolvePath(a->mValue, node_name); if(parent) break; if (!a->mValue.empty() && a->mValue[0] == '/') break; } } if (!parent) error(ctx, "cannot resolve path \"%s\"", a->mValue.c_str()); std::list<TreeNode *>::const_iterator it2(parent->mChildren.begin()), it2End(parent->mChildren.end()); ctx.invocation_stack.push_back(NULL); for(; it2!=it2End; ++it2) { if ((*it2)->mName == node_name) { ctx.invocation_stack.back() = *it2; output_tag_contents(ctx, out, tag); } } ctx.invocation_stack.pop_back(); } else if (tag.mName == "lina:apply") { const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:apply> must have NAME attribute"); std::map<std::string, TreeNode *>::const_iterator it(ctx.mpDocument->mMacros.find(a->mValue)); if (it == ctx.mpDocument->mMacros.end()) error(ctx, "macro \"%s\" undeclared", a->mValue.c_str()); std::list<TreeNode *>::const_iterator it2(tag.mChildren.begin()), it2End(tag.mChildren.end()); ctx.invocation_stack.push_back(NULL); for(; it2!=it2End; ++it2) { if (!(*it2)->mbIsText) { ctx.invocation_stack.back() = *it2; output_tag_contents(ctx, out, *(*it).second); } } ctx.invocation_stack.pop_back(); } else if (tag.mName == "lina:if-present") { if (ctx.invocation_stack.empty()) error(ctx, "<lina:if-present> can only be used during macro expansion"); const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:if-present> must have NAME attribute"); const TreeNode *t = ctx.find_tag(a->mValue); if (t) output_tag_contents(ctx, out, tag); } else if (tag.mName == "lina:if-not-present") { if (ctx.invocation_stack.empty()) error(ctx, "<lina:if-not-present> can only be used during macro expansion"); const TreeAttribute *a = tag.Attrib("name"); if (!a) error(ctx, "<lina:if-not-present> must have NAME attribute"); const TreeNode *t = ctx.find_tag(a->mValue); if (!t) output_tag_contents(ctx, out, tag); } else if (tag.mName == "lina:pre") { ++ctx.pre_count; ++ctx.cdata_count; if (!out) output_standard_tag(ctx, out, tag); else { output_tag_contents(ctx, out, tag); } --ctx.cdata_count; --ctx.pre_count; } else if (tag.mName == "lina:cdata") { ++ctx.cdata_count; if (!out) output_standard_tag(ctx, out, tag); else output_tag_contents(ctx, out, tag); --ctx.cdata_count; } else if (tag.mName == "lina:delay") { std::list<TreeNode *>::const_iterator it(tag.mChildren.begin()), itEnd(tag.mChildren.end()); for(; it!=itEnd; ++it) { output_standard_tag(ctx, out, **it); } } else if (tag.mName == "lina:dump-stack") { dump_stack(ctx); } else if (tag.mName == "lina:replace") { const TreeAttribute *a = tag.Attrib("from"); if (!a || a->mbNoValue) error(ctx, "<lina:replace> must have FROM attribute"); const TreeAttribute *a2 = tag.Attrib("to"); if (!a2 || a2->mbNoValue) error(ctx, "<lina:replace> must have TO attribute"); const std::string& x = a->mValue; const std::string& y = a2->mValue; std::string s, t; std::string::size_type i = 0; output_tag_contents(ctx, &s, tag); for(;;) { std::string::size_type j = s.find(x, i); if (j != i) t.append(s, i, j-i); if (j == std::string::npos) break; t.append(y); i = j + x.size(); } TreeNode *new_tag = ctx.mpDocument->AllocNode(); new_tag->mpLocation = tag.mpLocation; new_tag->mLineno = tag.mLineno; new_tag->mbIsText = true; new_tag->mbIsControl = false; new_tag->mName = t; output_tag(ctx, out, *new_tag); } else if (tag.mName == "lina:set-option") { const TreeAttribute *a_name = tag.Attrib("name"); if (!a_name) error(ctx, "<lina:set-option> must have NAME attribute"); if (a_name->mValue == "link-truncate") { const TreeAttribute *a_val = tag.Attrib("baseurl"); if (!a_val || a_val->mbNoValue) error(ctx, "option \"link-truncate\" requires BASEURL attribute"); bool bTruncate = !tag.Attrib("notruncate"); g_truncateURLs.push_back(std::make_pair(a_val->mValue, bTruncate)); } else if (a_name->mValue == "output-dir") { const TreeAttribute *a_val = tag.Attrib("target"); if (!a_val || a_val->mbNoValue) error(ctx, "option \"output-dir\" requires TARGET attribute"); g_outputDir = a_val->mValue; } else if (a_name->mValue == "tag-info") { const TreeAttribute *a_tagname = tag.Attrib("tag"); if (!a_tagname || a_tagname->mbNoValue) error(ctx, "option \"tag-info\" requires TAG attribute"); const TreeAttribute *a_cdata = tag.Attrib("cdata"); if (!a_cdata || a_cdata->mbNoValue) error(ctx, "option \"tag-info\" requires CDATA attribute"); TreeNode::SetSupportsCDATA(a_tagname->mValue, is_true(a_cdata->mValue)); } else error(ctx, "option \"%s\" unknown\n", a_name->mValue.c_str()); } else if (tag.mName == "lina:data") { // do nothing } else if (tag.mName == "lina:source") { if (out) { std::list<TreeNode *>::const_iterator itBegin(tag.mChildren.begin()), it(itBegin), itEnd(tag.mChildren.end()); for(; it!=itEnd; ++it) { output_source_tags(ctx, out, **it); } } } else if (tag.mName == "lina:htmlhelp-toc") { const TreeAttribute *a_val = tag.Attrib("file"); if (!a_val || a_val->mbNoValue) error(ctx, "<lina:htmlhelp-toc> requires FILE attribute"); const std::string filename(create_output_filename(a_val->mValue)); // build new tag with TOC contents ctx.construction_stack.push_back(ctx.mpDocument->AllocNode()); TreeNode *new_tag = ctx.construction_stack.back(); new_tag->mpLocation = tag.mpLocation; new_tag->mLineno = tag.mLineno; new_tag->mName = a_val->mValue; new_tag->mbIsText = false; new_tag->mbIsControl = false; output_tag_contents(ctx, NULL, tag); ctx.construction_stack.pop_back(); output_tag(ctx, out, *new_tag); FILE *f = fopen(filename.c_str(), "wb"); if (!f) error(ctx, "couldn't create htmlhelp toc \"%s\"", a_val->mValue.c_str()); output_toc(f, *new_tag); fclose(f); } else if (tag.mName == "lina:htmlhelp-project") { const TreeAttribute *file_val = tag.Attrib("file"); if (!file_val || file_val->mbNoValue) error(ctx, "<lina:htmlhelp-project> requires FILE attribute"); const TreeAttribute *output_val = tag.Attrib("output"); if (!output_val || output_val->mbNoValue) error(ctx, "<lina:htmlhelp-project> requires OUTPUT attribute"); const TreeAttribute *toc_val = tag.Attrib("toc"); if (!toc_val || toc_val->mbNoValue) error(ctx, "<lina:htmlhelp-project> requires TOC attribute"); const TreeAttribute *title_val = tag.Attrib("title"); if (!title_val || title_val->mbNoValue) error(ctx, "<lina:htmlhelp-project> requires TITLE attribute"); const std::string filename(create_output_filename(file_val->mValue)); FILE *f = fopen(filename.c_str(), "wb"); if (!f) error(ctx, "couldn't create htmlhelp project \"%s\"", file_val->mValue.c_str()); fprintf(f, "[OPTIONS]\n" "Auto Index=Yes\n" "Compatibility=1.1 or later\n" "Compiled file=%s\n" "Contents file=%s\n" "Default topic=index.html\n" "Display compile progress=no\n" "Full-text search=Yes\n" , output_val->mValue.c_str() , toc_val->mValue.c_str() ); const TreeAttribute *fullstop_val = tag.Attrib("fullstop"); if (fullstop_val && !fullstop_val->mbNoValue) fprintf(f, "Full text search stop list file=%s\n", fullstop_val->mValue.c_str()); fprintf(f, "Language=0x0409 English (United States)\n" "Title=%s\n" "\n" "[FILES]\n" , title_val->mValue.c_str() ); std::list<std::string>::const_iterator it(g_htmlHelpFiles.begin()), itEnd(g_htmlHelpFiles.end()); for(; it!=itEnd; ++it) { fprintf(f, "%s\n", (*it).c_str()); } fclose(f); } else if (tag.mName == "lina:htmlhelp-addfile") { const TreeAttribute *file_val = tag.Attrib("file"); if (!file_val || file_val->mbNoValue) error(ctx, "<lina:htmlhelp-addfile> requires FILE attribute"); g_htmlHelpFiles.push_back(file_val->mValue); } else { std::string macroName(tag.mName, 5, std::string::npos); std::map<std::string, TreeNode *>::const_iterator it = ctx.mpDocument->mMacros.find(macroName); if (it == ctx.mpDocument->mMacros.end()) error(ctx, "macro <lina:%s> not found", macroName.c_str()); // dump_stack(ctx); // printf("executing macro: %s (%s:%d)\n", tag.mName.c_str(), tag.mLocation->name.c_str(), tag.mLineno); ctx.invocation_stack.push_back(&tag); output_tag_contents(ctx, out, *(*it).second); ctx.invocation_stack.pop_back(); // printf("exiting macro: %s (%s:%d)\n", tag.mName.c_str(), tag.mLocation->name.c_str(), tag.mLineno); } }
static TreeNode* createRandomTree( const GlobalContext* ctx, const strus::utils::Document& doc, std::size_t& docitr, unsigned int depth=0) { TreeNode* rt = 0; if (RANDINT( 1,5-depth) == 1) { if (docitr >= doc.itemar.size()) return 0; rt = new TreeNode( termId( strus::utils::Token, doc.itemar[ docitr].termid)); } else { unsigned int argc = ctx->randomArgc(); unsigned int range = argc + ctx->randomRange(); unsigned int cardinality = 0; //... it seems currently too difficult to handle other than the default cardinality in this test TreeNode::JoinOperation op = ctx->randomOp(); std::vector<TreeNode*> args; unsigned int rangesum = 0; unsigned int ai; for (ai=0; docitr < doc.itemar.size() && ai<argc; ++ai,++docitr) { TreeNode* arg = createRandomTree( ctx, doc, docitr, depth+1); if (arg == 0) { TreeNode::deleteTreeAr( args); return 0; } args.push_back( arg); rangesum += arg->range(); } if (argc == 1 && (op == strus::PatternMatcherInstanceInterface::OpSequenceStruct || op == strus::PatternMatcherInstanceInterface::OpWithinStruct) && args[0]->term() == termId( strus::utils::SentenceDelim, 0)) { // ... add another node for a sequence of size 1, if we have a sequence of length 1 with a delimiter element only (prevent anomaly) TreeNode* arg = createRandomTree( ctx, doc, docitr, depth+1); if (arg == 0) { TreeNode::deleteTreeAr( args); return 0; } args.push_back( arg); rangesum += arg->range(); } range += rangesum; if (ai < argc) { TreeNode::deleteTreeAr( args); return 0; } switch (op) { case strus::PatternMatcherInstanceInterface::OpSequence: case strus::PatternMatcherInstanceInterface::OpSequenceImm: { break; } case strus::PatternMatcherInstanceInterface::OpSequenceStruct: { TreeNode* delim = new TreeNode( termId( strus::utils::SentenceDelim, 0)); args.insert( args.begin(), delim); ++argc; break; } case strus::PatternMatcherInstanceInterface::OpWithin: { for (int ii=0; ii<3; ii++) { unsigned int r1 = RANDINT(0,argc); unsigned int r2 = RANDINT(0,argc); if (r1 != r2) std::swap( args[r1], args[r2]); } break; } case strus::PatternMatcherInstanceInterface::OpWithinStruct: { for (int ii=0; ii<3; ii++) { unsigned int r1 = RANDINT(0,argc); unsigned int r2 = RANDINT(0,argc); if (r1 != r2) std::swap( args[r1], args[r2]); } TreeNode* delim = new TreeNode( termId( strus::utils::SentenceDelim, 0)); args.insert( args.begin(), delim); ++argc; break; } case strus::PatternMatcherInstanceInterface::OpAny: cardinality = 0; break; case strus::PatternMatcherInstanceInterface::OpAnd: throw std::runtime_error( "operator 'And' not implemented yet"); } rt = new TreeNode( op, args, range, cardinality); } if (RANDINT(1,10) == 1) { rt->attachVariable( RANDINT(1,10)); } return rt; }
bool insertBody(Body body) { //cout << "IN INSERT" << endl; int quad = getQuadrantOfBody(body); if (getState() == INTERNAL) { if (quad == 1) { // cout << "going to quad 1" << endl; return _NW->insertBody(body); } else if (quad == 2) { // cout << "going to quad 2" << endl; return _NE->insertBody(body); } else if (quad == 3) { // cout << "going to quad 3" << endl; return _SW->insertBody(body); } else if (quad == 4) { // cout << "going to quad 4" << endl; return _SE->insertBody(body); } else { // cout << "Invalid quadrant!" << endl; return false; } } else { if (_body == NULL){ _body = new Body(body); } else { quad = _parent->getQuadrantOfBody(body); if (quad == 1) { // cout << "inserting in quad 1" << endl; TreeNode* toDelete = _parent->_NW; _parent->_NW = new TreeNode(_box, INTERNAL); _parent->_NW->setParent(_parent); _parent->_NW->insertBody(*_body); _parent->_NW->insertBody(body); delete toDelete; return true; } else if (quad == 2) { // cout << "inserting in quad 2" << endl; TreeNode* toDelete = _parent->_NE; _parent->_NE = new TreeNode(_box, INTERNAL); _parent->_NE->setParent(_parent); _parent->_NE->insertBody(*_body); _parent->_NE->insertBody(body); delete toDelete; return true; } else if (quad == 3) { // cout << "inserting in quad 3" << endl; TreeNode* toDelete = _parent->_SW; _parent->_SW = new TreeNode(_box, INTERNAL); _parent->_SW->setParent(_parent); _parent->_SW->insertBody(*_body); _parent->_SW->insertBody(body); delete toDelete; return true; } else if (quad == 4) { // cout << "inserting in quad 4" << endl; TreeNode* toDelete = _parent->_SE; _parent->_SE = new TreeNode(_box, INTERNAL); _parent->_SE->setParent(_parent); _parent->_SE->insertBody(*_body); _parent->_SE->insertBody(body); delete toDelete; return true; } else { // cout << "Invalid quadrant!" << endl; return false; } } } // updateCenterOfMass(body); // cout << "LEAVING INSERT" << endl; }
int main( int argc, char* argv[] ) { using namespace ds; Tree tree; ds::TextReader textReader("D:\\cpp_practise\\test_cases\\tree_test.txt"); textReader(); //populating linkedList std::vector<std::string> strVec = textReader.strVec(); for (std::vector<std::string>::iterator strIt = strVec.begin(); strIt != strVec.end(); ++strIt) { tree.insert(*strIt); } //testing iterative search function bool found_1 = tree.search("one") != NULL; //testing recursive search function bool found_2 = tree.search(tree.root(),"these"); //in-order traversal LinkedList inOrderList; tree.inOrderTraversal(tree.root(), inOrderList); std::cout << "\n in-order traversal: \n"; Node* curNode = inOrderList.head(); while(curNode) { std::cout << curNode->item() << " "; curNode = curNode->next(); } std::cout << std::endl; //END of in-order traversal TreeNode* successorNode = tree.successor(tree.search("is")); std::cout << "successor node: "; if (successorNode) { std::cout << successorNode->item() << std::endl; } tree.remove(tree.search("was")); //test case: deleting an element which doesn't exist in the tree //test case: node to be deleted has only left child //e.g. node to be deleted: "used", node to be tested: "that" //test case: node to be deleted has both child. node's successor is its right child. //e.g. node to be deleted: "one", node to be tested: "that" //test case: node to be deleted has both child. node's successor is its right child's descendant. //e.g. node to be deleted: "introduces", node to be tested: "further" "is" tree.remove(tree.search("introduces")); TreeNode* testNode0 = tree.search("is"); std::cout << "parent: "; if (testNode0->parent()) { std::cout << (testNode0->parent())->item(); } std::cout << std::endl; std::cout << "left child: "; if (testNode0->left()) { std::cout << (testNode0->left())->item(); std::cout << " :: left child's parent: "; if ((testNode0->left())->parent()) { std::cout << ((testNode0->left())->parent())->item(); } } std::cout << std::endl; if (testNode0->right()) { std::cout << "right child: " << (testNode0->right())->item(); std::cout << " :: right child's parent: "; if ((testNode0->right())->parent()) { std::cout << ((testNode0->right())->parent())->item(); } } std::cout << std::endl; //testing char to int conversion //int gh = '\r'; return 0; }
void insertBody(Body body) { root->insertBody(body); double dummy; Vec2D dummy2; root->updateCenterOfMass(dummy, dummy2); }
double TreeDustGridStructure::density(int h, int m) const { TreeNode* node = getnode(m); return _dmib->massInBox(h, node->extent()) / node->volume(); }
Monitor::TreeNode* Monitor::MonitorDataStorage::getNode( const std::string& label, const OpenDDS::DCPS::GUID_t& parentId, const OpenDDS::DCPS::GUID_t& id, bool& create ) { TreeNode* node = 0; GuidToTreeMap::iterator location = this->guidToTreeMap_.find( id); if( location == this->guidToTreeMap_.end()) { // We are done if not creating a new node. if( !create) return 0; // We need to add a new DomainParticipant. // Find the parent node, if any. It is ok to not have a parent node // for cases of out-of-order udpates. We handle that as the updates // are actually processed. TreeNode* parent = 0; GuidToTreeMap::iterator parentLocation = this->guidToTreeMap_.find( parentId); if( parentLocation != this->guidToTreeMap_.end()) { parent = parentLocation->second.second; } // Node data. OpenDDS::DCPS::GuidConverter converter( id); QList<QVariant> list; list << QString( QObject::tr( label.c_str())) << QString( QObject::tr( std::string( converter).c_str())); node = new TreeNode( list, parent); if( parent) { parent->append( node); } // Install the new node. this->guidToTreeMap_[ id] = std::make_pair( node->row(), node); } else { node = location->second.second; create = false; } // If there have been some out-of-order reports, we may have been // created without a parent node. We can now fill in that information // if we can. If we created the node, we already know it has a // parent so this will be bypassed. if( !node->parent()) { // Need to search for the parent. TreeNode* parent = 0; GuidToTreeMap::iterator parentLocation = this->guidToTreeMap_.find( parentId); if( parentLocation != this->guidToTreeMap_.end()) { parent = parentLocation->second.second; } // And install anything that is found. node->parent() = parent; } return node; }