void alignMessages(t_message *resMessage, Bool doInternalSlick, unsigned int nbMessages, t_message * messages, Bool debugMode) { // local variable unsigned int numberOfOperations = 0; double costOfOperation; double status = 0.0; // Local variables t_message current_message; t_message new_message; t_score score; unsigned int i_message = 0; // Regex returned by the function alignTwoMessages() char * regex = NULL; score.s1 = 0; score.s2 = 0; score.s3 = 0; score.value = 0; //+------------------------------------------------------------------------+ // Estimate the number of operation //+------------------------------------------------------------------------+ numberOfOperations = nbMessages - 1; costOfOperation = 100.0 / numberOfOperations; // Create a current message (using first message) // current message = Align N+1 message with current message current_message.len = messages[0].len; current_message.alignment = messages[0].alignment; current_message.mask = malloc(messages[0].len * sizeof(unsigned char)); current_message.semanticTags = malloc(messages[0].len * sizeof(t_semanticTag*)); for (unsigned int j=0; j<messages[0].len; j++) { current_message.semanticTags[j] = malloc(sizeof(t_semanticTag)); current_message.semanticTags[j]->name = malloc((strlen(messages[0].semanticTags[j]->name)+1) * sizeof(char)); strcpy(current_message.semanticTags[j]->name, messages[0].semanticTags[j]->name); } memset(current_message.mask, 0, messages[0].len); current_message.score = &score; // Prepare for the resMessage if (nbMessages == 1) { resMessage->len = current_message.len; resMessage->mask = current_message.mask; resMessage->alignment = current_message.alignment; resMessage->score = current_message.score; resMessage->semanticTags = current_message.semanticTags; } for (i_message=1; i_message < nbMessages; i_message++) { // Update the execution status if (callbackStatus(0, status, "Consider message %d in the alignment process", i_message) == -1) { printf("Error, error while executing C callback.\n"); } if (callbackIsFinish() == 1) { return; } new_message.len = messages[i_message].len; new_message.alignment = messages[i_message].alignment; new_message.mask = malloc(messages[i_message].len * sizeof(unsigned char)); new_message.semanticTags = malloc(messages[i_message].len * sizeof(t_semanticTag*)); for (unsigned int j=0; j<messages[i_message].len; j++) { new_message.semanticTags[j] = malloc(sizeof(t_semanticTag)); new_message.semanticTags[j]->name = malloc((strlen(messages[i_message].semanticTags[j]->name)+1) * sizeof(char)); strcpy(new_message.semanticTags[j]->name, messages[i_message].semanticTags[j]->name); } memset(new_message.mask, 0, messages[i_message].len); // Align current_message with new_message regex = alignTwoMessages(resMessage, doInternalSlick, ¤t_message, &new_message, debugMode); // regex is malloced by the function alignTwoMessages() and we don't need it here if(regex) free(regex); free(current_message.mask); free(new_message.mask); // Copy result in the current message current_message.len = resMessage->len; current_message.alignment = resMessage->alignment; current_message.mask = resMessage->mask; current_message.semanticTags = resMessage->semanticTags; //udpate status status += costOfOperation; } // Update the execution status if (callbackStatus(0, status, "The %d messages have sucessfully been aligned.", nbMessages) == -1) { printf("Error, error while executing C callback.\n"); } free(messages); }
//+---------------------------------------------------------------------------+ //| py_alignTwoMessages : Python wrapper for alignTwoMessages //+---------------------------------------------------------------------------+ PyObject* py_alignTwoMessages(PyObject* self, PyObject* args) { // Parameters (in order) unsigned int doInternalSlick = 0; unsigned char *format; int sizeFormat; unsigned char *serialMessages; int sizeSerialMessages; unsigned int debugMode = 0; // local variables unsigned int nbDeserializedMessage = 0; t_message message1; t_score scoreMessage1; t_message message2; t_score scoreMessage2; t_message resMessage; t_score score; t_group group; Bool bool_doInternalSlick; Bool bool_debugMode; // Converts the arguments if (!PyArg_ParseTuple(args, "hs#s#h", &doInternalSlick, &format, &sizeFormat, &serialMessages, &sizeSerialMessages, &debugMode)) { PyErr_SetString(PyExc_TypeError, "Error while parsing the arguments provided to py_alignTwoMessages"); return NULL; } //+------------------------------------------------------------------------+ // Deserializes the provided arguments //+------------------------------------------------------------------------+ if (debugMode == 1) { printf("The following arguments were received : \n"); printf("doInternalSlick : %d\n", doInternalSlick); printf("Format :\n"); hexdump(format, sizeFormat); printf("Serial :\n"); hexdump(serialMessages, sizeSerialMessages); printf("Debug mode : %d\n", debugMode); } // Deserialization of messages group.len = 2; group.messages = malloc(2*sizeof(t_message)); nbDeserializedMessage = deserializeMessages(&group, format, sizeFormat, serialMessages, 2, sizeSerialMessages, debugMode); if (nbDeserializedMessage != 2) { printf("Error : impossible to deserialize all the provided messages.\n"); return NULL; } //+------------------------------------------------------------------------+ // Execute the alignment of two messages //+------------------------------------------------------------------------+ // Convert debugMode parameter in a BOOL if (debugMode) { bool_debugMode = TRUE; } else { bool_debugMode = FALSE; } // Concert doInternalSlick parameter in a BOOL if (doInternalSlick) { bool_doInternalSlick = TRUE; } else { bool_doInternalSlick = FALSE; } // Establishes message1 message1.len = group.messages[0].len; scoreMessage1.s1 = 0; scoreMessage1.s2 = 0; scoreMessage1.s3 = 0; message1.score = &scoreMessage1; message1.alignment = group.messages[0].alignment; message1.mask = malloc(group.messages[0].len * sizeof(unsigned char)); memset(message1.mask, 0, group.messages[0].len); // Establishes message2 message2.len = group.messages[1].len; scoreMessage2.s1 = 0; scoreMessage2.s2 = 0; scoreMessage2.s3 = 0; message2.score = &scoreMessage2; message2.alignment = group.messages[1].alignment; message2.mask = malloc(group.messages[1].len * sizeof(unsigned char)); memset(message2.mask, 0, group.messages[1].len); // Prepare the response resMessage.len = 0; score.s1 = 0; score.s2 = 0; score.s3 = 0; resMessage.score = &score;/* if (message1.len >= message2.len) { resMessage.mask = malloc(message1.len * sizeof(unsigned char)); memset(resMessage.mask, 0, message1.len); resMessage.alignment = malloc(message1.len * sizeof(unsigned char)); memset(resMessage.alignment, 0, message1.len); } else { resMessage.mask = malloc(message2.len * sizeof(unsigned char)); memset(resMessage.mask, 0, message2.len); resMessage.alignment = malloc(message2.len * sizeof(unsigned char)); memset(resMessage.alignment, 0, message2.len); }*/ // Execute the C function alignTwoMessages(&resMessage, bool_doInternalSlick, &message1, &message2, bool_debugMode); free(message1.mask); free(message2.mask); // Return the result return Py_BuildValue("(fffs#s#)", resMessage.score->s1, resMessage.score->s2, resMessage.score->s3, resMessage.alignment, resMessage.len, resMessage.mask, resMessage.len); }