Tests separated and cleanups done and cleanups done
diff --git a/ConcDCT.h b/ConcDCT.h
index 84ae605..59a4e34 100644
--- a/ConcDCT.h
+++ b/ConcDCT.h
@@ -25,10 +25,7 @@
void copy_pointer_val(ConcertedDef *copy_val1)
{
- //dct_node *val = (dct_node*)val1;
dct_node *copy_val = (dct_node*)copy_val1;
-
- cout<<"In dct_node copy_pointer_val"<<endl;
*this = *copy_val;
}
@@ -195,12 +192,10 @@
if (locksTaken == 0)
{
read_lock_val->GetLock();
- //cout<<"Taken read lock1"<<endl;
}
if (parent_pointer == NULL)
{
- //cout<<"parent pointer is NULL"<<endl;
return NULL;
}
@@ -208,24 +203,12 @@
if (locksTaken == 0)
{
read_lock_val->ReleaseLock();
- //cout<<"Released read lock1"<<endl;
}
traverse = head;
- if ((parent_pointer->get_child_pointer()) == NULL)
- {
- cout<<"child pointer is NULL search node"<<endl;
- }
- else
- {
- cout<<"child pointer is not NULL search node"<<" "<<(parent_pointer->get_child_pointer()->getval())<<endl;
- }
-
while (traverse != NULL)
{
-
- cout<<"In loop"<<endl;
write_lock_val = traverse->getwrite_lock_val();
read_lock_val = traverse->getread_lock_val();
@@ -236,7 +219,6 @@
if (locksTaken == 0)
{
read_lock_val->GetLock();
- //cout<<"Taken read lock2"<<endl;
}
if ((traverse->getval()) == val)
@@ -244,15 +226,10 @@
cout<<"value found search"<<" "<<traverse->getval()<<" "<<val<<endl;
return traverse;
}
- else
- {
- cout<<"value not found search2"<<" "<<traverse->getval()<<endl;
- }
if (locksTaken == 0)
{
read_lock_val->ReleaseLock();
- //cout<<"Released read lock2"<<endl;
}
traverse = traverse->getnext();
@@ -336,7 +313,6 @@
write_lock_val = traverse->getwrite_lock_val();
read_lock_val = traverse->getread_lock_val();
transact_val1.add_lock(write_lock_val);
- cout<<"lock value insert1"<<" "<<write_lock_val<<endl;
while ((read_lock_val->CheckLockIsAcquired()) == 1)
{
@@ -347,14 +323,6 @@
cout<<"write lock not taken"<<endl;
throw -1;
}
- else
- {
- cout<<"write lock taken"<<endl;
- }
-
- //throw -1;
-
- //cout<<"Write lock taken2"<<endl;
temp_return = search_node(val_array[i], traverse,1);
if (temp_return == NULL)
@@ -365,46 +333,16 @@
traverse->insert(temp);
write_lock_val->ReleaseLock();
transact_val1.delete_lock(write_lock_val);
- if ((traverse->get_child_pointer()) == NULL)
- {
- cout<<"child pointer is NULL insert"<<endl;
- }
- else
- {
- cout<<"child pointer is not NULL insert"<<" "<<((traverse->get_child_pointer()->getval()))<<endl;
- }
- //cout<<"Write lock released2"<<endl;
traverse = temp;
- cout<<"value inserted1"<<" "<<val_array[i]<<endl;
}
else
{
write_lock_val->ReleaseLock();
transact_val1.delete_lock(write_lock_val);
- if ((traverse->get_child_pointer()) == NULL)
- {
- cout<<"child pointer is NULL insert2"<<endl;
- }
- else
- {
- cout<<"child pointer is not NULL insert2"<<" "<<((traverse->get_child_pointer())->getval())<<endl;
- }
- //cout<<"Write lock released3"<<endl;
+
traverse = temp_return;
- cout<<"value inserted2"<<" "<<val_array[i]<<endl;
}
- cout<<"val is insert"<<" "<<dummy2<<" "<<dummy<<endl;
- //transact_val1.commit_transaction();
- }
-
- if (search_node(val_array[0], dummy, 1))
- {
- cout<<"0 value found after insertion"<<endl;
- }
- else
- {
- cout<<"0 value not found after insertion"<<endl;
}
}
diff --git a/ConcDCT.h~ b/ConcDCT.h~
new file mode 100644
index 0000000..e2dbe88
--- /dev/null
+++ b/ConcDCT.h~
@@ -0,0 +1,352 @@
+#include <iostream>
+#include "TransactionManager.h"
+using namespace std;
+
+class dct_node:public ConcertedDef
+{
+ int value;
+ int level;
+ int current_insertion_index;
+ dct_node *child_pointer;
+ dct_node *next;
+ QueueLock *read_lock_val;
+ QueueLock *write_lock_val;
+public:
+ dct_node()
+ {
+ value = 0;
+ level = 0;
+ current_insertion_index = 0;
+ child_pointer = NULL;
+ next = NULL;
+ read_lock_val = new QueueLock;
+ write_lock_val = new QueueLock;
+ }
+
+ void copy_pointer_val(ConcertedDef *copy_val1)
+ {
+ dct_node *copy_val = (dct_node*)copy_val1;
+
+ cout<<"In dct_node copy_pointer_val"<<endl;
+ *this = *copy_val;
+ }
+
+ int getval()
+ {
+ return value;
+ }
+
+ void setval(int a)
+ {
+ value = a;
+ }
+
+ int getlevel()
+ {
+ return level;
+ }
+
+ void setlevel(int a)
+ {
+ level = a;
+ }
+
+ void insert(dct_node *pointer_val)
+ {
+ dct_node *traverse = NULL;
+
+ if (child_pointer == NULL)
+ {
+ child_pointer = pointer_val;
+ return;
+ }
+
+ traverse = child_pointer;
+
+ while ((traverse->getnext()) != NULL)
+ {
+ traverse = traverse->getnext();
+ }
+
+ traverse->setnext(pointer_val);
+
+ }
+
+ dct_node* get_child_pointer()
+ {
+ return child_pointer;
+ }
+
+ void setnext(dct_node *next_element_pointer)
+ {
+ next = next_element_pointer;
+ }
+
+ dct_node* getnext()
+ {
+ return next;
+ }
+
+ QueueLock* getread_lock_val()
+ {
+ return read_lock_val;
+ }
+
+ QueueLock* getwrite_lock_val()
+ {
+ return write_lock_val;
+ }
+
+ ~dct_node()
+ {
+ dct_node *traverse = child_pointer;
+ dct_node *temp = NULL;
+
+ if (child_pointer != NULL)
+ {
+ temp = child_pointer->getnext();
+ }
+
+ while (traverse != NULL)
+ {
+ if (child_pointer != NULL)
+ {
+ delete child_pointer;
+ }
+
+ traverse = temp;
+ if (traverse != NULL)
+ {
+ temp = traverse->getnext();
+ }
+
+ }
+
+ }
+};
+
+class dct_tree
+{
+ dct_node *dummy;
+ int number_of_nodes;
+public:
+ dct_tree(int n)
+ {
+ dummy = new dct_node;
+ dummy->setlevel(0);
+ number_of_nodes = n;
+ }
+
+ dct_tree(dct_node *val, int n)
+ {
+ dummy = val;
+ dummy->setlevel(0);
+ number_of_nodes = n;
+ }
+
+ dct_node* getdummy()
+ {
+ return dummy;
+ }
+
+ int getnumber_of_nodes()
+ {
+ return number_of_nodes;
+ }
+
+ ~dct_tree()
+ {
+ delete dummy;
+ }
+
+};
+
+ dct_node* search_val(int[3], dct_node*);
+ dct_node* search_node(int, dct_node*);
+ dct_node* insert_val(int[3], dct_node*);
+ dct_tree* build_dcttree();
+
+ dct_tree* build_dcttree(int n)
+ {
+ dct_tree *tree_val = NULL;
+
+ tree_val = new dct_tree(n);
+
+ return tree_val;
+ }
+
+ dct_node* search_node(int val, dct_node *parent_pointer, int locksTaken)
+ {
+ dct_node *head = NULL;
+ dct_node *traverse = NULL;
+ QueueLock *write_lock_val = parent_pointer->getwrite_lock_val();
+ QueueLock *read_lock_val = parent_pointer->getread_lock_val();
+
+ if (locksTaken == 0)
+ {
+ while ((write_lock_val->CheckLockIsAcquired()) == 1)
+ {
+ cout<<"Waiting for write lock release1"<<endl;
+ }
+
+ }
+
+ if (locksTaken == 0)
+ {
+ read_lock_val->GetLock();
+ }
+
+ if (parent_pointer == NULL)
+ {
+ return NULL;
+ }
+
+ head = parent_pointer->get_child_pointer();
+ if (locksTaken == 0)
+ {
+ read_lock_val->ReleaseLock();
+ }
+
+ traverse = head;
+
+ while (traverse != NULL)
+ {
+
+ cout<<"In loop"<<endl;
+ write_lock_val = traverse->getwrite_lock_val();
+ read_lock_val = traverse->getread_lock_val();
+
+ while ((write_lock_val->CheckLockIsAcquired()) == 1)
+ {
+ }
+
+ if (locksTaken == 0)
+ {
+ read_lock_val->GetLock();
+ }
+
+ if ((traverse->getval()) == val)
+ {
+ cout<<"value found search"<<" "<<traverse->getval()<<" "<<val<<endl;
+ return traverse;
+ }
+
+ if (locksTaken == 0)
+ {
+ read_lock_val->ReleaseLock();
+ }
+
+ traverse = traverse->getnext();
+ }
+
+ cout<<"value not found"<<endl;
+ return NULL;
+ }
+
+ dct_node* search_val(int search_val_array[3], dct_tree *tree_val)
+ {
+ dct_node *dummy = tree_val->getdummy();
+ dct_node *traverse = dummy;
+ dct_node *temp = NULL;
+ int i = 0;
+ int current_value = 0;
+
+ for (i = 0;i < (tree_val->getnumber_of_nodes());i++)
+ {
+ current_value = search_val_array[i];
+ temp = search_node(current_value, traverse,1);
+ if (temp == NULL)
+ {
+ cout<<"value not found search val"<<" "<<current_value<<endl;
+ return NULL;
+ }
+
+ traverse = temp;
+ }
+
+ return traverse;
+
+ }
+
+ dct_tree* copy_val(dct_node *val, int number_of_nodes)
+ {
+ int i = 0;
+ dct_node *traverse1 = new dct_node();
+ dct_node *traverse2 = val->get_child_pointer();
+ dct_node *temp = NULL;
+ dct_tree *return_val = NULL;
+
+ i = val->getlevel();
+
+ traverse1->setval(val->getval());
+ traverse1->setlevel(val->getlevel());
+ for (;i < number_of_nodes;i++)
+ {
+ while (traverse2 != NULL)
+ {
+ temp = new dct_node(*(traverse2));
+ traverse1->insert(temp);
+ copy_val(temp, number_of_nodes);
+ traverse2 = traverse2->getnext();
+ }
+
+ }
+
+ return_val = new dct_tree(traverse1, number_of_nodes);
+
+ return return_val;
+
+ }
+
+ dct_node* insert_val(int val_array[3], dct_tree *tree_val, TransactionManager &transact_val1)
+ {
+ dct_tree *val1 = copy_val((tree_val->getdummy()), (tree_val->getnumber_of_nodes()));
+ dct_node *dummy = val1->getdummy();
+ dct_node *dummy2 = tree_val->getdummy();
+ dct_node *traverse = NULL;
+ dct_node *temp = NULL;
+ dct_node *temp_return = NULL;
+ QueueLock *write_lock_val = dummy->getwrite_lock_val();
+ QueueLock *read_lock_val = dummy->getread_lock_val();
+ int i = 0;
+
+ traverse = dummy;
+ transact_val1.add_commit_val(dummy2, dummy);
+ for (i = 0;i < (tree_val->getnumber_of_nodes());i++)
+ {
+ write_lock_val = traverse->getwrite_lock_val();
+ read_lock_val = traverse->getread_lock_val();
+ transact_val1.add_lock(write_lock_val);
+
+ while ((read_lock_val->CheckLockIsAcquired()) == 1)
+ {
+ }
+
+ if (!(write_lock_val->GetLock()))
+ {
+ cout<<"write lock not taken"<<endl;
+ throw -1;
+ }
+
+ temp_return = search_node(val_array[i], traverse,1);
+ if (temp_return == NULL)
+ {
+ temp = new dct_node;
+ temp->setval(val_array[i]);
+ temp->setlevel(i);
+ traverse->insert(temp);
+ write_lock_val->ReleaseLock();
+ transact_val1.delete_lock(write_lock_val);
+ traverse = temp;
+ }
+ else
+ {
+ write_lock_val->ReleaseLock();
+ transact_val1.delete_lock(write_lock_val);
+
+ traverse = temp_return;
+ }
+
+ }
+
+ }
diff --git a/ConcMAT.h b/ConcMAT.h
index 4ed99f4..1c8dc0e 100644
--- a/ConcMAT.h
+++ b/ConcMAT.h
@@ -130,10 +130,6 @@
cout<<"value found"<<" "<<temp->getval()<<" "<<val<<endl;
return temp;
}
- else
- {
- cout<<"value not found2"<<" "<<temp->getval()<<" "<<i<<endl;
- }
}
diff --git a/ConcMAT.h~ b/ConcMAT.h~
new file mode 100644
index 0000000..4ed99f4
--- /dev/null
+++ b/ConcMAT.h~
@@ -0,0 +1,197 @@
+#include<iostream>
+using namespace std;
+
+class mat_node
+{
+ int value;
+ int level;
+ int current_insertion_index;
+ mat_node *child_pointer_array[10];
+public:
+ mat_node()
+ {
+ int i = 0;
+ value = 0;
+ level = 0;
+ current_insertion_index = 0;
+ for (i = 0;i < 10;i++)
+ {
+ *(child_pointer_array + i) = NULL;
+ }
+ }
+ int getval()
+ {
+ return value;
+ }
+
+ void setval(int a)
+ {
+ value = a;
+ }
+
+ int getlevel()
+ {
+ return level;
+ }
+
+ void setlevel(int a)
+ {
+ level = a;
+ }
+
+ void insert(mat_node *pointer_val)
+ {
+ child_pointer_array[0] = pointer_val;
+ }
+
+ mat_node** get_child_pointer_array()
+ {
+ return child_pointer_array;
+ }
+
+ ~mat_node()
+ {
+ mat_node *traverse = child_pointer_array[0];
+ int i = 0;
+
+ while(traverse != NULL && i < 10)
+ {
+ delete traverse;
+ ++i;
+ traverse = *(child_pointer_array + i);
+ }
+
+ delete traverse;
+
+ }
+};
+
+ class mat_tree
+ {
+ mat_node *dummy;
+ int number_of_attributes;
+ public:
+ mat_tree(int n)
+ {
+ dummy = new mat_node;
+ dummy->setlevel(0);
+ number_of_attributes = n;
+ }
+
+ mat_node* getdummy()
+ {
+ return dummy;
+ }
+
+ int getnumber_of_attributes()
+ {
+ return number_of_attributes;
+ }
+
+ ~mat_tree()
+ {
+ delete dummy;
+ }
+ };
+
+ mat_tree* build_mattree(int);
+ mat_node* search_node(int, mat_node*, mat_node*);
+ mat_node* search_val(int[3],mat_node*);
+ mat_node* insert_val(int[3],mat_node*);
+
+ mat_tree* build_mattree(int n)
+ {
+ mat_tree* tree_val = NULL;
+
+ tree_val = new mat_tree(n);
+
+ return tree_val;
+ }
+
+ mat_node* search_node(int val, mat_node *parent_pointer, mat_node *dummy)
+ {
+ mat_node **traverse = parent_pointer->get_child_pointer_array();
+ mat_node *temp = NULL;
+ int i = 0;
+
+ if (parent_pointer == NULL)
+ {
+ cout<<"parent pointer is NULL"<<endl;
+ return NULL;
+ }
+
+ while (i < 3)
+ {
+ temp = *(traverse + i);
+ if (temp != NULL)
+ {
+ if ((temp->getval()) == val)
+ {
+ cout<<"value found"<<" "<<temp->getval()<<" "<<val<<endl;
+ return temp;
+ }
+ else
+ {
+ cout<<"value not found2"<<" "<<temp->getval()<<" "<<i<<endl;
+ }
+
+ }
+
+ ++i;
+ }
+
+ cout<<"value not found"<<endl;
+ return NULL;
+ }
+
+ mat_node* search_val(int search_val_array[3], mat_tree *tree_val)
+ {
+ mat_node *dummy = tree_val->getdummy();
+ mat_node *traverse = dummy;
+ mat_node *temp = NULL;
+ int i = 0;
+ int current_value = 0;
+
+ for (i = 0;i < 3;i++)
+ {
+ current_value = search_val_array[i];
+ temp = search_node(current_value, traverse, dummy);
+ if (temp == NULL)
+ {
+ cout<<"value not found"<<" "<<current_value<<endl;
+ return NULL;
+ }
+
+ traverse = temp;
+ }
+
+ }
+
+ mat_node* insert_val(int val_array[3], mat_tree *tree_val)
+ {
+ mat_node *dummy = tree_val->getdummy();
+ mat_node *traverse = NULL;
+ mat_node *temp = NULL;
+ mat_node *temp_return = NULL;
+ int i = 0;
+
+ traverse = dummy;
+ for (i = 0;i < 3;i++)
+ {
+ temp_return = search_node(val_array[i], traverse, dummy);
+ if (temp_return == NULL)
+ {
+ temp = new mat_node;
+ temp->setval(val_array[i]);
+ temp->setlevel(i);
+ traverse->insert(temp);
+ traverse = temp;
+ }
+ else
+ {
+ traverse = temp_return;
+ }
+
+ }
+
+ }
diff --git a/ConcDCTConcurrencyTest.cpp b/Tests/ConcDCTConcurrencyTest.cpp
similarity index 100%
rename from ConcDCTConcurrencyTest.cpp
rename to Tests/ConcDCTConcurrencyTest.cpp
diff --git a/ConcDCTFileReader.cpp b/Tests/ConcDCTFileReader.cpp
similarity index 100%
rename from ConcDCTFileReader.cpp
rename to Tests/ConcDCTFileReader.cpp
diff --git a/ConcDCTTest.cpp b/Tests/ConcDCTTest.cpp
similarity index 100%
rename from ConcDCTTest.cpp
rename to Tests/ConcDCTTest.cpp
diff --git a/ConcMATFileReader.cpp b/Tests/ConcMATFileReader.cpp
similarity index 100%
rename from ConcMATFileReader.cpp
rename to Tests/ConcMATFileReader.cpp
diff --git a/ConcMATTest.cpp b/Tests/ConcMATTest.cpp
similarity index 100%
rename from ConcMATTest.cpp
rename to Tests/ConcMATTest.cpp
diff --git a/ConcSegHashTableTest.cpp b/Tests/ConcSegHashTableTest.cpp
similarity index 100%
rename from ConcSegHashTableTest.cpp
rename to Tests/ConcSegHashTableTest.cpp
diff --git a/ConcSkipListTest.cpp b/Tests/ConcSkipListTest.cpp
similarity index 100%
rename from ConcSkipListTest.cpp
rename to Tests/ConcSkipListTest.cpp
diff --git a/FileReader.cpp b/Tests/FileReader.cpp
similarity index 100%
rename from FileReader.cpp
rename to Tests/FileReader.cpp
diff --git a/QueueLockTest.cpp b/Tests/QueueLockTest.cpp
similarity index 100%
rename from QueueLockTest.cpp
rename to Tests/QueueLockTest.cpp
diff --git a/TransactionManager.cpp b/Tests/TransactionManager.cpp
similarity index 100%
rename from TransactionManager.cpp
rename to Tests/TransactionManager.cpp
diff --git a/TransactionManager.h b/TransactionManager.h
index 4b4038b..cb7c1ff 100644
--- a/TransactionManager.h
+++ b/TransactionManager.h
@@ -72,7 +72,6 @@
{
if (lock_val_array[i] == val)
{
- cout<<"lock value found2"<<" "<<i<<endl;
lock_val_array[i] = NULL;
for (j = i;j < lock_counter;j++)
{
@@ -112,7 +111,6 @@
{
if (mem_allocated_val_array[i] == val)
{
- cout<<"memory location found2"<<" "<<i<<endl;
mem_allocated_val_array[i] = NULL;
for (j = i;j < memory_counter;j++)
{
@@ -176,7 +174,6 @@
lock_val_array[lock_counter] = val;
++lock_counter;
- cout<<"lock value is"<<" "<<val<<" "<<lock_val_array[lock_counter -1]<<endl;
}
void commit_transaction()
@@ -186,7 +183,6 @@
delete_val = 0;
for (i = 0;i < commit_val_counter;i++)
{
- cout<<"value is"<<" "<<current_val[i]<<" "<<copy_val[i]<<endl;
(current_val[i])->copy_pointer_val(copy_val[i]);
}
@@ -198,16 +194,13 @@
{
int i = 0;
- cout<<"in destructor"<<endl;
if (delete_val == 1)
{
- cout<<"delete_val is 1"<<endl;
cout<<"Rollback"<<endl;
for (i = 0;i < lock_counter;i++)
{
if (lock_val_array[i] != NULL && (lock_val_array[i])->CheckLockIsAcquired())
{
- cout<<"lock found"<<endl;
lock_val_array[i]->ReleaseLock();
}
diff --git a/TransactionManager.h~ b/TransactionManager.h~
new file mode 100644
index 0000000..8c1197b
--- /dev/null
+++ b/TransactionManager.h~
@@ -0,0 +1,230 @@
+#include <iostream>
+#include "QueueLock2.h"
+#include "ConcDef.h"
+using namespace std;
+
+class TransactionManager
+{
+ static int active_transaction_number;
+ int current_transaction_number;
+ static int counter;
+ int lock_counter;
+ int memory_counter;
+ int commit_val_counter;
+ static int active_transactions[10];
+ int delete_val;
+ ConcertedDef* current_val[10];
+ ConcertedDef* copy_val[10];
+ void *mem_allocated_val_array[10];
+ QueueLock *lock_val_array[10];
+public:
+ TransactionManager()
+ {
+ int i = 0;
+
+ for(i = 0;i < 10;i++)
+ {
+ current_val[i] = NULL;
+ copy_val[i] = NULL;
+ active_transactions[i] = 0;
+ lock_val_array[i] = NULL;
+ mem_allocated_val_array[i] = NULL;
+ }
+
+ if (counter == 10)
+ {
+ cout<<"A new transaction number cannot be inserted due to lack of space"<<endl;
+ throw -1;
+ }
+
+ current_transaction_number = ++active_transaction_number;
+ active_transactions[counter] = active_transaction_number;
+ ++counter;
+
+ lock_counter = 0;
+ memory_counter = 0;
+ commit_val_counter = 0;
+ delete_val = 1;
+ }
+
+ int add_transaction()
+ {
+
+ if (counter == 10)
+ {
+ cout<<"A new transaction number cannot be inserted due to lack of space"<<endl;
+ return -1;
+ }
+
+ ++active_transaction_number;
+ active_transactions[counter] = active_transaction_number;
+ ++counter;
+
+ return active_transaction_number;
+ }
+
+ void delete_lock(QueueLock *val)
+ {
+ int i = 0;
+ int j = 0;
+
+ for(i = 0;i < lock_counter;i++)
+ {
+ if (lock_val_array[i] == val)
+ {
+ lock_val_array[i] = NULL;
+ for (j = i;j < lock_counter;j++)
+ {
+ lock_val_array[j] = lock_val_array[j + 1];
+ }
+
+ --lock_counter;
+ break;
+ }
+
+ }
+
+ }
+
+ int add_mem_location(ConcertedDef *mem)
+ {
+ if (memory_counter == 10)
+ {
+ cout<<"new memory location val cannot be added due to lack of element in array"<<endl;
+ throw -1;
+ }
+
+ mem_allocated_val_array[memory_counter] = mem;
+ ++memory_counter;
+
+ return 1;
+ }
+
+ void delete_mem_location(ConcertedDef *val)
+ {
+ int i = 0;
+ int j = 0;
+
+ for (i = 0; i < memory_counter;i++)
+ {
+ if (mem_allocated_val_array[i] != NULL)
+ {
+ if (mem_allocated_val_array[i] == val)
+ {
+ mem_allocated_val_array[i] = NULL;
+ for (j = i;j < memory_counter;j++)
+ {
+ mem_allocated_val_array[j] = mem_allocated_val_array[j + 1];
+ }
+
+ --memory_counter;
+ break;
+ }
+
+ }
+
+ }
+
+ }
+
+ void delete_transaction(int val)
+ {
+ int i = 0;
+ int j = 0;
+
+ for (i = 0;i < 10;i++)
+ {
+ if (active_transactions[i] == val)
+ {
+ active_transactions[i] = 0;
+ for (j = i;j < counter;j++)
+ {
+ active_transactions[j] = active_transactions[j + 1];
+ }
+
+ --counter;
+ }
+
+ }
+
+ }
+
+ void add_commit_val(ConcertedDef *val, ConcertedDef *copy_val1)
+ {
+
+ if (commit_val_counter == 10)
+ {
+ cout<<"commit val cannot be added due to lack of element in array"<<endl;
+ throw -1;
+ }
+
+ current_val[commit_val_counter] = val;
+ copy_val[commit_val_counter] = copy_val1;
+ ++commit_val_counter;
+ }
+
+ void add_lock(QueueLock *val)
+ {
+
+ if (lock_counter == 10)
+ {
+ cout<<"lock cannot be added due to lack of element in array"<<endl;
+ throw -1;
+ }
+
+ lock_val_array[lock_counter] = val;
+ ++lock_counter;
+ cout<<"lock value is"<<" "<<val<<" "<<lock_val_array[lock_counter -1]<<endl;
+ }
+
+ void commit_transaction()
+ {
+ int i = 0;
+
+ delete_val = 0;
+ for (i = 0;i < commit_val_counter;i++)
+ {
+ (current_val[i])->copy_pointer_val(copy_val[i]);
+ }
+
+ cout<<"commit"<<endl;
+
+ }
+
+ ~TransactionManager()
+ {
+ int i = 0;
+
+ if (delete_val == 1)
+ {
+ cout<<"Rollback"<<endl;
+ for (i = 0;i < lock_counter;i++)
+ {
+ if (lock_val_array[i] != NULL && (lock_val_array[i])->CheckLockIsAcquired())
+ {
+ lock_val_array[i]->ReleaseLock();
+ }
+
+ }
+
+ i = 0;
+
+ for (i = 0;i < memory_counter;i++)
+ {
+ if (mem_allocated_val_array[i] != NULL)
+ {
+ free(mem_allocated_val_array[i]);
+ }
+
+ }
+
+ delete_transaction(current_transaction_number);
+
+ }
+
+ }
+};
+
+int TransactionManager::counter = 0;
+int TransactionManager::active_transaction_number = 0;
+int TransactionManager::active_transactions[10] = {0,0,0,0,0,0,0,0,0,0};
diff --git a/a.out b/a.out
new file mode 100755
index 0000000..8206f74
--- /dev/null
+++ b/a.out
Binary files differ
