source: branches/ali/MULTI_PROBE/MP_mo_liste.cxx

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

#include "MP_externs.hxx"
#include "MultiProbe.hxx"

#include <aw_msg.hxx>
#include <arbdbt.h>
#include <client.h>
#include <servercntrl.h>

// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Methoden MO_Liste

GBDATA *MO_Liste::gb_main = NULp;

MO_Liste::MO_Liste() {
    mp_assert(gb_main);

    laenge   = 0;
    mo_liste = NULp;
    current  = 0;
    hashptr  = NULp;
    // Nach dem new muss die MO_Liste erst mit fill_all_bakts bzw fill_marked_bakts gefuellt werden
}

MO_Liste::~MO_Liste() {
    if (mo_liste) {
        for (int c = 0; c<current; ++c) {
            delete mo_liste[c];
        }
    }
    delete [] mo_liste;
    if (hashptr) GBS_free_hash(hashptr);
}


GB_ERROR MO_Liste::get_all_species(int ptserver_id) {
    GB_ERROR     error = NULp;
    mp_gl_struct mp_pd_gl;
    {
        const char *servername = NULp;
        if (!(servername=arb_look_and_start_ptserver(AISC_MAGIC_NUMBER, ptserver_id, error))) {
            ; // @@@ swap branches
        }
        else {
            mp_assert(!error);

            mp_pd_gl.link = aisc_open(servername, mp_pd_gl.com, AISC_MAGIC_NUMBER, &error);
            mp_pd_gl.locs.clear();
        }
    }

    if (!error && !mp_pd_gl.link) error                                        = "Cannot contact PT server [1]";
    if (!error && MP_init_local_com_struct(mp_pd_gl)) error                    = "Cannot contact PT server [2]";
    if (!error && aisc_put(mp_pd_gl.link, PT_LOCS, mp_pd_gl.locs, NULp)) error = "Connection to PT_SERVER lost [3]";

    if (!error) {
        bytestring bs = { NULp, 0 };
        {
            char *locs_error = NULp;
            long  nr_of_species;

            aisc_get(mp_pd_gl.link, PT_LOCS, mp_pd_gl.locs,
                     LOCS_MP_ALL_SPECIES_STRING, &bs,
                     LOCS_MP_COUNT_ALL_SPECIES,  &nr_of_species,
                     LOCS_ERROR,                 &locs_error,
                     NULp);

            if (*locs_error) {
                error = GBS_global_string("PTSERVER: %s", locs_error);
            }

            laenge = nr_of_species;
            free(locs_error);
        }

        if (!error) {
            mo_liste = new Bakt_Info*[laenge+2];
            {
                long j = 0;
                while (j<laenge+2) {
                    mo_liste[j] = NULp;
                    j++;
                }
            }
            current = 1;    // ACHTUNG, CURRENT beginnt bei 1, da Hash bei 1 beginnt, d.h. Array[0] ist NULp

            // Initialisieren der Hashtabelle

            hashptr = GBS_create_hash(laenge + 1, GB_IGNORE_CASE);

            if (bs.data) {
                char toksep[2];
                toksep[0] = 1;
                toksep[1] = 0;

                char *match_name = NULp;
                match_name       = strtok(bs.data, toksep);
                GB_push_transaction(gb_main);

                int i = 0;
                while (match_name) {
                    i++;
                    if (!GBT_find_species(gb_main, match_name)) {
                        pt_server_different = true;
                        break; // abort
                    }
                    put_entry(match_name);
                    match_name = strtok(NULp, toksep);
                }
                delete match_name; // @@@ really allocated?
                GB_pop_transaction(gb_main);
            }
            else {
                error = "DB-query found no species";
            }
        }

        free(bs.data);
    }

    if (mp_pd_gl.link) {
        aisc_close(mp_pd_gl.link, mp_pd_gl.com);
    }

    return error;
}



positiontype MO_Liste::fill_marked_bakts() {
    long    j = 0;
    GBDATA *gb_species;


    GB_push_transaction(gb_main);
    laenge = GBT_count_marked_species(gb_main);     // laenge ist immer zuviel oder gleich der Anzahl wirklick markierter. weil pT-Server nur
    // die Bakterien mit Sequenz zurueckliefert.

    if (!laenge) {
        aw_message("Please mark some species!");
        laenge = 1;
    }
    mo_liste = new Bakt_Info*[laenge+2];

    while (j<laenge+2) {
        mo_liste[j] = NULp;
        j++;
    }
    current = 1;    // ACHTUNG, CURRENT beginnt bei 1, da Hash bei 1 beginnt, d.h. Array[0] ist NULp

    hashptr = GBS_create_hash(laenge, GB_IGNORE_CASE);


    for (gb_species = GBT_first_marked_species(gb_main);
         gb_species;
         gb_species = GBT_next_marked_species(gb_species))
    {
        put_entry(GBT_get_name_or_description(gb_species));
    }

    GB_pop_transaction(gb_main);

    anz_elem_marked = laenge;

    return laenge;
}



long MO_Liste::get_laenge() const {
    return laenge;
}

long MO_Liste::debug_get_current() {
    return current;
}

long MO_Liste::put_entry(const char* name) {
    // Pruefe: Gibts den Bakter schon in dieser Liste??
    if (get_index_by_entry(name)) {
        // wanns den Bakter scho gibt nicht eintragen
    }
    else {
        mo_liste[current] = new Bakt_Info(name);                    // MEL  koennte mit match_name zusammenhaengen
        GBS_write_hash(hashptr, name, current);
        current++;
    }
    return current;
}

const char* MO_Liste::get_entry_by_index(long index) const {
    if ((0<index) && (index < current))
        return mo_liste[index]->get_name();
    else
        return NULp;
}

long MO_Liste::get_index_by_entry(const char* key) {
    return key ? GBS_read_hash(hashptr, key) : 0;
}

Bakt_Info* MO_Liste::get_bakt_info_by_index(long index) {
    return (0<index) && (index < current) ? mo_liste[index] : NULp;
}