示例#1
0
/****************************** MAIN *****************************/
int main (int argc, char **argv)
{
	int c;
	while (1) {
		static struct option long_options[] =
		{
			//These options don’t set a flag.
			//We distinguish them by their indices. 
			{"help",   	no_argument, 		0, 		'h'},
			{"threads",   	required_argument, 	0, 		't'},
			{"name",   	required_argument, 	0, 		'n'},
			{0, 		0, 			0, 		0}
		};
		//getopt_long stores the option index here. 
		int option_index = 0;

		c = getopt_long (argc, argv, "h:t:o:p:r:",long_options, &option_index);

		//Detect the end of the options.
		if (c == -1) { 
			break;
		}

		switch (c) {
			case 'h':
				print_help();
				return 0;
			case 't':
				num_threads = atoi(optarg);
				break;
			case 'n':
				name = optarg;
				break;
		}
		
	}

	init_system();

	string aux_model;
	string id;
	string idrelated;
	string sample;
	int threshold;
	string func = "";;
	string line = "";
	int func_id;
	unordered_map<string,unsigned long>::const_iterator it_func_id;
	unordered_map<string,unsigned long>::const_iterator it_func_value_id;
	while (getline(std::cin, line)) {
		if(!line.empty()){
			istringstream iss(line);

			iss >> func >> id;

			it_func_id = APIID.find(func);

			if (it_func_id != APIID.end()){

				switch(it_func_id->second) {	
					case 0:
						if(exist_sample(id)) {
							cout << "[\"Err\",\"duplicated sample\"]" << endl;
						}else{
							iss >> sample;
							string ok = add_sample(id,&sample);
							
							save_sample(id,&sample);
							
							cout << ok << endl;
						}
						break;
					case 1:
						it_func_value_id = APIVALUEID.find(id);
						if(it_func_value_id == APIVALUEID.end()){
							cout << "[\"Err\",\"missmatch function\"]" << endl;
						}else{
							iss >> id;
							if(!exist_sample(id)) {
								cout << "[\"Err\",\"missing sample\"]" << endl;
							}else{
								iss >> threshold;
								switch(it_func_value_id->second) {	
									case 0: get_value_snps(id,threshold);
										break;
									case 1: get_value_ides(id,threshold);
										break;
								}
							}
						}

						break;
					case 3:
						it_func_value_id = APIVALUEID.find(id);
						if(it_func_value_id == APIVALUEID.end()){
							cout << "[\"Err\",\"missmatch function\"]" << endl;
						}else{
							iss >> threshold;
							switch(it_func_value_id->second) {	
								case 0: get_all_values_snps(threshold);
									break;
								case 1: get_all_values_ides(threshold);
									break;
							}
						}

						break;
					case 2:
						save_system();
						cout << "[\"OK\"]" << endl;
						break;
					case 4:
						iss >> idrelated;
						if(!exist_sample(id) || !exist_sample(idrelated)) {
							cout << "[\"Err\",\"missing sample\"]" << endl;
						}else{
							get_values_neighbour(id,idrelated);
						}
						break;
					case 5:
						iss >> idrelated;
						if(!processed_sample(id)) {
							cout << "[\"Err\",\"missing sample\"]" << endl;
						}else{
							cout << "[\"OK\"]" << endl;
						}
						break;
					case 6:
						write_log("{action:exit_system, date:"+current_date_time()+"}");
						cout << "Bye !!" << endl;
						return 0;
						break;
					case 7:
						aux_model = get_model();
						cout << "[\"OK\",\"" << aux_model << "\"]" << endl;
						break;
					default: 
						cout << "[\"Err\",\"missing function\"]" << endl;
						break;
				}
			}else{
				cout << "[\"Err\",\"missmatch function\"]" << endl;
			}
		}
示例#2
0
 unordered_map<int,int>::iterator begin (int s) {return g.find(s)->second.begin();}
示例#3
0
void flush_creatures (){
    creatures_map.clear();
}
示例#4
0
/******************************************************************************
Description: function for sending back the result
Input Value.:
Return Value:
******************************************************************************/
void server_result (int sock, string userID)
{
    if (debug) printf("result thread\n\n");

    int n, fd;
    char response[] = "ok";
    sem_t *sem_match = new sem_t(); // create a new semaphore in heap
    queue<string> *imgQueue = 0;    // queue storing the file names 

    //  Init semaphore and put the address of semaphore into map
    if (sem_init(sem_match, 0, 0) != 0)
    {
        errorSocket("ERROR semaphore init failed", sock);
    }
    // grap the lock
    pthread_mutex_lock(&sem_map_lock);
    sem_map[userID] = sem_match;
    pthread_mutex_unlock(&sem_map_lock);

    // reponse to the client
    if (!orbit)
    {
        n = write(sock, response, sizeof(response));
        if (n < 0)
        {
            error("ERROR writting to socket");
        }
    }
    else
    {
        MsgD.send(sock, response, sizeof(response));
    }

    struct sockaddr_in myaddr;
    int ret;
    char buf[1024];
    int serverPort = 9879;
    
    if (storm)
    {

        if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
            printf("socket create failed\n");
        if (debug) printf("socket created\n");

        /* bind it to all local addresses and pick any port number */

        memset((char *)&myaddr, 0, sizeof(myaddr));
        myaddr.sin_family = AF_INET;
        myaddr.sin_addr.s_addr = htonl(INADDR_ANY);
        myaddr.sin_port = htons(serverPort);

        if (bind(fd, (struct sockaddr *)&myaddr, sizeof(myaddr)) < 0) {
            perror("bind failed");
            goto stop;
        }       
        if (debug) printf("socket binded\n");
    }

    while(!global_stop) 
    {
        sem_wait(sem_match);
        // get the address of image queue
        if (imgQueue == 0)
        {
            imgQueue = queue_map[userID];
        }

        // check if the queue is empty
        if (imgQueue->empty())
        {
            sem_map.erase(userID);
            queue_map.erase(userID);
            user_map.erase(userID);
            delete(sem_match);
            delete(imgQueue);
            sem_destroy(sem_match);
            // if (orbit)
            // {
            //     MsgD.close(sock, 0);                
            // }
            printf("[server] client disconnected --- result\n");
            // pthread_exit(NULL); //terminate calling thread!
            return;
        }

        if (!storm)
        {
            if (debug) printf("\n----------- start matching -------------\n");
            string file_name = imgQueue->front(); 
            if (debug) printf("file name: [%s]\n", file_name.c_str());
            imgQueue->pop();

            // create a new thread to do the image processing

            pthread_t thread_id;
            struct arg_result trans_info;
            trans_info.sock = sock;
            strcpy(trans_info.file_name, file_name.c_str());
            /* create thread and pass socket and file name to send file */
            if (pthread_create(&thread_id, 0, result_child, (void *)&(trans_info)) == -1)
            {
                fprintf(stderr,"pthread_create error!\n");
                break; //break while loop
            }
            pthread_detach(thread_id);            
        }
        else
        {
            // receive part
            bzero(buf, sizeof(buf));
            printf("wait for the result...\n");
            ret = recv(fd, buf, sizeof(buf), 0);
            if (ret < 0)
            {
                printf("receive error\n");
            }
            else
            {
                int matchedIndex = atoi(buf);
                printf("received result: %d\n\n", matchedIndex);
                char defMsg[] = "none";
                char sendInfo[200];
                if (matchedIndex == 0)
                {
                    // write none to client
                    if (!orbit)
                    {
                        if (write(sock, defMsg, sizeof(defMsg)) < 0)
                        {
                           errorSocket("ERROR writting to socket", sock);
                        }
                    }
                    else
                    {
                        MsgD.send(sock, defMsg, sizeof(defMsg));
                    }

                    if (debug) printf("not match\n");
                }
                else
                {
                    // send result to client
                    string info = ImgMatch::getInfo(matchedIndex);
                    sprintf(sendInfo, "%s,0,0,0,0,0,0,0,0,", info.c_str());
                    
                    if (debug) printf("sendInfo: %s\n", sendInfo);

                    if (!orbit)
                    {
                        if (write(sock, sendInfo, sizeof(sendInfo)) < 0)
                        {
                            errorSocket("ERROR writting to socket", sock);
                        }
                    }
                    else
                    {
                        MsgD.send(sock, sendInfo, sizeof(sendInfo));
                    }

                    if (debug) printf("matched image index: %d\n", matchedIndex);
                }

            }
        }

        // end
    }

    stop:
    if (!orbit)
    {
        close(sock);
    }
    if (storm) {
        close(fd);
    }
    printf("[server] Connection closed. --- result\n\n");
    delete(sem_match);
    // pthread_exit(NULL); //terminate calling thread!
    return;

}
示例#5
0
/******************************************************************************
Description.: There is a separate instance of this function 
              for each connection.  It handles all communication
              once a connnection has been established.
Input Value.:
Return Value: -
******************************************************************************/
void *serverThread (void * inputsock)
{
    int sock = *((int *)inputsock);
    int n;
    char buffer[100];
    string userID;
    char *threadType;
    char fail[] = "failed";

    // Receive the header
    bzero(buffer, sizeof(buffer));
    if (!orbit)
    {
        n = read(sock, buffer, sizeof(buffer));
        if (n < 0)
        {
            errorSocket("ERROR reading from socket", sock);
        } 
    }
    // below is orbit mode, using MFAPI
    else
    {
        MsgD.recv(sock, buffer, sizeof(buffer));
    }

    printf("[server] header content: %s\n\n",buffer);

    threadType = strtok(buffer, ",");
    userID = strtok(NULL, ",");

    // grap the lock
    pthread_mutex_lock(&user_map_lock);
    // confirm that this user does not log in
    if (user_map.find(userID) == user_map.end())
    {
        // put the new user into user map
        user_map[userID] = 1;
    }
    else
    {
        if (user_map[userID] == 1)
        {
            // increase user thread count
            user_map[userID] = 2;
        }
        else
        {
            // remember to unlock!
            pthread_mutex_unlock(&user_map_lock);
            // reponse to the client
            if (!orbit)
            {
                if (write(sock, "failed", sizeof("failed")) < 0)
                {
                    errorSocket("ERROR writting to socket", sock);
                }
                close(sock); 
            }
            else
            {
                MsgD.send(sock, fail, sizeof(fail));
            }
            printf("[server] User exist. Connection closed.\n\n");
            return 0;
        }
    }
    pthread_mutex_unlock(&user_map_lock);

    if (strcmp(threadType, "transmit") == 0) 
    {
        server_transmit(sock, userID);
    }
    else if (strcmp(threadType, "result") == 0) 
    {
        server_result(sock, userID);
    }
    else
    {
        if (!orbit)
        {
            close(sock); 
        }
        printf("[server] Command Unknown. Connection closed.\n\n");
    }

    return 0;
}
示例#6
0
int main(int argc, char ** argv)
{
  ofstream log;
  log.open("/tmp/silben-master.log");
  int sbuf = pvm_initsend(PvmDataDefault);
  log << "read frequency list" << endl;
  read_word_frequency_list(WORD_FREQ_LIST);
  log << "finished reading" << endl;
  log << "spawning threads" << endl;
  int host_count;
  pvm_config(&host_count,NULL,NULL);
  int task_count=host_count*PER_HOST_TASK_COUNT;
  // Task-IDs
  int tids[task_count];
  char **args = NULL;
  int r=pvm_spawn((char *)"silben_slave",args,PvmTaskDefault /*PvmTaskDebug*/,NULL,task_count,tids);
  if (r<task_count)
  {
    for(int ct=0;ct<task_count;ct++)
      printf("Spawn error %d\n",tids[ct]);
  }
  log << "finished spawning" << endl;
  time_t begin_time, end_time;
  time(&begin_time);
  char *word = (char *) malloc(48);
  char *tree = (char *) malloc(1024*1024);
  //  log << "looping" << endl;
  while (word_list.size())
    {
      // See if DATA is pending
      while (pvm_probe(-1,DATA))
	{
	  int recbuf=pvm_recv(-1,DATA);
	  log << "got DATA with " << recbuf << endl;
	  int block_size;
	  pvm_upkint(&block_size,1,1);
	  log << "Recieving data block of size " << block_size << endl;
	  for (int ct = 0; ct < block_size; ct++)
	    {
	      pvm_upkstr(word);
	      pvm_upkstr(tree);
	      string sword = string(word);
	      string stree = string(tree);
	      //	      log << "Unpacked " << sword << " \t" << sword.size() << " and " << stree << " \t" << stree.size() << endl;
	      tree_list[sword] = stree;
	    }
	}
      // Wait for a NEXT request
      //      log << "Waiting for NEXT" << endl;
      int recbuf=pvm_recv(-1,NEXT);
      log << "Received NEXT with " << recbuf << endl;
      int tid;
      pvm_bufinfo(recbuf,NULL,NULL,&tid);
      pvm_initsend(PvmDataDefault);
      int block_size = BLOCK_SIZE;
      if (word_list.size() < BLOCK_SIZE)
	block_size = word_list.size();
      log << "Sending data block of size " << block_size << endl;
      pvm_pkint(&block_size,1,1);
      for (int ct = 0; ct < block_size; ct++)
	{
	  string sword = word_list.back();
	  //	  log << "Pack " << sword << endl;
	  pvm_pkstr((char *) sword.c_str() );
	  word_list.pop_back();
	}
      int sbuf = pvm_send(tid,DATA);
      log << "send DATA with " << sbuf << endl;
    }
  // See if DATA is pending
  while (pvm_probe(-1,DATA))
    {
      int recbuf=pvm_recv(-1,DATA);
      log << "got DATA with " << recbuf << endl;
      int block_size;
      pvm_upkint(&block_size,1,1);
      log << "Recieving data block of size " << block_size << endl;
      for (int ct = 0; ct < block_size; ct++)
	{
	  pvm_upkstr(word);
	  pvm_upkstr(tree);
	  string sword = string(word);
	  string stree = string(tree);
	  //	  log << "Unpacked " << sword << " \t" << sword.size() << " and " << stree << " \t" << stree.size() << endl;
	  tree_list[sword] = stree;
	}
    }

  // Syncing up after end of data
  for (int ct = 0; ct < task_count; ct++)
    {
      // Sending empty data twice to be sure to be received and unblock receive
      pvm_initsend(PvmDataDefault);
      int null = 0;
      pvm_pkint(&null,1,1);
      pvm_send(tids[ct],DATA);
      pvm_initsend(PvmDataDefault);
      pvm_send(tids[ct],DATA);
      log << "Send empty DATA to " << tids[ct] << endl;
      // Waiting for last message
      int recbuf=pvm_recv(tids[ct],FINAL);
      log << "got FINAL with " << recbuf << endl;
      int block_size;
      pvm_upkint(&block_size,1,1);
      log << "Recieving data block of size " << block_size << endl;
      for (int ct2 = 0; ct2 < block_size; ct2++)
  	{
  	  pvm_upkstr(word);
  	  pvm_upkstr(tree);
  	  string sword = string(word);
  	  string stree = string(tree);
  	  log << "Unpacked " << sword << " \t" << sword.size() << " and " << stree << " \t" << stree.size() << endl;
  	  tree_list[sword] = stree;
  	}
      int tid;
      pvm_bufinfo(recbuf,NULL,NULL,&tid);
      pvm_initsend(PvmDataDefault);
      int sbuf = pvm_send(tids[ct],DIE);
      log << "send DIE with " << sbuf << endl;
    }
  time(&end_time);
  log << "Matching took " << difftime(end_time,begin_time) << " seconds" << endl;
  log << "Start writing output" << endl;
  ofstream ofile;
  int wordcount = 0;
  ofile.open(OUTPUT_FILE);
  for (unordered_map<string,int>::iterator it = frequency_list.begin(); it != frequency_list.end(); it++)
    {
      //      log << it->first << "\t" << tree_list[it->first] << "\t" << it->second << endl;
      ofile << it->first << "\t" << tree_list[it->first] << "\t" << it->second << endl;
    }
  ofile.close();
  log << "Finished writing output" << endl;
  log.close();
  free(word);
  free(tree);
  log << "Exiting" << endl;
  pvm_exit();
}
示例#7
0
void rmscache(const char *path)
{
    pthread_mutex_lock(&slock);
    scache.erase(path);
    pthread_mutex_unlock(&slock);
}
int main(int argc, char** argv) {
    log.execname(basename(argv[0]));
    log << "starting" << endl;
    vector<string> args(&argv[1], &argv[argc]);
    signal_action(SIGINT, signal_handler);
    signal_action(SIGTERM, signal_handler);
    if (args.size() > 2)
        usage();
    string host = get_cix_server_host(args, 0);
    in_port_t port = get_cix_server_port(args, 1);
    log << to_string(hostinfo()) << endl;
    try {
        log << "connecting to " << host << " port " << port << endl;
        client_socket server(host, port);
        log << "connected to " << to_string(server) << endl;
        for (;;) {
            string line, command, file;
            getline(cin, line);
            //get command and the files in the command
            if (line.find(" ") != string::npos) {
                command = line.substr(0, line.find(" "));
                file = line.substr(line.find(" ") + 1);
            } else {
                command = line;  //if first space is the end
            }

            if (cin.eof())
                throw cix_exit();
            if (SIGINT_throw_cix_exit)
                throw cix_exit();
            log << "command " << command << endl;
            log << "file " << file << endl;
            const auto& itor = command_map.find(command);
            cix_command cmd =
                    itor == command_map.end() ?
                            CIX_ERROR : itor->second;
            switch (cmd) {
            case CIX_EXIT:
                throw cix_exit();
                break;
            case CIX_GET:
                cix_get(server, file);
                break;
            case CIX_HELP:
                cix_help();
                break;
            case CIX_LS:
                cix_ls(server);
                break;
            case CIX_PUT:
                cix_put(server, file);
                break;
            case CIX_RM:
                cix_rm(server, file);
                break;
            default:
                log << line << ": invalid command" << endl;
                break;
            }
        }
    } catch (socket_error& error) {
        log << error.what() << endl;
    } catch (cix_exit& error) {
        log << "caught cix_exit" << endl;
    }
    log << "finishing" << endl;
    return 0;
}
uint8_t* mbl_mw_metawearboard_serialize(const MblMwMetaWearBoard* board, uint32_t* size) {
    vector<uint8_t> serialized_state;

    serialized_state.push_back(SIGNAL_COMPONENT_SERIALIZATION_FORMAT);
    
    board->firmware_revision.serialize(serialized_state);

    serialized_state.push_back((uint8_t)board->module_number.size());
    serialized_state.insert(serialized_state.end(), board->module_number.begin(), board->module_number.end());

    {
        vector<uint8_t> sorted_keys;
        for (auto it : board->module_info) {
            sorted_keys.push_back(it.first);
        }
        sort(sorted_keys.begin(), sorted_keys.end());

        serialized_state.push_back((uint8_t)board->module_info.size());
        for (auto it : sorted_keys) {
            board->module_info.at(it).serialize(serialized_state);
        }
    }

    {
        uint8_t n_events= 0;
        vector<uint8_t> event_states;
        vector<ResponseHeader> sorted_keys;
        for (auto it : board->module_events) {
            sorted_keys.emplace_back(it.first.module_id, it.first.register_id, it.first.data_id);
        }
        sort(sorted_keys.begin(), sorted_keys.end());

        for (auto it : sorted_keys) {
            board->module_events.at(it)->serialize(event_states);
            n_events++;

            // serialize component signals after the main signal
            // rely on this ordering to restore the components vector
            if (MblMwDataSignal* signal= dynamic_cast<MblMwDataSignal*>(board->module_events.at(it))) {
                for(auto component: signal->components) {
                    component->serialize(event_states);
                    n_events++;
                }
            }
        }

        serialized_state.push_back(n_events);
        serialized_state.insert(serialized_state.end(), event_states.begin(), event_states.end());
    }

    {
        vector<uint8_t> sorted_keys;
        for (auto it : board->module_config) {
            sorted_keys.push_back(it.first);
        }
        sort(sorted_keys.begin(), sorted_keys.end());

        serialized_state.push_back((uint8_t)board->module_config.size());
        for (auto it : sorted_keys) {
            serialized_state.push_back(it);
            CONFIG_SERIALIZATION.at(it)(board, serialized_state);
        }
    }
    
    serialize_logging(board, serialized_state);
    
    *size = (uint32_t) serialized_state.size();
    uint8_t* state_bytes = (uint8_t*)malloc(sizeof(uint8_t) * (*size));
    memcpy(state_bytes, serialized_state.data(), *size);
    return state_bytes;
}
示例#10
0
void command_parse(SSL *ssl, char *command_line)
{
	char command[MAXLINE], arg[MAXLINE];
	char message[MAXLINE + 1];
	int n = sscanf(command_line, "%s%s", command, arg);
	if(strcmp(command, "signup") == 0) // signup a new user.
	{
		if(n != 2)
		{
			printf("wrong command.\n");
			return;
		}
		char password[MAXLINE];
		char retype[MAXLINE];
		//close the echo
		struct termios init_settings,new_settings;
		tcgetattr(fileno(stdin), &init_settings);
		new_settings = init_settings;
		new_settings.c_lflag &= ~ECHO;
		if(tcsetattr(fileno(stdin), TCSAFLUSH, &new_settings) != 0)
	    {
			printf("could not set termios attributes.\n");
			return;
	    }
		while(true)
		{
			printf("New password:");
			fgets(password,MAXLINE, stdin);
			printf("\nRetry new password:");
			fgets(retype, MAXLINE, stdin);
			if(strcmp(password, retype) == 0)
				break;
			printf("\nSorry, passwords do not match.\n");
		}
		printf("\n");
		tcsetattr(fileno(stdin), TCSANOW, &init_settings);
		int len = strlen(password);
		if(password[len - 1] == '\n')
			password[len - 1] = '\0';
		snprintf(message, MAXLINE,"signup %s %s", arg, password);
		int k = strlen(message);
		if(SSL_write(ssl, message, k) != k)
		{
			printf("command_parse: ssl_writen error");
			return;
		}
		k = SSL_read(ssl, message, MAXLINE);
		if(k < 0)
		{
			printf("command_parse: SSL_read error");
			return;
		}
		message[k] = '\0';
		printf("%s\n", message);
	}
	else if(strcmp(command, "signin") == 0) // user login 
	{
		if(n != 2)
		{
			printf("wrong command.\n");
			return;
		}
		char password[MAXLINE];
	    //cancel echo
		struct termios init_settings,new_settings;
		tcgetattr(fileno(stdin), &init_settings);
		new_settings = init_settings;
		new_settings.c_lflag &= ~ECHO;
		if(tcsetattr(fileno(stdin), TCSAFLUSH, &new_settings) != 0)
		{
			printf("could not set termios attributes.\n");
			return;
		}
		printf("Password: ");
		fgets(password, MAXLINE, stdin);
		printf("\n");
		tcsetattr(fileno(stdin), TCSANOW, &init_settings);
		int len = strlen(password);
		if(password[len - 1] == '\n')
			password[len - 1] = '\0';
		snprintf(message, MAXLINE, "signin %s %s", arg, password);
		SSL_write(ssl, message, strlen(message));
		int k = SSL_read(ssl, message, MAXLINE);
		if(k < 0)
		{
			printf("SSL_read error");
			return;
		}
		message[k] = '\0';
		printf("%s", message);

		char temp[MAXLINE];
		snprintf(temp, MAXLINE, "user %s signin successfully.\n", arg);
		if(strcmp(temp, message) ==0)
			snprintf(cmd_line, MAXLINE, "%[email protected]%s> ", arg, server_address);
	}
	else if(strcmp(command, "signout") == 0) // signout
	{
		if(n != 1)
		{
			printf("wrong command.\n");
			return;
		}
		SSL_write(ssl, "signout", strlen("signout"));
		int k = SSL_read(ssl, message, MAXLINE);
		if(k < 0)
		{
			printf("SSL_read error");
			return;
		}
		message[k] = '\0';
		printf("%s", message);

		snprintf(cmd_line, MAXLINE, "%s:%s> ", server_address, master_port);
	}
	else if(strcmp(command, "exit") == 0) // exit
	{
		if(n != 1)
		{
			printf("wrong command.\n");
			return;
		}
		SSL_write(ssl, "exit", strlen("exit"));
		stop = true;
	}
	else if(strcmp(command, "delete") == 0) // delete a file
	{
		if(n != 2)
		{
			printf("wrong command.\n");
			return;
		}
		int k = strlen(command_line);
		if(ssl_writen(ssl, command_line, k) != k)
		{
			printf("ssl_write error.\n");
			return;
		}
		k = SSL_read(ssl, message, MAXLINE);
		if(k < 0)
		{
			printf("SSL_read error.\n");
			return;
		}
		message[k] = '\0';
		printf("%s", message);
	}
	else if(strcmp(command, "ls") == 0) // list all the files of the user.
	{
		if(n != 1)
		{
			printf("wrong command.\n");
			return;
		}
		SSL_write(ssl, "ls", strlen("ls"));
		int len;
		int k = SSL_read(ssl, message, MAXLINE);
		message[k] = '\0';
		if(strcmp(message,"not signed in.\n")== 0)
			printf("not signed in.\n");
		else
		{
			sscanf(message, "%d\n", &len);
			char *p_list = (char *)malloc(len + 1);
			char *p = strchr(message, '\n') + 1;
			strcpy(p_list, p);
			int len_temp = strlen(p_list);
			if(len_temp < len)
			{
				if(ssl_readn(ssl, p_list + len_temp, len - len_temp) < 0)
				{
					printf("ssl_readn error.\n");
					return;
				}
			}
			p_list[len] = '\0';
			printf("%s", p_list);
		}
	}
	else if(strcmp(command, "upload") == 0) // upload a file to the slave server
	{
		// commandline format: upload ip_address file_name file_size
		if(n != 2)
		{
			printf("wrong command.\n");
			return;
		}
		// add the file to be uploaded to the upload array.
		struct stat64 buf;
		memset(&buf, 0, sizeof(buf));
		int file = open(arg,FILE_MODE);
		fstat64(file, &buf);
		if(file < 0)
		{
			printf("file %s not exist.\n", arg);
			return;
		}
		snprintf(message, MAXLINE, "upload %s %s %lld",ip_address, arg, (long long)buf.st_size);
		int len = strlen(message);

		if(ssl_writen(ssl, message, len) != len)
		{
			printf("ssl_writen error\n");
			return;
		}
		int k = SSL_read(ssl, message, MAXLINE);
		if(k < 0)
		{
			printf("SSL_read error\n");
			return;
		}
		message[k] = '\0';
		char temp[MAXLINE];
		snprintf(temp, MAXLINE, "file %s already exists.\n", arg);
		if(strcmp(temp, message) != 0)
		{
			pthread_mutex_lock(&upload_mutex);
			upload_array.insert(make_pair(arg, record(buf.st_size)));
			pthread_mutex_unlock(&upload_mutex);
		}
		close(file);
		printf("%s", message);
	}
	else if(strcmp(command, "download") == 0) // download a file from the slave server.
	{
		if(n != 2)
		{
			printf("wrong command.\n");
			return;
		}
		snprintf(message, MAXLINE, "download %s %s", ip_address, arg);
		int len = strlen(message);

		if(ssl_writen(ssl, message, len) != len)
		{
			printf("ssl_writen error\n");
			return;
		}
		
		int k = SSL_read(ssl, message, MAXLINE);
		if(k < 0)
		{
			printf("SSL_read error\n");
			return;
		}
		message[k] = '\0';
		if(strcmp(message, "file not exist.\n") != 0 && strcmp(message, "storage server not connected.\n") != 0)
		{
			// add the file to be downloaded to the download array.
			pthread_mutex_lock(&download_mutex);
			download_array.insert(make_pair(arg, record()));
			pthread_mutex_unlock(&download_mutex);
		}
		printf("%s", message);
	}
	else if(strcmp(command, "status") == 0)
	{
		if(n != 1)
		{
			printf("wrong command.\n");
			return;
		}
		status_query = true;
		pthread_create(&thread, NULL, status_thread, NULL);
		struct termios newt, oldt;
		// save terminal settings
		tcgetattr(0, &oldt);
		// init new settings
		newt = oldt;
		//change settings
		newt.c_lflag &= ~(ICANON | ECHO);
		//apply settings
		tcsetattr(0, TCSANOW, &newt);
		getchar();
		tcsetattr(0, TCSANOW, &oldt);
		status_query = false;
	}
	else if(command[0] == 'l')
	{
		char *p = command_line;
		while(*p == ' ')
			++p;
		system(p + 1);
		if(strncmp(p + 1,"cd", 2) == 0)
				chdir(arg);
	}
	else 
		printf("command not found.\n");
}
void parseVecReport(string fileName,unordered_map<string,string>& htabVecMessages,unordered_map<string,set<string>>& htabLines,bool isVec6){
	string line;
	bool isMsg = false;
	ifstream infile(fileName);
	if(infile.is_open()){
		while(getline(infile,line)){
			if(line.find("error") != string::npos){
				cout<<endl<<line;
				infile.close();
				exit(0);
			}		
			else if(line.find("warning") != string::npos)
				continue;
			else{
              			vector<string> vecTemp = splitStringByDelimiter(line,':');
				if(vecTemp.size() < 3){
                  			if(!isMsg){
                                        	cerr<<endl<<endl<<"The following line(s) from the vec report have not been processed:"<<endl;
                                        	isMsg = true;
                                	}
                                	cerr<<endl<<line;				
				}
				else{
					string strFileName = vecTemp[0].substr(0,vecTemp[0].find_first_of("("));
					string strLineNb = vecTemp[0].substr(vecTemp[0].find("(")+1,vecTemp[0].find(")")-vecTemp[0].find("(")-1);
					string strKey = strFileName + ";" + strLineNb;
                                	string strReason;
                                	for(int j=2;j<vecTemp.size();j++){
						if(isVec6){
							strReason += trimWhiteSpaces(vecTemp[j]);
						}
						else{
							string trimmedString = trimWhiteSpaces(vecTemp[j]);
							vector<string> vecInner = splitStringByDelimiter(trimmedString,' ');
							if(vecInner.size() > 0){
								if(htabVecMessages.find(vecInner[0]) != htabVecMessages.end()){
									strReason += htabVecMessages.at(vecInner[0]);
									if(vecInner.size() == 2)
										strReason += vecInner[1];	
								}
								else{
									strReason += trimmedString;
								}
							}
						}
                                        	if(j==vecTemp.size()-1)
                                                	strReason+=";";
                                        	else
                                                	strReason+=" - ";
                                	}
					if(htabLines.find(strKey) != htabLines.end()){
						set<string> reasons = htabLines.at(strKey);
						if(reasons.find(strReason) == reasons.end()){
							reasons.insert(strReason);
						}
						htabLines.at(strKey) = reasons;
					}				
					else{
						set<string> reasons;
						reasons.insert(strReason);
						htabLines.insert(make_pair<string,set<string>>(strKey,reasons));
					}							
				}
			}	
		}
		infile.close();
	}		
}
示例#12
0
static void manageEquipmentEvent(color_ostream& out) {
    if (!df::global::world)
        return;
    multimap<Plugin*,EventHandler> copy(handlers[EventType::INVENTORY_CHANGE].begin(), handlers[EventType::INVENTORY_CHANGE].end());

    unordered_map<int32_t, InventoryItem> itemIdToInventoryItem;
    unordered_set<int32_t> currentlyEquipped;
    for ( auto a = df::global::world->units.all.begin(); a != df::global::world->units.all.end(); a++ ) {
        itemIdToInventoryItem.clear();
        currentlyEquipped.clear();
        df::unit* unit = *a;
        /*if ( unit->flags1.bits.dead )
            continue;
        */

        auto oldEquipment = equipmentLog.find(unit->id);
        bool hadEquipment = oldEquipment != equipmentLog.end();
        vector<InventoryItem>* temp;
        if ( hadEquipment ) {
            temp = &((*oldEquipment).second);
        } else {
            temp = new vector<InventoryItem>;
        }
        //vector<InventoryItem>& v = (*oldEquipment).second;
        vector<InventoryItem>& v = *temp;
        for ( auto b = v.begin(); b != v.end(); b++ ) {
            InventoryItem& i = *b;
            itemIdToInventoryItem[i.itemId] = i;
        }
        for ( size_t b = 0; b < unit->inventory.size(); b++ ) {
            df::unit_inventory_item* dfitem_new = unit->inventory[b];
            currentlyEquipped.insert(dfitem_new->item->id);
            InventoryItem item_new(dfitem_new->item->id, *dfitem_new);
            auto c = itemIdToInventoryItem.find(dfitem_new->item->id);
            if ( c == itemIdToInventoryItem.end() ) {
                //new item equipped (probably just picked up)
                InventoryChangeData data(unit->id, NULL, &item_new);
                for ( auto h = copy.begin(); h != copy.end(); h++ ) {
                    EventHandler handle = (*h).second;
                    handle.eventHandler(out, (void*)&data);
                }
                continue;
            }
            InventoryItem item_old = (*c).second;

            df::unit_inventory_item& item0 = item_old.item;
            df::unit_inventory_item& item1 = item_new.item;
            if ( item0.mode == item1.mode && item0.body_part_id == item1.body_part_id && item0.wound_id == item1.wound_id )
                continue;
            //some sort of change in how it's equipped

            InventoryChangeData data(unit->id, &item_old, &item_new);
            for ( auto h = copy.begin(); h != copy.end(); h++ ) {
                EventHandler handle = (*h).second;
                handle.eventHandler(out, (void*)&data);
            }
        }
        //check for dropped items
        for ( auto b = v.begin(); b != v.end(); b++ ) {
            InventoryItem i = *b;
            if ( currentlyEquipped.find(i.itemId) != currentlyEquipped.end() )
                continue;
            //TODO: delete ptr if invalid
            InventoryChangeData data(unit->id, &i, NULL);
            for ( auto h = copy.begin(); h != copy.end(); h++ ) {
                EventHandler handle = (*h).second;
                handle.eventHandler(out, (void*)&data);
            }
        }
        if ( !hadEquipment )
            delete temp;

        //update equipment
        vector<InventoryItem>& equipment = equipmentLog[unit->id];
        equipment.clear();
        for ( size_t b = 0; b < unit->inventory.size(); b++ ) {
            df::unit_inventory_item* dfitem = unit->inventory[b];
            InventoryItem item(dfitem->item->id, *dfitem);
            equipment.push_back(item);
        }
    }
}
示例#13
0
/*
TODO: consider checking item creation / experience gain just in case
*/
static void manageJobCompletedEvent(color_ostream& out) {
    if (!df::global::world)
        return;
    int32_t tick0 = eventLastTick[EventType::JOB_COMPLETED];
    int32_t tick1 = df::global::world->frame_counter;

    multimap<Plugin*,EventHandler> copy(handlers[EventType::JOB_COMPLETED].begin(), handlers[EventType::JOB_COMPLETED].end());
    map<int32_t, df::job*> nowJobs;
    for ( df::job_list_link* link = &df::global::world->job_list; link != NULL; link = link->next ) {
        if ( link->item == NULL )
            continue;
        nowJobs[link->item->id] = link->item;
    }

#if 0
    //testing info on job initiation/completion
    //newly allocated jobs
    for ( auto j = nowJobs.begin(); j != nowJobs.end(); j++ ) {
        if ( prevJobs.find((*j).first) != prevJobs.end() )
            continue;

        df::job& job1 = *(*j).second;
        out.print("new job\n"
            "  location         : 0x%X\n"
            "  id               : %d\n"
            "  type             : %d %s\n"
            "  working          : %d\n"
            "  completion_timer : %d\n"
            "  workerID         : %d\n"
            "  time             : %d -> %d\n"
            "\n", job1.list_link->item, job1.id, job1.job_type, ENUM_ATTR(job_type, caption, job1.job_type), job1.flags.bits.working, job1.completion_timer, getWorkerID(&job1), tick0, tick1);
    }
    for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
        df::job& job0 = *(*i).second;
        auto j = nowJobs.find((*i).first);
        if ( j == nowJobs.end() ) {
            out.print("job deallocated\n"
                "  location         : 0x%X\n"
                "  id               : %d\n"
                "  type             : %d %s\n"
                "  working          : %d\n"
                "  completion_timer : %d\n"
                "  workerID         : %d\n"
                "  time             : %d -> %d\n"
                ,job0.list_link == NULL ? 0 : job0.list_link->item, job0.id, job0.job_type, ENUM_ATTR(job_type, caption, job0.job_type), job0.flags.bits.working, job0.completion_timer, getWorkerID(&job0), tick0, tick1);
            continue;
        }
        df::job& job1 = *(*j).second;

        if ( job0.flags.bits.working == job1.flags.bits.working &&
               (job0.completion_timer == job1.completion_timer || (job1.completion_timer > 0 && job0.completion_timer-1 == job1.completion_timer)) &&
               getWorkerID(&job0) == getWorkerID(&job1) )
            continue;

        out.print("job change\n"
            "  location         : 0x%X -> 0x%X\n"
            "  id               : %d -> %d\n"
            "  type             : %d -> %d\n"
            "  type             : %s -> %s\n"
            "  working          : %d -> %d\n"
            "  completion timer : %d -> %d\n"
            "  workerID         : %d -> %d\n"
            "  time             : %d -> %d\n"
            "\n",
            job0.list_link->item, job1.list_link->item,
            job0.id, job1.id,
            job0.job_type, job1.job_type,
            ENUM_ATTR(job_type, caption, job0.job_type), ENUM_ATTR(job_type, caption, job1.job_type),
            job0.flags.bits.working, job1.flags.bits.working,
            job0.completion_timer, job1.completion_timer,
            getWorkerID(&job0), getWorkerID(&job1),
            tick0, tick1
        );
    }
#endif

    for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
        //if it happened within a tick, must have been cancelled by the user or a plugin: not completed
        if ( tick1 <= tick0 )
            continue;

        if ( nowJobs.find((*i).first) != nowJobs.end() ) {
            //could have just finished if it's a repeat job
            df::job& job0 = *(*i).second;
            if ( !job0.flags.bits.repeat )
                continue;
            df::job& job1 = *nowJobs[(*i).first];
            if ( job0.completion_timer != 0 )
                continue;
            if ( job1.completion_timer != -1 )
                continue;

            //still false positive if cancelled at EXACTLY the right time, but experiments show this doesn't happen
            for ( auto j = copy.begin(); j != copy.end(); j++ ) {
                (*j).second.eventHandler(out, (void*)&job0);
            }
            continue;
        }

        //recently finished or cancelled job
        df::job& job0 = *(*i).second;
        if ( job0.flags.bits.repeat || job0.completion_timer != 0 )
            continue;

        for ( auto j = copy.begin(); j != copy.end(); j++ ) {
            (*j).second.eventHandler(out, (void*)&job0);
        }
    }

    //erase old jobs, copy over possibly altered jobs
    for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
        Job::deleteJobStruct((*i).second, true);
    }
    prevJobs.clear();

    //create new jobs
    for ( auto j = nowJobs.begin(); j != nowJobs.end(); j++ ) {
        /*map<int32_t, df::job*>::iterator i = prevJobs.find((*j).first);
        if ( i != prevJobs.end() ) {
            continue;
        }*/

        df::job* newJob = Job::cloneJobStruct((*j).second, true);
        prevJobs[newJob->id] = newJob;
    }
}
示例#14
0
void DFHack::EventManager::onStateChange(color_ostream& out, state_change_event event) {
    static bool doOnce = false;
//    const string eventNames[] = {"world loaded", "world unloaded", "map loaded", "map unloaded", "viewscreen changed", "core initialized", "begin unload", "paused", "unpaused"};
//    out.print("%s,%d: onStateChange %d: \"%s\"\n", __FILE__, __LINE__, (int32_t)event, eventNames[event].c_str());
    if ( !doOnce ) {
        //TODO: put this somewhere else
        doOnce = true;
        EventHandler buildingHandler(Buildings::updateBuildings, 100);
        DFHack::EventManager::registerListener(EventType::BUILDING, buildingHandler, NULL);
        //out.print("Registered listeners.\n %d", __LINE__);
    }
    if ( event == DFHack::SC_MAP_UNLOADED ) {
        lastJobId = -1;
        for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
            Job::deleteJobStruct((*i).second, true);
        }
        prevJobs.clear();
        tickQueue.clear();
        livingUnits.clear();
        buildings.clear();
        constructions.clear();
        equipmentLog.clear();

        Buildings::clearBuildings(out);
        lastReport = -1;
        lastReportUnitAttack = -1;
        gameLoaded = false;

        multimap<Plugin*,EventHandler> copy(handlers[EventType::UNLOAD].begin(), handlers[EventType::UNLOAD].end());
        for (auto a = copy.begin(); a != copy.end(); a++ ) {
            (*a).second.eventHandler(out, NULL);
        }
    } else if ( event == DFHack::SC_MAP_LOADED ) {
        /*
        int32_t tick = df::global::world->frame_counter;
        multimap<int32_t,EventHandler> newTickQueue;
        for ( auto i = tickQueue.begin(); i != tickQueue.end(); i++ )
            newTickQueue.insert(pair<int32_t,EventHandler>(tick+(*i).first, (*i).second));
        tickQueue.clear();
        tickQueue.insert(newTickQueue.begin(), newTickQueue.end());
        //out.print("%s,%d: on load, frame_counter = %d\n", __FILE__, __LINE__, tick);
        */
        //tickQueue.clear();
        if (!df::global::item_next_id)
            return;
        if (!df::global::building_next_id)
            return;
        if (!df::global::job_next_id)
            return;
        if (!df::global::ui)
            return;
        if (!df::global::world)
            return;

        nextItem = *df::global::item_next_id;
        nextBuilding = *df::global::building_next_id;
        nextInvasion = df::global::ui->invasions.next_id;
        lastJobId = -1 + *df::global::job_next_id;

        constructions.clear();
        for ( auto i = df::global::world->constructions.begin(); i != df::global::world->constructions.end(); i++ ) {
            df::construction* constr = *i;
            if ( !constr ) {
                if ( Once::doOnce("EventManager.onLoad null constr") ) {
                    out.print("EventManager.onLoad: null construction.\n");
                }
                continue;
            }
            if ( constr->pos == df::coord() ) {
                if ( Once::doOnce("EventManager.onLoad null position of construction.\n") )
                    out.print("EventManager.onLoad null position of construction.\n");
                continue;
            }
            constructions[constr->pos] = *constr;
        }
        for ( size_t a = 0; a < df::global::world->buildings.all.size(); a++ ) {
            df::building* b = df::global::world->buildings.all[a];
            Buildings::updateBuildings(out, (void*)b);
            buildings.insert(b->id);
        }
        lastSyndromeTime = -1;
        for ( size_t a = 0; a < df::global::world->units.all.size(); a++ ) {
            df::unit* unit = df::global::world->units.all[a];
            for ( size_t b = 0; b < unit->syndromes.active.size(); b++ ) {
                df::unit_syndrome* syndrome = unit->syndromes.active[b];
                int32_t startTime = syndrome->year*ticksPerYear + syndrome->year_time;
                if ( startTime > lastSyndromeTime )
                    lastSyndromeTime = startTime;
            }
        }
        lastReport = -1;
        if ( df::global::world->status.reports.size() > 0 ) {
            lastReport = df::global::world->status.reports[df::global::world->status.reports.size()-1]->id;
        }
        lastReportUnitAttack = -1;
        lastReportInteraction = -1;
        reportToRelevantUnitsTime = -1;
        reportToRelevantUnits.clear();
        for ( size_t a = 0; a < EventType::EVENT_MAX; a++ ) {
            eventLastTick[a] = -1;//-1000000;
        }

        gameLoaded = true;
    }
}
示例#15
0
 int get(int key) {
     if (m_map.find(key) == m_map.end()) return -1;
     MoveToHead(key);
     return m_map[key]->value;
 }
int32_t mbl_mw_metawearboard_deserialize(MblMwMetaWearBoard* board, uint8_t* state, uint32_t size) {
    uint8_t *current_addr = state, format = *current_addr;

    if (format != INIT_SERIALIZATION_FORMAT && format != SIGNAL_COMPONENT_SERIALIZATION_FORMAT) {
        return MBL_MW_STATUS_ERROR_SERIALIZATION_FORMAT;
    }

    board->firmware_revision.deserialize(&(++current_addr));

    uint8_t module_str_size = *current_addr;
    current_addr++;
    board->module_number.assign(current_addr, current_addr + module_str_size);
    current_addr += module_str_size;

    board->module_info.clear();
    uint8_t module_info_size = *current_addr;
    current_addr++;
    for (uint8_t i = 0; i < module_info_size; i++) {
        board->module_info.emplace(*current_addr, &current_addr);
    }
    
    for (auto it : board->module_events) {
        delete it.second;
    }
    board->module_events.clear();

    uint8_t n_events = *current_addr;
    current_addr++;
    for (uint8_t i = 0; i < n_events; i++) {
        MblMwEvent* saved_event;

        switch (*current_addr) {
        case MBL_MW_MODULE_GPIO:
            switch(static_cast<GpioRegister>(CLEAR_READ_MODIFIERS(*(current_addr + 1)))) {
            case GpioRegister::READ_AI_ABS_REF:
            case GpioRegister::READ_AI_ADC:
                saved_event= new MblMwGpioAnalogSignal(&current_addr, board);
                break;
            case GpioRegister::PIN_CHANGE_NOTIFY:
                saved_event= new MblMwGpioPinNotifySignal(&current_addr, board);
                break;
            default:
                saved_event = new MblMwDataSignal(&current_addr, board);
                break;
            }
            break;
        case MBL_MW_MODULE_DATA_PROCESSOR:
            saved_event = static_cast<DataProcessorRegister>(CLEAR_READ_MODIFIERS(*(current_addr + 1))) == DataProcessorRegister::STATE ?
                new MblMwDataSignal(&current_addr, board) :
                new MblMwDataProcessor(&current_addr, board);
            break;
        case MBL_MW_MODULE_TIMER:
            saved_event = new MblMwTimer(&current_addr, board);
            break;
        case MBL_MW_MODULE_I2C:
            switch(static_cast<SerialPassthroughRegister>(CLEAR_READ_MODIFIERS(*(current_addr + 1)))) {
            case SerialPassthroughRegister::I2C_READ_WRITE:
                saved_event= new MblMwI2cSignal(&current_addr, board);
                break;
            case SerialPassthroughRegister::SPI_READ_WRITE:
                saved_event= new MblMwSpiSignal(&current_addr, board);
                break;
            default:
                saved_event= new MblMwDataSignal(&current_addr, board);
                break;
            }
            break;
        case MBL_MW_MODULE_SETTINGS:
            saved_event = static_cast<SettingsRegister>(*(current_addr + 1)) == SettingsRegister::DISCONNECT_EVENT ?
                new MblMwEvent(&current_addr, board) :
                new MblMwDataSignal(&current_addr, board);
            break;
        default:
            saved_event = new MblMwDataSignal(&current_addr, board);
            break;
        }

        ResponseHeader header_copy(saved_event->header);
        header_copy.disable_silent();

        if (board->module_events.count(header_copy)) {
            auto signal = dynamic_cast<MblMwDataSignal*>(board->module_events[saved_event->header]);
            signal->components.push_back(dynamic_cast<MblMwDataSignal*>(saved_event));
        } else {
            board->module_events.emplace(header_copy, saved_event);
        }
    }

    uint8_t module_config_size= *current_addr;
    current_addr++;
    for (uint8_t i= 0; i < module_config_size; i++) {
        auto fn= CONFIG_DESERIALIZATION.at(*current_addr);
        current_addr++;
        fn(board, &current_addr);
    }

    deserialize_logging(board, (format == SIGNAL_COMPONENT_SERIALIZATION_FORMAT), &current_addr);

    return MBL_MW_STATUS_OK;
}
void asferknnclustering::kNNClustering(string distancemetric)
{
        bool converged=false;

        asferstringdistance asd;

	int max_no_of_points=0;
	int max_cluster_id=0;

	//training labelled dataset
        ifstream input1;
        char line1[256];
        char line2[256];
        string encstrpath1(asferroot);
        encstrpath1.append("/asfer.enterprise.encstr.kNN");
        input1.open(encstrpath1.c_str(), ifstream::in);
	labelled_points.clear();
	
	int i=0;
        while (!input1.eof())
        {
               input1.getline(line1,256);
               string encstrtr(line1);
	       if(encstrtr != "")
	       {
			cout<<"training dataset : encstrtr = "<<encstrtr<<endl;
			labelled_points[encstrtr] = i % MAX_NO_CLUSTERS;
	       		i++;
	       }
        }
	
	cout<<"Before kNN clustering"<<endl;
	printClusters();
                                            
       	//kNN clustering classification 
        ifstream input2;
        string encstrpath2(asferroot);
        encstrpath2.append("/asfer.enterprise.encstr");
        input2.open(encstrpath2.c_str(), ifstream::in);

        while (!input2.eof()) //for each unlabelled encoded string 
        {
                input2.getline(line2,256);
                string encstrtr(line2);
		if(encstrtr != "")
		{
			int editdistance_radius=8;
	      		unordered_map<string,int> kNearestNeighbours; // <encoded_string,cluster_id>
 
			printClusters();
			for(unordered_map<string,int>::iterator it1 = labelled_points.begin(); it1 != labelled_points.end(); it1++) // for each labelled encoded string
			{
				//compute distance to all labelled points from this unlabelled point
				//and create a map of k Nearest neighbours that are with in a
				//radius edit distance
	       			int ed;
				cout<<"kNNClustering iteration: encstrtr = "<<encstrtr<<endl;
				if(it1->first != "")
				{
					ed = asd.editDistanceWagnerFischer(encstrtr, it1->first);
					if(ed < editdistance_radius)
					{
						kNearestNeighbours[it1->first] = it1->second;
					}
				}
			}	
			
			//find the cluster id label that is
			//in majority in above k Nearest Neighbours
			unordered_map<int,int> labelMajority; // <cluster_id, no_of_points_in_cluster>
			for(unordered_map<string,int>::iterator it2 = kNearestNeighbours.begin(); it2 != kNearestNeighbours.end(); it2++)
			{
				//if(it2->first != "")
					labelMajority[it2->second]++;
			}
			
			for(unordered_map<int,int>::iterator it3 = labelMajority.begin(); it3 != labelMajority.end(); it3++)
			{
				if(it3->second > max_no_of_points)
				{
					max_no_of_points = it3->second;
					max_cluster_id = it3->first;
				}
			}
			//label with max_cluster_id
			labelled_points[encstrtr]=max_cluster_id;
			max_no_of_points=0;
			max_cluster_id=0;
        	}
	}
	printClusters();
}
vector<vector<int>> createTupleTable(unordered_map<int, vector<Pair>> clauseAnswers, vector<Relationship> relationships, unordered_map<string, int> *synIndexMap) {
	//// cout << "Begin creating tuple table" << endl;

	vector<vector<int>> tupleTable;
	vector<int> emptyTuple;
	tupleTable.push_back(emptyTuple);

	for(int i=0; i<int(relationships.size()); i++) {

		if (AbstractWrapper::GlobalStop) {
			// cout<< "Timeout detected! Stopping QueryProcessor Tuple!" << endl;
			return tupleTable;
		}

		//// cout << "Adding relationship " << i << " to tuple table" << endl;

		vector<Pair> clauseAns = clauseAnswers.at(i);
		//Initialize variables
		Relationship r = relationships.at(i);
		Relationship::RelType rt = r.getRelType();
		//// cout << "Relation Type being added to tuple table: " << rt << endl;
		string token1;
		string token2;
		Relationship::TokenType type1;
		Relationship::TokenType type2;

		if(rt == Relationship::PATTERN) {
			type1 = r.getToken1Type();
			if(type1 == Relationship::SYNONYM) {
				token1 = r.getPatternSyn();
				token2 = r.getToken1();
				type2 = r.getToken1Type();
			}
			else {
				token1 = r.getPatternSyn();
				token2 = r.getPatternSyn();
				type1 = Relationship::SYNONYM;
				type2 = Relationship::INVALIDTOKEN;
			}
		}
		else {
			token1 = r.getToken1();
			token2 = r.getToken2();
			type1 = r.getToken1Type();
			type2 = r.getToken2Type();
		}
		bool ignore1 = false;
		bool ignore2 = false;

		if(type1 != Relationship::SYNONYM)
			ignore1 = true;
		if(type2 != Relationship::SYNONYM || (token1==token2))
			ignore2 = true;

		//Case 1: both are Synonyms
		if(!ignore1 && !ignore2) {
			//// cout << "Case 1" << endl;
			bool tk1InMap = false;
			bool tk2InMap = false;

			if(synIndexMap->find(token1) != synIndexMap->end())
				tk1InMap = true;
			else {
				//// cout << "Adding " << token1 << " to synMap with index " << synIndexMap->size() << endl;
				synIndexMap->insert(make_pair(token1, synIndexMap->size()));
			}
			
			if(synIndexMap->find(token2) != synIndexMap->end())
				tk2InMap = true;
			else {
				//// cout << "Adding " << token2 << " to synMap with index " << synIndexMap->size() << endl;
				synIndexMap->insert(make_pair(token2, synIndexMap->size()));
			}
			// Check if clause has no answer, return empty tuple table
			if(clauseAns.size()==0) {
				//// cout << "empty clause detected, returning empty table" << endl;
				tupleTable.clear();
				break;
			}

			vector<vector<int>> newTable;

			//Case 1.1: Both Synonyms are new
			if(!tk1InMap && !tk2InMap) {
				//// cout << "Case 1.1" << endl;
				for(int x=0; x<int(tupleTable.size()); x++) {
					for(int y=0; y<int(clauseAns.size()); y++) {
						vector<int> tuple;
						vector<int> tuple1 = tupleTable.at(x);
						Pair tuple2 = clauseAns.at(y);
						tuple.insert(tuple.begin(), tuple1.begin(), tuple1.end());
						//// cout << tuple2.ans1 << " " << tuple2.ans2 << endl; 
						tuple.push_back(tuple2.ans1);
						tuple.push_back(tuple2.ans2);
						
						newTable.push_back(tuple);
					}
				}
			}
			//Case 1.2: First Synonym is new
			else if(!tk1InMap) {
				//// cout << "Case 1.2" << endl;
				for(int x=0; x<int(tupleTable.size()); x++) {
					for(int y=0; y<int(clauseAns.size()); y++) {
						vector<int> tuple;
						vector<int> tuple1 = tupleTable.at(x);
						Pair tuple2 = clauseAns.at(y);
						
						int index = synIndexMap->at(token2);
						if(tuple1.at(index) == tuple2.ans2) {
							tuple.insert(tuple.begin(), tuple1.begin(), tuple1.end());
							tuple.push_back(tuple2.ans1);
							newTable.push_back(tuple);
						}
					}
				}
			}
			//Case 1.3: Second Synonym is new
			else if(!tk2InMap) {
				//// cout << "Case 1.3" << endl;
				for(int x=0; x<int(tupleTable.size()); x++) {
					for(int y=0; y<int(clauseAns.size()); y++) {
						vector<int> tuple;
						vector<int> tuple1 = tupleTable.at(x);
						Pair tuple2 = clauseAns.at(y);
						
						int index = synIndexMap->at(token1);
						if(tuple1.at(index) == tuple2.ans1) {
							tuple.insert(tuple.begin(), tuple1.begin(), tuple1.end());
							tuple.push_back(tuple2.ans2);
							newTable.push_back(tuple);
						}
					}
				}
			}
			//Case 1.4: Both Synonyms have been seen before
			else {
				//// cout << "Case 1.4" << endl;
				for(int x=0; x<int(tupleTable.size()); x++) {
					for(int y=0; y<int(clauseAns.size()); y++) {
						vector<int> tuple;
						vector<int> tuple1 = tupleTable.at(x);
						Pair tuple2 = clauseAns.at(y);
						int index1 = synIndexMap->at(token1);
						int index2 = synIndexMap->at(token2);

						if(tuple1.at(index1) == tuple2.ans1 && tuple1.at(index2) == tuple2.ans2) {
							tuple.insert(tuple.begin(), tuple1.begin(), tuple1.end());
							newTable.push_back(tuple);
						}

					}
				}
			}

			tupleTable = newTable;
		}
		//Case 2: only first arg is Synonyms
		else if(!ignore1) {
			//// cout << "Case 2" << endl;
			bool tkInMap = false;

			if(synIndexMap->find(token1) != synIndexMap->end())
				tkInMap = true;
			else {
				//// cout << "Adding " << token1 << " to synMap with index " << synIndexMap->size() << endl;
				synIndexMap->insert(make_pair(token1, synIndexMap->size()));
			}
						
			// Check if clause has no answer, return empty tuple table
			if(clauseAns.size()==0) {
				//// cout << "empty clause detected, returning empty table" << endl;
				tupleTable.clear();
				break;
			}
			
			vector<vector<int>> newTable;

			//Case 2.1: have seen Synonym
			if(tkInMap) {
				//// cout << "Case 2.1" << endl;
				for(int x=0; x<int(tupleTable.size()); x++) {
					for(int y=0; y<int(clauseAns.size()); y++) {
						vector<int> tuple;
						vector<int> tuple1 = tupleTable.at(x);
						Pair tuple2 = clauseAns.at(y);
						
						int index = synIndexMap->at(token1);
						if(tuple1.at(index) == tuple2.ans1) {
							tuple.insert(tuple.begin(), tuple1.begin(), tuple1.end());
							newTable.push_back(tuple);
						}
					}
				}
			}
			//Case 2.2: haven't seen Synonym
			else {
				//// cout << "Case 2.2" << endl;
				for(int x=0; x<int(tupleTable.size()); x++) {
					for(int y=0; y<int(clauseAns.size()); y++) {
						vector<int> tuple;
						vector<int> tuple1 = tupleTable.at(x);
						Pair tuple2 = clauseAns.at(y);
						tuple.insert(tuple.begin(), tuple1.begin(), tuple1.end());
						tuple.push_back(tuple2.ans1);
						
						newTable.push_back(tuple);
					}
				}
			}

			tupleTable = newTable;
		}
		//Case 3: only second arg is Synonyms
		else if(!ignore2) {
			//// cout << "Case 3" << endl;
			bool tkInMap = false;

			if(synIndexMap->find(token2) != synIndexMap->end())
				tkInMap = true;
			else {
				//// cout << "Adding " << token2 << " to synMap with index " << synIndexMap->size() << endl;
				synIndexMap->insert(make_pair(token2, synIndexMap->size()));
			}

			// Check if clause has no answer, return empty tuple table
			if(clauseAns.size()==0) {
				//// cout << "empty clause detected, returning empty table" << endl;
				tupleTable.clear();
				break;
			}

			vector<vector<int>> newTable;

			//Case 3.1: have seen Synonym
			if(tkInMap) {
				//// cout << "Case 3.1" << endl;
				for(int x=0; x<int(tupleTable.size()); x++) {
					for(int y=0; y<int(clauseAns.size()); y++) {
						vector<int> tuple;
						vector<int> tuple1 = tupleTable.at(x);
						Pair tuple2 = clauseAns.at(y);
						
						int index = synIndexMap->at(token2);
						if(tuple1.at(index) == tuple2.ans2) {
							tuple.insert(tuple.begin(), tuple1.begin(), tuple1.end());
							newTable.push_back(tuple);
						}
					}
				}
			}
			//Case 3.2: haven't seen Synonym
			else {
				//// cout << "Case 3.2" << endl;
				for(int x=0; x<int(tupleTable.size()); x++) {
					for(int y=0; y<int(clauseAns.size()); y++) {
						vector<int> tuple;
						vector<int> tuple1 = tupleTable.at(x);
						Pair tuple2 = clauseAns.at(y);
						tuple.insert(tuple.begin(), tuple1.begin(), tuple1.end());
						tuple.push_back(tuple2.ans2);
						
						newTable.push_back(tuple);
					}
				}
			}

			tupleTable = newTable;
		}
		//Case 4: neither are Synonyms(answer is boolean)
		else {
			//// cout << "Case 4" << endl;
			if(clauseAns.size() == 0)
				tupleTable.clear();
		}

		//If tuple table is ever empty, return empty tuple table
		if(tupleTable.size() == 0)
			return tupleTable;
		//// cout <<"Tuple Table Size: " << tupleTable.size() << endl;

		//// cout << "Current Tuple Length: " << tupleTable.at(0).size() << endl;
	}

	//// cout << "End creating tuple table" << endl;
	return tupleTable;
}
示例#19
0
 bool haveSeenState(State* state) {
   assert(state != nullptr);
   return stateActions.count(state) > 0;
 }
示例#20
0
void deallocate_memory(){
	sample_path_list.clear();
	list_samples.clear();
	indexes.clear();
	ides_index_name.clear();
}
示例#21
0
void clearscache()
{
    pthread_mutex_lock(&slock);
    scache.clear();
    pthread_mutex_unlock(&slock);
}
  ////////////////////////////////////////////////////////////////////////////////
  // OTHERS
  void update_predefined_parameters(
    unordered_map<wstring, pair<wstring, int> > const& params) {

    unordered_map<wstring, pair<wstring, int> >::const_iterator i;


    ////////////////////////////////////////////////////////////////////////////////
    // SIZE

    if ((i=params.find(pre_edge_width))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_draw::set_edge_width(v);
      } catch (...) {}
    } else {
      sociarium_project_draw::set_edge_width(
        sociarium_project_draw::get_default_edge_width());
    }

    if ((i=params.find(pre_node_size))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_draw::set_node_size(v);
      } catch (...) {}
    } else {
      sociarium_project_draw::set_node_size(
        sociarium_project_draw::get_default_node_size());
    }

    if ((i=params.find(pre_coordinates_size))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_draw::set_coordinates_size(v);
      } catch (...) {}
    }

    if ((i=params.find(pre_grid_interval))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_layout::set_grid_interval(v);
      } catch (...) {}
    }


    ////////////////////////////////////////////////////////////////////////////////
    // FORCE DIRECTION

    if ((i=params.find(pre_force_scale))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_force_direction::set_force_scale(v);
      } catch (...) {}
    }

    if ((i=params.find(pre_kk_force_NN))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_force_direction::set_kk_force_CC(v);
      } catch (...) {}
    }

    if ((i=params.find(pre_kk_force_CC))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_force_direction::set_kk_force_CC(v);
      } catch (...) {}
    }

    if ((i=params.find(pre_spring_force_CN))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_force_direction::set_spring_force_CN(v);
      } catch (...) {}
    }

    if ((i=params.find(pre_spring_force_NN))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_force_direction::set_spring_force_NN(v);
      } catch (...) {}
    }

    if ((i=params.find(pre_spring_length_CN))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_force_direction::set_spring_length_CN(v);
      } catch (...) {}
    }

    if ((i=params.find(pre_spring_length_NN))!=params.end()) {
      wstring const& s = i->second.first;
      try {
        float const v = boost::lexical_cast<float>(s);
        if (v>0.0f) sociarium_project_force_direction::set_spring_length_NN(v);
      } catch (...) {}
    }

    sociarium_project_force_direction::should_be_updated();

  }
示例#23
0
/******************************************************************************
Description: function for transmitting the frames
Input Value.:
Return Value:
******************************************************************************/
void server_transmit (int sock, string userID)
{
    // printf("transmitting part\n");
    
    int n;
    char response[] = "ok";
    char file_name_temp[60];
    char *file_name;
    int write_length = 0;
    int length = 0;
    queue<string> *imgQueue = new queue<string>();    // queue storing the file names 

    // grap the lock
    pthread_mutex_lock(&queue_map_lock);
    queue_map[userID] = imgQueue; // put the address of queue into map
    pthread_mutex_unlock(&queue_map_lock);

    pthread_mutex_t queueLock; // mutex lock for queue operation
    sem_t *sem_match = 0;

    // init the mutex lock
    if (pthread_mutex_init(&queueLock, NULL) != 0)
    {
        errorSocket("ERROR mutex init failed", sock);
    }

    if (!orbit)
    {
        char buffer[BUFFER_SIZE];
        char *file_size_char;
        int file_size;
        int received_size = 0;

        // reponse to the client
        n = write(sock, response, sizeof(response));
        if (n < 0)
        {
            pthread_mutex_destroy(&queueLock);
            errorSocket("ERROR writting to socket", sock);
        }

        while (!global_stop)
        {
            received_size = 0;
            // receive the file info
            bzero(buffer, sizeof(buffer));
            n = read(sock,buffer, sizeof(buffer));
            if (n <= 0)
            {
                pthread_mutex_destroy(&queueLock);
                // signal the result thread to terminate
                sem_post(sem_match);
                errorSocket("ERROR reading from socket", sock);
            } 

            // store the file name and the block count
            file_name = strtok(buffer, ",");
            strcpy(file_name_temp, file_name);
            if (debug) printf("\n[server] file name: [%s]\n", file_name);
            file_size_char = strtok(NULL, ",");
            file_size = strtol(file_size_char, NULL, 10);
            if (debug) printf("file size: %d\n", file_size);

            // calculate the time consumption here
            struct timeval tpstart,tpend;
            double timeuse;
            gettimeofday(&tpstart,NULL);

            // reponse to the client
            n = write(sock, response, sizeof(response));
            if (n <= 0)
            {
                pthread_mutex_destroy(&queueLock);
                // signal the result thread to terminate
                sem_post(sem_match);
                errorSocket("ERROR writting to socket", sock);
            } 


            if (!storm)
            {
                FILE *fp = fopen(file_name, "w");  
                if (fp == NULL)  
                {  
                    printf("File:\t%s Can Not Open To Write!\n", file_name);  
                    break;
                }  

                // receive the data from client and store them into buffer
                bzero(buffer, sizeof(buffer));
                while((length = recv(sock, buffer, sizeof(buffer), 0)))  
                {
                    if (length < 0)  
                    {  
                        printf("Recieve Data From Client Failed!\n");  
                        break;  
                    }
              
                    write_length = fwrite(buffer, sizeof(char), length, fp);  
                    if (write_length < length)
                    {  
                        printf("File:\t Write Failed!\n");  
                        break;  
                    }  
                    bzero(buffer, sizeof(buffer));
                    received_size += length;
                    if (received_size >= file_size)
                    {
                        if (debug) printf("file size full\n");
                        break;
                    }
                }

                // print out time comsumption
                gettimeofday(&tpend,NULL);
                timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;// notice, should include both s and us
                // printf("used time:%fus\n",timeuse);
                printf("receive used time:%fms\n",timeuse / 1000);

                if (debug) printf("[server] Recieve Finished!\n\n");  

                // finished 
                fclose(fp);
            }
            // below is storm mode
            else
            {
                // in storm mode, don't save img into disk
                char img[file_size];
                int offset = 0;
                // receive the data from server and store them into buffer
                bzero(buffer, sizeof(buffer));
                while((length = recv(sock, buffer, sizeof(buffer), 0)))  
                {
                    if (length < 0)  
                    {  
                        printf("Recieve Data From Client Failed!\n");  
                        break;  
                    }
              
                    // copy the content into img
                    for (int i = 0; i < length; ++i)
                    {
                        img[i + offset] = buffer[i];
                    }

                    bzero(buffer, sizeof(buffer));
                    offset += length;
                    if (offset >= file_size)
                    {
                        if (debug) printf("file size full\n");
                        break;
                    }
                }

                // print out time comsumption
                gettimeofday(&tpend,NULL);
                timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;// notice, should include both s and us
                // printf("used time:%fus\n",timeuse);
                printf("receive used time:%fms\n",timeuse / 1000);

                if (debug) printf("[server] Recieve Finished!\n\n");  

                // send request to spout
                if (debug) printf("Now try to connect the spout\n");
                int sockfd, ret;
                int spoutPort = 9878;
                struct sockaddr_in spout_addr;
                struct hostent *spout;
                struct in_addr ipv4addr;
                char buf_spout[100];
                char* spout_IP;
                const int len = spoutIP.length();
                spout_IP = new char[len+1];
                strcpy(spout_IP, spoutIP.c_str());

                sockfd = socket(AF_INET, SOCK_STREAM, 0);
                if (sockfd < 0)
                {
                    printf("ERROR opening socket\n");
                    return;
                }
                inet_pton(AF_INET, spout_IP, &ipv4addr);
                spout = gethostbyaddr(&ipv4addr, sizeof(ipv4addr), AF_INET);
                if (debug) printf("\n[server] Spout address: %s\n", spout_IP);
                if (spout == NULL) {
                    fprintf(stderr,"ERROR, no such host\n");
                    exit(0);
                }
                bzero((char *) &spout_addr, sizeof(spout_addr));
                spout_addr.sin_family = AF_INET;
                bcopy((char *)spout->h_addr, (char *)&spout_addr.sin_addr.s_addr, spout->h_length); 
                spout_addr.sin_port = htons(spoutPort);

                while (connect(sockfd,(struct sockaddr *) &spout_addr, sizeof(spout_addr)) < 0)
                {
                    printf("The spout is not available now, wait a while and reconnect\n\n");
                    usleep(100000); // sleep 100ms
                }

                printf("[server] Get connection to spout\n");

                bzero(buf_spout, sizeof(buf_spout));
                sprintf(buf_spout, "%d", file_size);
                if (debug) printf("[server] send the file size\n");
                ret = write(sockfd, buf_spout, sizeof(buf_spout));
                if (ret < 0)
                {
                    printf("error sending\n");
                    return;
                }

                // get the response
                bzero(buf_spout, sizeof(buf_spout));
                if (debug) printf("[server] now wait for response\n");
                ret = read(sockfd, buf_spout, sizeof(buf_spout));
                if (ret < 0)
                {
                    printf("error reading\n");
                    return;
                }

                if (debug) printf("got response: %s\n", buf_spout);

                if (debug) printf("[server] send the img\n");
                ret = write(sockfd, img, sizeof(img));
                if (ret < 0)
                {
                    printf("error sending\n");
                    return;
                }
                if (debug) printf("ret: %d\n", ret);
                printf("[server] Finished transmitting image to spout\n\n");

                close(sockfd);

            }

            // lock the queue, ensure there is only one thread modifying the queue
            pthread_mutex_lock(&queueLock);

            // store the file name to the waiting queue
            string file_name_string(file_name_temp);
            imgQueue->push(file_name_string);

            pthread_mutex_unlock(&queueLock);
            // get the address of sem_match
            if (sem_match == 0)
            {
                while (sem_map.find(userID) == sem_map.end());
                sem_match = sem_map[userID];
            }
            // signal the result thread to do image processing
            sem_post(sem_match);
            // pause();
        }

        close(sock);
    }
    // below is orbit mode
    else
    {
        // get the id length
        int id_length = 1;
        int divisor = 10;
        while (sock / divisor > 0)
        {
            ++id_length;
            divisor *= 10;
        }
        int recv_length = BUFFER_SIZE * 4; // 4096 bytes per time
        char buffer[recv_length];
        char *file_size_char;
        int file_size;
        int received_size = 0;

        if (debug) printf("\nstart receiving file\n");


        // reponse to the client
        MsgD.send(sock, response, sizeof(response));

        while (!global_stop)
        {
            received_size = 0;
            bzero(buffer, sizeof(buffer));
            // get the file info from client
            n = MsgD.recv(sock, buffer, 100);
            if (n < 0)
            {
                pthread_mutex_destroy(&queueLock);
                // signal the result thread to terminate
                sem_post(sem_match);
                errorSocket("ERROR reading from socket", sock);
                return;
            } 
            file_name = strtok(buffer, ",");
            strcpy(file_name_temp, file_name);
            printf("\n[server] file name: [%s]\n", file_name);
            file_size_char = strtok(NULL, ",");
            file_size = strtol(file_size_char, NULL, 10);
            printf("[server] file size: %d\n", file_size);

            // calculate the time consumption here
            struct timeval tpstart,tpend;
            double timeuse;
            gettimeofday(&tpstart,NULL);

            // reponse to the client
            MsgD.send(sock, response, sizeof(response));

            // local mode
            if (!storm) {

                FILE *fp = fopen(file_name, "w");  
                if (fp == NULL)  
                {  
                    printf("File:\t[%s] Can Not Open To Write!\n", file_name);  
                }  


                // receive the data from server and store them into buffer
                while(1)  
                {
                    bzero(buffer, sizeof(buffer));
                    n = MsgD.recv(sock, buffer, sizeof(buffer));
                    if (n <= 0)
                    {
                        pthread_mutex_destroy(&queueLock);
                        // signal the result thread to terminate
                        sem_post(sem_match);
                        errorSocket("ERROR reading from socket", sock);
                    } 
                    
                    if (file_size - received_size <= recv_length)
                    {
                        int remain = file_size - received_size;
                        write_length = fwrite(buffer, sizeof(char), remain, fp);  
                        if (write_length < remain)  
                        {  
                            printf("File:\t Write Failed!\n");  
                            break;  
                        }
                        break;
                    }

                    write_length = fwrite(buffer, sizeof(char), recv_length, fp);  
                    if (write_length < recv_length)  
                    {  
                        printf("File:\t Write Failed!\n");  
                        break;  
                    }  
                    received_size += recv_length;
                }

                // print out time comsumption
                gettimeofday(&tpend,NULL);
                timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;// notice, should include both s and us
                // printf("used time:%fus\n",timeuse);
                printf("receive used time:%fms\n",timeuse / 1000);

                printf("[server] Recieve Finished!\n\n");  
                // finished 
                fclose(fp);
            }
            // below is storm mode
            else {
                // in storm mode, don't save img into disk
                char img[file_size];
                int offset = 0;
                // receive the data from client and store them into buffer
                while(1)  
                {
                    bzero(buffer, sizeof(buffer));
                    n = MsgD.recv(sock, buffer, sizeof(buffer));
                    if (n <= 0)
                    {
                        pthread_mutex_destroy(&queueLock);
                        // signal the result thread to terminate
                        sem_post(sem_match);
                        errorSocket("ERROR reading from socket", sock);
                    } 
                    
                    if (file_size - received_size <= recv_length)
                    {
                        int remain = file_size - received_size;
                        // copy the content into img
                        for (int i = 0; i < remain; ++i)
                        {
                            img[i + offset] = buffer[i];
                        }
                        break;
                    }

                    // copy the content into img
                    for (int i = 0; i < recv_length; ++i)
                    {
                        img[i + offset] = buffer[i];
                    }
                    offset += recv_length;

                    received_size += recv_length;
                }

                // print out time comsumption
                gettimeofday(&tpend,NULL);
                timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec;// notice, should include both s and us
                // printf("used time:%fus\n",timeuse);
                printf("receive used time:%fms\n",timeuse / 1000);

                if (debug) printf("[server] Recieve Finished!\n\n");  

                // send request to spout
                if (debug) printf("Now try to connect the spout\n");
                int sockfd, ret;
                int spoutPort = 9878;
                struct sockaddr_in spout_addr;
                struct hostent *spout;
                struct in_addr ipv4addr;
                char buf_spout[100];
                char* spout_IP;
                const int len = spoutIP.length();
                spout_IP = new char[len+1];
                strcpy(spout_IP, spoutIP.c_str());

                sockfd = socket(AF_INET, SOCK_STREAM, 0);
                if (sockfd < 0)
                {
                    printf("ERROR opening socket\n");
                    return;
                }
                inet_pton(AF_INET, spout_IP, &ipv4addr);
                spout = gethostbyaddr(&ipv4addr, sizeof(ipv4addr), AF_INET);
                if (debug) printf("\n[server] Spout address: %s\n", spout_IP);
                if (spout == NULL) {
                    fprintf(stderr,"ERROR, no such host\n");
                    exit(0);
                }
                bzero((char *) &spout_addr, sizeof(spout_addr));
                spout_addr.sin_family = AF_INET;
                bcopy((char *)spout->h_addr, (char *)&spout_addr.sin_addr.s_addr, spout->h_length); 
                spout_addr.sin_port = htons(spoutPort);

                while (connect(sockfd,(struct sockaddr *) &spout_addr, sizeof(spout_addr)) < 0)
                {
                    printf("The spout is not available now, wait a while and reconnect\n\n");
                    usleep(100000); // sleep 100ms
                }

                printf("[server] Get connection to spout\n");

                bzero(buf_spout, sizeof(buf_spout));
                sprintf(buf_spout, "%d", file_size);
                if (debug) printf("[server] send the file size\n");
                ret = write(sockfd, buf_spout, sizeof(buf_spout));
                if (ret < 0)
                {
                    printf("error sending\n");
                    return;
                }

                // get the response
                bzero(buf_spout, sizeof(buf_spout));
                if (debug) printf("[server] now wait for response\n");
                ret = read(sockfd, buf_spout, sizeof(buf_spout));
                if (ret < 0)
                {
                    printf("error reading\n");
                    return;
                }

                if (debug) printf("got response: %s\n", buf_spout);

                if (debug) printf("[server] send the img\n");
                ret = write(sockfd, img, sizeof(img));
                if (ret < 0)
                {
                    printf("error sending\n");
                    return;
                }
                if (debug) printf("ret: %d\n", ret);
                printf("[server] Finished transmitting image to spout\n\n");

                close(sockfd); 
            }
            
            // lock the queue, ensure there is only one thread modifying the queue
            pthread_mutex_lock(&queueLock);

            // store the file name to the waiting queue
            string file_name_string(file_name_temp);
            imgQueue->push(file_name_string);

            pthread_mutex_unlock(&queueLock);
            // get the address of sem_match
            if (sem_match == 0)
            {
                while (sem_map.find(userID) == sem_map.end());
                sem_match = sem_map[userID];
            }
            // signal the result thread to do image processing
            sem_post(sem_match);
        }
    }

    delete(imgQueue);
    printf("[server] Connection closed. --- transmit\n\n");
    // pthread_exit(NULL); //terminate calling thread!
    return;

}
  ////////////////////////////////////////////////////////////////////////////////
  // TEXTURE
  void update_texture_parameters(
    unordered_map<wstring, pair<wstring, int> > const& params) {

    unordered_map<wstring, pair<wstring, int> >::const_iterator i;

    if ((i=params.find(pre_texture_folder))!=params.end()) {
      wstring path = i->second.first;
      if (!path.empty() && path[path.size()-1]!=L'\\') path += L'\\';
      sociarium_project_texture::set_texture_folder_path(path);
    } else
      sociarium_project_texture::set_texture_folder_path(L"");

    GLint wrap_s = GL_CLAMP_TO_EDGE_EXT;
    GLint wrap_t = GL_CLAMP_TO_EDGE_EXT;
    /* GL_REPEAT
     * GL_CLAMP
     * GL_CLAMP_TO_BORDER_EXT (unavailable??)
     * GL_CLAMP_TO_EDGE_EXT
     */

    if ((i=params.find(pre_texture_wrap_s))!=params.end()) {

      wstring const s = i->second.first;

      if (s==L"GL_CLAMP")
        wrap_s = GL_CLAMP;
      else if (s==L"GL_REPEAT")
        wrap_s = GL_REPEAT;
      else if (s==L"GL_CLAMP_TO_EDGE_EXT")
        wrap_s = GL_CLAMP_TO_EDGE_EXT;

      sociarium_project_texture::set_texture_parameter_wrap_s(wrap_s);
    }

    if ((i=params.find(pre_texture_wrap_t))!=params.end()) {

      wstring const s = i->second.first;

      if (s==L"GL_CLAMP")
        wrap_t = GL_CLAMP;
      else if (s==L"GL_REPEAT")
        wrap_t = GL_REPEAT;
      else if (s==L"GL_CLAMP_TO_EDGE_EXT")
        wrap_t = GL_CLAMP_TO_EDGE_EXT;

      sociarium_project_texture::set_texture_parameter_wrap_t(wrap_t);
    }

    if ((i=params.find(pre_node_texture))!=params.end()) {
      // Change default node texture.
      wstring const filename = i->second.first;
      sociarium_project_texture::set_default_node_texture_tmp(filename);
    } else {
      wstring const path_tmp
        = sociarium_project_texture::get_texture_folder_path();
      sociarium_project_texture::set_texture_folder_path(L"");
      sociarium_project_texture::set_default_node_texture_tmp(
        DEFAULT_NODE_TEXTURE_FILE);
      sociarium_project_texture::set_texture_folder_path(path_tmp);
    }

    if ((i=params.find(pre_edge_texture))!=params.end()) {
      // Change default edge texture.
      wstring const filename = i->second.first;
      sociarium_project_texture::set_default_edge_texture_tmp(filename);
    } else {
      wstring const path_tmp
        = sociarium_project_texture::get_texture_folder_path();
      sociarium_project_texture::set_texture_folder_path(L"");
      sociarium_project_texture::set_default_edge_texture_tmp(
        DEFAULT_EDGE_TEXTURE_FILE);
      sociarium_project_texture::set_texture_folder_path(path_tmp);
    }

    if ((i=params.find(pre_community_texture))!=params.end()) {
      // Change default community texture.
      wstring const filename = i->second.first;
      sociarium_project_texture::set_default_community_texture_tmp(filename);
    } else {
      wstring const path_tmp
        = sociarium_project_texture::get_texture_folder_path();
      sociarium_project_texture::set_texture_folder_path(L"");
      sociarium_project_texture::set_default_community_texture_tmp(
        DEFAULT_COMMUNITY_TEXTURE_FILE);
      sociarium_project_texture::set_texture_folder_path(path_tmp);
    }

    if ((i=params.find(pre_community_edge_texture))!=params.end()) {
      // Change default community edge texture.
      wstring const filename = i->second.first;
      sociarium_project_texture::set_default_community_edge_texture_tmp(filename);
    } else {
      wstring const path_tmp
        = sociarium_project_texture::get_texture_folder_path();
      sociarium_project_texture::set_texture_folder_path(L"");
      sociarium_project_texture::set_default_community_edge_texture_tmp(
        DEFAULT_COMMUNITY_EDGE_TEXTURE_FILE);
      sociarium_project_texture::set_texture_folder_path(path_tmp);
    }
  }
示例#25
0
 unordered_map<int,int>::iterator find(int s, int d){
     return g.find(s)->second.find(d);}
示例#26
0
int main(int argc, char *argv[])
{
    int D, K;
    if (argc != 7 || sscanf(argv[3], "%d", &D) != 1 || sscanf(argv[4], "%d", &K) != 1) {
        printf("[usage] <vector.bin> <length*.csv folder path> <D> <K> <unigram2phrase-nn> <word2word-nn>\n");
        return 0;
    }
    
    loadVector(argv[1]);
    loadPatterns(argv[2]);
    
    cerr << unigrams.size() << endl;
    cerr << phrases.size() << endl;
    
    vector< vector<double> > axis(D, vector<double>(dimension, 0));
    double sqrt3 = sqrt(3.0);
    for (int i = 0; i < D; ++ i) {
        for (int j = 0; j < dimension; ++ j) {
            axis[i][j] = sample_normal();
            /*double roll = next_double2();
            if (roll < 1.0 / 6) {
                axis[i][j] = sqrt3;
            } else if (roll < 1.0 / 3) {
                axis[i][j] = -sqrt3;
            }*/
        }
    }
    for (int i = 0; i < D; ++ i) {
        double sum = 0;
        for (int j = 0; j < dimension; ++ j) {
            sum += sqr(axis[i][j]);
        }
        sum = sqrt(sum);
        for (int j = 0; j < dimension; ++ j) {
            axis[i][j] /= sum;
        }
    }

    vector<Point> unigramPoints, phrasesPoints, wordsPoints;

    FOR (unigram, unigrams) {
        if (word2vec.count(unigram->first)) {
            Point cur(unigram->first, word2vec[unigram->first]);
            unigramPoints.push_back(cur);
            wordsPoints.push_back(cur);
        }
    }
    
    FOR (phrase, phrases) {
        if (word2vec.count(phrase->first)) {
            Point cur(phrase->first, word2vec[phrase->first]);
            phrasesPoints.push_back(cur);
            wordsPoints.push_back(cur);
        }
    }
    
    normalize(unigramPoints);
    normalize(phrasesPoints);
    normalize(wordsPoints);
    
    vector<Point> projUnigramPoints, projPhrasesPoints, projWordsPoints;
    projUnigramPoints = project(unigramPoints, axis);
    projPhrasesPoints = project(phrasesPoints, axis);
    projWordsPoints = project(wordsPoints, axis);
    
/*    normalize(projUnigramPoints);
    normalize(projPhrasesPoints);
    normalize(projWordsPoints);*/
    
    
    for (int i = 0; i < wordsPoints.size(); ++ i) {
        word2vec[wordsPoints[i].name] = wordsPoints[i].x;
    }
    
    cerr << "vectors projected" << endl;
    
    KDTree phraseTree(projPhrasesPoints);
    vector<vector<pair<string, double>>> u2p(unigramPoints.size(), vector<pair<string,double>>(K, make_pair("", 0.0)));
    #pragma omp parallel for schedule(dynamic, 1000)
    for (int i = 0; i < unigramPoints.size(); ++ i) {
//        if (i % 1000 == 0) {
//            cerr << i << " " << unigramPoints[i].name<< endl;
//        }
        vector<string> sim = phraseTree.query(projUnigramPoints[i], 100);
        
        vector< pair<double, string> > order;
        const vector<double> &u = unigramPoints[i].x;
        for (int j = 0; j < sim.size(); ++ j) {
            double dot = 0;
            const vector<double> &v = word2vec[sim[j]];
            myAssert(u.size() == v.size(), "dimension mismatch!");
            for (int d = 0; d < u.size(); ++ d) {
                dot += u[d] * v[d];
            }
            order.push_back(make_pair(dot, sim[j]));
        }
        sort(order.rbegin(), order.rend());
        if (order.size() > K) {
            order.resize(K);
        }
        
        myAssert(order.size() == K, "not enough neighbors!");
        
        double maxi = order[0].first;
        for (int j = 0; j < order.size(); ++ j) {
            u2p[i][j].first = order[j].second;
            u2p[i][j].second = order[j].first / maxi;
        }
    }
    cerr << "u2p nn done" << endl;
    
    FILE* out = tryOpen(argv[5], "w");
    for (int i = 0; i < unigramPoints.size(); ++ i) {
        fprintf(out, "%s", unigramPoints[i].name.c_str());
        for (int j = 0; j < K; ++ j) {
            fprintf(out, "\t%s\t%.10f", u2p[i][j].first.c_str(), u2p[i][j].second);
        }
        fprintf(out, "\n");
    }
    fclose(out);
    cerr << "u2p output done" << endl;
    
    KDTree wordTree(projWordsPoints);
    vector<vector<pair<string, double>>> w2w(wordsPoints.size(), vector<pair<string,double>>(K, make_pair("", 0.0)));
    #pragma omp parallel for schedule(dynamic, 1000)
    for (int i = 0; i < wordsPoints.size(); ++ i) {
        vector<string> sim = wordTree.query(projWordsPoints[i], 100);
        
        vector< pair<double, string> > order;
        const vector<double> &u = wordsPoints[i].x;
        for (int j = 0; j < sim.size(); ++ j) {
            double dot = 0;
            const vector<double> &v = word2vec[sim[j]];
            myAssert(u.size() == v.size(), "dimension mismatch!");
            for (int d = 0; d < u.size(); ++ d) {
                dot += u[d] * v[d];
            }
            order.push_back(make_pair(dot, sim[j]));
        }
        sort(order.rbegin(), order.rend());
        if (order.size() > K) {
            order.resize(K);
        }
        
        myAssert(order.size() == K, "not enough neighbors!");
        
        double maxi = order[0].first;
        for (int j = 0; j < order.size(); ++ j) {
            w2w[i][j].first = order[j].second;
            w2w[i][j].second = order[j].first / maxi;
        }
    }

    cerr << "w2w nn done" << endl;
    
    out = tryOpen(argv[6], "w");
    for (int i = 0; i < wordsPoints.size(); ++ i) {
        fprintf(out, "%s", wordsPoints[i].name.c_str());
        for (int j = 0; j < K; ++ j) {
            fprintf(out, "\t%s\t%.10f", w2w[i][j].first.c_str(), w2w[i][j].second);
        }
        fprintf(out, "\n");
    }
    fclose(out);
    cerr << "w2w output done" << endl;
}
示例#27
0
 unordered_map<int,int>::iterator end (int s) {return g.find(s)->second.end();}
示例#28
0
void Buildings::clearBuildings(color_ostream& out) {
    corner1.clear();
    corner2.clear();
    locationToBuilding.clear();
}
示例#29
0
void inline CCreature::unmap()
{creatures_map.erase(x + (y << 8));};
示例#30
0
文件: main.cpp 项目: toddwithers/Bot
void handleUpdatePacket(uint8* data, int len)
{

	UpdatePacketSelf update = *(UpdatePacketSelf*)&data[1];

	//if( player_x != update.positionX || player_y != update.positionY ) {
		//printf( "X/Y: %i, %i\n", update.positionX, update.positionY );
	//}
	player_x = update.positionX;
	player_y = update.positionY;
	player_health = update.currentHPPct;

	if( player_health <= 25 ) {
		printf( "[%s] Health (%i) < 25. Exiting!\n", currentDateTime().c_str(), player_health );
		logout( player_id );
		SLEEP( 100 );
		exit_bot       = true;
		finished_quest = true;
		missing_quest  = true;
	}

	/*for( int j = 0; j < len; j++ ) {
		fprintf( out, "%02X ", data[j] );
	}
	fprintf( out, "\n" );

	fprintf( out, "Update positionX: %i\n", update.positionX );
	fprintf( out, "Update positionY: %i\n", update.positionY );
	fprintf( out, "Update spellflags: %i\n", update.spellflags );
	fprintf( out, "Update colorbits: %i\n", update.colorbits );
	fprintf( out, "Update numInRangeDynamicObjects: %i\n", update.numInRangeDynamicObjects );
	fprintf( out, "Update numInRangeUnits: %i\n", update.numInRangeUnits );
	fprintf( out, "Update unklol: %i\n", update.unklol );
	fprintf( out, "Update flags: %i\n", update.flags );
	fprintf( out, "Update rotation: %i\n", update.rotation );
	fprintf( out, "Update animation: %i\n", update.animation );
	fprintf( out, "Update spellEffect: %i\n", update.spellEffect );
	fprintf( out, "Update numInRangeSpellEffects: %i\n", update.numInRangeSpellEffects );
	fprintf( out, "Update unklol2: %i\n", update.unklol2 );
	fprintf( out, "Update unklol3: %i\n", update.unklol3 );
	fprintf( out, "Update currentHPPct: %i\n", update.currentHPPct );
	fprintf( out, "Update currentMPPct: %i\n", update.currentMPPct );
	fprintf( out, "Update currentExpPct: %i\n", update.currentExpPct );
	fprintf( out, "\n\n" );*/

	int offset = 23;

	if( update.numInRangeDynamicObjects > 0 )
	{
		for( int i = 0; i < update.numInRangeDynamicObjects; i++ )
		{
			if( data[offset] == 0x01 ) offset += 8;
			else if( data[offset] == 0x02 ) offset += 12;
			else if( data[offset] == 0x03 ) offset += 6;
		}
	}

	if( update.numInRangeSpellEffects > 0 )
	{
		for( int x = 0; x < update.numInRangeSpellEffects; x++ )
		{
			if( data[offset] >= 240 ) offset += 12;
			else offset += 8;
		}
	}

	setAllOoR();

	if( update.numInRangeUnits > 0 )
	{
		for( int i = 0; i < update.numInRangeUnits; i++ )
		{
			uint16 id = ( data[offset+1] << 8 ) + data[offset];
			uint16 trueid = id & 0x7FFF;
			
			// Attempt to find unit in our unitmap
			setInRange( trueid );

			offset += 2;

			if( id & 0x8000 )
				continue;
			else
			{
				uint8 updateflag = data[offset];
				offset += 1;

				if(updateflag & 0x01)
				{
					UpdatePacketUnitMovement movement = *(UpdatePacketUnitMovement*)&data[offset];
					um_units.at( trueid ).movement = movement;
					//fprintf( out, "Player: %i | Movement | X/Y: %i, %i\n", trueid, movement.positionX, movement.positionY );
					//UnitMap::UpdateUnitsMovement(trueid, *(UpdatePacketUnitMovement*)&data[offset]); 
					offset += 5;
				}
				if(updateflag & 0x02)
				{
					UpdatePacketUnitAuras auras = *(UpdatePacketUnitAuras*)&data[offset];
					um_units.at( trueid ).auras = auras;
					//UnitMap::UpdateUnitsAuras(trueid, *(UpdatePacketUnitAuras*)&data[offset]);
					offset += 3;
				}
				if(updateflag & 0x04)
				{
					UpdatePacketUnitModels models = *(UpdatePacketUnitModels*)&data[offset];
					um_units.at( trueid ).models = models;
					//fprintf( out, "Player: %i | ModelInfo | Model: %i, Weapon: %i, Shield: %i, Helmet: %i\n", trueid, models.model, models.weapon, models.shield, models.helmet );
					//UnitMap::UpdateUnitsModel(trueid, *(UpdatePacketUnitModels*)&data[offset]);
					offset += 8;
				}
				if(updateflag & 0x08)
				{
					UpdatePacketUnitAnim anim = *(UpdatePacketUnitAnim*)&data[offset];
					//UnitMap::UpdateUnitsAnim(trueid, *(UpdatePacketUnitAnim*)&data[offset]);
					um_units.at( trueid ).anim = anim; 

					if( anim.anim == 21 || anim.anim == 45 )
					{
						um_units.at( trueid ).dead = true;
					} else {
						um_units.at( trueid ).dead = false;
					}

					offset += 1;
				}
				if(updateflag & 0x10)
				{
					UpdatePacketUnitSpellEffect spellfx = *(UpdatePacketUnitSpellEffect*)&data[offset];
					//UnitMap::UpdateUnitsSpellEffect(trueid, *(UpdatePacketUnitSpellEffect*)&data[offset]);
					um_units.at( trueid ).spelleffect = spellfx;
					offset += 1;
				}
				if(updateflag & 0x20)
				{
					offset += 1 + data[offset];
				}
			}
		}
	}

	clearOoR();

	if( update.flags & 0x01 ) {
		if( data[offset] == 0x31 && data[offset+1] == 0x30 && data[offset+2] == 0x30 ) {
			finished_quest = true;
		}
	}

	//fprintf( out, "\n\n" );
}