void GMLWriter::write(char* n, MyList<BCUser*> list)
{
ofstream outputFile;
outputFile.open(n);
if (outputFile.is_open())
{
outputFile<< "graph [\n";
for (int i= 0; i<list.size(); i++)//gets info for each User
{
outputFile<<" node ["<<endl;
outputFile<<" id "<<list[i]->getIdNum()<<endl;
outputFile<<" name \""<<list[i]->getName()<<"\""<<endl;
outputFile<<" age "<<list[i]->getAge()<<endl;
outputFile<<" zip "<<list[i]->getZip()<<endl;
outputFile<<" ]"<<endl;
}
for (int j = 0; j < list.size(); j++)
{
if (list[j]->getFriendId().size()!=0)//get info for each edge
{
for (int k=0; k<list[j]->getFriendId().size(); k++ ){
outputFile<<" edge ["<<endl;
outputFile<<" source "<< list[j]->getIdNum()<<endl;
outputFile<<" target "<< list[j]->getFriendId()[k]<<endl;
outputFile<<" ]"<<endl;
}
}
}
outputFile<<"]"<<endl;
outputFile.close();
}
}
int main ()
{
//We will create a buffer of 1000 bytes to store a list
managed_heap_memory heap_memory(1000);
MyList * mylist = heap_memory.construct<MyList>("MyList")
(heap_memory.get_segment_manager());
//Obtain handle, that identifies the list in the buffer
managed_heap_memory::handle_t list_handle = heap_memory.get_handle_from_address(mylist);
//Fill list until there is no more memory in the buffer
try{
while(1) {
mylist->insert(mylist->begin(), 0);
}
}
catch(const bad_alloc &){
//memory is full
}
//Let's obtain the size of the list
MyList::size_type old_size = mylist->size();
//<-
(void)old_size;
//->
//To make the list bigger, let's increase the heap buffer
//in 1000 bytes more.
heap_memory.grow(1000);
//If memory has been reallocated, the old pointer is invalid, so
//use previously obtained handle to find the new pointer.
mylist = static_cast<MyList *>
(heap_memory.get_address_from_handle(list_handle));
//Fill list until there is no more memory in the buffer
try{
while(1) {
mylist->insert(mylist->begin(), 0);
}
}
catch(const bad_alloc &){
//memory is full
}
//Let's obtain the new size of the list
MyList::size_type new_size = mylist->size();
//<-
(void)new_size;
//->
assert(new_size > old_size);
//Destroy list
heap_memory.destroy_ptr(mylist);
return 0;
}
int main() {
MyList<int> ml;
int choose;
int pos, entry;
while (1) {
cout << "1.insert 2.remove 3. replace 4.size 5.empty 6.retrive 7.display" << endl;
cin >> choose;
switch (choose) {
case 1:
cin >> pos >> entry;
ml.insert(pos, entry);
break;
case 2:
cin >> pos;
ml.remove(pos, entry);
cout << entry << endl;
break;
case 3:
cin >> pos >> entry;
ml.replace(pos, entry);
break;
case 4:
cout << ml.size() << endl;
break;
case 5:
cout << ml.empty() << endl;
break;
case 6:
cin >> pos;
ml.retrieve(pos, entry);
cout << entry << endl;
break;
case 7:
ml.display();
}
}
}
int main ()
{
const char *FileName = "file_mapping";
const std::size_t FileSize = 1000;
file_mapping::remove(FileName);
try{
std::size_t old_size = 0;
managed_mapped_file::handle_t list_handle;
{
managed_mapped_file mfile_memory(create_only, FileName, FileSize);
MyList *mylist = mfile_memory.construct<MyList>("MyList")
(mfile_memory.get_segment_manager());
//Obtain handle, that identifies the list in the buffer
list_handle = mfile_memory.get_handle_from_address(mylist);
//Fill list until there is no more room in the file
try{
while(1) {
mylist->insert(mylist->begin(), 0);
}
}
catch(const bad_alloc &){
//mapped file is full
}
//Let's obtain the size of the list
old_size = mylist->size();
}
//To make the list bigger, let's increase the mapped file
//in FileSize bytes more.
managed_mapped_file::grow(FileName, FileSize*2);
{
managed_mapped_file mfile_memory(open_only, FileName);
//If mapping address has changed, the old pointer is invalid,
//so use previously obtained handle to find the new pointer.
MyList *mylist = static_cast<MyList *>
(mfile_memory.get_address_from_handle(list_handle));
//Fill list until there is no more room in the file
try{
while(1) {
mylist->insert(mylist->begin(), 0);
}
}
catch(const bad_alloc &){
//mapped file is full
}
//Let's obtain the new size of the list
std::size_t new_size = mylist->size();
assert(new_size > old_size);
//Destroy list
mfile_memory.destroy_ptr(mylist);
}
}
catch(...){
file_mapping::remove(FileName);
throw;
}
file_mapping::remove(FileName);
return 0;
}
MyList<double>* BCAlg:: computeBC(MyList<BCUser*> &userList){
//BC Algorithm Execution
for(int i = 0; i < userList.size(); i++){
userList[i]->bc = 0;
}
for(int s = 0; s < userList.size(); s++){
for(int t = 0; t < userList.size(); t++){
delete userList[t]->preds;
userList[t]->preds = new MyList<int>;
userList[t]->numsp = 0;
userList[t]->dist = -1;
userList[t]->delta = 0.0;
}
userList[s]->numsp = 1;
userList[s]->dist = 0;
Stack<BCUser*> myStack;
Queue<BCUser*> myQueue;
myQueue.push_back(userList[s]);
while(!myQueue.empty()){ //BFS searching
BCUser *v = myQueue.front();
myQueue.pop_front();
myStack.push(v);
for(int w = 0; w < v->getFriendList().size(); w++){
BCUser *doubleU = userList[v->getFriendList()[w]];
if(doubleU->dist == -1){
myQueue.push_back(doubleU);
doubleU->dist = v->dist + 1;
}
if(doubleU->dist == v->dist + 1){
doubleU->numsp = doubleU->numsp + v->numsp;
doubleU->preds->push_back(v->getID());
}
}
}
while(!myStack.empty()){
BCUser *w = myStack.top();
myStack.pop();
for(int v = 0; v < w->preds->size(); v++){
userList[w->preds->at(v)]->delta = userList[w->preds->at(v)]->delta + (userList[w->preds->at(v)]->numsp*1.0)/(w->numsp)*(1+w->delta);
}
w->bc = w->bc + w->delta;
}
}
MyList<double> *normals = new MyList<double>(); //Normalize scores below
double minScore = userList[0]->bc;
double maxScore = userList[0]->bc;
for(int i = 0; i < userList.size(); i++){ //Initializes normal values
normals->push_back(-1);
}
for(int i = 1; i < userList.size(); i++){ //Finds min score
if(userList[i]->bc < minScore) { minScore = userList[i]->bc; }
}
for(int i = 1; i < userList.size(); i++){
if(userList[i]->bc > maxScore) { maxScore = userList[i]->bc; } //Finds max score
}
for(int i = 0; i < userList.size(); i++){
(*normals)[userList[i]->getID()] = userList[i]->bc;
}
for(int i = 0; i < normals->size(); i++){
normals->at(i) = (normals->at(i) - minScore)/(maxScore-minScore); //Finishes calculation
}
return normals;
}