/*!\brief Remove an edge between two nodes. Can remove isolated nodes
* 1) Test if both nodes of the edge exist
* 2) Remove edges
* 3) Remove isolated nodes
*/
int DirectionalGraph::eraseEdge( const node_type &fromNode,
const node_type &toNode, const bool removeIsolatedNodes ){
/* 1) Test if both nodes of the edge exist */
if( nodes.find(fromNode) == nodes.end() ){
return 1;
}
if( nodes.find(toNode) == nodes.end() ){
return 2;
}
/* 2) Remove edges */
outArrows[fromNode].erase(toNode);
inArrows[toNode].erase(fromNode);
/* 3) Remove isolated nodes */
if( removeIsolatedNodes ){
if( (outArrows[fromNode].size() == 0)
&& (inArrows[fromNode].size() == 0) ){
eraseNode(fromNode);
}
if( (outArrows[toNode].size() == 0)
&& (inArrows[toNode].size() == 0) ){
eraseNode(toNode);
}
}
return 0;
}
void ContentLayer::popNode(Layout *node) {
auto it = _nodes.find(node);
if (it == _nodes.end()) {
return;
}
node->retain();
_nodes.erase(it);
node->onPopTransitionBegan(this, false);
if (!_nodes.empty()) {
_nodes.back()->onForegroundTransitionBegan(this, node);
}
auto tit = _exitTransitions.find(node);
if (tit != _exitTransitions.end()) {
node->runAction(action::callback(tit->second, [this, node] {
eraseNode(node);
node->onPop(this, false);
if (!_nodes.empty()) {
_nodes.back()->onForeground(this, node);
}
node->release();
}));
} else {
eraseNode(node);
node->onPop(this, false);
if (!_nodes.empty()) {
_nodes.back()->onForeground(this, node);
}
node->release();
}
}
void ContentLayer::replaceTopNode(Layout *node, Transition *enterTransition, Transition *exitTransition) {
if (!_nodes.empty()) {
auto back = _nodes.back();
back->retain();
_nodes.popBack();
back->onPopTransitionBegan(this, false);
auto tit = _exitTransitions.find(back);
if (tit != _exitTransitions.end()) {
safe_retain(node);
safe_retain(enterTransition);
safe_retain(exitTransition);
back->runAction(action::callback(tit->second, [this, back, node, enterTransition, exitTransition] {
eraseNode(back);
back->onPop(this, false);
back->release();
pushNode(node, enterTransition, exitTransition);
safe_release(node);
safe_release(enterTransition);
safe_release(exitTransition);
}));
} else {
eraseNode(back);
back->onPop(this, false);
back->release();
pushNode(node, enterTransition, exitTransition);
}
}
}
void Tetgen::cleanBadTetra(double min_value)
{
Node* nd;
Tetra* itet;
double mindens,minvolm;
mindens = cr_crowd->getCurrentMinDensity();
minvolm = mindens * mindens * mindens * rate_minvolm;
int n = getSize();
for(int i = 0; i < n; i++)
{
itet = getTetra(i);
if(itet->getVolume() > minvolm &&
itet->getValue() > min_value)
continue;
for(int j = 0; j < 4; j++)
{
nd = itet->getNode(j);
if(nd->getType() == 0 )
continue;
if(eraseNode(nd))
break;
}
n = getSize();
}
}
int main(int argc, char* argv[]){
char buffer[BUFFER_SIZE];
int index, pages;
int requests = 0;
int faults = 0;
if(argc < 1){
printf("Too many arguments. Please look at documentation to compile.\n");
return 0;
}
sscanf(argv[1], "%d", &pages);
Set* set = create(pages);
FILE* fp = fopen("out.txt", "w");
assert(fp != NULL);
while(fgets(buffer, sizeof(buffer), stdin) != NULL) {
if(!isdigit((int)buffer[0]))
continue;
sscanf(buffer, "%d", &index);
requests++;
if(findNode(set, index) >= 0){
setRef(set, index, requests);
}
else{
if(getSize(set) == pages)
eraseNode(set, findMin(set));
insertNode(set, index, 0);
setRef(set, index, requests);
faults++;
assert(fprintf(fp, "%d \n", index) >= 0);
}
} // while
fclose(fp);
free(set);
printf("Number of page requests: %d \nNumber of page faults: %d \n", requests, faults);
return 1;
}
void MatchTrie::eraseNode(MatchTrie::TrieNode *&node){
if (!node) return;
for (int i = 0; i < 4; i ++) eraseNode(node -> next[i]);
delete node;
node = 0;
}
MatchTrie::~MatchTrie(){
eraseNode(_root);
}
/*!\brief Remove a node with the id of the node from a node iterator */
bool DirectionalGraph::eraseNode( const node_iterator &node ){
if( nodes.find(*node) == nodes.end() )
return false;
return eraseNode(*node);
}
