int Treap::find(string str)
{
return findNode(str)->getValue();
}
int Circuit::createSHIFTModule(const string &input, const string &output, unsigned int numBits, unsigned int numShift)
{
Node* node;
// create input nodes
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = input + "[" + sstr.str() + "]";
node = createNode(name);
}
// create output nodes
for (unsigned int i = 0; i < numBits+numShift; ++i)
{
stringstream sstr;
sstr << i;
string name = output + "[" + sstr.str() + "]";
node = createNode(name);
}
// assign '0's to the least numShift bits
Node* zeroNode = createNode("ZERO");
createZERONode(zeroNode);
for (unsigned int i = 0; i < numShift; ++i)
{
stringstream sstr;
sstr << i;
string name = output + "[" + sstr.str() + "]";
Node* outNode = findNode(name);
assert(outNode != NULL);
createBUF1Node(zeroNode, outNode);
}
// assign inputs to the remaining numBits bits
for (unsigned int i = numShift; i < numBits+numShift; ++i)
{
string name;
// find input node[i-numShift]
stringstream inStr;
inStr << i-numShift;
name = input + "[" + inStr.str() + "]";
Node* inNode = findNode(name);
assert(inNode != NULL);
// find output node[i]
stringstream outStr;
outStr << i;
name = output + "[" + outStr.str() + "]";
Node* outNode = findNode(name);
assert(outNode != NULL);
// assign
createBUF1Node(inNode, outNode);
}
return 0;
}
bool TreeSetImpl::contains(const void *key) const {
return findNode(key) != NULL;
}
//procura código na árvore a partir da raíz (representado por String com 0s e 1s): procura código inteiro
int findNode(HuffmanTree *hft, char* s, short verbose)
{
return findNode(hft, s, hft->root, verbose);
}
int Circuit::createADDModule(const string &input1, const string &input2, const string &cin, const string &output, const string &cout, unsigned int numBits)
{
Node* node;
// create input1 and input2 nodes
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = input1 + "[" + sstr.str() + "]";
node = createNode(name);
}
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = input2 + "[" + sstr.str() + "]";
node = createNode(name);
}
// create cin node
node = createNode(cin);
// create output nodes
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output + "[" + sstr.str() + "]";
node = createNode(name);
}
// create cout
node = createNode(cout);
// create internal nodes C
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output+"c" ;
name = name + "[" + sstr.str() + "]";
node = createNode(name);
}
// create other internal nodes d, f, g, c
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output+"d" ;
name = name + "[" + sstr.str() + "]";
node = createNode(name);
}
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output+"e" ;
name = name + "[" + sstr.str() + "]";
node = createNode(name);
}
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output+"f" ;
name = name + "[" + sstr.str() + "]";
node = createNode(name);
}
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output+"g" ;
name = name + "[" + sstr.str() + "]";
node = createNode(name);
}
for (unsigned int i = 0; i < numBits; ++i)
{
Node* internal_c_previous;
if(i!=0)
{
stringstream sstr;
sstr << i-1;
string name = output+"c";
name = name + "[" + sstr.str() + "]";
internal_c_previous = findNode(name);
assert(internal_c_previous != NULL);
}
stringstream sstr;
sstr << i;
string name = output + "[" + sstr.str() + "]";
Node* outNode = findNode(name);
assert(outNode != NULL);
name = input1 + "[" + sstr.str() + "]";
Node* inNode1 = findNode(name);
assert(inNode1 != NULL);
name = input2 + "[" + sstr.str() + "]";
Node* inNode2 = findNode(name);
assert(inNode2 != NULL);
//internal node for c(n-1) to c0
name = output+"c";
name = name + "[" + sstr.str() + "]";
Node* internal_c = findNode(name);
assert(internal_c != NULL);
//internal node1
name = output+"d";
name = name + "[" + sstr.str() + "]";
Node* dd = findNode(name);
assert(dd != NULL);
//internal node2
name = output+"e";
name = name + "[" + sstr.str() + "]";
Node* ee = findNode(name);
assert(ee != NULL);
//internal node3
name = output+"f";
name = name + "[" + sstr.str() + "]";
Node* ff = findNode(name);
assert(ff != NULL);
//internal node4
name = output+"g";
name = name + "[" + sstr.str() + "]";
Node* gg = findNode(name);
assert(gg != NULL);
Node* c_in = findNode(cin);
assert(c_in != NULL);
Node* c_out = findNode(cout);
assert(c_out != NULL);
//To calculate each bit of the adder
if (i==0)
{
//s0=a0^b0^cin;
createXOR3Node(inNode1, inNode2, c_in, outNode);
//c0=a0*b0+b0*cin+cin*a0;
createAND2Node(inNode1,inNode2,dd);
createAND2Node(inNode1,c_in,ee);
createAND2Node(inNode2,c_in,ff);
createOR2Node(dd,ee,gg);
createOR2Node(gg,ff,internal_c);
}
else if ( i==(numBits-1) )
{
//sn=an^bn^c(n-1);
createXOR3Node(inNode1, inNode2, internal_c_previous, outNode);
//cn=an*bn+bn*c(n-1)+c(n-1)*an;
createAND2Node(inNode1,inNode2,dd);
createAND2Node(inNode1,internal_c_previous,ee);
createAND2Node(inNode2,internal_c_previous,ff);
createOR2Node(dd,ee,gg);
createOR2Node(gg,ff,c_out);
}
else
{
//sk=ak^bk^c(k-1);
createXOR3Node(inNode1, inNode2, internal_c_previous, outNode);
//ck=ak*bk+bk*c(k-1)+c(k-1)*ak;
createAND2Node(inNode1,inNode2,dd);
createAND2Node(inNode1,internal_c_previous,ee);
createAND2Node(inNode2,internal_c_previous,ff);
createOR2Node(dd,ee,gg);
createOR2Node(gg,ff,internal_c);
}
}
// when you have implemented this function,
// change 'return -1' to 'return 0'
return 0;
}
/**
* Wrapper to findNode()
*
* @param graph Input graph
* @param node Node id to find
* @return A pointer to the node or NULL if node does not exist
*/
node_t* find_node(graph_t* graph, int node)
{
return findNode(graph, node);
}
void getLocalToGlobalMap(int (*local2global)[2],
int &off_global,
const Basis<Scalar,ArrayType> &basis,
const int *element) {
const int local = 0, global = 1;
const int nbf = basis.getCardinality();
const shards::CellTopology cell = basis.getBaseCellTopology();
const int dim = cell.getDimension();
int cnt = 0, off_element = 0;
int subcell_verts[4], nids;
const int nvert = cell.getVertexCount();
for (int i=0;i<nvert;++i) {
const int ord_vert = (off_element < nbf ? basis.getDofOrdinal(0, i, 0) : 0);
const int dof_vert = (off_element < nbf ? basis.getDofTag(ord_vert)[3] : 0);
local2global[cnt][local] = off_element;
off_element += dof_vert;
Orientation::getElementNodeMap(subcell_verts, nids,
cell, element,
0, i);
if (!findNode(local2global[cnt][global], subcell_verts, nids, true)) {
addNode(subcell_verts, nids, off_global);
local2global[cnt][global] = off_global;
off_global += dof_vert;
}
++cnt;
}
const int nedge = cell.getEdgeCount();
for (int i=0;i<nedge;++i) {
const int ord_edge = (off_element < nbf ? basis.getDofOrdinal(1, i, 0) : 0);
const int dof_edge = (off_element < nbf ? basis.getDofTag(ord_edge)[3] : 0);
local2global[cnt][local] = off_element;
off_element += dof_edge;
Orientation::getElementNodeMap(subcell_verts, nids,
cell, element,
1, i);
if (!findNode(local2global[cnt][global], subcell_verts, nids, true)) {
addNode(subcell_verts, nids, off_global);
local2global[cnt][global] = off_global;
off_global += dof_edge;
}
++cnt;
}
const int nface = cell.getFaceCount();
for (int i=0;i<nface;++i) {
const int ord_face = (off_element < nbf ? basis.getDofOrdinal(2, i, 0) : 0);
const int dof_face = (off_element < nbf ? basis.getDofTag(ord_face)[3] : 0);
local2global[cnt][local] = off_element;
off_element += dof_face;
Orientation::getElementNodeMap(subcell_verts, nids,
cell, element,
2, i);
if (!findNode(local2global[cnt][global], subcell_verts, nids, true)) {
addNode(subcell_verts, nids, off_global);
local2global[cnt][global] = off_global;
off_global += dof_face;
}
++cnt;
}
{
const int i = 0;
const int ord_intr = (off_element < nbf ? basis.getDofOrdinal(dim, i, 0) : 0);
const int dof_intr = (off_element < nbf ? basis.getDofTag(ord_intr)[3] : 0);
local2global[cnt][local] = off_element;
off_element += dof_intr;
Orientation::getElementNodeMap(subcell_verts, nids,
cell, element,
dim, i);
if (!findNode(local2global[cnt][global], subcell_verts, nids, true)) {
addNode(subcell_verts, nids, off_global);
local2global[cnt][global] = off_global;
off_global += dof_intr;
}
++cnt;
}
// add the last offset
local2global[cnt][local] = off_element;
local2global[cnt][global] = -1; // invalid values
}
void probabilitat_Segons_Fitxer(RBTree * tree){
int i;
Node *node;
RBdata *data;
char * paraula = malloc(sizeof(char) * MAXLINEA);
printf("Paraula a buscar a l'arbre?\n");
printf(">>> ");
scanf("%s", paraula);
/* Search if the word is in the tree */
node = findNode(tree, paraula);
if (node != NULL){
float * prob = malloc(sizeof(float) * n_files);
data = node->data;
printf("La paraula %s surt un total de %d vegades.\n", data->key, data->num);
/* Calculate and print the probability in each file with a bucle */
for (i = 0; i < n_files; i++){
printf("Al fitxer %d surt %d vegades,", i, data->vector[i]);
prob[i] = (float) data->vector[i] / (float) data->num;
printf(" prob: %f \n", prob[i]);
}
/* Sort the probabilities */
qsort(prob, n_files, sizeof(float), compare_floats);
FILE *fp_data, *fp_gnuplot;
fp_data = fopen("vector.data","w");
if (!fp_data){
printf("ERROR: no he pogut obrir el fitxer.\n");
exit(EXIT_FAILURE);
}
printf("The ordered vector is: ");
/* Store probabilities in a file */
fprintf(fp_data, "%s\n", "#Funcio prob(paraula)" );
fprintf(fp_data, "%s\n", "#x prob(x)" );
for(i = 0; i < n_files; i++){
fprintf(fp_data, "%d %f\n", i, prob[i]);
printf("%f ", prob[i]);
}
printf("\n");
/* Close file and release memory */
fclose(fp_data);
free(prob);
/* Print a graphic of probs using gnuplot with a pipe */
fp_gnuplot = popen("gnuplot", "w");
if (!fp_gnuplot){
printf("ERROR: no he pogut obrir el fitxer.\n");
exit(EXIT_FAILURE);
}
fprintf(fp_gnuplot, "set xlabel \"apareix en el fitxer x\"\n");
fprintf(fp_gnuplot, "set ylabel \"amb probabilitat y\"\n");
fprintf(fp_gnuplot, "plot \"vector.data\" with lines title \"la paraula %s\"\n", data->key);
fflush(fp_gnuplot);
printf("\nEnviat....\n");
sleep(10);
pclose(fp_gnuplot);
}else{
printf("No s'ha trobat la paraula a l'arbre!");
}
/* Release memory */
free(paraula);
}
void Domain::writeClickFiles() {
ofstream click_conf;
for (int i = 0; i < network_nodes.size(); i++) {
vector<string> unique_ifaces;
vector<string> unique_srcips;
NetworkNode *nn = network_nodes[i];
click_conf.open((write_conf + nn->label + ".conf").c_str());
click_conf << "require(blackadder);" << endl << endl;
/*Blackadder Elements First*/
click_conf << "globalconf::GlobalConf(MODE " << overlay_mode << ", NODEID " << nn->label << "," << endl;
click_conf << "DEFAULTRV " << nn->FID_to_RV.to_string() << "," << endl;
click_conf << "TMFID " << nn->FID_to_TM.to_string() << "," << endl;
click_conf << "iLID " << nn->iLid.to_string() << ");" << endl << endl;
click_conf << "localRV::LocalRV(globalconf," << nn->connections.size() /*number of neighbours*/ << "," << endl;
for (int j = 0; j < nn->connections.size(); j++) {
NetworkConnection *nc = nn->connections[j];
NetworkNode *dest_nn = findNode(nc->dst_label);
if (j == nn->connections.size() - 1) {
click_conf << /*a neighbour*/dest_nn->label << "," << /*LID to it*/dest_nn->iLid.to_string() << "," << /*iLID of it*/ nc->LID.to_string() << ");" << endl << endl;
} else {
click_conf << /*a neighbour*/dest_nn->label << "," << /*LID to it*/dest_nn->iLid.to_string() << "," << /*iLID of it*/ nc->LID.to_string() << "," << endl;
}
}
click_conf << "netlink::Netlink();" << endl << "tonetlink::ToNetlink(netlink);" << endl << "fromnetlink::FromNetlink(netlink);" << endl << endl;
click_conf << "proxy::LocalProxy(globalconf);" << endl << endl;
click_conf << "fw::Forwarder(globalconf," << nn->connections.size() << "," << endl;
for (int j = 0; j < nn->connections.size(); j++) {
NetworkConnection *nc = nn->connections[j];
int offset;
if (overlay_mode.compare("mac") == 0) {
if ((offset = findOffset(unique_ifaces, nc->src_if)) == -1) {
unique_ifaces.push_back(nc->src_if);
if (j == nn->connections.size() - 1) {
click_conf << unique_ifaces.size() << "," << nc->src_mac << "," << nc->dst_mac << "," << nc->LID.to_string() << ");" << endl << endl;
} else {
click_conf << unique_ifaces.size() << "," << nc->src_mac << "," << nc->dst_mac << "," << nc->LID.to_string() << "," << endl;
}
} else {
if (j == nn->connections.size() - 1) {
click_conf << offset + 1 << "," << nc->src_mac << "," << nc->dst_mac << "," << nc->LID.to_string() << ");" << endl << endl;
} else {
click_conf << offset + 1 << "," << nc->src_mac << "," << nc->dst_mac << "," << nc->LID.to_string() << "," << endl;
}
}
} else {
if ((offset = findOffset(unique_srcips, nc->src_ip)) == -1) {
unique_srcips.push_back(nc->src_ip);
//cout << "PUSHING BACK " << nc->src_ip << endl;
//cout << unique_srcips.size() << endl;
if (j == nn->connections.size() - 1) {
click_conf << unique_srcips.size() << "," << nc->src_ip << "," << nc->dst_ip << "," << nc->LID.to_string() << ");" << endl << endl;
} else {
click_conf << unique_srcips.size() << "," << nc->src_ip << "," << nc->dst_ip << "," << nc->LID.to_string() << "," << endl;
}
} else {
if (j == nn->connections.size() - 1) {
click_conf << offset + 1 << "," << nc->src_ip << "," << nc->dst_ip << "," << nc->LID.to_string() << ");" << endl << endl;
} else {
click_conf << offset + 1 << "," << nc->src_ip << "," << nc->dst_ip << "," << nc->LID.to_string() << "," << endl;
}
}
}
}
if (overlay_mode.compare("mac") == 0) {
for (int j = 0; j < unique_ifaces.size(); j++) {
click_conf << "tsf" << j << "::ThreadSafeQueue(1000);" << endl;
if (nn->running_mode.compare("user") == 0) {
click_conf << "fromdev" << j << "::FromDevice(" << unique_ifaces[j] << ");" << endl << "todev" << j << "::ToDevice(" << unique_ifaces[j] << ");" << endl;
} else {
click_conf << "fromdev" << j << "::FromDevice(" << unique_ifaces[j] << ", BURST 8);" << endl << "todev" << j << "::ToDevice(" << unique_ifaces[j] << ", BURST 8);" << endl;
}
}
/*Necessary Click Elements*/
if (nn->running_mode.compare("user") == 0) {
click_conf << "classifier::Classifier(12/080a);" << endl;
} else {
click_conf << "classifier::Classifier(12/080a, -);" << endl;
click_conf << "tohost::ToHost();" << endl;
}
} else {
/*raw sockets here*/
click_conf << "tsf" << "::ThreadSafeQueue(1000);" << endl;
if (nn->running_mode.compare("user") == 0) {
click_conf << "rawsocket" << "::RawSocket(UDP, 7777)" << endl;
click_conf << "classifier::IPClassifier(dst udp port 8888 and src udp port 7777)" << endl;
} else {
cerr << "Something is wrong...I should not build click config using raw sockets for node " << nn->label << "that will run in kernel space" << endl;
}
}
/*Now link all the elements appropriately*/
click_conf << endl << endl << "proxy[0]->tonetlink;" << endl << "fromnetlink->[0]proxy;" << endl << "localRV[0]->[1]proxy[1]->[0]localRV;" << endl << "proxy[2]-> [0]fw[0] -> [2]proxy;" << endl;
if (overlay_mode.compare("mac") == 0) {
for (int j = 0; j < unique_ifaces.size(); j++) {
click_conf << "fw[" << (j + 1) << "]->tsf" << j << "->todev" << j << ";" << endl;
click_conf << "fromdev" << j << "->classifier[0]->[" << (j + 1) << "]fw;" << endl;
}
if (nn->running_mode.compare("kernel") == 0) {
click_conf << "classifier[1]->tohost;" << endl;
}
} else {
/*raw sockets here*/
click_conf << "fw[1] -> tsf -> rawsocket -> classifier -> [1]fw" << endl;
}
click_conf.close();
}
}
int findBST(BST bt, book b){
return findNode(bt->root, b);
}
int MtpStorage::getObjectPropertyList(MtpObjectHandle handle, uint32_t format, uint32_t property, int groupCode, int depth, MtpDataPacket& packet) {
MTPD("MtpStorage::getObjectPropertyList handle: %u, format: %x, property: %x\n", handle, format, property);
if (groupCode != 0)
{
MTPE("getObjectPropertyList: groupCode unsupported\n");
return -1; // TODO: RESPONSE_SPECIFICATION_BY_GROUP_UNSUPPORTED
}
// TODO: support all the special stuff, like:
// handle == 0 -> all objects at the root level
// handle == 0xffffffff -> all objects (on all storages? how could we support that?)
// format == 0 -> all formats, otherwise filter by ObjectFormatCode
// property == 0xffffffff -> all properties except those with group code 0xffffffff
// if property == 0 then use groupCode
// groupCode == 0 -> return Specification_By_Group_Unsupported
// depth == 0xffffffff -> all objects incl. and below handle
std::vector<PropEntry> results;
if (handle == 0xffffffff) {
// TODO: all object on all storages (needs a different design, result packet needs to be built by server instead of storage)
} else if (handle == 0) {
// all objects at the root level
Tree* root = mtpmap[0];
MtpObjectHandleList list;
root->getmtpids(&list);
for (MtpObjectHandleList::iterator it = list.begin(); it != list.end(); ++it) {
Node* node = root->findNode(*it);
if (!node) {
MTPE("BUG: node not found for root entry with handle %u\n", *it);
break;
}
queryNodeProperties(results, node, property, groupCode, mStorageID);
}
} else {
// single object
Node* node = findNode(handle);
if (!node) {
// Item is not on this storage device
return -1;
}
queryNodeProperties(results, node, property, groupCode, mStorageID);
}
MTPD("count: %u\n", results.size());
packet.putUInt32(results.size());
for (size_t i = 0; i < results.size(); ++i) {
PropEntry& p = results[i];
MTPD("handle: %u, propertyCode: %x = %s, datatype: %x, value: %llu\n",
p.handle, p.property, MtpDebug::getObjectPropCodeName(p.property),
p.datatype, p.intvalue);
packet.putUInt32(p.handle);
packet.putUInt16(p.property);
packet.putUInt16(p.datatype);
switch (p.datatype) {
case MTP_TYPE_INT8:
MTPD("MTP_TYPE_INT8\n");
packet.putInt8(p.intvalue);
break;
case MTP_TYPE_UINT8:
MTPD("MTP_TYPE_UINT8\n");
packet.putUInt8(p.intvalue);
break;
case MTP_TYPE_INT16:
MTPD("MTP_TYPE_INT16\n");
packet.putInt16(p.intvalue);
break;
case MTP_TYPE_UINT16:
MTPD("MTP_TYPE_UINT16\n");
packet.putUInt16(p.intvalue);
break;
case MTP_TYPE_INT32:
MTPD("MTP_TYPE_INT32\n");
packet.putInt32(p.intvalue);
break;
case MTP_TYPE_UINT32:
MTPD("MTP_TYPE_UINT32\n");
packet.putUInt32(p.intvalue);
break;
case MTP_TYPE_INT64:
MTPD("MTP_TYPE_INT64\n");
packet.putInt64(p.intvalue);
break;
case MTP_TYPE_UINT64:
MTPD("MTP_TYPE_UINT64\n");
packet.putUInt64(p.intvalue);
break;
case MTP_TYPE_INT128:
MTPD("MTP_TYPE_INT128\n");
packet.putInt128(p.intvalue);
break;
case MTP_TYPE_UINT128:
MTPD("MTP_TYPE_UINT128\n");
packet.putUInt128(p.intvalue);
break;
case MTP_TYPE_STR:
MTPD("MTP_TYPE_STR: %s\n", p.strvalue.c_str());
packet.putString(p.strvalue.c_str());
break;
default:
MTPE("bad or unsupported data type: %x in MyMtpDatabase::getObjectPropertyList", p.datatype);
break;
}
}
return 0;
}
//findNode- finds the node at the passed in position
//node- the node
//x- the x coord of the position
//y- the y coord of the position
//outputHeight- the output to assign the height to
void TerrainQuadTree::findNode(Node* node, float x, float z, float& outputHeight)
{
float xMin, xMax, zMin, zMax;
int count, i, index;
float vertex1[3], vertex2[3], vertex3[3];
bool foundHeight;
// Calculate the dimensions of this node.
xMin = node->positionX - (node->width / 2.0f);
xMax = node->positionX + (node->width / 2.0f);
zMin = node->positionZ - (node->width / 2.0f);
zMax = node->positionZ + (node->width / 2.0f);
// See if the x and z coordinate are in this node, if not then stop traversing this part of the tree.
if ((x < xMin) || (x > xMax) || (z < zMin) || (z > zMax))
{
return;
}
// If the coordinates are in this node then check first to see if children nodes exist.
count = 0;
for (i = 0; i<4; i++)
{
if (node->nodes[i] != 0)
{
count++;
findNode(node->nodes[i], x, z, outputHeight);
}
}
// If there were children nodes then return since the polygon will be in one of the children.
if (count > 0)
{
return;
}
// If there were no children then the polygon must be in this node. Check all the polygons in this node to find
// the height of which one the polygon we are looking for.
for (i = 0; i<node->triangleCount; i++)
{
index = i * 3;
vertex1[0] = node->vertexArray[index].x;
vertex1[1] = node->vertexArray[index].y;
vertex1[2] = node->vertexArray[index].z;
index++;
vertex2[0] = node->vertexArray[index].x;
vertex2[1] = node->vertexArray[index].y;
vertex2[2] = node->vertexArray[index].z;
index++;
vertex3[0] = node->vertexArray[index].x;
vertex3[1] = node->vertexArray[index].y;
vertex3[2] = node->vertexArray[index].z;
// Check to see if this is the polygon we are looking for.
foundHeight = checkHeightOfTriangle(x, z, outputHeight, vertex1, vertex2, vertex3);
// If this was the triangle then quit the function and the height will be returned to the calling function.
if (foundHeight)
{
return;
}
}
}
_redblacktree::tree* _redblacktree::nodeWithSizeNotLessThen( size_t size ) {
return findNode( root, size );
}
const char *xml_get_string_attribute(xmlDoc *doc, char *format, ...)
{
va_list ap;
char str[4096];
va_start(ap, format);
vsnprintf(str, 4095, format, ap);
va_end(ap);
int i,n;
char **arr;
int found = TRUE;
split_into_array(str, '.', &n, &arr);
xmlNode *cur = xmlDocGetRootElement(doc);
// first item much match the name of the root
if (strcmp(arr[0], (char*)cur->name)!=0) {
// root node doesn't match -- return empty string
strcpy(buf, "");
}
else {
// subsequent items specify the search path through the xml tree
// all except the last one -- that is the attribute name
for (i=1; i<n-1; ++i) {
char *elem;
int k;
extract_array_specifier(arr[i], &elem, &k);
xmlNode *next = findNode(doc, cur, elem, k);
if (!next) {
// not found -- return NULL
found = FALSE;
strcpy(buf, "");
FREE(elem);
break;
}
FREE(elem);
cur = next;
}
}
if (found) {
assert(cur != NULL);
xmlChar *val = xmlGetProp(cur, (xmlChar*)(arr[n-1]));
if (val) {
strncpy_safe(buf, (char*)val, MAX_LEN-1);
xmlFree(val);
}
else {
// found the node, but it did not have the requested attribute
found = FALSE;
}
}
if (!found) {
strcpy(buf, MAGIC_UNSET_STRING);
}
free_char_array(&arr, n);
return buf;
}
void findNode( Node* node, Bolt bolt, std::vector<Pair>& result, unsigned int& cmp )
{
// Если болт меньше гайки в текущем узле, то нужно посмотреть есть ли слева
// пара.
if (bolt.size < node->pair.nut.size)
{
++cmp;
// Если пара есть, то вызываем findNode для нее.
if (node->left)
{
findNode(node->left, bolt, result, cmp);
}
// Если же пары нет, то это значит, что мы достигли листа дерева. Значит
// нужно разделить находящуюся здесь кучку гаек на две.
else
{
Node* newNode = new Node();
// Между прочим, для уменьшения количества сравнений можно сделать
// дополнительный цикл, который будет запускаться после того, как
// соответствующая гайка будет найдена. Тогда нам не придется проверять
// два условия (> и <), а можно будет проверять только одно (например, >),
// ибо среди оставшихся гаек не найдется еще одной равной текущему болту.
std::vector<Nut>::iterator beginFrom;
// Начинаем разбирать кучку гаек.
for (std::vector<Nut>::iterator nut = node->lower.begin(); nut != node->lower.end(); ++nut)
{
// Если текущий болт больше гайки, то отправляем эту гайку в левую кучку.
if (bolt.size > (*nut).size)
{
cmp += 1;
newNode->lower.push_back(*nut);
continue;
}
// Иначе, если болт меньше гайки, отправляем ее в правую кучку.
else if (bolt.size < (*nut).size)
{
cmp += 2;
newNode->upper.push_back(*nut);
continue;
}
// Иначе мы нашли соответствующую гайку. Сохраним пару и прервем
// цикл, чтобы оставшиеся гайки перебирать уже в другом цикле,
// с меньшим количеством сравнений.
else
{
newNode->pair.bolt = bolt;
newNode->pair.nut = *nut;
result.push_back(newNode->pair);
beginFrom = ++nut;
break;
}
}
for (std::vector<Nut>::iterator nut = beginFrom; nut != node->lower.end(); ++nut)
{
++cmp;
if (bolt.size > (*nut).size)
{
newNode->lower.push_back(*nut);
continue;
}
else
{
newNode->upper.push_back(*nut);
continue;
}
}
// Удаляем гайки из левой кучки текущего узла, чтобы не держать их
// в памяти за зря.
node->lower.clear();
// Сохраняем новый узел в дереве
node->left = newNode;
}
}
// Иначе болт больше гайки в текущем узле. То есть смотрим есть ли пара справа.
else
{
++cmp;
// Если пара есть, то вызываем findNode для нее.
if (node->right)
{
findNode(node->right, bolt, result, cmp);
}
// Если же пары нет, то это значит, что мы достигли листа дерева. Значит
// нужно разделить находящуюся здесь кучку гаек на две.
else
{
Node* newNode = new Node();
std::vector<Nut>::iterator beginFrom;
for (std::vector<Nut>::iterator nut = node->upper.begin(); nut != node->upper.end(); ++nut)
{
if (bolt.size > (*nut).size)
{
cmp += 1;
newNode->lower.push_back(*nut);
continue;
}
else if (bolt.size < (*nut).size)
{
cmp += 2;
newNode->upper.push_back(*nut);
continue;
}
else
{
newNode->pair.bolt = bolt;
newNode->pair.nut = *nut;
result.push_back(newNode->pair);
beginFrom = ++nut;
break;
}
}
for (std::vector<Nut>::iterator nut = beginFrom; nut != node->upper.end(); ++nut)
{
++cmp;
if (bolt.size > (*nut).size)
{
newNode->lower.push_back(*nut);
continue;
}
else
{
newNode->upper.push_back(*nut);
continue;
}
}
node->upper.clear();
// Сохраняем новый узел в дереве
node->right = newNode;
}
}
}
Node *findKey(HashTable *table,char *key){
uint32_t k = prehash(key);
//printf("The key is : %s %08x\n",key,k);
//printf("Looking at address : %08x\n",k % table->maxSize);
return findNode(table->values[k % table->maxSize],key);
}
void CNetwork::getLinks(FILE *file)
{
// get the information about the links in the TRAF file and create the link list
char line[81] = { '\0' };
int card_type = 0;
int index = 0;
CLink *link = NULL;
// link data
char up[5] = { '\0' };
char dn[5] = { '\0' };
char th[5] = { '\0' };
char le[5] = { '\0' };
char ri[5] = { '\0' };
char op[5] = { '\0' };
char length[5] = { '\0' };
char speed[5] = { '\0' };
char left_bays_len[5] = { '\0' };
char right_bays_len[5] = { '\0' };
char full_lanes_num[5] = { '\0' };
char left_bays_num[5] = { '\0' };
char right_bays_num[5] = { '\0' };
char ch[net_max_lanes][5] = { '\0' };
// search the TRAF file for link data records
while (!feof(file))
{
// read a line of the file
card_type = readTRFLine(file, line);
// parse the type 11 (link data) cards
if (card_type == 11)
{
// initialize all the character data strings
for (index = 0; index < 5; index++)
{
up[index] = '\0';
dn[index] = '\0';
th[index] = '\0';
le[index] = '\0';
ri[index] = '\0';
op[index] = '\0';
length[index] = '\0';
speed[index] = '\0';
left_bays_len[index] = '\0';
right_bays_len[index] = '\0';
full_lanes_num[index] = '\0';
left_bays_num[index] = '\0';
right_bays_num[index] = '\0';
// iterate ch with net_max_lanes
for (int li = 0; li < net_max_lanes; li++)
{
ch[li][index] = '\0';
}
}
// parse the line, which contains: the upstream node number, the downstream node number, the link length, etc. - see card 11
for (index = 0; index < 4; index++)
{
up[index] = line[index];
dn[index] = line[index + 4];
length[index] = line[index + 8];
left_bays_len[index] = line[index + 12];
right_bays_len[index] = line[index + 16];
th[index] = line[index + 40];
le[index] = line[index + 36];
ri[index] = line[index + 44];
op[index] = line[index + 52];
speed[index] = line[index + 64];
}
// read the channelization codes for each lane
for (index = 0; index < net_max_lanes; index++)
{
ch[index][1] = line[index + 29];
}
full_lanes_num[0] = line[21];
left_bays_num[0] = line[23];
right_bays_num[0] = line[25];
if ((atoi(dn) < 8000) && (atoi(up) < 8000))
{
// link is not a source link so create it
link = new CLink();
link->m_full_lanes_num = atoi(full_lanes_num);
link->m_left_turn_bays_num = atoi(left_bays_num);
link->m_left_bays_len = atoi(left_bays_len);
link->m_right_turn_bays_num = atoi(right_bays_num);
link->m_right_bays_len = atoi(right_bays_len);
link->m_length = atoi(length);
link->m_free_flow_speed = atoi(speed);
if (link->m_free_flow_speed == 0)
link->m_free_flow_speed = 44;
link->m_up_node = findNode(atoi(up));
link->m_dn_node = findNode(atoi(dn));
link->m_thru_node = findNode(atoi(th));
link->m_left_node = findNode(atoi(le));
link->m_right_node = findNode(atoi(ri));
link->m_corsim_id = getLinkCorsimId(link->m_up_node->getId(), link->m_dn_node->getId());
link->setOpposingNodeId(atoi(op));
if ((atoi(up) < 8000) && (atoi(dn) < 8000))
link->m_travel_time = link->computeTravelTime();
for (index = 0; index < net_max_lanes; index++)
{
link->m_str_channel_code[index] = _T(ch[index][1]);
}
m_link_list.AddTail(link);
}
}
else if (card_type > 11)
{
// because corsim expects the cards to be in ascending order by card type, we can jump out of the loop as soon as we encounter a card type greater than 11
break;
}
}
}
const_iterator HashMap<Key, T, Hasher, EqualKey, Alloc>::
find(const Key& key) const {
return const_iterator(findNode(key) );
}
/**
* Find the shortest path between two nodes
* using a simple implementation of dijkstra's algorithm:
* http://en.wikipedia.org/wiki/Dijkstra's_algorithm
*
* @param graph Graph to traverse
* @param node1 Starting node
* @param node2 Destination node
* @return The id which is the nexthop otherwise NULL if no path exists
*/
int shortest_path(graph_t* graph, int node1, int node2)
{
node_t* u = NULL;
node_t* v = NULL;
node_t* target = NULL;
edge_t* e = NULL;
int* lut = NULL;
int* d = NULL;
int numnodes = 0;
int i = 0;
int j = 0;
int idx = 0;
int mindist = INFINITY;
int minidx = -1;
int ret = 0;
if(graph == NULL)
return -1;
u = findNode(graph, node1);
v = target = findNode(graph, node2);
if(u == NULL || v == NULL)
return -1;
numnodes = u->edgecount;
lut = malloc(numnodes * sizeof(int));
d = malloc(numnodes * sizeof(int));
memset(d, INFINITY, numnodes * sizeof(int));
// lut simply maps our node id's into a range from [0, nodecount)
for(i = 0 ; i < numnodes ; ++i) {
e = u->edges[i];
lut[i] = (e->p1 == u) ? ((node_t*)e->p2)->id : ((node_t*)e->p1)->id;
d[i] = INFINITY;
}
u->marked = 1;
// Now, for each neighbor, find the distance to
// the target node
for(i = 0 ; i < numnodes ; ++i) {
// Unmark all nodes
for(j = 0 ; j < graph->nodecount ; ++j) {
if(graph->nodes[j] != u)
graph->nodes[j]->marked = 0;
}
e = u->edges[i];
if(e->weight == INFINITY) // No longer exists
continue;
v = (node_t*)((e->p1 == u) ? e->p2 : e->p1);
idx = findIdx(lut, v->id, numnodes);
d[idx] = shortest_path_helper(graph, v, target);
d[idx] += (d[idx] != INFINITY) ? e->weight : 0;
if((d[idx] < mindist || mindist == INFINITY) && d[idx] != INFINITY) {
mindist = d[idx];
minidx = idx;
}
}
ret = (minidx >= 0 && minidx < numnodes) ? lut[minidx] : -1;
free(d);
free(lut);
return ret;
}
bool BinaryNodeTree<ItemType>:: contains(const ItemType& anEntry) const
{
bool isSuccessful = false;
findNode(rootPtr, anEntry, isSuccessful);
return isSuccessful;
} // end contains
void test(bool mirrorX, bool mirrorY, qreal rotation, bool mirrorDabX, bool mirrorDabY, qreal dabRotation) {
KisSurrogateUndoStore *undoStore = new KisSurrogateUndoStore();
KisImageSP image = createTrivialImage(undoStore);
image->initialRefreshGraph();
KisNodeSP paint1 = findNode(image->root(), "paint1");
QVERIFY(paint1->extent().isEmpty());
KisPainter gc(paint1->paintDevice());
QScopedPointer<KoCanvasResourceManager> manager(
utils::createResourceManager(image, 0, m_presetFileName));
KisPaintOpPresetSP preset =
manager->resource(KisCanvasResourceProvider::CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
preset->settings()->setCanvasRotation(rotation);
preset->settings()->setCanvasMirroring(mirrorY, mirrorX);
if (mirrorDabX || mirrorDabY) {
KisPaintOpSettingsSP settings = preset->settings()->clone();
KisPressureMirrorOption mirrorOption;
mirrorOption.readOptionSetting(settings);
mirrorOption.setChecked(true);
mirrorOption.setCurveUsed(false);
mirrorOption.enableHorizontalMirror(mirrorDabX);
mirrorOption.enableVerticalMirror(mirrorDabY);
mirrorOption.writeOptionSetting(settings.data());
preset->setSettings(settings);
}
if (dabRotation != 0.0) {
KisPaintOpSettingsSP settings = preset->settings()->clone();
KisPressureRotationOption rotationOption;
rotationOption.readOptionSetting(settings);
rotationOption.setChecked(true);
rotationOption.setCurveUsed(false);
rotationOption.setValue(dabRotation / 360.0);
rotationOption.writeOptionSetting(settings.data());
preset->setSettings(settings);
}
QString testName =
QString("%7_cmY_%1_cmX_%2_cR_%3_dmX_%4_dmY_%5_dR_%6")
.arg(mirrorY)
.arg(mirrorX)
.arg(rotation)
.arg(mirrorDabX)
.arg(mirrorDabY)
.arg(std::fmod(360.0 - dabRotation, 360.0))
.arg(m_prefix);
KisResourcesSnapshotSP resources =
new KisResourcesSnapshot(image,
paint1,
manager.data());
resources->setupPainter(&gc);
doPaint(gc);
checkOneLayer(image, paint1, testName);
}
static void printTypeExample(Tree *example, unsigned num, char *names[],
char orders[], unsigned indices[],
int *univs[], int trees[])
{
trace_descr bools;
int i;
bools = find_one_path(example->bddm,
BDD_ROOT(example->bddm,
example->behavior_handle),
example->state);
for (i = 0; i < num; i++) {
printf(" %s = ", names[i]);
switch (orders[i]) {
case 0: /* Boolean variable */
{
trace_descr t = bools;
while (t && (t->index != indices[i]))
t = t->next;
if (t && t->value)
printf("true\n");
else
printf("false\n");
break;
}
case 1: /* first-order variable */
{
int j, first = 1, any = 0;
for (j = 0; univs[i][j] != -1; j++) {
int u = univs[i][j];
Tree *t = findNode(example, guide.univPos[u], 0);
if (t) {
char *univname = guide.univName[u];
char *path = (char *) mem_alloc(strlen(univname)+2);
sprintf(path, "%s:", univname);
printTypePositions(t, indices[i], &first, 1, 0, path,
guide.ssType[t->d]);
if (!first)
any = 1;
mem_free(path);
}
}
if (!any)
printf("?");
printf("\n");
break;
}
case 2: /* second-order variable */
{
if (trees[i]) { /* print as typed tree */
int j, any = 0;
for (j = 0; univs[i][j] != -1 && !any; j++) {
int u = univs[i][j];
Tree *t = findNode(example, guide.univPos[u], 0);
if (t) {
char *univname = guide.univName[u];
char *path = (char *) mem_alloc(strlen(univname)+2);
sprintf(path, "%s:", univname);
t = printTreeRoot(t, indices[i], guide.ssType[t->d], path);
mem_free(path);
if (t) {
printTypedTree(guide.ssType[t->d], t, indices[i]);
any = 1;
}
}
}
if (!any)
printf("?");
printf("\n");
}
else { /* print as set of positions */
int j, first = 1;
printf("{");
for (j = 0; univs[i][j] != -1; j++) {
int u = univs[i][j];
Tree *t = findNode(example, guide.univPos[u], 0);
if (t) {
char *univname = guide.univName[u];
char *path = (char *) mem_alloc(strlen(univname)+2);
sprintf(path, "%s:", univname);
printTypePositions(t, indices[i], &first, 1, 1, path,
guide.ssType[t->d]);
mem_free(path);
}
}
printf("}\n");
}
break;
}
}
}
kill_trace(bools);
}
bool ZLBlockTreeView::onStylusMove(int x, int y) {
ZLBlockTreeNode *node = findNode(y);
ZLApplication::Instance().setHyperlinkCursor(node != 0 && node->isOverHyperlink(x, y));
return true;
}
int main(void)
{
HuffmanTree *hft = createHFTree();
int erro, pos;
char code[100];
short verbose = 1;
//Inserir código novo
strcpy(code, "000");
erro = addNode(hft, code, 0, verbose);
//Inserir código já inserido
strcpy(code, "000");
erro = addNode(hft, code, 1, verbose);
//Tentar derivar folha
strcpy(code, "00001");
erro = addNode(hft, code, 1, verbose);
//Inserir código novo
strcpy(code, "11100");
erro = addNode(hft, code, 3, verbose);
//Inserir código já inserido
strcpy(code, "11100");
erro = addNode(hft, code, 3, verbose);
//Tentar derivar folha
strcpy(code, "111001");
erro = addNode(hft, code, 3, verbose);
printf("---------------\n");
//---- pesquisar código bit a bit (simula situação correspondente ao deflate)
//exemplo 1
char buffer[100];
strcpy (buffer, "11100010");
int lv = 0, lenc, len = (int) strlen(buffer);
int sair = false;
strcpy (code, "");
char nextBit;
while(!sair && lv < len)
{
nextBit = buffer[lv];
//actualizar code com o próximo bit
lenc = (int) strlen(code);
code[lenc] = nextBit;
code[lenc+1] = 0;
//pesquisar next bit na árvore, a partir do nó corrente
pos = nextNode(hft, nextBit);
//printf("%d %d %d %d\n", lv, hft->curNode->index, hft->curNode->left, hft->curNode->right);
if (pos != -2)
sair = true;
else
lv = lv + 1;
}
if (pos == -1)
printf("Código '%s' não encontrado\n", code);
else if (pos == -2)
printf("Código '%s' não encontrado, mas prefixo\n", code);
else
printf("Código '%s' corresponde à posição %d do alfabeto\n", code, pos);
//exemplo 2
resetCurNode(hft); //volta a possicionar curNode na raíz da árvore
strcpy (buffer, "1110");
lv = 0;
len = (int) strlen(buffer);
sair = 0;
strcpy (code, "");
while(!sair && lv < len)
{
nextBit = buffer[lv];
//actualizar code com o próximo bit
lenc = (int) strlen(code);
code[lenc] = nextBit;
code[lenc+1] = 0;
//pesquisar next bit na árvore, a partir do nó corrente
pos = nextNode(hft, nextBit);
//printf("%d %d %d %d\n", lv, hft->curNode->index, hft->curNode->left, hft->curNode->right);
if (pos != -2)
sair = true;
else
lv = lv + 1;
}
if (pos == -1)
printf("Código '%s' não encontrado\n", code);
else if (pos == -2)
printf("Código '%s' não encontrado, mas prefixo\n", code);
else
printf("Código '%s' corresponde à posição %d do alfabeto\n", code, pos);
printf("---------------\n");
// ------------------- Pesquisa de códigos inteiros
strcpy(code, "000");
pos = findNode(hft, code, verbose);
strcpy(code, "11100");
pos = findNode(hft, code, verbose);
strcpy(code, "111");
pos = findNode(hft, code, verbose);
system("PAUSE");
return EXIT_SUCCESS;
}
int Circuit::createSUBModule(const string &input1, const string &input2, const string &output, unsigned int numBits)
{
Node* node;
// create input nodes
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = input1 + "[" + sstr.str() + "]";
node = createNode(name);
}
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = input2 + "[" + sstr.str() + "]";
node = createNode(name);
}
// create output nodes
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output + "[" + sstr.str() + "]";
node = createNode(name);
}
// create one node and zero node
Node* zeroNode = createNode("ZERO");
createZERONode(zeroNode);
Node* oneNode = createNode("ONE");
createONENode(oneNode);
// create c_out node
Node* c_out = createNode("cout");
// create internal1 nodes
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output+"h";
name = name + "[" + sstr.str() + "]";
node = createNode(name);
}
// inverse the input2
for (unsigned int i = 0; i < numBits; ++i)
{
stringstream sstr;
sstr << i;
string name = output +"h";
name = name + "[" + sstr.str() + "]";
Node* hh = findNode(name);
assert(hh != NULL);
name = input2 + "[" + sstr.str() + "]";
Node* inNode2 = findNode(name);
assert(inNode2 != NULL);
createXOR3Node(zeroNode, oneNode, inNode2, hh);
}
// add input1 and the complemented input2
createADDModule(input1, output+"h", "ONE", output, "cout" ,numBits);
// when you have implemented this function,
// change 'return -1' to 'return 0'
return 0;
}
int ccTreeMap::findValue(const char* key, ICompareStrings *comparer) {
ccTreeMap *result = findNode(key, comparer);
if (result == NULL)
return -1;
return result->value;
}
void Tree::deleteNode(int key)
{
// Find the node.
Node* thisKey = findNode(key, root);
MTPD("Tree::deleteNode found node: %d\n", thisKey);
MTPD("handle: %d\n", thisKey->Mtpid());
if (thisKey == root) {
if (thisKey->Right()) {
root = thisKey->Right();
root->setParent(NULL);
return;
}
if (thisKey->Left()) {
root = thisKey->Left();
root->setParent(NULL);
return;
}
root = NULL;
delete thisKey;
return;
}
if ( thisKey->Left() == NULL && thisKey->Right() == NULL )
{
if ( thisKey->Mtpid() > thisKey->Parent()->Mtpid() ) {
thisKey->Parent()->setRight(NULL);
}
else {
thisKey->Parent()->setLeft(NULL);
}
delete thisKey;
return;
}
if ( thisKey->Left() == NULL && thisKey->Right() != NULL )
{
if ( thisKey->Mtpid() > thisKey->Parent()->Mtpid() )
thisKey->Parent()->setRight(thisKey->Right());
else
thisKey->Parent()->setLeft(thisKey->Right());
thisKey->Right()->setParent(thisKey->Parent());
delete thisKey;
return;
}
if ( thisKey->Left() != NULL && thisKey->Right() == NULL )
{
if ( thisKey->Mtpid() > thisKey->Parent()->Mtpid() )
thisKey->Parent()->setRight(thisKey->Left());
else
thisKey->Parent()->setLeft(thisKey->Left());
thisKey->Left()->setParent(thisKey->Parent());
delete thisKey;
return;
}
if ( thisKey->Left() != NULL && thisKey->Right() != NULL )
{
Node* sub = predecessor(thisKey->Mtpid(), thisKey);
if ( sub == NULL )
sub = successor(thisKey->Mtpid(), thisKey);
if ( sub->Parent()->Mtpid() <= sub->Mtpid() )
sub->Parent()->setRight(sub->Right());
else
sub->Parent()->setLeft(sub->Left());
thisKey->setMtpid(sub->Mtpid());
delete sub;
return;
}
}
int main(int argc, char *argv[]) {
/*
printf("Argument count: %d\n", argc);
for (int i = 0; i < argc; i++) {
printf("Argument vector values:%s at %p memory\n", argv[i], argv[i]);
for (char *j=argv[i]; *j!='\0'; j++) {
printf("Another way to print argument vector values: "
"%c at %p memory\n", *j, j);
}
}
*/
//int arr[MAX_LEN] = {5,60,14,50,9,10,5,14,130,14,0,1,2,13,4,10,5,14,130,14,0,1,2,13,4};
//int arr[MAX_LEN] = {14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
int arr[MAX_LEN] = {14,60,14,50,9,10,5,14,130,14,0,1,2,15,14};
//int arr[MAX_LEN] = {5,5,5,5,5,0,2,7,2,15,6,6,0,15,5};
//int arr[MAX_LEN] = {5,5,5,5,5,5,5,15,15,5,5,5,5,5,5};
//int arr[MAX_LEN] = {5,5,5,5,5,5,5,5,5,5,5,5,5,5,5};
struct node *head = NULL; /* beginning */
struct node *end = NULL; /* end */
head = newNode(arr[0]);
//printf("Start Pointer of Linked List is: %p\n",head);
//printf("Start Data of Linked List is: %d\n",head->data);
end = newNode(arr[1]);
head->next = end;
//printf("Initial End Pointer of Linked List is: %p\n",end);
//printf("Initial End Data of Linked List is: %d\n",end->data);
for (int num = 2; num<MAX_LEN; num++) {
end = appendNode(end,arr[num]);
//printf("Appended Pointer of Linked List is: %p\n",end);
//printf("Appended Data of Linked List is: %d\n",end->data);
}
iterateNodes(head);
//head = addNodetoFront(head,14);
//iterateNodes(head);
int findVal = 14;
struct node *foundNode, *newHead = NULL;
foundNode = findNode(head,findVal);
if (foundNode) {
printf("Value: %d found at address: %p\n",findVal,foundNode);
newHead = sortAroundVal(&head,newHead,findVal);
}
else {
printf("Value: %d not found\n",findVal);
}
iterateNodes(newHead);
iterateNodes(head);
printf("\nFreeing Linked List old:\n");
struct node *temp;
while (head!=NULL) {
temp = head;
head=head->next;
free(temp);
}
//head = NULL; /* Mark list as empty*/
printf("\nFreeing Linked List new:\n");
while (newHead!=NULL) {
temp = newHead;
newHead=newHead->next;
free(temp);
}
return 0;
}
void FixAspectRatio(){
unsigned int cameraNode = findNode("avatar_camera");
if(cameraNode)
setCameraAspectRatio(cameraNode, (float)getScreenWidth() / (float)getScreenHeight());
}
// Removes one element from the dictionary
bool
AVLDictionary::removeElement(KeyType key)
{
if (debug)
{
printf("------------------------------------\n");
printf("removeElement(\"%s\")\n", key);
printf("---------- Before -----------------\n");
printNode("", root, 0);
}
AVLNode *node;
node = findNode(key);
if (node == NULL)
{
return false;
}
if (node->left == NULL && node->right == NULL)
{
if ( node == node->parent->left)
{
node->parent->left = NULL;
}
else
{
node->parent->right = NULL;
}
AVLNode *m;
m = node->parent;
while(m != NULL)
{
int maxheight = 0;
if(m->left != NULL)
{
maxheight = m->left->height;
}
if (m->right != NULL && maxheight < m->right->height)
{
maxheight = m->right->height;
}
m->height = maxheight +1;
m = m->parent;
}
restructure(node->parent);
delete node;
}
else if (node->left == NULL)
{
AVLNode temp;
temp.height = node->height;
strcpy((char*)temp.key, node->key);
temp.data = node->data;
node->height = node->right->height;
strcpy((char*)node->key, node->right->key);
node->data = node->right->data;
node->right->height = temp.height;
strcpy((char*)node->right->key, temp.key);
node->right->data = temp.data;
delete node->right;
node->right = NULL;
AVLNode *m = node->parent;
while(m != NULL)
{
int maxheight = 0;
if(m->left != NULL)
{
maxheight = m->left->height;
}
if (m->right != NULL && maxheight < m->right->height)
{
maxheight = m->right->height;
}
m->height = maxheight +1;
m = m->parent;
}
restructure(node);
}
else if (node->right == NULL)
{
AVLNode temp;
temp.height = node->height;
strcpy((char*)temp.key, node->key);
temp.data = node->data;
node->height = node->left->height;
strcpy((char*)node->key, node->left->key);
node->data = node->left->data;
node->left->height = temp.height;
strcpy((char*)node->left->key, temp.key);
node->left->data = temp.data;
delete node->left;
node->left = NULL;
AVLNode *m;
m = node->parent;
while(m != NULL)
{
int maxheight = 0;
if( m->left != NULL)
{
maxheight = m->left->height;
}
if (m->right != NULL && maxheight < m->right->height)
{
maxheight = m->right->height;
}
m->height = maxheight +1;
m = m->parent;
}
restructure(node);
}
else
{
AVLNode *replacement;
replacement = node->left;
if (replacement->right == NULL)
{
replacement = node->right;
while(replacement->left != NULL)
{
replacement = replacement->left;
}
}
else
{
while (replacement->right != NULL)
{
replacement = replacement->right;
}
}
AVLNode temp;
temp.height = node->height;
strcpy((char*)temp.key, node->key);
temp.data = node->data;
node->height = replacement->height;
strcpy((char*)node->key, replacement->key);
node->data = replacement->data;
replacement->height = temp.height;
strcpy((char*)replacement->key, temp.key);
replacement->data = temp.data;
AVLNode *n;
n = replacement->parent;
if (n != NULL)
{
if (replacement == n->left)
{
n->left = NULL;
delete replacement;
}
else
{
n->right = NULL;
delete replacement;
}
AVLNode *m = n;
while(m != NULL)
{
int maxheight = 0;
if(m->left != NULL)
{
maxheight = m->left->height;
}
if (m->right != NULL && maxheight < m->right->height)
{
maxheight = m->right->height;
}
m->height = maxheight +1;
m = m->parent;
}
restructure(n);
}
}
nElements--;
if (debug)
{
printf("---------- After -----------------\n");
printNode("", root, 0);
checkRecursive(root);
}
return true;
}
