void intersys_query_free(struct rbQuery* query) {
if(!query->closed && query->executed) {
query_close(query);
RUN(cbind_free_query(query->query));
xfree(query);
}
}
void ro_gui_download_window_destroy_wrapper(void *p)
{
struct gui_download_window *dw = p;
if (dw->query != QUERY_INVALID)
query_close(dw->query);
dw->query = QUERY_INVALID;
dw->close_confirmed = true;
ro_gui_download_window_destroy(dw, false);
}
VALUE intersys_query_each(VALUE self) {
struct rbQuery* query;
int i;
Data_Get_Struct(self, struct rbQuery, query);
if(query->offset > 0) {
RUN(cbind_query_skip(query->query, query->offset));
}
for(i = query->offset; i < query->offset + query->limit; i++) {
VALUE row = intersys_query_fetch(self);
if(row == Qnil || RARRAY(row)->len == 0) {
break;
}
rb_yield(row);
}
query_close(query);
return self;
}
bool ro_gui_download_window_destroy(struct gui_download_window *dw, bool quit)
{
bool safe = dw->saved && !dw->ctx;
os_error *error;
if (!safe && !dw->close_confirmed)
{
query_reason rsn = quit ? QueryRsn_Quit : QueryRsn_Abort;
if (dw->query != QUERY_INVALID) {
/* can we just reuse the existing query? */
if (rsn == dw->query_rsn) {
ro_gui_query_window_bring_to_front(dw->query);
return false;
}
query_close(dw->query);
dw->query = QUERY_INVALID;
}
if (quit) {
/* bring all download windows to the front of the desktop as
a convenience if there are lots of windows open */
struct gui_download_window *d = download_window_list;
while (d) {
ro_gui_dialog_open_top(d->window, NULL, 0, 0);
d = d->next;
}
}
dw->query_rsn = rsn;
dw->query = query_user(quit ? "QuitDownload" : "AbortDownload",
NULL, &close_funcs, dw, NULL, NULL);
return false;
}
schedule_remove(ro_gui_download_update_status_wrapper, dw);
schedule_remove(ro_gui_download_window_destroy_wrapper, dw);
/* remove from list */
if (dw->prev)
dw->prev->next = dw->next;
else
download_window_list = dw->next;
if (dw->next)
dw->next->prev = dw->prev;
/* delete window */
error = xwimp_delete_window(dw->window);
if (error) {
LOG(("xwimp_delete_window: 0x%x: %s",
error->errnum, error->errmess));
warn_user("WimpError", error->errmess);
}
ro_gui_wimp_event_finalise(dw->window);
/* close download file */
if (dw->file) {
error = xosfind_closew(dw->file);
if (error) {
LOG(("xosfind_closew: 0x%x: %s",
error->errnum, error->errmess));
warn_user("SaveError", error->errmess);
}
}
/* delete temporary file */
if (!dw->saved) {
const char *temp_name = ro_gui_download_temp_name(dw);
error = xosfile_delete(temp_name, 0, 0, 0, 0, 0);
if (error) {
LOG(("xosfile_delete: 0x%x: %s",
error->errnum, error->errmess));
warn_user("SaveError", error->errmess);
}
}
if (dw->ctx) {
download_context_abort(dw->ctx);
download_context_destroy(dw->ctx);
}
free(dw);
return true;
}
VALUE intersys_query_close(VALUE self) {
struct rbQuery* query;
Data_Get_Struct(self, struct rbQuery, query);
query_close(query);
return self;
}
static pllAlignmentData *
pllParseFASTA (const char * filename)
{
int i,j;
int status;
pllAlignmentData * alignmentData;
if (!query_open(filename))
{
errno = PLL_ERROR_FILE_OPEN;
return NULL;
}
alignmentData = (pllAlignmentData *) malloc(sizeof(pllAlignmentData));
alignmentData->sequenceData = NULL;
alignmentData->sequenceLabels = NULL;
int prev_qseqlen = -1;
while(1)
{
char * qhead;
int query_head_len;
char *qseq;
int qseqlen;
// int query_no = -1;
if ((status = query_getnext(&qhead, &query_head_len,
&qseq, &qseqlen, &query_no)) > 0)
{
alignmentData->sequenceData = (unsigned char **)realloc(alignmentData->sequenceData,
(query_no + 2)*sizeof(unsigned char *));
alignmentData->sequenceLabels = (char **)realloc(alignmentData->sequenceLabels,
(query_no + 2)*sizeof(char *));
/* remove trailing whitespace from sequence names */
j = query_head_len-1;
while(j>0 && (qhead[j] == ' ' || qhead[j] == '\t'))
{
qhead[j] = 0;
}
alignmentData->sequenceData[query_no+1] = (unsigned char *)strdup(qseq);
alignmentData->sequenceLabels[query_no+1] = strdup(qhead);
if (prev_qseqlen != -1)
{
/* fasta sequences not aligned, free everything except last read
which will be freed by query_close() */
if (qseqlen != prev_qseqlen)
{
errno = PLL_ERROR_FASTA_SYNTAX;
_pll_free_temp_alignment(alignmentData, query_no+1);
query_close();
return NULL;
}
}
else
{
alignmentData->sequenceLength = qseqlen;
alignmentData->originalSeqLength = qseqlen;
prev_qseqlen = qseqlen;
}
}
else if (status == -1)
{
errno = PLL_ERROR_FASTA_SYNTAX;
_pll_free_temp_alignment(alignmentData, query_no+1);
query_close();
return NULL;
}
else break;
}
alignmentData->sequenceCount = query_no+1;
query_close();
alignmentData->siteWeights = (int *) rax_malloc (alignmentData->sequenceLength * sizeof (int));
for (i = 0; i < alignmentData->sequenceLength; ++ i)
alignmentData->siteWeights[i] = 1;
/* ugly hack to turn it to one contiguous block of memory. This should be redesigned */
void * mem = malloc((alignmentData->sequenceCount)*(alignmentData->sequenceLength+1)*sizeof(unsigned char));
for (i = 1; i <= alignmentData->sequenceCount; ++i)
{
void * tmp = alignmentData->sequenceData[i];
alignmentData->sequenceData[i] = (unsigned char *) (mem + (i - 1) * (alignmentData->sequenceLength + 1) * sizeof (unsigned char));
memcpy(alignmentData->sequenceData[i], tmp, alignmentData->sequenceLength);
alignmentData->sequenceData[i][alignmentData->sequenceLength] = 0;
free(tmp);
}
alignmentData->sequenceData[0] = NULL;
return (alignmentData);
}
