source: branches/lib/NALIGNER/ali_pt.cxx

// =============================================================== //
//                                                                 //
//   File      : ali_pt.cxx                                        //
//   Purpose   :                                                   //
//                                                                 //
//   Institute of Microbiology (Technical University Munich)       //
//   http://www.arb-home.de/                                       //
//                                                                 //
// =============================================================== //

#include "ali_pt.hxx"

int ALI_PT::init_communication() {
    // Initialize the communication with the pt server
    const char *user = GB_getenvUSER();
    if (aisc_create(link, PT_MAIN, com,
                    MAIN_LOCS, PT_LOCS, locs,
                    LOCS_USER, user,
                    NULp))
    {
        return 1;
    }
    return 0;
}

char *ALI_PT::get_family_member(char *specifiedfamily, unsigned long number) {
    char *ptr = specifiedfamily;
    char *end;
    char *buffer, *dest;

    while (number > 0 && *ptr != '\0' && *ptr != ';') {
        while (*ptr != '\0' && *ptr != ';' && *ptr != ',')
            ptr++;
        if (*ptr == ',')
            ptr++;
        number--;
    }

    if (*ptr != '\0' && *ptr != ';') {
        end = ptr;
        while (*end != '\0' && *end != ',' && *end != ';')
            end++;

        buffer = dest = (char *) CALLOC((unsigned int) (end - ptr) + 1, sizeof(char));
        ali_out_of_memory_if(!buffer);

        while (ptr != end)
            *dest++ = *ptr++;
        *dest = '\0';

        return buffer;
    }
    return NULp;
}

char *ALI_PT::get_extension_member(char *specifiedfamily,    unsigned long number) {
    char *ptr = specifiedfamily;
    char *end;
    char *buffer, *dest;

    while (*ptr != '\0' && *ptr != ';')
        ptr++;
    if (*ptr == ';')
        ptr++;

    while (number > 0 && *ptr != '\0') {
        while (*ptr != '\0' && *ptr != ',')
            ptr++;
        if (*ptr == ',')
            ptr++;
        number--;
    }

    if (*ptr != '\0') {
        end = ptr;
        while (*end != '\0' && *end != ',')
            end++;

        buffer = dest = (char *) CALLOC((unsigned int) (end - ptr) + 1, sizeof(char));
        ali_out_of_memory_if(!buffer);

        while (ptr != end)
            *dest++ = *ptr++;
        *dest = '\0';

        return buffer;
    }

    return NULp;
}


int ALI_PT::open(char *servername) {
    if (arb_look_and_start_server(AISC_MAGIC_NUMBER, servername)) {
        ali_message ("Cannot contact Probe bank server");
        return -1;
    }

    const char *socketid = GBS_read_arb_tcp(servername);

    if (!socketid) {
        ali_message(GB_await_error());
        return -1;
    }

    GB_ERROR openerr = NULp;
    link             = aisc_open(socketid, com, AISC_MAGIC_NUMBER, &openerr);

    if (openerr) {
        ali_message (openerr);
        return -1;
    }

    if (!link) {
        ali_message ("Cannot contact Probe bank server ");
        return -1;
    }

    if (init_communication()) {
        ali_message ("Cannot contact Probe bank server (2)");
        return -1;
    }

    return 0;
}

void ALI_PT::close() {
    if (link) aisc_close(link, com);
    link = NULp;
}

ALI_PT::ALI_PT(ALI_PT_CONTEXT *context) {
    link = NULp;

    fam_list_max = context->fam_list_max;
    ext_list_max = context->ext_list_max;
    percent_min = context->percent_min;
    matches_min = context->matches_min;

    family_list    = NULp;
    extension_list = NULp;

    if (context->use_specified_family) {
        mode = SpecifiedMode;
        specified_family = ARB_strdup(context->use_specified_family);
    }
    else {
        mode             = ServerMode;
        specified_family = NULp;

        ali_message("Connecting to PT server");
        if (open(context->servername) != 0) {
            ali_fatal_error("Can't connect to PT server");
        }
        ali_message("Connection established");
    }
}

ALI_PT::~ALI_PT() {
    close();

    if (family_list && !family_list->is_empty()) {
        delete family_list->first();
        while (family_list->has_next())
            delete family_list->next();
        delete family_list;
    }
    if (extension_list && !extension_list->is_empty()) {
        delete extension_list->first();
        while (extension_list->has_next())
            delete extension_list->next();
        delete extension_list;
    }
}


int ALI_PT::find_family(ALI_SEQUENCE *sequence, int find_type) {
    unsigned long number;
    int matches, max_matches;
    char *seq_name;
    T_PT_FAMILYLIST f_list;
    ali_pt_member *pt_member;
    char *species;

    bytestring bs;
    bs.data = sequence->string();
    bs.size = strlen(bs.data)+1;

    family_list = new ALI_TLIST<ali_pt_member *>;
    extension_list = new ALI_TLIST<ali_pt_member *>;
    ali_out_of_memory_if(!family_list || !extension_list);

    if (mode == ServerMode) {
        /* Start find_family() at the PT_SERVER
         *
         * Here we have to make a loop, until the match count of the
         * first member is big enought
         */

        T_PT_FAMILYFINDER ffinder;
        if (aisc_create(link, PT_LOCS, locs,
                        LOCS_FFINDER, PT_FAMILYFINDER, ffinder,
                        FAMILYFINDER_FIND_TYPE,   (long)find_type,
                        FAMILYFINDER_FIND_FAMILY, &bs,
                        NULp))
        {
            ali_message ("Communication Error (2)");
            return -1;
        }

        // Read family list
        aisc_get(link, PT_FAMILYFINDER, ffinder,
                 FAMILYFINDER_FAMILY_LIST, f_list.as_result_param(),
                 NULp);
        if (!f_list.exists())
            ali_error("Family not found in PT Server");

        aisc_get(link, PT_FAMILYLIST, f_list,
                 FAMILYLIST_NAME,    &seq_name,
                 FAMILYLIST_MATCHES, &matches,
                 FAMILYLIST_NEXT,    f_list.as_result_param(),
                 NULp);

        while (strcmp(seq_name, sequence->name()) == 0) {
            free(seq_name);
            if (!f_list.exists())
                ali_error("Family too small in PT Server");
            aisc_get(link, PT_FAMILYLIST, f_list,
                     FAMILYLIST_NAME,    &seq_name,
                     FAMILYLIST_MATCHES, &matches,
                     FAMILYLIST_NEXT,    f_list.as_result_param(),
                     NULp);
        }
        // found the first element

        // make the family list
        max_matches = matches;
        number = 0;
        do {
            pt_member = new ali_pt_member(seq_name, matches);
            family_list->append_end(pt_member);
            number++;
            do {
                if (!f_list.exists())
                    ali_error("Family too small in PT Server");
                aisc_get(link, PT_FAMILYLIST, f_list,
                         FAMILYLIST_NAME,    &seq_name,
                         FAMILYLIST_MATCHES, &matches,
                         FAMILYLIST_NEXT,    f_list.as_result_param(),
                         NULp);
                if (strcmp(seq_name, sequence->name()) == 0)
                    free(seq_name);
            } while (strcmp(seq_name, sequence->name()) == 0);
        } while (number < fam_list_max &&
                 (float) matches / (float) max_matches > percent_min);

        // make the extension list
        number = 0;
        while (number < ext_list_max) {
            pt_member = new ali_pt_member(seq_name, matches);
            extension_list->append_end(pt_member);
            number++;
            do {
                if (!f_list.exists())
                    ali_error("Family too small in PT Server");
                aisc_get(link, PT_FAMILYLIST, f_list,
                         FAMILYLIST_NAME,    &seq_name,
                         FAMILYLIST_MATCHES, &matches,
                         FAMILYLIST_NEXT,    f_list.as_result_param(),
                         NULp);
                if (strcmp(seq_name, sequence->name()) == 0)
                    free(seq_name);
            } while (strcmp(seq_name, sequence->name()) == 0);
        }
    }
    else {
        number = 0;
        while ((species = get_family_member(specified_family, number))) {
            pt_member = new ali_pt_member(species, matches_min);
            ali_out_of_memory_if(!pt_member);
            family_list->append_end(pt_member);
            number++;
        }

        if (number == 0)
            ali_fatal_error("Specified family too small");

        number = 0;
        while ((species = get_extension_member(specified_family, number))) {
            pt_member = new ali_pt_member(species, (int) (matches_min * percent_min) - 1);
            ali_out_of_memory_if(!pt_member);
            extension_list->append_end(pt_member);
            number++;
        }
    }

    free(bs.data);
    return 0;
}


ALI_TLIST<ali_pt_member *> *ALI_PT::get_family_list() {
    ALI_TLIST<ali_pt_member *> *ret;

    ret = family_list;
    family_list = NULp;

    return ret;
}


ALI_TLIST<ali_pt_member *> *ALI_PT::get_extension_list() {
    ALI_TLIST<ali_pt_member *> *ret;

    ret = extension_list;
    extension_list = NULp;

    return ret;
}