int main(
int argc,
char **argv)
{
olRoot root;
olNode node;
uint32 xNode;
utStart();
utInitLogFile("ordered_benchmark.log");
olDatabaseStart();
root = olRootAlloc();
if(argc != 1) {
utExit("Usage: benchmark");
}
for(xNode = 0; xNode < NUM_NODES; xNode++) {
nodeCreate(root, xNode);
}
for(xNode = NUM_NODES; xNode < NUM_NODES << 1; xNode++) {
nodeCreate(root, xNode);
node = olRootGetFirstNode(root);
olRootRemoveNode(root, node);
olNodeFree(node);
}
olVerifyOrderedList(root);
olReportStats(root);
olSafeForeachRootNode(root, node) {
olRootRemoveNode(root, node);
olNodeFree(node);
} olEndSafeRootNode;
int main() {
Node head = nodeCreate(10);
printf("2. The list and the linked list is now:\n");
int array[] = {9,8,7,6,5,4,3,2,1};
for(int i = 0; i < 9; i++) {
head = listAppend(head, array[i]);
}
Node item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
head = partitionList(head, 9);
item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
return 0;
}
// loadFile, load input file into a stack
stack * loadFile(char *Filename, int * n)
{
char split;
double width, height;
int success;
FILE *fptr = fopen(Filename, "r");
if(!fptr || feof(fptr))
{
printf("File loading failed: File does not exist or is empty.\n");
return NULL;
}
stack * stackMem = NULL;
success = fscanf(fptr, "%lf %c %lf %c", &width, &split, &height, &split);
if(success){};
node * leaf;
while(fscanf(fptr, "%c", &split) != EOF)
{
if (split=='(')
{
success = fscanf(fptr, "%lf %c %lf %c", &width, &split, &height, &split);
leaf = nodeCreate(width,height,'-',*n);
stackMem = StackPush(stackMem, leaf);
(*n)++;
}
else if (split=='H')
{
leaf = nodeCreate(0,0,split,*n);
stackMem = StackPush(stackMem, leaf);
(*n)++;
}
else if (split=='V')
{
leaf = nodeCreate(0,0,split,*n);
stackMem = StackPush(stackMem, leaf);
(*n)++;
}
else
printf("\n");
}
fclose(fptr);
return stackMem;
}
Node listAppend(Node head, int number) { //2.向list的尾巴增加一个node
Node node = nodeCreate(number);
Node item = head;
while(item->next != NULL) {
item = item->next;
}
item->next = node;
return head;
}
int main() {
Node head1 = nodeCreate(3);
Node head2 = nodeCreate(3);
int array1[] = {8,7,8,9,2};
for(int i = 0; i < 2; i++) {
head1 = listAppend(head1, array1[i]);
}
int array2[] = {4,5,3};
for(int i = 0; i < 2; i++) {
head2 = listAppend(head2, array2[i]);
}
printf("1.1 list 1 and the linked list is now:\n");
Node item = head1;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
printf("1.2 list 2 and the linked list is now:\n");
item = head2;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
Node head = addTwoLists(head1, head2);
item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
return 0;
}
int commandExecuterNewEntity(CommandExecuter commandExecuter,Command command){
CommandExecuterInternal* internal=(CommandExecuterInternal*)commandExecuter;
Node node;
StringHashMap attributesMap=commandGetAttributes(command,ATTRIBUTES);
int lock=commandGetInt(command,LOCK)==TRUE?TRUE:FALSE;
int result= nodeCreate(internal->registry,commandGetInt(command,ENTITY_ID),commandGetInt(command,SCHEMA_ID),lock,&node,internal->sessionMetaData->id);
if(result==VALID){
stringHashmapPutAll(node->attributes,attributesMap);
}
stringHashmapFree(attributesMap);
return result;
}
/*------------*/
void treeCreate(int npoin,double x[],double y[],double rad)
{
int i,j;
double xfind;
double yfind;
double rfind2;
node* inode;
inode = nodeCreate(x[0],y[0]);
mytree.root = inode;
id = id + 1;
/* put remaining points into tree */
for(i=1;i<npoin;i++)
{
inode = nodeCreate(x[i],y[i]);
nodeInsert(mytree.root,inode);
id = id + 1;
}
/* search for a point */
xfind = 0.34;
yfind = 0.1;
node* nget = NULL;
nodeGet(mytree.root,&nget,xfind,yfind);
if(nget != NULL){
xfind = nget->x;
yfind = nget->y;
rfind2 = nget->norm2;
}
else{
rfind2 = xfind*xfind + yfind*yfind;
}
nodeSeperation(mytree.root,xfind,yfind,rfind2,rad);
}
// buildTree, build tree from stack
void buildTree(stack * head, node * root, node ** topHead, int n)
{
if(head==NULL || root == NULL)
{
printf("Error, Tree is NULL\n");
return;
}
while(head)
{
root -> left = nodeCreate(NODE->width, NODE->height, NODE->split, NODE->index-1);
root = root -> left;
head = head->next;
}
}
int main() {
Node head = nodeCreate(1);
printf("1. head is %d\n\n\n\n", head->num);
printf("2. The list and the linked list is now:\n");
int array[] = {10, 3, 10, 7, 2, 11, 5, 9, 11, 6, 0, 6, 11, 6};
for(int i = 0; i < 9; i++) {
head = listAppend(head, array[i]);
}
Node item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
printf("3. Now we are testing the nodDel() function.\n");
Node target = listSearch(head, 1);
head = nodeDel(head, target);
printf("4.\n");
// printf("3. Now we are testing the delDups() function.\n");
// head = delDups(head);
item = head;
if(head == NULL)
{
printf("The list is empty");
}
else
{
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
}
return 0;
}
List listCreate(CopyListElement copyElement, FreeListElement freeElement) {
if (!copyElement || !freeElement) {
return NULL;
}
List ptr = malloc(sizeof(struct List_t));
if (!ptr) {
return NULL;
}
ptr->head = nodeCreate(NULL, NULL);
if (!ptr->head) {
free(ptr);
return NULL;
}
ptr->current = NULL;
ptr->size = 0;
ptr->copyElement = copyElement;
ptr->freeElement = freeElement;
return ptr;
}
int main() {
Node head = nodeCreate(1);
printf("1. head is %d\n\n\n\n", head->num);
printf("2. The list and the linked list is now:\n");
int array[] = {4, 3, 2, 7, 2, 6, 5, 9, 5, 6, 0, 6, 11, 6};
for(int i = 0; i < 14; i++) {
head = listAppend(head, array[i]);
}
Node item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
printf("3. Now we are testing listSort() function.\n");
Node sorted;
sorted = listSort(head);
printf("The list after sorting is:");
item = sorted;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
printf("4. Now we are testing deleting the duplicated element.\n");
Node headFin = removeDup(sorted);
item = headFin;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n", item->num);
return 0;
}
int main() {
Node head = nodeCreate(1);
printf("1. head is %d\n\n\n\n", head->num);
printf("2. The list and the linked list is now:\n");
int array[] = {10, 3, 10, 7, 2, 9, 5, 9, 11, 6, 0, 6, 11, 6};
for(int i = 0; i < 9; i++) {
head = listAppend(head, array[i]);
}
Node item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
Node target = listSearch(head, 11);
_Bool isDel = NodeDelWithNoReturnValue(target);
if(isDel == true)
{
item = head;
while(item->next != NULL) {
printf("%d ", item->num);
item = item->next;
}
printf("%d\n\n\n\n", item->num);
}
else
{
printf("can not delete\n");
}
return 0;
}
void fileHelperLoad(FileHelper fileHelper) {
FileHelperInternal *m = (FileHelperInternal *) fileHelper;
fileHelperCheckCreate(m->filePath);
int sizeOfInt = sizeof(int);
struct direct **schemasIds = {0};
struct direct *schenaId;
int size = scandir(m->filePath, &schemasIds, 0, alphasort);
// loop all schemas
int i;
for (i = 0; i < size; i++) {
schenaId = (struct direct *) schemasIds[i];
char *schemaIdString = schenaId->d_name;
int schemaId = atoi(schemaIdString);
if (schemaId != 0) {
printf("schema %s\n", schenaId->d_name);
struct direct **pagesIds = {0};
struct direct *pageStruct;
char endOdString = '\0';
int pageDirLength = strlen(m->filePath);
int schemaIdStringLength = strlen(schemaIdString);
char slesh = '/';
char *pageDir = (char *) memoryAlloc(pageDirLength + 1 + schemaIdStringLength + 1);
memcpy(pageDir, m->filePath, pageDirLength);
memcpy(pageDir + pageDirLength, &slesh, 1);
memcpy(pageDir + pageDirLength + 1, schemaIdString, schemaIdStringLength);
memcpy(pageDir + pageDirLength + 1 + schemaIdStringLength, &endOdString, 1);
// cleanBuffer(pageDir);
// strcat(pageDir,m->filePath);
// strcat(pageDir,"/");
// strcat(pageDir,schemaIdString);
HashMap childrenRelations = hashmapCreate(SMALL_CONTAINER_SIZE);
Registry registry = registryCreate();
hashmapPut(m->registryMap, schemaId, registry);
PageManager pageManager = pageManagerCreate(schemaId, pageDir);
hashmapPut(m->managers, schemaId, pageManager);
int size = scandir(pageDir, &pagesIds, 0, alphasort);
int h;
//loop pages
for (h = 0; h < size; h++) {
//scandir (pageDir, &pagesIds, 0, alphasort);
pageStruct = (struct direct *) pagesIds[h];
char *pageString = pageStruct->d_name;
int pageId = atoi(pageString);
if (pageId != 0) {
printf("page %s\n", pageStruct->d_name);
// create file path.
//int i=0;
int pageDirLength = strlen(pageDir);
int pageStringLength = strlen(pageString);
char slesh = '/';
char *filePath = (char *) memoryAlloc(pageDirLength + 1 + pageStringLength + 1);
memcpy(filePath, pageDir, pageDirLength);
memcpy(filePath + pageDirLength, &slesh, 1);
memcpy(filePath + pageDirLength + 1, pageString, pageStringLength);
memcpy(filePath + pageDirLength + 1 + pageStringLength, &endOdString, 1);
FILE *fp;
long len;
// Create pointer to file.
fp = fopen(filePath, "rb");
if (fp == NULL) {
printf("couldn't open the properties file");
}
fseek(fp, 0, SEEK_END); // Go to end
len = ftell(fp); // Get position at end (length)
// Read data to buffer
char *buffer = memoryAlloc(sizeof(char) * len); // Create buffer
char *pointerToFreeBuffer = buffer;
fseek(fp, 0, SEEK_SET); // Go to the beginning.
int result = fread(buffer, len, 1, fp); // Read into buffer
if (result < 0) {
printf("Fail to read file : %s", buffer);
}
fclose(fp);
int order = 0;
long index = 0;
long step = 0;
while (index < len) {
char *start = buffer;
int id;
int schemaId;
int numberOfAttributes;
int childrenSize;
int attributeSize;
memcpy(&schemaId, buffer + SIZE_OF_INT * 0, SIZE_OF_INT);
memcpy(&id, buffer + SIZE_OF_INT * 1, SIZE_OF_INT);
memcpy(&numberOfAttributes, buffer + SIZE_OF_INT * 2, SIZE_OF_INT);
buffer += SIZE_OF_INT * 3;
Node node;
nodeCreate(registry, id, schemaId, FALSE, &node);
int h;
for (h = 0; h < numberOfAttributes; h++) {
memcpy(&attributeSize, buffer, SIZE_OF_INT);
Attribute attribute = attributeDeserializeLocal(buffer);
buffer += attributeSize;
stringHashmapPut(node->attributes, attribute->name, attribute->nameLength, attribute);
}
memcpy(&childrenSize, buffer, SIZE_OF_INT);
Array children = arrayCreate(childrenSize);
hashmapPut(childrenRelations, id, children);
int i;
buffer += SIZE_OF_INT;
int childrenIdBuffer;
for (i = 0; i < childrenSize; i++) {
memcpy(&childrenIdBuffer, buffer + SIZE_OF_INT, SIZE_OF_INT);
void *bufferElement = memoryAlloc(childrenIdBuffer + SIZE_OF_INT * 2);
memcpy(bufferElement, buffer, SIZE_OF_INT * 2 + childrenIdBuffer);
arrayInsertObject(children, bufferElement);
buffer += SIZE_OF_INT * 2 + childrenIdBuffer;
}
step = buffer - start;
index += step;
pageManagerRegister(pageManager, pageId, id, index - step, index, order, filePath);
order++;
}
// Free the file buffer
memoryFree(pointerToFreeBuffer);
}
}
if (size > 0) {
while (size) {
size = size - 1;
free(pagesIds[size]);
}
free(pagesIds);
}
hashmapIterate(childrenRelations, &updateChildren, registry);
hashmapFree(childrenRelations);
}
}
if (size > 0) {
while (size) {
size = size - 1;
free(schemasIds[size]);
}
free(schemasIds);
}
}
int validationManagerValidateOnCoreExecuteInternalRecurcive(ValidationManager validationManager,ArrayList commands,int administrator,int dept){
ValidationManagerStruct* internal=(ValidationManagerStruct*)validationManager;
if(commands!=NULL&&dept<arrayListSize(commands)){
Command command=arrayListGetValueAt(commands,dept);
int coreManagerId=commandGetInt(command,CORE_MANAGER_ID);
int sessionId=commandGetInt(command,SESSION_ID);
int transaction=commandGetInt(command,TRANSACTION);
int schimaId=commandGetInt(command,SCHEMA_ID);
int type=commandGetInt(command,COMMAND_TYPE);
int version=commandGetInt(command,VERSION);
int entityId=commandGetInt(command,ENTITY_ID);
VALIDATE_TRANSACTION(transaction);
VALIDATE_CORE_MANAGER_ID(coreManagerId);
VALIDATE_SESSION_ID(sessionId);
if(IS_CREATE_NEW_ENTITY(type)){
int lock=commandGetInt(command,LOCK);
StringHashMap newAttributesMap=commandGetAttributes(command,ATTRIBUTES);
VALIDATE(registryValidateNodeCreate(internal->registry,entityId));
Node node;
nodeCreate(internal->registry,entityId,schimaId,lock,&node);
stringHashmapPutAll(node->attributes,newAttributesMap);
stringHashmapFree(newAttributesMap);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
registryDeleteNode(internal->registry,node);
return result;
}
char* buf;
int length=nodeSerialize(node,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_ADD_CHILD_ENTITY_TO_PARENT_ENTITY(type)){
char* arcName;
int childEntityId=commandGetInt(command,ENTITY_CHILD_ID);
int arcNameLenght=commandGetString(command,ARC_NAME,&arcName);
Node parent;
registryGetNode(internal->registry,entityId,&parent);
Node child;
registryGetNode(internal->registry,childEntityId,&child);
VALIDATE(registryValidateAddChild(parent,child,arcName,arcNameLenght,sessionId));
registryAddChild(internal->registry,parent,child,arcName,arcNameLenght);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
registryRemoveChild(internal->registry,parent,arcName,arcNameLenght);
return result;
}
char* buf;
int length=nodeSerialize(parent,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_REMOVE_CHILD_ENTITY_FROM_PARENT_ENTITY(type)){
char* arcName;
int childEntityId=commandGetInt(command,ENTITY_CHILD_ID);
int arcNameLenght=commandGetString(command,ARC_NAME,&arcName);
Node parent;
registryGetNode(internal->registry,entityId,&parent);
Node child;
registryGetNode(internal->registry,childEntityId,&child);
VALIDATE(registryValidateRemoveChild(parent,arcName,arcNameLenght,sessionId));
registryRemoveChild(internal->registry,parent,arcName,arcNameLenght);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
registryAddChild(internal->registry,parent,child,arcName,arcNameLenght);
return result;
}
char* buf;
int length=nodeSerialize(parent,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_LOCK_ENTITY(type)){
int lock=commandGetInt(command,LOCK);
int forceLock=commandGetInt(command,FORCE_LOCK);
Node node;
registryGetNode(internal->registry,entityId,&node);
VALIDATE(registryValidateUpdateLock(node,lock,sessionId,forceLock,administrator));
registryUpdateLock(internal->registry,node,lock,sessionId);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
int revertedLock=lock==TRUE?FALSE:TRUE;
registryUpdateLock(internal->registry,node,revertedLock,sessionId);
return result;
}
}
if(IS_DELETE_ENTITY(type)){
int lock=commandGetInt(command,LOCK);
Node node;
VALIDATE(registryGetNode(internal->registry,entityId,&node));
VALIDATE(registryValidateDeleteNode(node,sessionId));
registryDeleteNode(internal->registry,node);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if( VALID!= result){
nodeCreate(internal->registry,entityId,schimaId,lock,&node);
return result;
}
}
if(IS_ADD_ATTRIBUTE(type)){
StringHashMap newAttributesMap=commandGetAttributes(command,ATTRIBUTES);
Node node;
registryGetNode(internal->registry,entityId,&node);
VALIDATE(registryValidateUpdate(node,sessionId));
Array array;
stringHashmapToArray(newAttributesMap,&array);
int lenght=arrayGetLength(array);
int i;
StringHashMap toRemove = stringHashmapCreate(SMALL_CONTAINER_SIZE);
for(i=0;i<lenght;i++){
Attribute newAttribute=(Attribute)arrayGetObject(array,i);
Attribute oldAttribute;
stringHashmapGet(node->attributes,newAttribute->name,newAttribute->nameLength,(Object) &oldAttribute);
if(oldAttribute!=NULL){
stringHashmapPut(toRemove,newAttribute->name,newAttribute->nameLength,oldAttribute);
stringHashmapRemove(node->attributes,newAttribute->name,newAttribute->nameLength);
}
stringHashmapPut(node->attributes,newAttribute->name,newAttribute->nameLength,(Object)newAttribute);
}
arrayFree(array);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if(result!=VALID){
stringHashmapToArray(newAttributesMap,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute newAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(node->attributes,newAttribute->name,newAttribute->nameLength);
attributeFree(newAttribute,TRUE);
}
stringHashmapPutAll(node->attributes,toRemove);
arrayFree(array);
stringHashmapFree(toRemove);
}else{
stringHashmapToArray(toRemove,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute oldAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(toRemove,oldAttribute->name,oldAttribute->nameLength);
attributeFree(oldAttribute,TRUE);
}
arrayFree(array);
stringHashmapFree(toRemove);
}
stringHashmapFree(newAttributesMap);
char* buf;
int length=nodeSerialize(node,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_REMOVE_ATTRIBUTE(type)){
StringHashMap toRemoveAttributeMap=commandGetAttributes(command,ATTRIBUTES);
Node node;
registryGetNode(internal->registry,entityId,&node);
VALIDATE(registryValidateUpdate(node,sessionId));
Array array;
stringHashmapToArray(toRemoveAttributeMap,&array);
int lenght=arrayGetLength(array);
int i;
StringHashMap oldAttributes = stringHashmapCreate(SMALL_CONTAINER_SIZE);
for(i=0;i<lenght;i++){
Attribute toRemoveAttribute=(Attribute)arrayGetObject(array,i);
Attribute oldAttribute;
stringHashmapGet(node->attributes,toRemoveAttribute->name,toRemoveAttribute->nameLength,(Object) &oldAttribute);
if(oldAttribute!=NULL){
stringHashmapPut(oldAttributes,toRemoveAttribute->name,toRemoveAttribute->nameLength,(Object)oldAttribute);
stringHashmapRemove(node->attributes,toRemoveAttribute->name,toRemoveAttribute->nameLength);
}
}
arrayFree(array);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if(result!=VALID){
stringHashmapToArray(oldAttributes,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute oldAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapPut(node->attributes,oldAttribute->name,oldAttribute->nameLength,(Object)oldAttribute);
}
arrayFree(array);
stringHashmapToArray(toRemoveAttributeMap,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute toRemoveAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapPut(toRemoveAttributeMap,toRemoveAttribute->name,toRemoveAttribute->nameLength,(Object)toRemoveAttribute);
attributeFree(toRemoveAttribute,TRUE);
}
arrayFree(array);
stringHashmapFree(toRemoveAttributeMap);
}else{
stringHashmapToArray(oldAttributes,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute oldAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(oldAttributes,oldAttribute->name,oldAttribute->nameLength);
attributeFree(oldAttribute,TRUE);
}
arrayFree(array);
stringHashmapToArray(toRemoveAttributeMap,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute toAddAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapPut(toRemoveAttributeMap,toAddAttribute->name,toAddAttribute->nameLength,(Object)toAddAttribute);
attributeFree(toAddAttribute,TRUE);
}
arrayFree(array);
stringHashmapFree(toRemoveAttributeMap);
}
char* buf;
int length=nodeSerialize(node,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
if(IS_UPDATE_ENTITY(type)){
StringHashMap newAttributesMap=commandGetAttributes(command,ATTRIBUTES);
Node node;
registryGetNode(internal->registry,entityId,&node);
StringHashMap oldAttributesMap=stringHashmapCreate(SMALL_CONTAINER_SIZE);
stringHashmapPutAll(oldAttributesMap,node->attributes);
Array array;
stringHashmapToArray(node->attributes,&array);
int lenght=arrayGetLength(array);
int i;
for(i=0;i<lenght;i++){
Attribute toRemoveAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(node->attributes,toRemoveAttribute->name,toRemoveAttribute->nameLength);
}
stringHashmapPutAll(node->attributes,newAttributesMap);
int result=validationManagerValidateOnCoreExecuteInternalRecurcive(validationManager,commands,administrator,dept+1);
if(result!=VALID){
stringHashmapToArray(node->attributes,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute toRemoveAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(node->attributes,toRemoveAttribute->name,toRemoveAttribute->nameLength);
attributeFree(toRemoveAttribute,TRUE);
}
stringHashmapPutAll(node->attributes,oldAttributesMap);
stringHashmapFree(newAttributesMap);
stringHashmapFree(oldAttributesMap);
}else{
stringHashmapToArray(oldAttributesMap,&array);
lenght=arrayGetLength(array);
for(i=0;i<lenght;i++){
Attribute oldAttribute=(Attribute)arrayGetObject(array,i);
stringHashmapRemove(oldAttributesMap,oldAttribute->name,oldAttribute->nameLength);
attributeFree(oldAttribute,TRUE);
}
stringHashmapFree(oldAttributesMap);
stringHashmapFree(newAttributesMap);
}
char* buf;
int length=nodeSerialize(node,&buf);
commandPush(command,SERIALIZED_NODE,BYTE_ARRAY,buf,length);
memoryFree(buf);
}
}
return VALID;
}
int main(int argc, char * * argv)
{
if (argc != 3)
{
printf("usage: ./proj4 input output\n");
return EXIT_FAILURE;
}
int index = 0;
double x = 0, y=0;
// Build binary tree
stack * root = loadFile(argv[1], &index);
node * head = nodeCreate(root->stackNode->width, root->stackNode->height, root->stackNode->split, root->stackNode->index-1); //= buildTree(root);
root = StackPop(root);
buildTree(root, head, &head, index);
node * tree = NULL;
tree = nodeArrange(tree, &head);
// Packing
clock_t timeStart = clock();
assignCutline(tree);
setCoord(tree);
clock_t timeEnd = clock();
double packTime = (double) (timeEnd - timeStart) / CLOCKS_PER_SEC;
searchNode(tree, &x, &y, 1);
//printPostorderFull(tree);
//Reset output file and save output
FILE * fptr = fopen(argv[2], "w");
saveTree(tree, argv[2]);
// Screen dump
printf("Preorder: ");
printPreorder(tree);
printf("\n\nInorder: ");
printInorder(tree);
printf("\n\nPostorder: ");
printPostorder(tree);
printf("\n\nWidth: %le", tree->width);
printf("\nHeight: %le", tree->height);
printf("\n\nX-coordinate: %le", x);
printf("\nY-coordinate: %le", y);
printf("\n");
// Rerooting
box * minBox = malloc(sizeof(box));
minBox->width = tree->width;
minBox->height = tree->height;
timeStart = clock();
// ------------------------------------ to run cases without rerooting, comment out the following lines
while (tree->right->split!='-')
{
tree = reroot(tree, minBox);
decideMin(minBox, tree);
//printPostorderFull(tree);
}
// ------------------------------------
timeEnd = clock();
double rootTime = (double) (timeEnd - timeStart) / CLOCKS_PER_SEC;
printf("\nElapsed Time: %le", packTime);
printf("\n\nBest width: %le", minBox->width);
printf("\nBest height: %le\n", minBox->height);
printf("\nElapsed Time for re-routing: %le\n", rootTime);
// Free stack
while(root!=NULL){
root = StackPop(root);
}
// Memory management
free(root);
free(minBox);
deleteTree(head);
deleteTree(tree);
fclose(fptr);
return EXIT_SUCCESS;
}
