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);
}
