bool ChartElemNavaids::addIntersection(const Intersection& intersection, QDomElement& element, QDomDocument& dom_doc, QString& err_msg) { QString leaf_id = getLeafID(intersection); // check for double entries if (containsLeaf(leaf_id)) { err_msg = QString("Double Intersection entry detected: (%1)").arg(intersection.getId()); return false; } // process the INTERSECTION ChartElemIntersection* chart_elem_intersection = new ChartElemIntersection(this, m_chart_model, intersection); MYASSERT(chart_elem_intersection); if (!chart_elem_intersection->loadFromDomElement(element, dom_doc, err_msg)) { delete chart_elem_intersection; return false; } addLeaf(leaf_id, chart_elem_intersection); return true; }
Tree * addLeaf(Tree * t, pid_t pid, int proc) { if (NULL == t) { t = treealloc(); t->pid = pid; t->proc = proc; t->left = NULL; t->right = NULL; } else if (proc < t->proc) { t->left = addLeaf(t->left, pid, proc); } else if (proc > t->proc) { t->right = addLeaf(t->right, pid, proc); } return t; }
bool ChartElemNavaids::addAirport(const Airport& airport, QDomElement& element, QDomDocument& dom_doc, QString& err_msg) { QString leaf_id = getLeafID(airport); // check for double entries if (containsLeaf(leaf_id)) { err_msg = QString("Double Aiport entry detected: (%1)").arg(airport.getId()); return false; } // process the AIRPORT ChartElemAirport* chart_elem_airport = new ChartElemAirport(this, m_chart_model, airport); MYASSERT(chart_elem_airport); if (!chart_elem_airport->loadFromDomElement(element, dom_doc, err_msg)) { delete chart_elem_airport; return false; } addLeaf(leaf_id, chart_elem_airport); return true; }
bool ChartElemNavaids::addNdb(const Ndb& ndb, QDomElement& element, QDomDocument& dom_doc, QString& err_msg) { QString leaf_id = getLeafID(ndb); // check for double entries if (containsLeaf(leaf_id)) { err_msg = QString("Double NDB entry detected: (%1)").arg(ndb.getId()); return false; } // process the NDB ChartElemNdb* chart_elem_ndb = new ChartElemNdb(this, m_chart_model, ndb); MYASSERT(chart_elem_ndb != 0); if (!chart_elem_ndb->loadFromDomElement(element, dom_doc, err_msg)) { delete chart_elem_ndb; return false; } addLeaf(leaf_id, chart_elem_ndb); return true; }
bool ChartElemNavaids::addVor(const Vor& vor, QDomElement& element, QDomDocument& dom_doc, QString& err_msg) { QString leaf_id = getLeafID(vor); // check for double entries if (containsLeaf(leaf_id)) { err_msg = QString("Double VOR entry detected: (%1)").arg(vor.getId()); return false; } // process the VOR ChartElemVor *chart_elem_vor = new ChartElemVor(this, m_chart_model, vor); MYASSERT(chart_elem_vor != 0); if (!chart_elem_vor->loadFromDomElement(element, dom_doc, err_msg)) { delete chart_elem_vor; return false; } addLeaf(leaf_id, chart_elem_vor); return true; }
void KTREE::insert (TNode* node,int ch) { TNode* tmp; //insert to tree point=top; if (top==0) { top=new TNode(); top->setElement(node->getElement()); top->setParent(0); for (int i=0;i<MAX;i++) top->setChild(node->getChild(i),i); point=top; } else { while (point!=0) { tmp=point; point=point->getChild(ch); } point=tmp; addLeaf(node,ch); } }
heap* getData(char *file){ FILE* input_file = fopen(file,"r"); if(input_file == NULL){ printf("Error opening input file %s\n",file); exit(1); } float inputx = 0.0; float inputy = 0.0; heap *newheap = createHeap(); int i = 0; while(fscanf(input_file, "%f", &inputx) != EOF){ fscanf(input_file, "%f", &inputy); data *d= createData(inputx,inputy); d->distance = calculateDistance(d->valx,d->valy); if(i>9){ if(d->distance < newheap->root->d->distance){ leaf *removeleaf = removeRoot(newheap); #if DEBUG printf("deleted : %f and inserted : %f -- \n",removeleaf->d->distance,d->distance); #endif popBack(newheap->q->ll); free(removeleaf->d); free(removeleaf); addLeaf(newheap,d); } else { #if DEBUG printf("Skipped : %f => ",d->distance); printf("deleting ...... \n"); #endif free(d); } } else { #if DEBUG printf("inserted : %f -- \n",d->distance); #endif addLeaf(newheap,d); } i++; } fclose(input_file); return newheap; }
void addLeaf(Node &node, Leafs &leafs) { if (node.childs.empty()) { leafs.push_back(&node); return; } for (auto &ch: node.childs) addLeaf(*ch, leafs); }
Tree * mkTree(int depth, pid_t parent) { int i = 2, count = 1 << depth; Tree * t = addLeaf(NULL, parent, 1); for (; i < count; ++i) { if (getpid() == parent) { pid_t child = fork(); if (0 == child) { continue; } else if (-1 == child) { _Exit(printChildError()); } else { t = addLeaf(t, child, i); } } } return t; }
void addLeaf(Sprig* thisSprig, int key, int caliper){ Leaf* thisLeaf = thisSprig->firstLeaf; if (thisLeaf == NULL) { thisLeaf = (Leaf*)malloc(sizeof(Leaf)); createLeaf(thisLeaf, key, NULL, NULL, thisSprig); thisSprig->firstLeaf = thisLeaf; return; } int count = caliper; while(thisLeaf->key < key) { if (thisLeaf->nextLeaf != NULL) { thisLeaf = thisLeaf->nextLeaf; } else if (count == 2) { //reached end of sprig, keys still smaller. if (thisLeaf->childSprig == NULL) { //split and promote, because no far right sprig available splitPromote(thisLeaf, thisSprig, key, caliper); } //add this key to far right sprig because it exists addLeaf(thisLeaf->childSprig, key, caliper); } else { //there is room in this sprig for a new leaf Leaf* newLeaf = (Leaf*)malloc(sizeof(Leaf)); createLeaf(newLeaf, key, thisLeaf, NULL, thisSprig); thisLeaf->nextLeaf = newLeaf; return; } count--; } //ran into a key too big //try to fit in same sprig if (numLeaves(thisSprig) < caliper - 1) { int tempKey = thisLeaf->key; thisLeaf->key = key; Leaf* newLeaf = (Leaf*)malloc(sizeof(Leaf)); createLeaf(newLeaf, tempKey, thisLeaf, NULL, thisSprig); if (thisLeaf->nextLeaf != NULL) { thisLeaf->nextLeaf->prevLeaf = newLeaf; newLeaf->nextLeaf = thisLeaf->nextLeaf; } thisLeaf->nextLeaf = newLeaf; } //sprig is too full, else { splitPromote(thisLeaf, thisSprig, key, caliper); } return; }
void printHeap(heap *h){ data **listCor = (data**)malloc(sizeof(data*)*10); int i = 0; while(h->root){ if(i>9){ popBack(h->q->ll); break; } leaf *rootleaf = removeRoot(h); #if DEBUG printf("removing data %f at %d \n",rootleaf->d->distance,i); #endif listCor[i] = createData(rootleaf->d->valx,rootleaf->d->valy); listCor[i]->distance = calculateDistance(listCor[i]->valx,listCor[i]->valy); if(h->root == rootleaf){ free(h->root->d); free(h->root); h->root = NULL; } else { free(rootleaf->d); free(rootleaf); } popBack(h->q->ll); i++; } for(i = 9;i>=0;i--){ printf(" %.2f %.2f %.2f \n",listCor[i]->distance,listCor[i]->valx,listCor[i]->valy); data *d = createData(listCor[i]->valx,listCor[i]->valy); d->distance = calculateDistance(d->valx,d->valy); addLeaf(h,d); free(listCor[i]); } free(listCor); }
//file reading from zyante 9.5 Sprig* fileRead(char filename[]) { FILE* inFile = fopen(filename, "r"); if( inFile == NULL ) { return NULL; //file read error } int caliper; //the order of the b-tree int key; fscanf(inFile, "%d", &caliper); //initialize the topmost Sprig Sprig* topSprig = (Sprig*)malloc(sizeof(Sprig)); createSprig(topSprig, NULL); fscanf(inFile, "%d", &key); while (!feof(inFile)) { addLeaf(topSprig, key, caliper); fscanf(inFile, "%d", &key); } fclose(inFile); return topSprig; //file read worked }
/** * AddSysVar * * @param * @return S_OK; * @exception - */ HRESULT CSysVarPool::AddSysVar(CSysVar *pVar) { HRESULT hr; if (pVar == NULL) { return E_POINTER; } CSysVar *pVarTest = NULL; CString strName = pVar->getName(); strName.MakeLower(); if (m_sysVarMap.Lookup(strName, pVarTest)) { // already in map, refuse! return S_FALSE; } addLeaf(pVar); hr = pVar->Reread(); if (FAILED(hr)) { removeLeaf(pVar); return hr; } pVar->addRef(); m_sysVarMap.SetAt(strName, pVar); return S_OK; }
void splitPromote(Leaf* thisLeaf, Sprig* thisSprig, int key, int caliper) { //new sprig Sprig* newRightSprig = (Sprig*)malloc(sizeof(Sprig)); if (thisSprig->parentSprig == NULL) { //need to make new sprig on top Sprig* newTopSprig = (Sprig*)malloc(sizeof(Sprig)); newRightSprig->parentSprig = newTopSprig; thisSprig->parentSprig = newTopSprig; } else { //need to incorporate with existing upper sprig newRightSprig->parentSprig = thisSprig->parentSprig; } Leaf* newLeaf = (Leaf*)malloc(sizeof(Leaf)); if (thisLeaf->nextLeaf == NULL) { //add leaf to end createLeaf(newLeaf, key, thisLeaf, NULL, newRightSprig); thisLeaf->nextLeaf = newLeaf; } else { createLeaf(newLeaf, key, thisLeaf->prevLeaf, thisLeaf, newRightSprig); thisLeaf->prevLeaf->nextLeaf = newLeaf; thisLeaf->prevLeaf = newLeaf; } //start at the rightmost Leaf while (thisLeaf->nextLeaf != NULL) { thisLeaf = thisLeaf->nextLeaf; } //then move back to split int count = caliper/2; while (count > 0) { //every leaf on this side of the split needs to reassociate thisLeaf->currSprig = newRightSprig; //newRightSprig needs to find its first leaf newRightSprig->firstLeaf = thisLeaf; thisLeaf = thisLeaf->prevLeaf; count--; } //now thisLeaf is the median thisLeaf->childSprig = newRightSprig; //separate from the right leaves if (thisLeaf->nextLeaf != NULL) { thisLeaf->nextLeaf->prevLeaf = NULL; thisLeaf->nextLeaf = NULL; } //bring this leaf up to the parentSprig addLeaf(thisSprig->parentSprig, thisLeaf->key, caliper); //find the leaf just before the one we just added up there Leaf* currLeaf = thisSprig->parentSprig->firstLeaf; while (currLeaf->key < thisLeaf->key) { currLeaf = currLeaf->nextLeaf; } //give the promoted leaf the right child sprig currLeaf->childSprig = newRightSprig; //currLeaf is now one step too far right... if (currLeaf->prevLeaf != NULL) { currLeaf->prevLeaf->childSprig = thisSprig; } else { currLeaf->currSprig->leftSprig = thisSprig; } //separate from the left leaf if (thisLeaf->prevLeaf != NULL) { thisLeaf->prevLeaf->nextLeaf = NULL; } //free up the memory of the left behind leaf free(thisLeaf); }