//clears tree
void AVLTreeIndex::clearTree(AVL_Node* r){
if (r != NULL){
clearTree(r->left);
clearTree(r->right);
delete r;
}
r = NULL;
}
void HCTree::clearTree(HCNode *node)
{
if (node != nullptr){
//go left first and then right recursively
clearTree(node->c0);
clearTree(node->c1);
//finally delete the node from the tree
delete node;
node = nullptr;
}
}
void clearTree(binTree *root)
{
if (root == NULL)
{
return;
}
clearTree(root->left);
clearTree(root->right);
free(root);
return;
}
void ompl::geometric::TRRTConnect::clear() {
Planner::clear();
sampler_.reset();
freeMemory();
clearTree(tStart_);
clearTree(tGoal_);
connectionPoint_ = std::make_pair<base::State*,base::State*>(NULL,NULL);
}
void clearTree(BVHnode* root) {
if (root == NULL) {
return;
} else {
if (root->leftChild != NULL) {
clearTree(root->leftChild);
}
if (root->rightChild != NULL) {
clearTree(root->rightChild);
}
}
root->~BVHnode();
}
/*
* Deallocates tree memory.
* parameters: IFBLOCK* ifBlock - destroys tree rooted at ifBlock
*/
static void clearTree(IFBLOCK* ifBlock)
{
COMMSEQ *node,*tempNode;//for linked list iteration
COMMSEQ* nodes[2];//then and else nodes
int i;//loop counter
IFBLOCK* currIfBlock;//nested if block
char* command;//sequence command
nodes[0] = ifBlock->thenComSeq;//then command sequesnce
nodes[1] = ifBlock->elseComSeq;//else command sequence
for(i = 0; i <2; ++i){
node = nodes[i];
while(node != NULL){
if(node->type == COMMAND){
tempNode = node->next;
command = (char*)node->cmd;
free(command);
free(node);//free command sequence node
node = tempNode;
}
else{//if nested_if
currIfBlock = (IFBLOCK*)node->cmd;//get if block
clearTree(currIfBlock);//free nested if block recursively
tempNode = node->next;
free(command);
free(node);//then free command sequence node
node = tempNode;
}
}
}
free(ifBlock);//free if block
}
bool LevelDBTransaction::commit()
{
ASSERT(!m_finished);
if (m_tree.is_empty()) {
m_finished = true;
return true;
}
OwnPtr<LevelDBWriteBatch> writeBatch = LevelDBWriteBatch::create();
TreeType::Iterator iterator;
iterator.start_iter_least(m_tree);
while (*iterator) {
AVLTreeNode* node = *iterator;
if (!node->deleted)
writeBatch->put(node->key, node->value);
else
writeBatch->remove(node->key);
++iterator;
}
if (!m_db->write(*writeBatch))
return false;
clearTree();
m_finished = true;
return true;
}
/**
* insert a new point, with an associated number.
*/
void addPointWithId( const node_type& n, size_type i, uint16_type comp, size_type indice_global=0 )
{
if ( M_tree )
clearTree();
M_pts.push_back( boost::make_tuple( n, i, comp,indice_global ) );
}
frmMainChart_State::frmMainChart_State(int portfolioID_, const QMap<int, portfolio> &portfolios_, const QHash<QString, historicalPrices> &prices_, QWidget *parent_):
frmMainStateToolbar(portfolios_.value(portfolioID_), parent_),
frmMainStateTree(portfolios_, prices_),
ui(new frmMainChart_UI()),
m_counter(0)
{
ui->setupUI(static_cast<QWidget*>(this->parent()));
foreach(const portfolio &p, m_portfolios)
ui->treeCmb->addItem(p.displayText(), p.id());
ui->treeCmb->setCurrentIndex(ui->treeCmb->findData(m_portfolio.id()));
populateTree(portfolioID_);
int beginDate = m_portfolio.startDate();
int endDate = m_portfolio.endDate();
ui->toolbarDateBeginEdit->setDate(QDate::fromJulianDay(beginDate));
ui->toolbarDateEndEdit->setDate(QDate::fromJulianDay(endDate));
connect(ui->toolbarDateBeginEdit, SIGNAL(dateChanged(QDate)), this, SLOT(refreshTab()));
connect(ui->toolbarDateEndEdit, SIGNAL(dateChanged(QDate)), this, SLOT(refreshTab()));
connect(ui->toolbarExport, SIGNAL(triggered()), ui->chart, SLOT(exportChart()));
connect(ui->tree, SIGNAL(itemChanged(QTreeWidgetItem*,int)), this, SLOT(itemChecked(QTreeWidgetItem*,int)));
connect(ui->treeCmb, SIGNAL(currentIndexChanged(int)), SLOT(portfolioChange(int)));
connect(ui->treeAllPortfolios, SIGNAL(clicked()), this, SLOT(addAllPortfolios()));
connect(ui->treeClearBtn, SIGNAL(clicked()), this, SLOT(clearTree()));
connect(ui->toolbar3M, SIGNAL(triggered()), this, SLOT(dateClicked()));
connect(ui->toolbar6M, SIGNAL(triggered()), this, SLOT(dateClicked()));
connect(ui->toolbarYTD, SIGNAL(triggered()), this, SLOT(dateClicked()));
connect(ui->toolbar1Y, SIGNAL(triggered()), this, SLOT(dateClicked()));
connect(ui->toolbar5Y, SIGNAL(triggered()), this, SLOT(dateClicked()));
connect(ui->toolbarMax, SIGNAL(triggered()), this, SLOT(dateClicked()));
refreshTab();
}
DirTree::~DirTree()
// Directory tree deconstructor.
{
clearTree();
delete(mrmime);
cout << "DIRTREE DELETED\n";
}
void FunctionsTreeWidget::updateTree()
{
blockSignals(true);
clearTree();
foreach (Function* function, m_doc->functions())
updateFunctionItem(new QTreeWidgetItem(parentItem(function)), function);
blockSignals(false);
}
int main(int argc, char *argv[])
{
struct Tree *gameTree = malloc (sizeof(struct Tree));
gameTree->root = parseFile();
if (DEBUG) printTree(gameTree);
play (gameTree);
writeFile(gameTree);
clearTree(gameTree);
return 0;
}
void RemoteReplayList_TreeModel::replayListFinished(const Response &r)
{
const Response_ReplayList &resp = r.GetExtension(Response_ReplayList::ext);
beginResetModel();
clearTree();
for (int i = 0; i < resp.match_list_size(); ++i)
replayMatches.append(new MatchNode(resp.match_list(i)));
endResetModel();
emit treeRefreshed();
}
int testDerivative() {
DParam d;
int error;
double vars[] = {4, 1};
double ret;
char dstr[64];
int l = 0;
Function *f;
f = (Function*)malloc(sizeof(Function));
f->prefix = NULL;
f->domain = NULL;
f->criterias = NULL;
f->str = NULL;
f->len = 0;
f->variableNode = NULL;
f->numVarNode = 0;
f->valLen = 0;
printf("Input function: ");
scanf("%s", &dstr);
l = strlen(dstr);
parseFunction(dstr, l, f);
if(getErrorCode() != NMATH_NO_ERROR) {
printError(getErrorColumn(), getErrorCode());
releaseFunct(f);
free(f);
return getErrorCode();
}
if( f->valLen==0 ) {
printf("This expression is not a function due to variables not determined.\n");
}
d.t = f->prefix->list[0];
d.error = 0;
d.returnValue = NULL;
d.variables[0] = 'x';
derivative(&d);
toString(d.returnValue, dstr, &l, 64);
printf("f' = %s\n", dstr);
clearTree(&(d.returnValue));
releaseFunct(f);
clearPool();
free(f);
return 0;
}
int main()
{
binTree* root = NULL;
int i = 0;
while(i == 0)
{
char c;
int cur;
scanf("%c", &c);
switch (c)
{
case 'a':
scanf("%d", &cur);
root = addElement(root, cur);
break;
case 'r':
scanf("%d", &cur);
root = removeElement(root, cur);
break;
case 'i':
scanf("%d", &cur);
if(hasElement(root, cur) == 0)
{
printf("Element doesn't belong to tree\n");
}
else
{
printf("Element belongs to tree\n");
}
break;
case 'p':
printParenthesis(root);
printf("\n");
break;
case 'u':
printUp(root);
printf("\n");
break;
case 'd':
printDown(root);
printf("\n");
break;
case 'c':
clearTree(root);
i = 1;
break;
}
}
return 0;
}
void KonqSidebarTree::rescanConfiguration()
{
kdDebug(1201) << "KonqSidebarTree::rescanConfiguration()" << endl;
m_autoOpenTimer->stop();
clearTree();
if (m_dirtreeDir.type==VIRT_Folder)
{
kdDebug(1201)<<"KonqSidebarTree::rescanConfiguration()-->scanDir"<<endl;
scanDir( 0, m_dirtreeDir.dir.path(), true);
}
else
{
kdDebug(1201)<<"KonqSidebarTree::rescanConfiguration()-->loadTopLevel"<<endl;
loadTopLevelItem( 0, m_dirtreeDir.dir.path() );
}
}
void clearPopulation(Population *population) {
int i;
for (i = 0; i < population->size; i++) {
if (population->inds[i]->derivationTree)
clearTree(population->inds[i]->derivationTree);
if (population->inds[i]->phenotype)
free(population->inds[i]->phenotype);
if (population->inds[i]->genotype) {
if (population->inds[i]->genotype->codons)
free(population->inds[i]->genotype->codons);
free(population->inds[i]->genotype);
}
free(population->inds[i]);
}
free(population->inds);
free(population);
}
void CSVWholeview::refresh()
{
string strUserID = GetWebUserID();
HitLog LogItem;
LogItem.sUserName = strUserID;
LogItem.sHitPro = "wholetree";
LogItem.sHitFunc = "refresh";
LogItem.sDesc = strRefresh;
DWORD dcalBegin=GetTickCount();
InsertHitRecord(LogItem.sUserName, LogItem.sHitPro, LogItem.sHitFunc, LogItem.sDesc, 0, 0);
svutil::TTime ttime = svutil::TTime::GetCurrentTimeEx();
string curTime = ttime.Format();
if(m_pTime)
m_pTime->setText(m_szRefreshTime + curTime);
char szQuery[4096]={0};
int nSize = 4095;
m_nShowType = -1;
GetEnvironmentVariable( "QUERY_STRING", szQuery,nSize);
char *pPos = strchr(szQuery, '=');
if(pPos)
{
pPos ++;
m_nShowType = atoi(pPos);
}
string szUserID = GetWebUserID();
if(szUserID != m_szUserID)
{
m_szUserID = szUserID;
if(m_pSVUser)
m_pSVUser->setUserID(m_szUserID);
else
m_pSVUser = new CUser(m_szUserID);
}
clearTree();
initTree();
DWORD dcalEnd1=GetTickCount();
InsertHitRecord(LogItem.sUserName, LogItem.sHitPro, LogItem.sHitFunc, LogItem.sDesc, 1, dcalEnd1 - dcalBegin);
}
void TreeInspector::inspectTree(ds::ui::Sprite* sp) {
clearTree();
mTreeRoot = sp;
// todo: make this an xml
mLayout = new ds::ui::LayoutSprite(mEngine);
mLayout->setSpriteName(L"This layout");
mLayout->setLayoutType(ds::ui::LayoutSprite::kLayoutVFlow);
mLayout->setSpacing(5.0f);
mLayout->setShrinkToChildren(ds::ui::LayoutSprite::kShrinkBoth);
mLayout->setTransparent(false);
mLayout->setColor(ci::Color(0.2f, 0.2f, 0.2f));
addChildPtr(mLayout);
treeParseRecursive(sp, 0);
layout();
animateOn();
}
void
ActionListViewItem::loadTree()
{
QString oclass;
aCfgItem cobj;
// clear tree
clearTree();
if ( !md ) return;
setPixmap(0, rcIcon("actions.png"));
cobj = md->firstChild ( obj );
while ( !cobj.isNull() )
{
oclass = md->objClass ( cobj );
if ( oclass == md_actiongroup )
loadGroup ( this, cobj );
oclass = md->objClass ( cobj );
if ( oclass == md_action )
new ActionListViewItem( this, getLastChild(), md, cobj, QString::null );
cobj = md->nextSibling ( cobj );
}
};
void clearTree ( TNODE ** root )
{
if (*root == NULL) {
return;
}
int alive = FALSE;
for (int i = 0; i < TELCO_NUMBERS; i++) {
clearTree(&((*root)->m_Child[i]));
if ( ((*root)->m_Child[i]) != NULL ) {
alive = TRUE;
}
}
if (!alive && ((*root)->m_Dest == NULL)) {
delTree(*root);
*root = NULL;
}
}
int delDest ( TNODE ** root, const char * prefix )
{
TNODE *ptr = *root;
int idx = -1;
if ((ptr == NULL) || (strlen(prefix) == 0)) {
return FALSE;
}
for (size_t i = 0; i < strlen(prefix); i++) {
idx = prefix[i] - '0';
if (idx > 9 || idx < 0 ) {
return FALSE;
}
if (ptr->m_Child[idx] == NULL) {
return FALSE;
}
ptr = ptr->m_Child[idx];
}
free(ptr->m_Dest);
ptr->m_Dest = NULL;
for (int i = 0; i < TELCO_NUMBERS; i++) {
if (ptr->m_Child[i])
return TRUE;
}
clearTree(root);
return TRUE;
}
void MyGL::SceneLoadDialog()
{
QString filepath = QFileDialog::getOpenFileName(0, QString("Load Scene"), QString("../scene_files"), tr("*.xml"));
if(filepath.length() == 0)
{
return;
}
QFile file(filepath);
int i = filepath.length() - 1;
while(QString::compare(filepath.at(i), QChar('/')) != 0)
{
i--;
}
QStringRef local_path = filepath.leftRef(i+1);
//Reset all of our objects
scene.Clear();
integrator = Integrator();
//delete existing bvh tree
clearTree(this->intersection_engine.BVHrootNode);
delete this->intersection_engine.BVHrootNode;
intersection_engine = IntersectionEngine();
//Load new objects based on the XML file chosen.
xml_reader.LoadSceneFromFile(file, local_path, scene, integrator);
integrator.scene = &scene;
integrator.intersection_engine = &intersection_engine;
intersection_engine.scene = &scene;
//create new tree with this new set of geometry!
this->intersection_engine.BVHrootNode = new BVHnode();
this->intersection_engine.BVHrootNode = createBVHtree(this->intersection_engine.BVHrootNode, this->scene.objects, 0);
update();
}
KonqSidebarTree::~KonqSidebarTree()
{
clearTree();
delete d;
}
RemoteReplayList_TreeModel::~RemoteReplayList_TreeModel()
{
clearTree();
}
/* ~GST ********************************************************************************
*
* @params: none
*
* @modifies: deletes full game board
*
* @returns: nothing
****************************************************************************************/
GST::~GST() {
clearTree();
delete root;
}
void AVLTreeIndex::clearTree(){
clearTree(root);
}
HCTree::~HCTree()
{
clearTree(root);
root = nullptr;
}
/*
* Destroys tree and sets the_if_block to NULL
*/
static void clearCallTree()
{
clearTree(the_if_block);//deallocate tree
the_if_block = NULL;//set it back to NULL
}
Indexer::~Indexer()
// Deconstructor. Clear and delete the file list.
{
clearTree();
delete(dir_tree);
}
