ARB
EDB_root_bact.cxx
Go to the documentation of this file.
1 // =============================================================== //
2 // //
3 // File : EDB_root_bact.cxx //
4 // Purpose : //
5 // //
6 // Institute of Microbiology (Technical University Munich) //
7 // http://www.arb-home.de/ //
8 // //
9 // =============================================================== //
10 
11 #include <ed4_extern.hxx>
12 #include "ed4_class.hxx"
13 
14 #include <aw_msg.hxx>
15 #include <arb_progress.h>
16 #include <arbdbt.h>
17 #include <arb_strbuf.h>
18 #include <ad_config.h>
19 
20 void EDB_root_bact::calc_no_of_all(const char *string_to_scan, long *group, long *species) {
21  *group = 0;
22  *species = 0;
23 
24  if (string_to_scan) {
25  long i = 0;
26  while (string_to_scan[i]) {
27  if (string_to_scan[i] == 1) {
28  if (string_to_scan[i+1] == 'L' || string_to_scan[i+1] == 'S') {
29  (*species)++;
30  i++;
31  }
32  else if (string_to_scan[i+1] == 'F' || string_to_scan[i+1] == 'G') {
33  (*group)++;
34  i++;
35  }
36  }
37  i++;
38  }
39  }
40 }
41 
43  ED4_reference_terminals& refterms,
44  char *str,
45  int group_depth,
46  ED4_datamode datamode)
47 {
48  GBDATA *gb_item = NULp;
49  switch (datamode) {
50  case ED4_D_EXTENDED: gb_item = GBT_find_SAI(GLOBAL_gb_main, str); break;
51  case ED4_D_SPECIES: gb_item = GBT_find_species(GLOBAL_gb_main, str); break;
52  }
53 
54  if (!gb_item) { // didn't find this species/SAI
57  char dummy[150];
58  sprintf(dummy, "%zu. %s\n", not_found_counter, str);
61  }
62  return ED4_R_BREAK;
63  }
64 
65  // check whether sequence has data in desired alignment
66  bool has_alignment = GB_entry(gb_item, ED4_ROOT->alignment_name);
67  if (!has_alignment) {
68  if (datamode == ED4_D_SPECIES) { // only warn about species w/o data (SAIs are skipped silently)
71  char dummy[150];
72  sprintf(dummy, "%zu. %s (no data in alignment)\n", not_found_counter, str);
74  }
75  }
76  return ED4_R_BREAK;
77  }
78 
79  ED4_species_type spec_type = (datamode == ED4_D_EXTENDED) ? ED4_SP_SAI : ED4_SP_SPECIES;
80 
81 
82  {
83  char namebuffer[NAME_BUFFERSIZE];
84  int count_two = 0;
85 
86  sprintf(namebuffer, "Species_Manager.%ld.%d", ED4_counter, count_two);
87  ED4_species_manager *species_manager = new ED4_species_manager(spec_type, namebuffer, 0, 0, multi_species_manager);
88 
89  species_manager->set_property(PROP_MOVABLE);
90  if (spec_type == ED4_SP_SAI) {
91  ED4_abstract_group_manager *group_man = species_manager->get_parent(ED4_level(LEV_GROUP|LEV_ROOTGROUP))->to_abstract_group_manager();
92  group_man->table().ignore_me(); // ignore SAI tables (does not work - instead ignore SAIs when calculating consensus)
93  }
94  species_manager->set_species_pointer(gb_item);
95  multi_species_manager->append_member(species_manager);
96 
97  sprintf(namebuffer, "MultiName_Manager.%ld.%d", ED4_counter, count_two);
98  ED4_multi_name_manager *multi_name_manager = new ED4_multi_name_manager(namebuffer, 0, 0, species_manager);
99  species_manager->append_member(multi_name_manager);
100 
101  sprintf(namebuffer, "MultiSeq_Manager.%ld.%d", ED4_counter, count_two++);
102  ED4_multi_sequence_manager *multi_sequence_manager = new ED4_multi_sequence_manager(namebuffer, 0, 0, species_manager);
103  species_manager->append_member(multi_sequence_manager);
104 
105  sprintf(namebuffer, "Name_Manager%ld.%d", ED4_counter, count_two++);
106  ED4_name_manager *name_manager = new ED4_name_manager(namebuffer, 0, 0, multi_name_manager);
107  name_manager->set_property(PROP_MOVABLE); // only Speciesname should be movable
108  multi_name_manager->append_member(name_manager);
109 
110  {
111  sprintf(namebuffer, "Species_Name_Term%ld.%d", ED4_counter, count_two++);
112  ED4_species_name_terminal *species_name_terminal = new ED4_species_name_terminal(namebuffer, MAXNAME_WIDTH-(group_depth*BRACKET_WIDTH), TERMINAL_HEIGHT, name_manager);
113  species_name_terminal->set_property((ED4_properties) (PROP_SELECTABLE | PROP_DRAGABLE | PROP_IS_HANDLE));
114  species_name_terminal->set_links(NULp, refterms.sequence());
115  species_name_terminal->set_species_pointer(GB_entry(gb_item, "name"));
116  name_manager->append_member(species_name_terminal);
117  }
118 
119  {
120  sprintf(namebuffer, "Flag_Term%ld.%d", ED4_counter, count_two++);
121  ED4_flag_terminal *flag_terminal = new ED4_flag_terminal(namebuffer, FLAG_WIDTH, TERMINAL_HEIGHT, name_manager);
122  flag_terminal->set_links(NULp, refterms.sequence());
123  name_manager->append_member(flag_terminal);
124  }
125 
126  GBDATA *gb_ali_xxx = GB_entry(gb_item, ED4_ROOT->alignment_name);
127  if (gb_ali_xxx) {
128  search_sequence_data_rek(multi_sequence_manager, refterms, gb_ali_xxx, count_two, &max_seq_terminal_length, datamode == ED4_D_EXTENDED);
129  }
130  }
131 
132  return ED4_R_OK;
133 }
134 
136  ED4_reference_terminals& refterms,
137  GBDATA *gb_ali_xxx, // alignment-container (or any subcontainer of)
138  int count_too,
139  ED4_index *max_sequence_terminal_length,
140  bool isSAI)
141 {
142  char namebuffer[NAME_BUFFERSIZE];
144 
145  e4_assert(gb_ali_xxx);
146 
147  for (GBDATA *gb_ali_child = GB_child(gb_ali_xxx); gb_ali_child; gb_ali_child = GB_nextChild(gb_ali_child)) {
148  GB_TYPES type = GB_read_type(gb_ali_child);
149 
150  if (type == GB_INTS || type == GB_FLOATS) {
151  continue;
152  }
153 
154  if (type == GB_DB) { // we have to unpack container
155  search_sequence_data_rek(multi_sequence_manager, refterms, gb_ali_child, count_too, max_sequence_terminal_length, isSAI);
156  }
157  else { // otherwise we enter the data
158  char *key_string = GB_read_key(gb_ali_child);
159  if (key_string[0] != '_') { // don't show sequences starting with an underscore
160  sprintf(namebuffer, "Sequence_Manager.%ld.%d", ED4_counter, count_too++);
161  ED4_sequence_manager *seq_manager = new ED4_sequence_manager(namebuffer, 0, 0, multi_sequence_manager);
162  seq_manager->set_property(PROP_MOVABLE);
163  multi_sequence_manager->append_member(seq_manager);
164 
165  {
166  ED4_sequence_info_terminal *sequence_info_terminal = new ED4_sequence_info_terminal(key_string, SEQUENCE_INFO_WIDTH, TERMINAL_HEIGHT, seq_manager);
167  sequence_info_terminal->set_property((ED4_properties) (PROP_SELECTABLE | PROP_DRAGABLE | PROP_IS_HANDLE));
168  sequence_info_terminal->set_both_links(refterms.sequence_info());
169  sequence_info_terminal->set_species_pointer(gb_ali_child);
170  seq_manager->append_member(sequence_info_terminal);
171  }
172 
173  ED4_text_terminal *text_terminal = NULp;
174 
175  bool is_data = false;
176  bool is_data2 = false;
177  bool is_bits = false;
178  bool is_quality = false;
179 
180  if (strcmp(key_string, "data") == 0) is_data = true; // SAI or species
181  else if (strcmp(key_string, "data2") == 0) is_data2 = true; // used by SAIs with two entries (e.g. first and second digit of 2-digit-numbers)
182  else if (strcmp(key_string, "bits") == 0) is_bits = true; // used by binary SAIs (e.g. MARKERLINE)
183  else if (strcmp(key_string, "quality") == 0) is_quality = true; // used by "quality" entry written by chimera check; see ../STAT/ST_quality.cxx@chimera_check_quality_string
184 
185  bool is_aligned = is_data || is_data2 || is_bits || is_quality;
186 
187  if (is_aligned) {
188  bool shall_display_secinfo = is_data;
189 
190  if (isSAI) {
191  GBDATA *gb_sai = GB_get_grandfather(gb_ali_child);
192  GBDATA *gb_disp_sec = GB_searchOrCreate_int(gb_sai, "showsec", 0);
193  shall_display_secinfo = GB_read_int(gb_disp_sec);
194  }
195 
196  sprintf(namebuffer, "Sequence_Term%ld.%d", ED4_counter, count_too++);
197  ED4_sequence_terminal *seq_term = new ED4_sequence_terminal(namebuffer, 0, TERMINAL_HEIGHT, seq_manager, shall_display_secinfo);
198  seq_term->species_name = seq_term->get_name_of_species();
199 
200  if (is_data) seq_term->set_property(PROP_CONSENSUS_RELEVANT);
202 
203  text_terminal = seq_term;
204  }
205  else {
206  sprintf(namebuffer, "PureText_Term%ld.%d", ED4_counter, count_too++);
207  text_terminal = new ED4_pure_text_terminal(namebuffer, 0, TERMINAL_HEIGHT, seq_manager);
208  }
209 
210  text_terminal->set_property(PROP_CURSOR_ALLOWED);
211  text_terminal->set_both_links(refterms.sequence());
212  seq_manager->append_member(text_terminal);
213 #if defined(DEBUG)
214  // ensure only 1 terminal is consensus-relevant!
215  if (is_data) {
216  seq_manager->get_consensus_relevant_terminal(); // does an error otherwise!
217  }
218 #endif // DEBUG
219  text_terminal->set_species_pointer(gb_ali_child);
220 
221  long string_length;
222  if (gb_ali_child) {
223  string_length = GB_read_count(gb_ali_child);
224  }
225  else {
226  string_length = 100;
227  }
228 
229  int pixel_length = device->get_string_size(ED4_G_SEQUENCES, string_length) + 100; // @@@ "+ 100" looks like a hack
230 
231  *max_sequence_terminal_length = std::max(*max_sequence_terminal_length, long(pixel_length));
232  text_terminal->extension.size[WIDTH] = pixel_length;
233 
234  if (MAXSEQUENCECHARACTERLENGTH < string_length) {
235  MAXSEQUENCECHARACTERLENGTH = string_length;
236  refterms.sequence()->extension.size[WIDTH] = pixel_length;
237  }
238 
240  ED4_ROOT->scroll_links.link_for_hor_slider = text_terminal;
241  }
242  else if (*max_sequence_terminal_length > ED4_ROOT->scroll_links.link_for_hor_slider->extension.size[WIDTH]) {
243  ED4_ROOT->scroll_links.link_for_hor_slider = text_terminal;
244  }
245  }
246  free(key_string);
247  }
248  }
249 
250  return ED4_R_OK;
251 }
252 
253 
255  const char *sep_name = "\1"; // Trennzeichen
256  char* configstring = new char[500];
257 
258  strcpy(configstring, sep_name);
259 
260  strcat(configstring, "FGruppe1lang");
261  strcat(configstring, sep_name);
262  strcat(configstring, "SHELIX_PAIRS");
263  strcat(configstring, sep_name);
264  strcat(configstring, "SHELIX_LINE");
265  strcat(configstring, sep_name);
266  strcat(configstring, "E");
267  strcat(configstring, sep_name);
268  strcat(configstring, "GFltDorot"); // Speciesmark L
269  strcat(configstring, sep_name);
270  strcat(configstring, "LCasElega");
271  strcat(configstring, sep_name);
272  strcat(configstring, "E");
273  strcat(configstring, sep_name);
274  strcat(configstring, "LBaeFrag3");
275  strcat(configstring, sep_name);
276  strcat(configstring, "LFlaFerr2");
277  strcat(configstring, sep_name);
278  strcat(configstring, "LCytLyti3");
279  strcat(configstring, "\0");
280 
281  return configstring;
282 }
283 
284 char* EDB_root_bact::make_top_bot_string() { // is only called when started manually
285  char* configstring;
286  configstring = new char[400];
287  sprintf(configstring, "%cFSAI's%cSHELIX_PAIRS%cSHELIX_LINE%cSALI_ERR%cSALI_CON%cSALI_INT%cSALI_BIND%cSantibiot%cSmodnuc%cSelong%cStRNA%cSALI_BOR%cSALI_PRE_I%cSALI_PRE%cSALI_INSERTS%cSinseuca2%cSregaps%cSallr5%cSbacr5%cSarcr5%cSeucr5%cSgplr5%cSinsEuca%cSprimer1%cSprimer2%cSbetar5%cSprimer3%cE", 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
288 
289  strcat(configstring, "\0");
290 
291  return configstring;
292 }
293 
294 
296  ED4_reference_terminals& refterms,
297  const char *str,
298  int *index,
299  int group_depth,
300  arb_progress *progress)
301 {
302  const int MAXNAMELEN = 1024;
303 
304  bool expect_separator = true;
305  ED4_datamode datamode = ED4_D_SPECIES;
306  ED4_returncode retCode = ED4_R_OK;
307 
308  char *name = ARB_calloc<char>(MAXNAMELEN);
309  int npos = 0;
310 
311  do {
312  if (expect_separator) {
313  if (str[(*index)+1] == 'L') {
314  datamode = ED4_D_SPECIES;
315  }
316  else if (str[(*index)+1] == 'S') {
317  datamode = ED4_D_EXTENDED;
318  }
319  else {
320  const char *entry = str+*index+1;
321  char tag = entry[0];
322  const char *sep = strchr(entry, 1);
323 
324  if (sep) {
325  int len = sep-entry+1;
326  char *content = ARB_strndup(entry+1, len);
327  char *message = GBS_global_string_copy("Unknown or misplaced tag-id '%c' (with content '%s'). Error in configuration-data!\nTrying to continue..", tag, content);
328 
329  fprintf(stderr, "ARB_EDIT4: %s\n", message);
330  aw_message(message);
331 
332  free(message);
333  free(content);
334  retCode = ED4_R_WARNING;
335 
336  (*index) += sep-entry+1; // set index to next separator
337  continue;
338  }
339  else {
340  fprintf(stderr, "Error reading configuration: Unexpected end of data (at '%s')\n", str+*index);
341 
342  e4_assert(0);
343  retCode = ED4_R_ERROR;
344  break;
345  }
346  e4_assert(0); // never reached!
347  }
348 
349  (*index) += 2;
350  }
351 
352  if (str[*index] != 1) {
353  name[npos++] = str[*index];
354  expect_separator = false;
355  (*index)++;
356  }
357 
358  if (str[*index] == 1 || str[*index] == '\0') {
359  name[npos] = '\0'; // speciesname-generation finished
360  npos = 0;
361 
362  if (progress) {
363  progress->inc();
364  if (progress->aborted()) ED4_exit();
365  }
366 
367  fill_data(multi_species_manager, refterms, name, group_depth, datamode);
368 
369  ED4_counter++;
370  expect_separator = true;
371  }
372  }
373  while (!((str[(*index)] == 1) && (str[(*index)+1] == 'G' || str[(*index)+1]=='E' || str[(*index)+1]=='F')) && (str[*index] != '\0'));
374 
375  free(name);
376 
377  return retCode;
378 }
379 
381  ED4_reference_terminals& refterms,
382  const char *str,
383  int *index,
384  arb_progress& progress)
385 {
386  static int group_depth = 0;
387 
388  while (str[(*index)] != '\0' && str[(*index)+1] != 'E') { // E =
389  if (str[(*index)+1] == 'L' || str[(*index)+1] == 'S') { // L = species, S = SAI
390  fill_species(parent, refterms, str, index, group_depth, &progress);
391  ED4_counter++; // counter is only needed to generate ids
392  }
393 
394  if (str[(*index)] && (str[(*index)+1] == 'G' || str[(*index)+1] == 'F')) { // Group or folded group
395  group_depth++;
396  bool is_folded = str[(*index)+1]=='F';
397 
398  char groupname[GB_GROUP_NAME_MAX];
399  {
400  ED4_index gpos = 0;
401  for (*index += 2, gpos = 0; str[*index] != 1; (*index)++) { // Jump over 'G' and Blank to get Groupname
402  groupname[gpos++] = str[*index];
403  }
404  groupname[gpos] = '\0';
405  }
406 
407  ED4_multi_species_manager *multi_species_manager;
408  ED4_build_group_manager_start(parent, groupname, group_depth, is_folded, refterms, multi_species_manager);
409 
410  ED4_counter++;
411  scan_string(multi_species_manager, refterms, str, index, progress);
412 
413  ED4_build_group_manager_end(multi_species_manager);
414 
415  if (is_folded) multi_species_manager->hide_children();
416  }
417  }
418 
419  if (str[(*index)] && str[(*index)+1] == 'E') {
420  (*index)+=2;
421  group_depth--;
422  }
423 }
424 
425 void EDB_root_bact::save_current_config(char *confname) { // and save it in database
426  GB_ERROR error;
427  GBT_config cfg(GLOBAL_gb_main, confname, error);
428  error = NULp; // ignore not-found error
429 
430  int counter = 0;
431  ED4_device_manager *device_manager = ED4_ROOT->get_device_manager();
432 
433  for (int i=0; i<device_manager->members(); i++) {
434  ED4_base *area = device_manager->member(i);
435  if (area->is_area_manager()) {
436  GBS_strstruct area_config(10000);
437  area->generate_configuration_string(area_config);
438  cfg.set_definition(counter++, area_config.release());
439  }
440  }
441 
442  // add/update comment
443  {
444  char *newComment = GBS_log_action_to(cfg.get_comment(), "saved from ARB_EDIT4", true);
445  cfg.set_comment(newComment);
446  free(newComment);
447  }
448 
449  error = cfg.save(GLOBAL_gb_main, confname, true);
450  aw_message_if(error);
451 }
452 
void set_both_links(ED4_base *ref)
Definition: ed4_class.hxx:977
AW_device * get_device() const
Definition: ed4_class.hxx:772
GB_TYPES type
size_t not_found_counter
Definition: ED4_main.cxx:63
AW_pos size[2]
Definition: ed4_defs.hxx:262
long GB_read_int(GBDATA *gbd)
Definition: arbdb.cxx:699
char * GB_read_key(GBDATA *gbd)
Definition: arbdb.cxx:1626
GBDATA * GB_child(GBDATA *father)
Definition: adquery.cxx:322
int MAXNAME_WIDTH
Definition: ED4_main.cxx:57
ED4_base * member(ED4_index i) const
Definition: ed4_class.hxx:800
ED4_datamode
Definition: ed4_defs.hxx:148
BaseFrequencies & table()
Definition: ed4_class.hxx:1648
#define BRACKET_WIDTH
Definition: ed4_defs.hxx:79
void set_species_pointer(GBDATA *gbd)
Definition: ed4_class.hxx:954
ED4_root * ED4_ROOT
Definition: ED4_main.cxx:48
void scan_string(ED4_multi_species_manager *parent, ED4_reference_terminals &refterms, const char *str, int *index, arb_progress &progress)
char * release()
Definition: arb_strbuf.h:80
ED4_group_manager * ED4_build_group_manager_start(ED4_manager *group_parent, GB_CSTR group_name, int group_depth, bool is_folded, ED4_reference_terminals &refterms, ED4_multi_species_manager *&multi_species_manager)
Definition: ED4_base.cxx:231
GBDATA * GB_get_grandfather(GBDATA *gbd)
Definition: arbdb.cxx:1702
long ED4_counter
Definition: ED4_main.cxx:61
#define e4_assert(bed)
Definition: ed4_class.hxx:11
const int WIDTH
GBDATA * GLOBAL_gb_main
Definition: DI_main.cxx:27
#define MAXNAMELEN
GBDATA * GBT_find_SAI(GBDATA *gb_main, const char *name)
Definition: aditem.cxx:172
ED4_level
Definition: ed4_defs.hxx:120
#define SEQUENCE_INFO_WIDTH
Definition: ed4_defs.hxx:82
char * get_name_of_species()
Definition: ED4_base.cxx:678
long GB_read_count(GBDATA *gbd)
Definition: arbdb.cxx:728
void append_member(ED4_base *new_member)
Definition: arbdb.h:78
GB_TYPES GB_read_type(GBDATA *gbd)
Definition: arbdb.cxx:1617
void calc_no_of_all(const char *string_to_scan, long *group, long *species)
void ED4_build_group_manager_end(ED4_multi_species_manager *multi_species_manager)
Definition: ED4_base.cxx:314
ED4_index members() const
Definition: ed4_class.hxx:802
#define MAX_SHOWN_MISSING_SPECIES
Definition: ed4_defs.hxx:56
int get_string_size(int gc, long textlen) const
Definition: AW_device.cxx:443
ED4_returncode
Definition: ed4_defs.hxx:161
void save_current_config(char *confname)
void hide_children()
Definition: ED4_base.cxx:817
ED4_returncode fill_species(ED4_multi_species_manager *multi_species_manager, ED4_reference_terminals &refterms, const char *str, int *index, int group_depth, arb_progress *progress)
bool aborted()
Definition: arb_progress.h:277
char * alignment_name
Definition: ed4_class.hxx:1440
static int group[MAXN+1]
Definition: ClustalV.cxx:65
ED4_species_type
Definition: ed4_class.hxx:891
void message(char *errortext)
ED4_window * first_window
Definition: ed4_class.hxx:1427
const char * get_comment() const
Definition: ad_config.h:60
void GBS_strcat(GBS_strstruct *strstr, const char *ptr)
Definition: arb_strbuf.cxx:108
static void error(const char *msg)
Definition: mkptypes.cxx:96
void set_comment(const char *newComment)
Definition: ad_config.h:61
int FLAG_WIDTH
Definition: ED4_main.cxx:59
GBDATA * GB_searchOrCreate_int(GBDATA *gb_container, const char *fieldpath, long default_value)
Definition: adquery.cxx:569
GB_ERROR save(GBDATA *gb_main, const char *name, bool warnIfSavingDefault) const
Definition: ad_config.h:64
void ignore_me()
Definition: chartable.h:238
ED4_returncode fill_data(ED4_multi_species_manager *multi_species_manager, ED4_reference_terminals &refterms, char *str, int group_depth, ED4_datamode datamode)
GBS_strstruct * not_found_message
Definition: ED4_main.cxx:64
char * GBS_log_action_to(const char *comment, const char *action, bool stamp)
Definition: adstring.cxx:990
void ED4_exit() __ATTR__NORETURN
ED4_scroll_links scroll_links
Definition: ed4_class.hxx:1434
ED4_extension extension
Definition: ed4_class.hxx:929
int TERMINAL_HEIGHT
Definition: ED4_main.cxx:51
#define NAME_BUFFERSIZE
Definition: ed4_defs.hxx:113
Definition: arbdb.h:72
ED4_sequence_info_terminal * sequence_info()
Definition: ed4_class.hxx:1364
void generate_configuration_string(GBS_strstruct &buffer)
Definition: ED4_base.cxx:322
int MAXSEQUENCECHARACTERLENGTH
Definition: ED4_main.cxx:56
#define GB_GROUP_NAME_MAX
Definition: arbdbt.h:16
void set_property(ED4_properties prop)
Definition: ed4_class.hxx:980
char * ARB_strndup(const char *start, int len)
Definition: arb_string.h:83
ED4_sequence_terminal * sequence()
Definition: ed4_class.hxx:1363
ED4_properties
Definition: ed4_defs.hxx:176
void aw_message(const char *msg)
Definition: AW_status.cxx:932
long max_seq_terminal_length
Definition: ED4_main.cxx:66
#define NULp
Definition: cxxforward.h:97
GBDATA * GBT_find_species(GBDATA *gb_main, const char *name)
Definition: aditem.cxx:136
int is_area_manager() const
Definition: ed4_class.hxx:1115
GB_TYPES
Definition: arbdb.h:62
GBDATA * GB_nextChild(GBDATA *child)
Definition: adquery.cxx:326
char * make_top_bot_string()
char * make_string()
ED4_device_manager * get_device_manager()
Definition: ed4_class.hxx:2230
ED4_manager * get_parent(ED4_level lev) const
Definition: ed4_class.hxx:1823
const ED4_terminal * get_consensus_relevant_terminal() const
Definition: ED4_base.cxx:617
long ED4_index
Definition: ed4_defs.hxx:115
GBDATA * GB_entry(GBDATA *father, const char *key)
Definition: adquery.cxx:334
void aw_message_if(GB_ERROR error)
Definition: aw_msg.hxx:21
char * GBS_global_string_copy(const char *templat,...)
Definition: arb_msg.cxx:195
void set_definition(int area, char *new_def)
Definition: ad_config.h:54
ED4_returncode search_sequence_data_rek(ED4_multi_sequence_manager *multi_sequence_manager, ED4_reference_terminals &refterms, GBDATA *gb_ali_xxx, int count_too, ED4_index *max_sequence_terminal_length, bool isSAI)
#define max(a, b)
Definition: f2c.h:154