1 /* @source ensregistry ********************************************************
2 **
3 ** Ensembl Registry functions
4 **
5 ** @author Copyright (C) 1999 Ensembl Developers
6 ** @author Copyright (C) 2006 Michael K. Schuster
7 ** @version $Revision: 1.68 $
8 ** @modified 2009 by Alan Bleasby for incorporation into EMBOSS core
9 ** @modified $Date: 2013/07/15 20:55:27 $ by $Author: rice $
10 ** @@
11 **
12 ** This library is free software; you can redistribute it and/or
13 ** modify it under the terms of the GNU Lesser General Public
14 ** License as published by the Free Software Foundation; either
15 ** version 2.1 of the License, or (at your option) any later version.
16 **
17 ** This library is distributed in the hope that it will be useful,
18 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 ** Lesser General Public License for more details.
21 **
22 ** You should have received a copy of the GNU Lesser General Public
23 ** License along with this library; if not, write to the Free Software
24 ** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
25 ** MA 02110-1301, USA.
26 **
27 ******************************************************************************/
28
29 /* ========================================================================= */
30 /* ============================= include files ============================= */
31 /* ========================================================================= */
32
33 #include "ensregistry.h"
34
35
36
37
38 /* ========================================================================= */
39 /* =============================== constants =============================== */
40 /* ========================================================================= */
41
42
43
44
45 /* ========================================================================= */
46 /* =========================== global variables ============================ */
47 /* ========================================================================= */
48
49
50
51
52 /* ========================================================================= */
53 /* ============================= private data ============================== */
54 /* ========================================================================= */
55
56 /* @datastatic RegistryPComparativeGenomics ***********************************
57 **
58 ** Registry Comparative Genomics structure.
59 **
60 ** Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
61 ** specific for Ensembl Comparative Genomics databases.
62 **
63 ** @alias RegistrySComparativeGenomics
64 ** @alias RegistryOComparativeGenomics
65 **
66 ** @attr Databaseadaptor [EnsPDatabaseadaptor]
67 ** Ensembl Database Adaptor
68 ** @@
69 ******************************************************************************/
70
71 typedef struct RegistrySComparativeGenomics
72 {
73 EnsPDatabaseadaptor Databaseadaptor;
74 } RegistryOComparativeGenomics;
75
76 #define RegistryPComparativeGenomics RegistryOComparativeGenomics*
77
78
79
80
81 /* @datastatic RegistryPCoreStyle *********************************************
82 **
83 ** Registry Core-Style structure.
84 **
85 ** Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
86 ** specific for Ensembl Core-Style databases.
87 **
88 ** @alias RegistrySCoreStyle
89 ** @alias RegistryOCoreStyle
90 **
91 ** @attr Stableidentifierprefix [AjPStr]
92 ** Ensembl Stable Identifier Prefix
93 ** @attr Databaseadaptor [EnsPDatabaseadaptor]
94 ** Ensembl Database Adaptor
95 ** @attr Referenceadaptor [EnsPDatabaseadaptor]
96 ** Ensembl Database Adaptor
97 ** @attr Analysisadaptor [EnsPAnalysisadaptor]
98 ** Ensembl Analysis Adaptor
99 ** @attr Assemblyexceptionadaptor [EnsPAssemblyexceptionadaptor]
100 ** Ensembl Assembly Exception Adaptor
101 ** @attr Assemblyexceptionfeatureadaptor [EnsPAssemblyexceptionfeatureadaptor]
102 ** Ensembl Assembly Exception Feature Adaptor
103 ** @attr Assemblymapperadaptor [EnsPAssemblymapperadaptor]
104 ** Ensembl Assembly Mapper Adaptor
105 ** @attr Attributetypeadaptor [EnsPAttributetypeadaptor]
106 ** Ensembl Attribute Type Adaptor
107 ** @attr Coordsystemadaptor [EnsPCoordsystemadaptor]
108 ** Ensembl Coordinate System Adaptor
109 ** @attr Densityfeatureadaptor [EnsPDensityfeatureadaptor]
110 ** Ensembl Density Feature Adaptor
111 ** @attr Densitytypeadaptor [EnsPDensitytypeadaptor]
112 ** Ensembl Density Type Adaptor
113 ** @attr Ditagadaptor [EnsPDitagadaptor]
114 ** Ensembl Ditag Adaptor
115 ** @attr Ditagfeatureadaptor [EnsPDitagfeatureadaptor]
116 ** Ensembl Ditag Feature Adaptor
117 ** @attr Dnaalignfeatureadaptor [EnsPDnaalignfeatureadaptor]
118 ** Ensembl DNA Alignment Feature Adaptor
119 ** @attr Exonadaptor [EnsPExonadaptor]
120 ** Ensembl Exon Adaptor
121 ** @attr Externaldatabaseadaptor [EnsPExternaldatabaseadaptor]
122 ** Ensembl External Database Adaptor
123 ** @attr Geneadaptor [EnsPGeneadaptor]
124 ** Ensembl Gene Adaptor
125 ** @attr Intronsupportingevidenceadaptor [EnsPIntronsupportingevidenceadaptor]
126 ** Ensembl Intron Supporting Evidence Adaptor
127 ** @attr Karyotypebandadaptor [EnsPKaryotypebandadaptor]
128 ** Ensembl Karyotype Band Adaptor
129 ** @attr Markeradaptor [EnsPMarkeradaptor]
130 ** Ensembl Marker Adaptor
131 ** @attr Markerfeatureadaptor [EnsPMarkerfeatureadaptor]
132 ** Ensembl Marker Feature Adaptor
133 ** @attr Metacoordinateadaptor [EnsPMetacoordinateadaptor]
134 ** Ensembl Meta-Coordinate Adaptor
135 ** @attr Metainformationadaptor [EnsPMetainformationadaptor]
136 ** Ensembl Meta-Information Adaptor
137 ** @attr Miscellaneousfeatureadaptor [EnsPMiscellaneousfeatureadaptor]
138 ** Ensembl Miscellaneous Feature Adaptor
139 ** @attr Miscellaneoussetadaptor [EnsPMiscellaneoussetadaptor]
140 ** Ensembl Miscellaneous Set Adaptor
141 ** @attr Operonadaptor [EnsPOperonadaptor]
142 ** Ensembl Operon Adaptor
143 ** @attr Operontranscriptadaptor [EnsPOperontranscriptadaptor]
144 ** Ensembl Operon Transcript Adaptor
145 ** @attr Predictionexonadaptor [EnsPPredictionexonadaptor]
146 ** Ensembl Prediction Exon Adaptor
147 ** @attr Predictiontranscriptadaptor [EnsPPredictiontranscriptadaptor]
148 ** Ensembl Prediction Transcript Adaptor
149 ** @attr Proteinalignfeatureadaptor [EnsPProteinalignfeatureadaptor]
150 ** Ensembl Protein Alignment Feature Adaptor
151 ** @attr Proteinfeatureadaptor [EnsPProteinfeatureadaptor]
152 ** Ensembl Protein Feature Adaptor
153 ** @attr Repeatconsensusadaptor [EnsPRepeatconsensusadaptor]
154 ** Ensembl Repeat Consensus Adaptor
155 ** @attr Repeatfeatureadaptor [EnsPRepeatfeatureadaptor]
156 ** Ensembl Repeat Feature Adaptor
157 ** @attr Seqregionadaptor [EnsPSeqregionadaptor]
158 ** Ensembl Sequence Region Adaptor
159 ** @attr Seqregionsynonymadaptor [EnsPSeqregionsynonymadaptor]
160 ** Ensembl Sequence Region Synonym Adaptor
161 ** @attr Sequenceadaptor [EnsPSequenceadaptor]
162 ** Ensembl Sequence Adaptor
163 ** @attr Simplefeatureadaptor [EnsPSimplefeatureadaptor]
164 ** Ensembl Simple Feature Adaptor
165 ** @attr Sliceadaptor [EnsPSliceadaptor]
166 ** Ensembl Slice Adaptor
167 ** @attr Transcriptadaptor [EnsPTranscriptadaptor]
168 ** Ensembl Transcript Adaptor
169 ** @attr Translationadaptor [EnsPTranslationadaptor]
170 ** Ensembl Translation Adaptor
171 ** @@
172 ******************************************************************************/
173
174 typedef struct RegistrySCoreStyle
175 {
176 AjPStr Stableidentifierprefix;
177 EnsPDatabaseadaptor Databaseadaptor;
178 EnsPDatabaseadaptor Referenceadaptor;
179 EnsPAnalysisadaptor Analysisadaptor;
180 EnsPAssemblyexceptionadaptor Assemblyexceptionadaptor;
181 EnsPAssemblyexceptionfeatureadaptor Assemblyexceptionfeatureadaptor;
182 EnsPAssemblymapperadaptor Assemblymapperadaptor;
183 EnsPAttributetypeadaptor Attributetypeadaptor;
184 EnsPCoordsystemadaptor Coordsystemadaptor;
185 EnsPDensityfeatureadaptor Densityfeatureadaptor;
186 EnsPDensitytypeadaptor Densitytypeadaptor;
187 EnsPDitagadaptor Ditagadaptor;
188 EnsPDitagfeatureadaptor Ditagfeatureadaptor;
189 EnsPDnaalignfeatureadaptor Dnaalignfeatureadaptor;
190 EnsPExonadaptor Exonadaptor;
191 EnsPExternaldatabaseadaptor Externaldatabaseadaptor;
192 EnsPGeneadaptor Geneadaptor;
193 EnsPIntronsupportingevidenceadaptor Intronsupportingevidenceadaptor;
194 EnsPKaryotypebandadaptor Karyotypebandadaptor;
195 EnsPMarkeradaptor Markeradaptor;
196 EnsPMarkerfeatureadaptor Markerfeatureadaptor;
197 EnsPMetacoordinateadaptor Metacoordinateadaptor;
198 EnsPMetainformationadaptor Metainformationadaptor;
199 EnsPMiscellaneousfeatureadaptor Miscellaneousfeatureadaptor;
200 EnsPMiscellaneoussetadaptor Miscellaneoussetadaptor;
201 EnsPOperonadaptor Operonadaptor;
202 EnsPOperontranscriptadaptor Operontranscriptadaptor;
203 EnsPPredictionexonadaptor Predictionexonadaptor;
204 EnsPPredictiontranscriptadaptor Predictiontranscriptadaptor;
205 EnsPProteinalignfeatureadaptor Proteinalignfeatureadaptor;
206 EnsPProteinfeatureadaptor Proteinfeatureadaptor;
207 EnsPRepeatconsensusadaptor Repeatconsensusadaptor;
208 EnsPRepeatfeatureadaptor Repeatfeatureadaptor;
209 EnsPSeqregionadaptor Seqregionadaptor;
210 EnsPSeqregionsynonymadaptor Seqregionsynonymadaptor;
211 EnsPSequenceadaptor Sequenceadaptor;
212 EnsPSimplefeatureadaptor Simplefeatureadaptor;
213 EnsPSliceadaptor Sliceadaptor;
214 EnsPTranscriptadaptor Transcriptadaptor;
215 EnsPTranslationadaptor Translationadaptor;
216 } RegistryOCoreStyle;
217
218 #define RegistryPCoreStyle RegistryOCoreStyle*
219
220
221
222
223 /* @datastatic RegistryPEntry *************************************************
224 **
225 ** Registry Entry structure.
226 **
227 ** Holds Ensembl Database Adaptor Group-specific Registry objects.
228 **
229 ** @alias RegistrySEntry
230 ** @alias RegistryOEntry
231 **
232 ** @attr Registry [void*[EnsMDatabaseadaptorGroups]]
233 ** Array of database-specific Registry Entry objects, indexed by the
234 ** Ensembl Database Adaptor Group enumeration.
235 ** @@
236 ******************************************************************************/
237
238 typedef struct RegistrySEntry
239 {
240 void *Registry[EnsMDatabaseadaptorGroups];
241 } RegistryOEntry;
242
243 #define RegistryPEntry RegistryOEntry*
244
245
246
247
248 /* @datastatic RegistryPFunctionalGenomics ************************************
249 **
250 ** Registry Functional Genomics structure.
251 **
252 ** Holds an Ensembl Database Adaptors and associated Ensembl Object Adaptors
253 ** specific for Ensembl Functional Genomics databases.
254 **
255 ** @alias RegistrySFunctionalGenomics
256 ** @alias RegistryOFunctionalGenomics
257 **
258 ** @attr Databaseadaptor [EnsPDatabaseadaptor]
259 ** Ensembl Database Adaptor
260 ** @@
261 ******************************************************************************/
262
263 typedef struct RegistrySFunctionalGenomics
264 {
265 EnsPDatabaseadaptor Databaseadaptor;
266 } RegistryOFunctionalGenomics;
267
268 #define RegistryPFunctionalGenomics RegistryOFunctionalGenomics*
269
270
271
272
273 /* @datastatic RegistryPGeneticVariation **************************************
274 **
275 ** Registry Genetic Variation structure.
276 **
277 ** Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
278 ** specific for Ensembl Genetic Variation databases.
279 **
280 ** @alias RegistrySGeneticVariation
281 ** @alias RegistryOGeneticVariation
282 **
283 ** @attr Databaseadaptor [EnsPDatabaseadaptor]
284 ** Ensembl Database Adaptor
285 ** @attr Gvalleleadaptor [EnsPGvalleleadaptor]
286 ** Ensembl Genetic Variation Allele Adaptor
287 ** @attr Gvattributeadaptor [EnsPGvattributeadaptor]
288 ** Ensembl Genetic Variation Attribute Adaptor
289 ** @attr Gvdatabaseadaptor [EnsPGvdatabaseadaptor]
290 ** Ensembl Genetic Variation Database Adaptor
291 ** @attr Gvgenotypecodeadaptor [EnsPGvgenotypecodeadaptor]
292 ** Ensembl Genetic Variation Genotype Code Adaptor
293 ** @attr Gvindividualadaptor [EnsPGvindividualadaptor]
294 ** Ensembl Genetic Variation Individual Adaptor
295 ** @attr Gvpopulationadaptor [EnsPGvpopulationadaptor]
296 ** Ensembl Genetic Variation Population Adaptor
297 ** @attr Gvpopulationgenotypeadaptor [EnsPGvpopulationgenotypeadaptor]
298 ** Ensembl Genetic Variation Population Genotype Adaptor
299 ** @attr Gvsampleadaptor [EnsPGvsampleadaptor]
300 ** Ensembl Genetic Variation Sample Adaptor
301 ** @attr Gvsourceadaptor [EnsPGvsourceadaptor]
302 ** Ensembl Genetic Variation Source Adaptor
303 ** @attr Gvtranscriptvariationadaptor [EnsPGvtranscriptvariationadaptor]
304 ** Ensembl Genetic Variation Transcript Variation Adaptor
305 ** @attr Gvvariationadaptor [EnsPGvvariationadaptor]
306 ** Ensembl Genetic Variation Variation Adaptor
307 ** @attr Gvvariationfeatureadaptor [EnsPGvvariationfeatureadaptor]
308 ** Ensembl Genetic Variation Variation Feature Adaptor
309 ** @attr Gvvariationsetadaptor [EnsPGvvariationsetadaptor]
310 ** Ensembl Genetic Variation Variation Set Adaptor
311 ** @@
312 ******************************************************************************/
313
314 typedef struct RegistrySGeneticVariation
315 {
316 EnsPDatabaseadaptor Databaseadaptor;
317 EnsPGvalleleadaptor Gvalleleadaptor;
318 EnsPGvattributeadaptor Gvattributeadaptor;
319 EnsPGvdatabaseadaptor Gvdatabaseadaptor;
320 EnsPGvgenotypecodeadaptor Gvgenotypecodeadaptor;
321 EnsPGvindividualadaptor Gvindividualadaptor;
322 EnsPGvpopulationadaptor Gvpopulationadaptor;
323 EnsPGvpopulationgenotypeadaptor Gvpopulationgenotypeadaptor;
324 EnsPGvsampleadaptor Gvsampleadaptor;
325 EnsPGvsourceadaptor Gvsourceadaptor;
326 EnsPGvtranscriptvariationadaptor Gvtranscriptvariationadaptor;
327 EnsPGvvariationadaptor Gvvariationadaptor;
328 EnsPGvvariationfeatureadaptor Gvvariationfeatureadaptor;
329 EnsPGvvariationsetadaptor Gvvariationsetadaptor;
330 } RegistryOGeneticVariation;
331
332 #define RegistryPGeneticVariation RegistryOGeneticVariation*
333
334
335
336
337 /* @datastatic RegistryPIdentifier ********************************************
338 **
339 ** Registry Identifier structure.
340 **
341 ** Holds regular expressions for matching Ensembl Gene, Transcript,
342 ** Translation and Exon stable identifiers, as well as
343 ** Ensembl Database Adaptor species and group information.
344 **
345 ** @alias RegistrySIdentifier
346 ** @alias RegistryOIdentifier
347 **
348 ** @attr RegularExpression [AjPStr] Regular expression
349 ** @attr SpeciesName [AjPStr] Ensembl Database Adaptor species name
350 ** @attr Group [EnsEDatabaseadaptorGroup]
351 ** Ensembl Database Adaptor Group enumeration
352 ** @attr Padding [ajuint] Padding to alignment boundary
353 ** @@
354 ******************************************************************************/
355
356 typedef struct RegistrySIdentifier
357 {
358 AjPStr RegularExpression;
359 AjPStr SpeciesName;
360 EnsEDatabaseadaptorGroup Group;
361 ajuint Padding;
362 } RegistryOIdentifier;
363
364 #define RegistryPIdentifier RegistryOIdentifier*
365
366
367
368
369 /* @datastatic RegistryPOntology **********************************************
370 **
371 ** Registry Ontology structure.
372 **
373 ** Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
374 ** specific for Ensembl Ontology databases.
375 **
376 ** @alias RegistrySOntology
377 ** @alias RegistryOOntology
378 **
379 ** @attr Databaseadaptor [EnsPDatabaseadaptor]
380 ** Ensembl Database Adaptor
381 ** @attr Ontologyadaptor [EnsPOntologyadaptor]
382 ** Ensembl Ontology Adaptor
383 ** @attr Ontologytermadaptor [EnsPOntologytermadaptor]
384 ** Ensembl Ontology Term Adaptor
385 ** @@
386 ******************************************************************************/
387
388 typedef struct RegistrySOntology
389 {
390 EnsPDatabaseadaptor Databaseadaptor;
391 EnsPOntologyadaptor Ontologyadaptor;
392 EnsPOntologytermadaptor Ontologytermadaptor;
393 } RegistryOOntology;
394
395 #define RegistryPOntology RegistryOOntology*
396
397
398
399
400 /* @datastatic RegistryPQualityCheck ******************************************
401 **
402 ** Registry Quality Check structure.
403 **
404 ** Holds an Ensembl Database Adaptor and associated Ensembl Object Adaptors
405 ** specific for Ensembl Quality Check databases.
406 **
407 ** @alias RegistrySQualityCheck
408 ** @alias RegistryOQualityCheck
409 **
410 ** @attr Databaseadaptor [EnsPDatabaseadaptor]
411 ** Ensembl Database Adaptor
412 ** @attr Qcalignmentadaptor [EnsPQcalignmentadaptor]
413 ** Ensembl Quality Check Alignment Adaptor
414 ** @attr Qcdasfeatureadaptor [EnsPQcdasfeatureadaptor]
415 ** Ensembl Quality Check DAS Feature Adaptor
416 ** @attr Qcdatabaseadaptor [EnsPQcdatabaseadaptor]
417 ** Ensembl Quality Check Database Adaptor
418 ** @attr Qcsequenceadaptor [EnsPQcsequenceadaptor]
419 ** Ensembl Quality Check Sequence Adaptor
420 ** @attr Qcsubmissionadaptor [EnsPQcsubmissionadaptor]
421 ** Ensembl Quality Check Submission Adaptor
422 ** @attr Qcvariationadaptor [EnsPQcvariationadaptor]
423 ** Ensembl Quality Check Variation Adaptor
424 ** @@
425 ******************************************************************************/
426
427 typedef struct RegistrySQualityCheck
428 {
429 EnsPDatabaseadaptor Databaseadaptor;
430 EnsPQcalignmentadaptor Qcalignmentadaptor;
431 EnsPQcdasfeatureadaptor Qcdasfeatureadaptor;
432 EnsPQcdatabaseadaptor Qcdatabaseadaptor;
433 EnsPQcsequenceadaptor Qcsequenceadaptor;
434 EnsPQcsubmissionadaptor Qcsubmissionadaptor;
435 EnsPQcvariationadaptor Qcvariationadaptor;
436 } RegistryOQualityCheck;
437
438 #define RegistryPQualityCheck RegistryOQualityCheck*
439
440
441
442
443 /* ========================================================================= */
444 /* =========================== private constants =========================== */
445 /* ========================================================================= */
446
447 /* @conststatic registryKAliasMetaKey *****************************************
448 **
449 ** Register species aliases from the following Ensembl Meta-Information keys.
450 **
451 ******************************************************************************/
452
453 static const char *const registryKAliasMetaKey[] =
454 {
455 "assembly.name",
456 "species.alias",
457 "species.common_name",
458 "species.stable_id_prefix",
459 "species.taxonomy_id",
460 (const char *) NULL
461 };
462
463
464
465
466 /* ========================================================================= */
467 /* =========================== private variables =========================== */
468 /* ========================================================================= */
469
470 /* #varstatic registryGAlias **************************************************
471 **
472 ** AJAX Table storing
473 ** AJAX String object (alias) key data and
474 ** AJAX String object (species name) value data.
475 **
476 ** key data: AJAX String object (alias)
477 ** value data: AJAX String object (species name)
478 **
479 ******************************************************************************/
480
481 static AjPTable registryGAlias = NULL;
482
483
484
485
486 /* #varstatic registryGEntry **************************************************
487 **
488 ** AJAX Table storing
489 ** AJAX String object (species name) key data and
490 ** Registry Entry object value data.
491 **
492 ** key data: AJAX String object (species name)
493 ** value data: Registry Entry object
494 **
495 ******************************************************************************/
496
497 static AjPTable registryGEntry = NULL;
498
499
500
501
502 /* #varstatic registryGIdentifier *********************************************
503 **
504 ** AJAX List storing Registry Identifier objects.
505 **
506 ******************************************************************************/
507
508 static AjPList registryGIdentifier = NULL;
509
510
511
512
513 /* #varstatic registryGSource *************************************************
514 **
515 ** AJAX Table storing
516 ** AJAX String (URL) key data and
517 ** AJAX unsigned integer (Number of Ensembl Database Adaptor objects)
518 ** value data, representing sources that have been used to populate the
519 ** Ensembl Registry. Keeping track of sources prevents multiple attempts
520 ** to initialise and potentially overwrite the Ensembl Registry.
521 **
522 ** key data: AJAX String object
523 ** Source URL of schema mysql:// or file:/// representing an
524 ** Ensembl Database Connection
525 ** value data: AJAX unsigned integer
526 ** Number of Ensembl Database Adaptor objects
527 ** registered from this source.
528 **
529 ** Valid sources are:
530 **
531 ** * AJAX String object representation of Ensembl Database Connection object
532 ** URLs used in ensRegistryLoadDatabaseconnection.
533 ** * AJAX String object representation of AJAX Server chache file
534 ** URLs used in ensRegistryLoadServername.
535 **
536 ******************************************************************************/
537
538 static AjPTable registryGSource = NULL;
539
540
541
542
543 /* ========================================================================= */
544 /* =========================== private functions =========================== */
545 /* ========================================================================= */
546
547 static void registryEntryDel(
548 RegistryPEntry *Pentry);
549
550 static AjBool registryEntryTrace(
551 const RegistryPEntry entry,
552 ajuint level);
553
554 static RegistryPIdentifier registryIdentifierNew(
555 AjPStr expression,
556 AjPStr species,
557 EnsEDatabaseadaptorGroup dbag);
558
559 static void registryIdentifierDel(
560 RegistryPIdentifier *Pri);
561
562 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
563 static AjBool registryIdentifierTrace(
564 const RegistryPIdentifier ri,
565 ajuint level);
566 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
567
568 static void registryCoreStyleDel(
569 RegistryPCoreStyle *Prcs);
570
571 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
572 static AjBool registryCoreStyleTrace(
573 const RegistryPCoreStyle rcs,
574 ajuint level);
575 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
576
577 static void registryComparativeGenomicsDel(
578 RegistryPComparativeGenomics *Prcg);
579
580 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
581 static AjBool registryComparativeGenomicsTrace(
582 const RegistryPComparativeGenomics rcg,
583 ajuint level);
584 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
585
586 static void registryFunctionalGenomicsDel(
587 RegistryPFunctionalGenomics *Prfg);
588
589 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
590 static AjBool registryFunctionalGenomicsTrace(
591 const RegistryPFunctionalGenomics rfg,
592 ajuint level);
593 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
594
595 static void registryGeneticVariationDel(
596 RegistryPGeneticVariation *Prgv);
597
598 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
599 static AjBool registryGeneticVariationTrace(
600 const RegistryPGeneticVariation rgv,
601 ajuint level);
602 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
603
604 static void registryOntologyDel(
605 RegistryPOntology *Pro);
606
607 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
608 static AjBool registryOntologyTrace(
609 const RegistryPOntology ro,
610 ajuint level);
611 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
612
613 static void registryQualityCheckDel(
614 RegistryPQualityCheck *Pqc);
615
616 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
617 static AjBool registryQualityCheckTrace(
618 const RegistryPQualityCheck rqc,
619 ajuint level);
620 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
621
622 static AjBool registryAliasLoadDatabaseconnection(
623 EnsPDatabaseconnection dbc,
624 EnsPDatabaseadaptor dba);
625
626 static ajuint registryEntryLoadCollection(EnsPDatabaseconnection dbc,
627 AjPStr dbname,
628 EnsEDatabaseadaptorGroup dbag);
629
630 static int registryStringCompareCase(
631 const void *item1,
632 const void *item2);
633
634 static void registryStringDelete(void **Pitem, void *cl);
635
636
637
638
639 /* ========================================================================= */
640 /* ======================= All functions by section ======================== */
641 /* ========================================================================= */
642
643
644
645
646 /* @filesection ensregistry ***************************************************
647 **
648 ** @nam1rule ens Function belongs to the Ensembl library
649 ** @nam2rule Registry Functions for manipulating the Ensembl Registry
650 **
651 ******************************************************************************/
652
653
654
655
656 /* @funcstatic registryComparativeGenomicsDel *********************************
657 **
658 ** Default destructor for a Registry Comparative Genomics object.
659 **
660 ** @param [d] Prcg [RegistryPComparativeGenomics*]
661 ** Registry Comparative Genomics object address
662 **
663 ** @return [void]
664 **
665 ** @release 6.2.0
666 ** @@
667 ******************************************************************************/
668
registryComparativeGenomicsDel(RegistryPComparativeGenomics * Prcg)669 static void registryComparativeGenomicsDel(
670 RegistryPComparativeGenomics *Prcg)
671 {
672 RegistryPComparativeGenomics pthis = NULL;
673
674 if (!Prcg)
675 return;
676
677 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
678 if (ajDebugTest("registryComparativeGenomicsDel"))
679 {
680 ajDebug("registryComparativeGenomicsDel\n"
681 " *Prcg %p\n",
682 *Prcg);
683
684 registryComparativeGenomicsTrace(*Prcg, 1);
685 }
686 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
687
688 if (!(pthis = *Prcg))
689 return;
690
691 /* Delete all Ensembl Object Adaptors based on the Database Adaptor. */
692
693 /* Finally, delete the Ensembl Database Adaptor. */
694
695 ensDatabaseadaptorDel(&pthis->Databaseadaptor);
696
697 ajMemFree((void **) Prcg);
698
699 return;
700 }
701
702
703
704
705 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
706 /* @funcstatic registryComparativeGenomicsTrace *******************************
707 **
708 ** Trace a Registry Comparative Genomics object.
709 **
710 ** @param [r] rcg [const RegistryPComparativeGenomics]
711 ** Registry Comparative Genomics object
712 ** @param [r] level [ajuint] Indentation level
713 **
714 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
715 **
716 ** @release 6.4.0
717 ** @@
718 ******************************************************************************/
719
registryComparativeGenomicsTrace(const RegistryPComparativeGenomics rcg,ajuint level)720 static AjBool registryComparativeGenomicsTrace(
721 const RegistryPComparativeGenomics rcg,
722 ajuint level)
723 {
724 AjPStr indent = NULL;
725
726 if (!rcg)
727 return ajFalse;
728
729 indent = ajStrNew();
730
731 ajStrAppendCountK(&indent, ' ', level * 2);
732
733 ajDebug("%registryComparativeGenomicsTrace %p\n"
734 "%S Databaseadaptor %p\n",
735 indent, rcg,
736 indent, rcg->Databaseadaptor);
737
738 ensDatabaseadaptorTrace(rcg->Databaseadaptor, level + 1);
739
740 ajStrDel(&indent);
741
742 return ajTrue;
743 }
744 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
745
746
747
748
749 /* @funcstatic registryCoreStyleDel *******************************************
750 **
751 ** Default destructor for a Registry Core-Style object.
752 **
753 ** @param [d] Prcs [RegistryPCoreStyle*] Registry Core-Style object address
754 **
755 ** @return [void]
756 **
757 ** @release 6.2.0
758 ** @@
759 ******************************************************************************/
760
registryCoreStyleDel(RegistryPCoreStyle * Prcs)761 static void registryCoreStyleDel(
762 RegistryPCoreStyle *Prcs)
763 {
764 RegistryPCoreStyle pthis = NULL;
765
766 if (!Prcs)
767 return;
768
769 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
770 if (ajDebugTest("registryCoreStyleDel"))
771 {
772 ajDebug("registryCoreStyleDel\n"
773 " *Prcs %p\n",
774 *Prcs);
775
776 registryCoreStyleTrace(*Prcs, 1);
777 }
778 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
779
780 if (!(pthis = *Prcs))
781 return;
782
783 ajStrDel(&pthis->Stableidentifierprefix);
784
785 /* Delete all Ensembl Object Adaptors based on Database Adaptors. */
786
787 ensAnalysisadaptorDel(
788 &pthis->Analysisadaptor);
789
790 ensAssemblyexceptionadaptorDel(
791 &pthis->Assemblyexceptionadaptor);
792
793 ensAssemblyexceptionfeatureadaptorDel(
794 &pthis->Assemblyexceptionfeatureadaptor);
795
796 ensAssemblymapperadaptorDel(
797 &pthis->Assemblymapperadaptor);
798
799 ensAttributetypeadaptorDel(
800 &pthis->Attributetypeadaptor);
801
802 ensCoordsystemadaptorDel(
803 &pthis->Coordsystemadaptor);
804
805 ensDensityfeatureadaptorDel(
806 &pthis->Densityfeatureadaptor);
807
808 ensDensitytypeadaptorDel(
809 &pthis->Densitytypeadaptor);
810
811 ensDitagadaptorDel(
812 &pthis->Ditagadaptor);
813
814 ensDitagfeatureadaptorDel(
815 &pthis->Ditagfeatureadaptor);
816
817 ensDnaalignfeatureadaptorDel(
818 &pthis->Dnaalignfeatureadaptor);
819
820 ensExonadaptorDel(
821 &pthis->Exonadaptor);
822
823 ensExternaldatabaseadaptorDel(
824 &pthis->Externaldatabaseadaptor);
825
826 ensGeneadaptorDel(
827 &pthis->Geneadaptor);
828
829 ensIntronsupportingevidenceadaptorDel(
830 &pthis->Intronsupportingevidenceadaptor);
831
832 ensKaryotypebandadaptorDel(
833 &pthis->Karyotypebandadaptor);
834
835 ensMarkeradaptorDel(
836 &pthis->Markeradaptor);
837
838 ensMarkerfeatureadaptorDel(
839 &pthis->Markerfeatureadaptor);
840
841 ensMetainformationadaptorDel(
842 &pthis->Metainformationadaptor);
843
844 ensMetacoordinateadaptorDel(
845 &pthis->Metacoordinateadaptor);
846
847 ensMiscellaneousfeatureadaptorDel(
848 &pthis->Miscellaneousfeatureadaptor);
849
850 ensMiscellaneoussetadaptorDel(
851 &pthis->Miscellaneoussetadaptor);
852
853 ensOperonadaptorDel(
854 &pthis->Operonadaptor);
855
856 ensOperontranscriptadaptorDel(
857 &pthis->Operontranscriptadaptor);
858
859 ensPredictionexonadaptorDel(
860 &pthis->Predictionexonadaptor);
861
862 ensPredictiontranscriptadaptorDel(
863 &pthis->Predictiontranscriptadaptor);
864
865 ensProteinalignfeatureadaptorDel(
866 &pthis->Proteinalignfeatureadaptor);
867
868 ensProteinfeatureadaptorDel(
869 &pthis->Proteinfeatureadaptor);
870
871 ensRepeatconsensusadaptorDel(
872 &pthis->Repeatconsensusadaptor);
873
874 ensRepeatfeatureadaptorDel(
875 &pthis->Repeatfeatureadaptor);
876
877 ensSeqregionadaptorDel(
878 &pthis->Seqregionadaptor);
879
880 ensSeqregionsynonymadaptorDel(
881 &pthis->Seqregionsynonymadaptor);
882
883 ensSequenceadaptorDel(
884 &pthis->Sequenceadaptor);
885
886 ensSimplefeatureadaptorDel(
887 &pthis->Simplefeatureadaptor);
888
889 ensSliceadaptorDel(
890 &pthis->Sliceadaptor);
891
892 ensTranscriptadaptorDel(
893 &pthis->Transcriptadaptor);
894
895 ensTranslationadaptorDel(
896 &pthis->Translationadaptor);
897
898 /* Finally, delete the Ensembl Database Adaptors. */
899
900 ensDatabaseadaptorDel(
901 &pthis->Referenceadaptor);
902
903 ensDatabaseadaptorDel(
904 &pthis->Databaseadaptor);
905
906 ajMemFree((void **) Prcs);
907
908 return;
909 }
910
911
912
913
914 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
915 /* @funcstatic registryCoreStyleTrace *****************************************
916 **
917 ** Trace a Registry Core-Style object.
918 **
919 ** @param [r] rcs [const RegistryPCoreStyle] Registry Core-Style object
920 ** @param [r] level [ajuint] Indentation level
921 **
922 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
923 **
924 ** @release 6.2.0
925 ** @@
926 ******************************************************************************/
927
registryCoreStyleTrace(const RegistryPCoreStyle rcs,ajuint level)928 static AjBool registryCoreStyleTrace(
929 const RegistryPCoreStyle rcs,
930 ajuint level)
931 {
932 AjPStr indent = NULL;
933
934 if (!rcs)
935 return ajFalse;
936
937 indent = ajStrNew();
938
939 ajStrAppendCountK(&indent, ' ', level * 2);
940
941 ajDebug("%SregistryCoreStyleTrace %p\n"
942 "%S Stableidentifierprefix '%S'\n"
943 "%S Databaseadaptor %p\n"
944 "%S Referenceadaptor %p\n"
945 "%S Analysisadaptor %p\n"
946 "%S Assemblyexceptionadaptor %p\n"
947 "%S Assemblyexceptionfeatureadaptor %p\n"
948 "%S Assemblymapperadaptor %p\n"
949 "%S Coordsystemadaptor %p\n"
950 "%S Dnaalignfeatureadaptor %p\n"
951 "%S Exonadaptor %p\n"
952 "%S Externaldatabaseadaptor %p\n"
953 "%S Geneadaptor %p\n"
954 "%S Intronsupportingevidenceadaptor %p\n"
955 "%S Karyotypebandadaptor %p\n"
956 "%S Metainformationadaptor %p\n"
957 "%S Metacoordinateadaptor %p\n"
958 "%S Miscellaneousfeatureadaptor %p\n"
959 "%S Miscellaneoussetadaptor %p\n"
960 "%S Operonadaptor %p\n"
961 "%S Operontranscriptadaptor %p\n"
962 "%S Proteinalignfeatureadaptor %p\n"
963 "%S Proteinfeatureadaptor %p\n"
964 "%S Repeatfeatureadaptor %p\n"
965 "%S Seqregionadaptor %p\n"
966 "%S Seqregionsynonymadaptor %p\n"
967 "%S Sequenceadaptor %p\n"
968 "%S Simplefeatureadaptor %p\n"
969 "%S Sliceadaptor %p\n"
970 "%S Transcriptadaptor %p\n"
971 "%S Translationadaptor %p\n",
972 indent, rcs,
973 indent, rcs->Stableidentifierprefix,
974 indent, rcs->Databaseadaptor,
975 indent, rcs->Referenceadaptor,
976 indent, rcs->Analysisadaptor,
977 indent, rcs->Assemblyexceptionadaptor,
978 indent, rcs->Assemblyexceptionfeatureadaptor,
979 indent, rcs->Assemblymapperadaptor,
980 indent, rcs->Coordsystemadaptor,
981 indent, rcs->Dnaalignfeatureadaptor,
982 indent, rcs->Exonadaptor,
983 indent, rcs->Externaldatabaseadaptor,
984 indent, rcs->Geneadaptor,
985 indent, rcs->Intronsupportingevidenceadaptor,
986 indent, rcs->Karyotypebandadaptor,
987 indent, rcs->Metainformationadaptor,
988 indent, rcs->Metacoordinateadaptor,
989 indent, rcs->Miscellaneousfeatureadaptor,
990 indent, rcs->Miscellaneoussetadaptor,
991 indent, rcs->Operonadaptor,
992 indent, rcs->Operontranscriptadaptor,
993 indent, rcs->Proteinalignfeatureadaptor,
994 indent, rcs->Proteinfeatureadaptor,
995 indent, rcs->Repeatfeatureadaptor,
996 indent, rcs->Seqregionadaptor,
997 indent, rcs->Seqregionsynonymadaptor,
998 indent, rcs->Sequenceadaptor,
999 indent, rcs->Simplefeatureadaptor,
1000 indent, rcs->Sliceadaptor,
1001 indent, rcs->Transcriptadaptor,
1002 indent, rcs->Translationadaptor);
1003
1004 ensDatabaseadaptorTrace(rcs->Databaseadaptor, level + 1);
1005
1006 ajStrDel(&indent);
1007
1008 return ajTrue;
1009 }
1010 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1011
1012
1013
1014
1015 /* @funcstatic registryEntryDel ***********************************************
1016 **
1017 ** Default destructor for a Registry Entry object.
1018 **
1019 ** @param [d] Pentry [RegistryPEntry*] Registry Entry address
1020 **
1021 ** @return [void]
1022 **
1023 ** @release 6.2.0
1024 ** @@
1025 ******************************************************************************/
1026
registryEntryDel(RegistryPEntry * Pentry)1027 static void registryEntryDel(
1028 RegistryPEntry *Pentry)
1029 {
1030 RegistryPEntry pthis = NULL;
1031
1032 if (!Pentry)
1033 return;
1034
1035 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1036 if (ajDebugTest("registryEntryDel"))
1037 {
1038 ajDebug("registryEntryDel\n"
1039 " *Pentry %p\n",
1040 *Pentry);
1041
1042 registryEntryTrace(*Pentry, 1);
1043 }
1044 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1045
1046 if (!(pthis = *Pentry))
1047 return;
1048
1049 registryCoreStyleDel(
1050 (RegistryPCoreStyle *)
1051 &pthis->Registry[ensEDatabaseadaptorGroupCore]);
1052
1053 registryCoreStyleDel(
1054 (RegistryPCoreStyle *)
1055 &pthis->Registry[ensEDatabaseadaptorGroupVega]);
1056
1057 registryCoreStyleDel(
1058 (RegistryPCoreStyle *)
1059 &pthis->Registry[ensEDatabaseadaptorGroupOtherFeatures]);
1060
1061 registryCoreStyleDel(
1062 (RegistryPCoreStyle *)
1063 &pthis->Registry[ensEDatabaseadaptorGroupCopyDNA]);
1064
1065 registryGeneticVariationDel(
1066 (RegistryPGeneticVariation *)
1067 &pthis->Registry[ensEDatabaseadaptorGroupGeneticVariation]);
1068
1069 registryFunctionalGenomicsDel(
1070 (RegistryPFunctionalGenomics *)
1071 &pthis->Registry[ensEDatabaseadaptorGroupFunctionalGenomics]);
1072
1073 registryComparativeGenomicsDel(
1074 (RegistryPComparativeGenomics *)
1075 &pthis->Registry[ensEDatabaseadaptorGroupComparativeGenomics]);
1076
1077 registryOntologyDel(
1078 (RegistryPOntology *)
1079 &pthis->Registry[ensEDatabaseadaptorGroupOntology]);
1080
1081 registryQualityCheckDel(
1082 (RegistryPQualityCheck *)
1083 &pthis->Registry[ensEDatabaseadaptorGroupQualityCheck]);
1084
1085 ajMemFree((void **) Pentry);
1086
1087 return;
1088 }
1089
1090
1091
1092
1093 /* @funcstatic registryEntryTrace *********************************************
1094 **
1095 ** Trace a Registry Entry object.
1096 **
1097 ** @param [r] entry [const RegistryPEntry] Registry Entry object
1098 ** @param [r] level [ajuint] Indentation level
1099 **
1100 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1101 **
1102 ** @release 6.2.0
1103 ** @@
1104 ******************************************************************************/
1105
registryEntryTrace(const RegistryPEntry entry,ajuint level)1106 static AjBool registryEntryTrace(
1107 const RegistryPEntry entry,
1108 ajuint level)
1109 {
1110 AjPStr indent = NULL;
1111
1112 if (!entry)
1113 return ajFalse;
1114
1115 indent = ajStrNew();
1116
1117 ajStrAppendCountK(&indent, ' ', level * 2);
1118
1119 ajDebug("%SregistryEntryTrace %p\n"
1120 "%S Registry[0] NULL %p\n"
1121 "%S Registry[1] Core %p\n"
1122 "%S Registry[2] Vega %p\n"
1123 "%S Registry[3] Other Features %p\n"
1124 "%S Registry[4] Copy DNA %p\n"
1125 "%S Registry[5] Genetic Variation %p\n"
1126 "%S Registry[6] Functional Genomics %p\n"
1127 "%S Registry[7] Comparative Genomics %p\n"
1128 "%S Registry[8] Gene Ontology %p\n"
1129 "%S Registry[9] Quality Check %p\n",
1130 indent, entry,
1131 indent, entry->Registry[0],
1132 indent, entry->Registry[1],
1133 indent, entry->Registry[2],
1134 indent, entry->Registry[3],
1135 indent, entry->Registry[4],
1136 indent, entry->Registry[5],
1137 indent, entry->Registry[6],
1138 indent, entry->Registry[7],
1139 indent, entry->Registry[8],
1140 indent, entry->Registry[9]);
1141
1142 ajStrDel(&indent);
1143
1144 return ajTrue;
1145 }
1146
1147
1148
1149
1150 /* @funcstatic registryFunctionalGenomicsDel **********************************
1151 **
1152 ** Default destructor for a Registry Functional Genomics object.
1153 **
1154 ** @param [d] Prfg [RegistryPFunctionalGenomics*]
1155 ** Registry Functional Genomics address
1156 **
1157 ** @return [void]
1158 **
1159 ** @release 6.2.0
1160 ** @@
1161 ******************************************************************************/
1162
registryFunctionalGenomicsDel(RegistryPFunctionalGenomics * Prfg)1163 static void registryFunctionalGenomicsDel(
1164 RegistryPFunctionalGenomics *Prfg)
1165 {
1166 RegistryPFunctionalGenomics pthis = NULL;
1167
1168 if (!Prfg)
1169 return;
1170
1171 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1172 if (ajDebugTest("registryFunctionalGenomicsDel"))
1173 {
1174 ajDebug("registryFunctionalGenomicsDel\n"
1175 " *Prfg %p\n",
1176 *Prfg);
1177
1178 registryFunctionalGenomicsTrace(*Prfg, 1);
1179 }
1180 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1181
1182 if (!(pthis = *Prfg))
1183 return;
1184
1185 /* Delete all Ensembl Object Adaptors based on the Database Adaptor. */
1186
1187 /* Finally, delete the Ensembl Database Adaptor. */
1188
1189 ensDatabaseadaptorDel(&pthis->Databaseadaptor);
1190
1191 ajMemFree((void **) Prfg);
1192
1193 return;
1194 }
1195
1196
1197
1198
1199 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1200 /* @funcstatic registryFunctionalGenomicsTrace ********************************
1201 **
1202 ** Trace a Registry Functional Genomics object.
1203 **
1204 ** @param [r] rfg [const RegistryPFunctionalGenomics]
1205 ** Registry Functional Genomics object
1206 ** @param [r] level [ajuint] Indentation level
1207 **
1208 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1209 **
1210 ** @release 6.4.0
1211 ** @@
1212 ******************************************************************************/
1213
registryFunctionalGenomicsTrace(const RegistryPFunctionalGenomics rfg,ajuint level)1214 static AjBool registryFunctionalGenomicsTrace(
1215 const RegistryPFunctionalGenomics rfg,
1216 ajuint level)
1217 {
1218 AjPStr indent = NULL;
1219
1220 if (!rfg)
1221 return ajFalse;
1222
1223 indent = ajStrNew();
1224
1225 ajStrAppendCountK(&indent, ' ', level * 2);
1226
1227 ajDebug("%registryFunctionalGenomicsTrace %p\n"
1228 "%S Databaseadaptor %p\n",
1229 indent, rfg,
1230 indent, rfg->Databaseadaptor);
1231
1232 ensDatabaseadaptorTrace(rfg->Databaseadaptor, level + 1);
1233
1234 ajStrDel(&indent);
1235
1236 return ajTrue;
1237 }
1238 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1239
1240
1241
1242
1243 /* @funcstatic registryGeneticVariationDel ************************************
1244 **
1245 ** Default destructor for a Registry Genetic Variation object.
1246 **
1247 ** @param [d] Prgv [RegistryPGeneticVariation*]
1248 ** Registry Genetic Variation address
1249 **
1250 ** @return [void]
1251 **
1252 ** @release 6.2.0
1253 ** @@
1254 ******************************************************************************/
1255
registryGeneticVariationDel(RegistryPGeneticVariation * Prgv)1256 static void registryGeneticVariationDel(
1257 RegistryPGeneticVariation *Prgv)
1258 {
1259 RegistryPGeneticVariation pthis = NULL;
1260
1261 if (!Prgv)
1262 return;
1263
1264 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1265 if (ajDebugTest("registryGeneticVariationDel"))
1266 {
1267 ajDebug("registryGeneticVariationDel\n"
1268 " *Prgv %p\n",
1269 *Prgv);
1270
1271 registryGeneticVariationTrace(*Prgv, 1);
1272 }
1273 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1274
1275 if (!(pthis = *Prgv))
1276 return;
1277
1278 /* Delete all Ensembl Object Adaptors based on the Database Adaptor. */
1279
1280 ensGvalleleadaptorDel(
1281 &pthis->Gvalleleadaptor);
1282
1283 ensGvattributeadaptorDel(
1284 &pthis->Gvattributeadaptor);
1285
1286 ensGvgenotypecodeadaptorDel(
1287 &pthis->Gvgenotypecodeadaptor);
1288
1289 ensGvindividualadaptorDel(
1290 &pthis->Gvindividualadaptor);
1291
1292 ensGvpopulationadaptorDel(
1293 &pthis->Gvpopulationadaptor);
1294
1295 ensGvpopulationgenotypeadaptorDel(
1296 &pthis->Gvpopulationgenotypeadaptor);
1297
1298 ensGvsampleadaptorDel(
1299 &pthis->Gvsampleadaptor);
1300
1301 ensGvsourceadaptorDel(
1302 &pthis->Gvsourceadaptor);
1303
1304 ensGvvariationadaptorDel(
1305 &pthis->Gvvariationadaptor);
1306
1307 ensGvvariationfeatureadaptorDel(
1308 &pthis->Gvvariationfeatureadaptor);
1309
1310 ensGvvariationsetadaptorDel(
1311 &pthis->Gvvariationsetadaptor);
1312
1313 /* Finally, delete the Ensembl Database Adaptor. */
1314
1315 ensGvdatabaseadaptorDel(
1316 &pthis->Gvdatabaseadaptor);
1317
1318 ensDatabaseadaptorDel(
1319 &pthis->Databaseadaptor);
1320
1321 ajMemFree((void **) Prgv);
1322
1323 return;
1324 }
1325
1326
1327
1328
1329 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1330 /* @funcstatic registryGeneticVariationTrace **********************************
1331 **
1332 ** Trace a Registry Genetic Variation object.
1333 **
1334 ** @param [r] rgv [const RegistryPGeneticVariation] Registry Genetic Variation
1335 ** object
1336 ** @param [r] level [ajuint] Indentation level
1337 **
1338 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1339 **
1340 ** @release 6.4.0
1341 ** @@
1342 ******************************************************************************/
1343
registryGeneticVariationTrace(const RegistryPGeneticVariation rgv,ajuint level)1344 static AjBool registryGeneticVariationTrace(
1345 const RegistryPGeneticVariation rgv,
1346 ajuint level)
1347 {
1348 AjPStr indent = NULL;
1349
1350 if (!rgv)
1351 return ajFalse;
1352
1353 indent = ajStrNew();
1354
1355 ajStrAppendCountK(&indent, ' ', level * 2);
1356
1357 ajDebug("%registryGeneticVariationTrace %p\n"
1358 "%S Databaseadaptor %p\n"
1359 "%S Gvalleleadaptor %p\n"
1360 "%S Gvdatabaseadaptor %p\n"
1361 "%S Gvindividualadaptor %p\n"
1362 "%S Gvpopulationadaptor %p\n"
1363 "%S Gvpopulationgenotypeadaptor %p\n"
1364 "%S Gvsampleadaptor %p\n"
1365 "%S Gvsourceadaptor %p\n"
1366 "%S Gvvariationfeatureadaptor %p\n"
1367 "%S Gvvariationsetadaptor %p\n",
1368 indent, rgv,
1369 indent, rgv->Databaseadaptor,
1370 indent, rgv->Gvalleleadaptor,
1371 indent, rgv->Gvdatabaseadaptor,
1372 indent, rgv->Gvindividualadaptor,
1373 indent, rgv->Gvpopulationadaptor,
1374 indent, rgv->Gvpopulationgenotypeadaptor,
1375 indent, rgv->Gvsampleadaptor,
1376 indent, rgv->Gvsourceadaptor,
1377 indent, rgv->Gvvariationfeatureadaptor,
1378 indent, rgv->Gvvariationsetadaptor);
1379
1380 ensDatabaseadaptorTrace(rgv->Databaseadaptor, level + 1);
1381
1382 ajStrDel(&indent);
1383
1384 return ajTrue;
1385 }
1386 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1387
1388
1389
1390
1391 /* @funcstatic registryIdentifierNew ******************************************
1392 **
1393 ** Default constructor for a Registry Identifier object.
1394 **
1395 ** @param [u] expression [AjPStr] Regular expression
1396 ** @param [u] species [AjPStr] Ensembl Database Adaptor species
1397 ** @param [u] dbag [EnsEDatabaseadaptorGroup]
1398 ** Ensembl Database Adaptor Group enumeration
1399 **
1400 ** @return [RegistryPIdentifier] Registry Identifier object or NULL
1401 **
1402 ** @release 6.2.0
1403 ** @@
1404 ******************************************************************************/
1405
registryIdentifierNew(AjPStr expression,AjPStr species,EnsEDatabaseadaptorGroup dbag)1406 static RegistryPIdentifier registryIdentifierNew(
1407 AjPStr expression,
1408 AjPStr species,
1409 EnsEDatabaseadaptorGroup dbag)
1410 {
1411 RegistryPIdentifier ri = NULL;
1412
1413 if (!expression)
1414 return NULL;
1415
1416 if (!species)
1417 return NULL;
1418
1419 if (!dbag)
1420 return NULL;
1421
1422 AJNEW0(ri);
1423
1424 ri->RegularExpression = ajStrNewS(expression);
1425 ri->SpeciesName = ajStrNewS(species);
1426 ri->Group = dbag;
1427
1428 return ri;
1429 }
1430
1431
1432
1433
1434 /* @funcstatic registryIdentifierDel ******************************************
1435 **
1436 ** Default destructor for a Registry Identifier object.
1437 **
1438 ** @param [d] Pri [RegistryPIdentifier*] Registry Identifier object address
1439 **
1440 ** @return [void]
1441 **
1442 ** @release 6.2.0
1443 ** @@
1444 ******************************************************************************/
1445
registryIdentifierDel(RegistryPIdentifier * Pri)1446 static void registryIdentifierDel(
1447 RegistryPIdentifier *Pri)
1448 {
1449 RegistryPIdentifier pthis = NULL;
1450
1451 if (!Pri)
1452 return;
1453
1454 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1455 if (ajDebugTest("registryIdentifierDel"))
1456 {
1457 ajDebug("registryIdentifierDel\n"
1458 " *Pri %p\n",
1459 *Pri);
1460
1461 registryIdentifierTrace(*Pri, 1);
1462 }
1463 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1464
1465 if (!(pthis = *Pri))
1466 return;
1467
1468 ajStrDel(&pthis->RegularExpression);
1469 ajStrDel(&pthis->SpeciesName);
1470
1471 ajMemFree((void **) Pri);
1472
1473 return;
1474 }
1475
1476
1477
1478
1479 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1480 /* @funcstatic registryIdentifierTrace ****************************************
1481 **
1482 ** Trace a Registry Identifier object.
1483 **
1484 ** @param [r] ri [const RegistryPIdentifier] Registry Identifier object
1485 ** @param [r] level [ajuint] Indentation level
1486 **
1487 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1488 **
1489 ** @release 6.5.0
1490 ** @@
1491 ******************************************************************************/
1492
registryIdentifierTrace(const RegistryPIdentifier ri,ajuint level)1493 static AjBool registryIdentifierTrace(
1494 const RegistryPIdentifier ri,
1495 ajuint level)
1496 {
1497 AjPStr indent = NULL;
1498
1499 if (!ri)
1500 return ajFalse;
1501
1502 indent = ajStrNew();
1503
1504 ajStrAppendCountK(&indent, ' ', level * 2);
1505
1506 ajDebug("%registryIdentifierTrace %p\n"
1507 "%S RegularExpression '%S'\n"
1508 "%S SpeciesName '%S'\n",
1509 indent, ri,
1510 indent, ri->RegularExpression,
1511 indent, ri->SpeciesName);
1512
1513 ajStrDel(&indent);
1514
1515 return ajTrue;
1516 }
1517 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1518
1519
1520
1521
1522 /* @funcstatic registryOntologyDel ********************************************
1523 **
1524 ** Default destructor for a Registry Ontology object.
1525 **
1526 ** @param [d] Pro [RegistryPOntology*] Registry Ontology object address
1527 **
1528 ** @return [void]
1529 **
1530 ** @release 6.3.0
1531 ** @@
1532 ******************************************************************************/
1533
registryOntologyDel(RegistryPOntology * Pro)1534 static void registryOntologyDel(
1535 RegistryPOntology *Pro)
1536 {
1537 RegistryPOntology pthis = NULL;
1538
1539 if (!Pro)
1540 return;
1541
1542 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1543 if (ajDebugTest("registryOntologyDel"))
1544 {
1545 ajDebug("registryOntologyDel\n"
1546 " *Pro %p\n",
1547 *Pro);
1548
1549 registryOntologyTrace(*Pro, 1);
1550 }
1551 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1552
1553 if (!(pthis = *Pro))
1554 return;
1555
1556 /* Delete all Ensembl Object Adaptors based on the Database Adaptor. */
1557
1558 ensOntologyadaptorDel(
1559 &pthis->Ontologyadaptor);
1560
1561 ensOntologytermadaptorDel(
1562 &pthis->Ontologytermadaptor);
1563
1564 /* Finally, delete the Ensembl Database Adaptor. */
1565
1566 ensDatabaseadaptorDel(&pthis->Databaseadaptor);
1567
1568 ajMemFree((void **) Pro);
1569
1570 return;
1571 }
1572
1573
1574
1575
1576 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1577 /* @funcstatic registryOntologyTrace ******************************************
1578 **
1579 ** Trace a Registry Ontology object.
1580 **
1581 ** @param [r] ro [const RegistryPOntology] Registry Ontology object
1582 ** @param [r] level [ajuint] Indentation level
1583 **
1584 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1585 **
1586 ** @release 6.4.0
1587 ** @@
1588 ******************************************************************************/
1589
registryOntologyTrace(const RegistryPOntology ro,ajuint level)1590 static AjBool registryOntologyTrace(
1591 const RegistryPOntology ro,
1592 ajuint level)
1593 {
1594 AjPStr indent = NULL;
1595
1596 if (!ro)
1597 return ajFalse;
1598
1599 indent = ajStrNew();
1600
1601 ajStrAppendCountK(&indent, ' ', level * 2);
1602
1603 ajDebug("%registryOntologyTrace %p\n"
1604 "%S Databaseadaptor %p\n"
1605 "%S Ontologyadaptor %p\n"
1606 "%S Ontologytermadaptor %p\n",
1607 indent, ro,
1608 indent, ro->Databaseadaptor,
1609 indent, ro->Ontologyadaptor,
1610 indent, ro->Ontologytermadaptor);
1611
1612 ensDatabaseadaptorTrace(ro->Databaseadaptor, level + 1);
1613
1614 ajStrDel(&indent);
1615
1616 return ajTrue;
1617 }
1618 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1619
1620
1621
1622
1623 /* @funcstatic registryQualityCheckDel ****************************************
1624 **
1625 ** Default destructor for a Registry Quality Check object.
1626 **
1627 ** @param [d] Prqc [RegistryPQualityCheck*] Registry Quality Check address
1628 **
1629 ** @return [void]
1630 **
1631 ** @release 6.2.0
1632 ** @@
1633 ******************************************************************************/
1634
registryQualityCheckDel(RegistryPQualityCheck * Prqc)1635 static void registryQualityCheckDel(
1636 RegistryPQualityCheck *Prqc)
1637 {
1638 RegistryPQualityCheck pthis = NULL;
1639
1640 if (!Prqc)
1641 return;
1642
1643 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1644 if (ajDebugTest("registryQualityCheckDel"))
1645 {
1646 ajDebug("registryQualityCheckDel\n"
1647 " *Prqc %p\n",
1648 *Prqc);
1649
1650 registryQualityCheckTrace(*Prqc, 1);
1651 }
1652 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1653
1654 if (!(pthis = *Prqc))
1655 return;
1656
1657 /* Delete all Ensembl Object Adaptors based on the Database Adaptor. */
1658
1659 ensQcalignmentadaptorDel(
1660 &pthis->Qcalignmentadaptor);
1661
1662 ensQcdasfeatureadaptorDel(
1663 &pthis->Qcdasfeatureadaptor);
1664
1665 ensQcdatabaseadaptorDel(
1666 &pthis->Qcdatabaseadaptor);
1667
1668 ensQcsequenceadaptorDel(
1669 &pthis->Qcsequenceadaptor);
1670
1671 ensQcsubmissionadaptorDel(
1672 &pthis->Qcsubmissionadaptor);
1673
1674 ensQcvariationadaptorDel(
1675 &pthis->Qcvariationadaptor);
1676
1677 /* Finally, delete the Ensembl Database Adaptor. */
1678
1679 ensDatabaseadaptorDel(
1680 &pthis->Databaseadaptor);
1681
1682 ajMemFree((void **) Prqc);
1683
1684 return;
1685 }
1686
1687
1688
1689
1690 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1691 /* @funcstatic registryQualityCheckTrace **************************************
1692 **
1693 ** Trace a Registry Quality Check object.
1694 **
1695 ** @param [r] rqc [const RegistryPQualityCheck] Registry Quality Check object
1696 ** @param [r] level [ajuint] Indentation level
1697 **
1698 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1699 **
1700 ** @release 6.4.0
1701 ** @@
1702 ******************************************************************************/
1703
registryQualityCheckTrace(const RegistryPQualityCheck rqc,ajuint level)1704 static AjBool registryQualityCheckTrace(
1705 const RegistryPQualityCheck rqc,
1706 ajuint level)
1707 {
1708 AjPStr indent = NULL;
1709
1710 if (!rqc)
1711 return ajFalse;
1712
1713 indent = ajStrNew();
1714
1715 ajStrAppendCountK(&indent, ' ', level * 2);
1716
1717 ajDebug("%registryQualityCheckTrace %p\n"
1718 "%S Databaseadaptor %p\n"
1719 "%S Qcalignmentadaptor %p\n"
1720 "%S Qcdasfeatureadaptor %p\n"
1721 "%S Qcdatabaseadaptor %p\n"
1722 "%S Qcsequenceadaptor %p\n"
1723 "%S Qcsubmissionadaptor %p\n"
1724 "%S Qcvariationadaptor %p\n",
1725 indent, rqc,
1726 indent, rqc->Databaseadaptor,
1727 indent, rqc->Qcalignmentadaptor,
1728 indent, rqc->Qcdasfeatureadaptor,
1729 indent, rqc->Qcdatabaseadaptor,
1730 indent, rqc->Qcsequenceadaptor,
1731 indent, rqc->Qcsubmissionadaptor,
1732 indent, rqc->Qcvariationadaptor);
1733
1734 ensDatabaseadaptorTrace(rqc->Databaseadaptor, level + 1);
1735
1736 ajStrDel(&indent);
1737
1738 return ajTrue;
1739 }
1740 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1741
1742
1743
1744
1745 /* @datasection [none] Ensembl Registry Internals *****************************
1746 **
1747 ** Functions to control Ensembl Registry Internals
1748 **
1749 ** @cc Bio::EnsEMBL::Registry
1750 ** @cc CVS Revision: 1.227.4.2
1751 ** @cc CVS Tag: branch-ensembl-68
1752 **
1753 ******************************************************************************/
1754
1755
1756
1757
1758 /* @section Internals *********************************************************
1759 **
1760 ** @fdata [none]
1761 **
1762 ** @nam3rule Clear Clear Ensembl Registry internals
1763 ** @nam3rule Exit Clear and free Ensembl Registry internals
1764 ** @nam3rule Init Initialise Ensembl Registry internals
1765 **
1766 ** @valrule * [void]
1767 **
1768 ** @fcategory internals
1769 ******************************************************************************/
1770
1771
1772
1773
1774 /* @func ensRegistryClear *****************************************************
1775 **
1776 ** Clear Ensembl Registry internals.
1777 **
1778 ** @return [void]
1779 **
1780 ** @release 6.2.0
1781 ** @@
1782 ******************************************************************************/
1783
ensRegistryClear(void)1784 void ensRegistryClear(void)
1785 {
1786 ensRegistryAliasClear();
1787
1788 ensRegistryEntryClear();
1789
1790 ensRegistryIdentifierClear();
1791
1792 return;
1793 }
1794
1795
1796
1797
1798 /* @func ensRegistryExit ******************************************************
1799 **
1800 ** Clear and free Ensembl Registry internals.
1801 **
1802 ** @return [void]
1803 **
1804 ** @release 6.2.0
1805 ** @@
1806 ******************************************************************************/
1807
ensRegistryExit(void)1808 void ensRegistryExit(void)
1809 {
1810 ensRegistryClear();
1811
1812 ajTableDel(®istryGAlias);
1813 ajTableDel(®istryGEntry);
1814 ajTableDel(®istryGSource);
1815
1816 ajListFree(®istryGIdentifier);
1817
1818 return;
1819 }
1820
1821
1822
1823
1824 /* @func ensRegistryInit ******************************************************
1825 **
1826 ** Initialise Ensembl Registry internals.
1827 **
1828 ** @return [void]
1829 **
1830 ** @release 6.2.0
1831 ** @@
1832 ******************************************************************************/
1833
ensRegistryInit(void)1834 void ensRegistryInit(void)
1835 {
1836 registryGAlias = ajTablestrNew(0U);
1837 registryGEntry = ajTablestrNew(0U);
1838 registryGSource = ajTablestrNew(0U);
1839
1840 ajTableSetDestroyvalue(registryGAlias,
1841 (void (*)(void **)) &ajStrDel);
1842 ajTableSetDestroyvalue(registryGEntry,
1843 (void (*)(void **)) ®istryEntryDel);
1844 ajTableSetDestroyvalue(registryGSource, &ajMemFree);
1845
1846 registryGIdentifier = ajListNew();
1847
1848 return;
1849 }
1850
1851
1852
1853
1854 /* @section Load **************************************************************
1855 **
1856 ** @fdata [none]
1857 **
1858 ** @nam3rule Load Load Ensembl Registry internals
1859 ** @nam4rule Databaseconnection Load from an Ensembl Database Connection
1860 ** @nam4rule Filename Load from an EMBOSS data file
1861 ** @nam4rule Servername Load via an AJAX Server name
1862 **
1863 ** @argrule Databaseconnection dbc [EnsPDatabaseconnection]
1864 ** Ensembl Database Connection
1865 ** @argrule Filename filename [const AjPStr] EMBOSS data file name
1866 ** @argrule Servername servername [AjPStr] AJAX Server name
1867 **
1868 ** @valrule * [ajuint] Number of Ensembl Database Adaptor objects registered
1869 **
1870 ** @fcategory internals
1871 ******************************************************************************/
1872
1873
1874
1875
1876 /* @func ensRegistryLoadDatabaseconnection ************************************
1877 **
1878 ** Load Ensembl Registry internals from an Ensembl Database Connection.
1879 **
1880 ** @param [u] dbc [EnsPDatabaseconnection] Ensembl Database Connection
1881 **
1882 ** @return [ajuint] Number of Ensembl Database Adaptor objects registered
1883 **
1884 ** @release 6.4.0
1885 ** @@
1886 ** NOTE: In this implementation the reference adaptor is not set during
1887 ** registration of core-style, but non-core databases (i.e. cdna,
1888 ** otherfeatures, vega databases). The ensRegistryGetReferenceadaptor function
1889 ** checks a hierarchy of Ensembl Database Adaptors to return an appropriate one
1890 ** in case none has been explicitly set as reference adaptor.
1891 ** Bio::EnsEMBL::Utils::ConfigRegistry::load_core
1892 ** Bio::EnsEMBL::Utils::ConfigRegistry::load_adaptors
1893 ** Bio::EnsEMBL::Utils::ConfigRegistry::load_and_attach_dnadb_to_core
1894 ******************************************************************************/
1895
ensRegistryLoadDatabaseconnection(EnsPDatabaseconnection dbc)1896 ajuint ensRegistryLoadDatabaseconnection(EnsPDatabaseconnection dbc)
1897 {
1898 ajuint *Presult = NULL;
1899
1900 ajuint result = 0U;
1901
1902 AjBool debug = AJFALSE;
1903
1904 AjPRegexp rec = NULL;
1905 AjPRegexp rem = NULL;
1906 AjPRegexp res = NULL;
1907
1908 AjPSqlstatement sqls = NULL;
1909 AjISqlrow sqli = NULL;
1910 AjPSqlrow sqlr = NULL;
1911
1912 AjPStr statement = NULL;
1913 AjPStr dbname = NULL;
1914 AjPStr group = NULL;
1915 AjPStr prefix = NULL;
1916 AjPStr swversion = NULL;
1917 AjPStr multi = NULL;
1918 AjPStr source = NULL;
1919
1920 EnsEDatabaseadaptorGroup dbag = ensEDatabaseadaptorGroupNULL;
1921
1922 EnsPDatabaseadaptor dba = NULL;
1923
1924 debug = ajDebugTest("ensRegistryLoadDatabaseconnection");
1925
1926 if (debug)
1927 {
1928 ajDebug("ensRegistryLoadDatabaseconnection\n"
1929 " dbc %p\n",
1930 dbc);
1931
1932 ensDatabaseconnectionTrace(dbc, 1);
1933
1934 ajDebug("ensRegistryLoadDatabaseconnection "
1935 "software version '%s'.\n",
1936 ensKSoftwareVersion);
1937 }
1938
1939 if (!dbc)
1940 return 0U;
1941
1942 /* Check if this Ensembl Database Connection has been registered before. */
1943
1944 ensDatabaseconnectionFetchUrl(dbc, &source);
1945
1946 if ((Presult = ajTablestrFetchS(registryGSource, source)))
1947 {
1948 ajStrDel(&source);
1949
1950 return *Presult;
1951 }
1952
1953 multi = ajStrNewC("default");
1954
1955 rec = ajRegCompC(ensKDatabaseadaptorRegCollection);
1956 rem = ajRegCompC(ensKDatabaseadaptorRegMulti);
1957 res = ajRegCompC(ensKDatabaseadaptorRegSpecies);
1958
1959 statement = ajStrNewC("SHOW DATABASES");
1960
1961 sqls = ensDatabaseconnectionSqlstatementNew(dbc, statement);
1962
1963 if (!sqls)
1964 ajFatal("ensRegistryLoadDatabaseconnection "
1965 "SQL statement failed.\n"
1966 "Please check the SQL server address '%S', "
1967 "your network connection or that any firewalls "
1968 "permit outgong TCP/IP connections on port '%S'.\n",
1969 ensDatabaseconnectionGetHostname(dbc),
1970 ensDatabaseconnectionGetHostport(dbc));
1971
1972 sqli = ajSqlrowiterNew(sqls);
1973
1974 while (!ajSqlrowiterDone(sqli))
1975 {
1976 dbname = ajStrNew();
1977
1978 sqlr = ajSqlrowiterGet(sqli);
1979
1980 ajSqlcolumnToStr(sqlr, &dbname);
1981
1982 if (ajRegExec(rec, dbname))
1983 {
1984 /* Ensembl Collection databases have to be matched first. */
1985
1986 group = ajStrNew();
1987 swversion = ajStrNew();
1988
1989 ajRegSubI(rec, 2, &group);
1990 ajRegSubI(rec, 3, &swversion);
1991
1992 if (ajStrMatchCaseC(swversion, ensKSoftwareVersion))
1993 {
1994 if (debug)
1995 ajDebug("ensRegistryLoadDatabaseconnection '%S' "
1996 "collection matched\n",
1997 dbname);
1998
1999 dbag = ensDatabaseadaptorGroupFromStr(group);
2000
2001 if (dbag)
2002 result += registryEntryLoadCollection(dbc, dbname, dbag);
2003 else
2004 ajDebug("ensRegistryLoadDatabaseconnection got unexpected "
2005 "group string '%S' for database name '%S'.\n",
2006 group, dbname);
2007 }
2008 else
2009 {
2010 if (debug)
2011 ajDebug("ensRegistryLoadDatabaseconnection '%S' "
2012 "collection\n",
2013 dbname);
2014 }
2015
2016 ajStrDel(&group);
2017 ajStrDel(&swversion);
2018 }
2019 else if (ajRegExec(rem, dbname))
2020 {
2021 /* Multi-species databases */
2022
2023 group = ajStrNew();
2024 prefix = ajStrNew();
2025 swversion = ajStrNew();
2026
2027 ajRegSubI(rem, 1, &group);
2028
2029 if (ajRegLenI(rem, 3))
2030 {
2031 ajRegSubI(rem, 2, &prefix);
2032 ajRegSubI(rem, 3, &swversion);
2033
2034 /* Remove leading underscores from the species prefix. */
2035
2036 if (ajStrPrefixC(prefix, "_"))
2037 ajStrCutStart(&prefix, 1);
2038 }
2039 else
2040 ajRegSubI(rem, 2, &swversion);
2041
2042 if (ajStrMatchCaseC(swversion, ensKSoftwareVersion))
2043 {
2044 if (debug)
2045 ajDebug("ensRegistryLoadDatabaseconnection '%S' "
2046 "multi-species matched\n",
2047 dbname);
2048
2049 dbag = ensDatabaseadaptorGroupFromStr(group);
2050
2051 if (dbag)
2052 {
2053 dba = ensRegistryNewDatabaseadaptor(
2054 dbc,
2055 dbname,
2056 (ajStrGetLen(prefix)) ? prefix : multi,
2057 dbag,
2058 ajFalse,
2059 0);
2060
2061 if (dba)
2062 result++;
2063 }
2064 else
2065 ajDebug("ensRegistryLoadDatabaseconnection got unexpected "
2066 "group string '%S' for database name '%S'.\n",
2067 group, dbname);
2068 }
2069 else
2070 {
2071 if (debug)
2072 ajDebug("ensRegistryLoadDatabaseconnection '%S' "
2073 "multi-species\n",
2074 dbname);
2075 }
2076
2077 ajStrDel(&group);
2078 ajStrDel(&prefix);
2079 ajStrDel(&swversion);
2080 }
2081 else if (ajRegExec(res, dbname))
2082 {
2083 /* Species-specific databases */
2084
2085 prefix = ajStrNew();
2086 group = ajStrNew();
2087 swversion = ajStrNew();
2088
2089 ajRegSubI(res, 1, &prefix);
2090 ajRegSubI(res, 2, &group);
2091 ajRegSubI(res, 3, &swversion);
2092
2093 if (ajStrMatchCaseC(swversion, ensKSoftwareVersion))
2094 {
2095 if (debug)
2096 ajDebug("ensRegistryLoadDatabaseconnection '%S' "
2097 "species-specific matched\n",
2098 dbname);
2099
2100 dbag = ensDatabaseadaptorGroupFromStr(group);
2101
2102 if (dbag)
2103 {
2104 dba = ensRegistryNewDatabaseadaptor(
2105 dbc,
2106 dbname,
2107 prefix,
2108 dbag,
2109 ajFalse,
2110 0);
2111
2112 if (dba)
2113 {
2114 registryAliasLoadDatabaseconnection(dbc, dba);
2115
2116 result++;
2117 }
2118 }
2119 else
2120 ajDebug("ensRegistryLoadDatabaseconnection got unexpected "
2121 "group string '%S' for database name '%S'.\n",
2122 group, dbname);
2123 }
2124 else
2125 {
2126 if (debug)
2127 ajDebug("ensRegistryLoadDatabaseconnection '%S' "
2128 "species-specific\n",
2129 dbname);
2130 }
2131
2132 ajStrDel(&prefix);
2133 ajStrDel(&group);
2134 ajStrDel(&swversion);
2135 }
2136 else
2137 ajDebug("ensRegistryLoadDatabaseconnection '%S' no match\n",
2138 dbname);
2139
2140 ajStrDel(&dbname);
2141 }
2142
2143 ajSqlrowiterDel(&sqli);
2144
2145 ensDatabaseconnectionSqlstatementDel(dbc, &sqls);
2146
2147 ajRegFree(&rec);
2148 ajRegFree(&rem);
2149 ajRegFree(&res);
2150
2151 /*
2152 ** Register this source. The AJAX String object source remains with the
2153 ** AJAX Table object.
2154 */
2155
2156 AJNEW0(Presult);
2157 *Presult = result;
2158
2159 ajTablePut(registryGSource, (void *) source, (void *) Presult);
2160
2161 Presult = NULL;
2162 source = NULL;
2163
2164 ajStrDel(&statement);
2165 ajStrDel(&multi);
2166
2167 if (debug)
2168 {
2169 ajDebug("ensRegistryLoadDatabaseconnection\n");
2170
2171 ensRegistryAliasTrace(1U);
2172 ensRegistryEntryTrace(1U);
2173 ensRegistrySourceTrace(1U);
2174 }
2175
2176 return result;
2177 }
2178
2179
2180
2181
2182 /* @func ensRegistryLoadServername ********************************************
2183 **
2184 ** Load Ensembl Registry internals via an AJAX Server name.
2185 **
2186 ** @param [uN] servername [AjPStr] AJAX Server name (optional)
2187 **
2188 ** @return [ajuint] Number of Ensembl Database Adaptor objects registered
2189 **
2190 ** @release 6.4.0
2191 ** @@
2192 ******************************************************************************/
2193
ensRegistryLoadServername(AjPStr servername)2194 ajuint ensRegistryLoadServername(AjPStr servername)
2195 {
2196 ajuint *Presult = NULL;
2197
2198 ajuint adaptors = 0U;
2199 ajuint dbid = 0U;
2200 ajuint result = 0U;
2201
2202 AjBool debug = AJFALSE;
2203
2204 AjIList dbniter = NULL;
2205 AjIList svriter = NULL;
2206 AjPList svrnames = NULL;
2207 AjPList dbnames = NULL;
2208
2209 AjPStr dbname = NULL;
2210 AjPStr source = NULL;
2211 AjPStr svrname = NULL;
2212 AjPStr urlpfx = NULL;
2213 AjPStr value = NULL;
2214
2215 EnsPDatabaseadaptor dba = NULL;
2216
2217 EnsPDatabaseconnection dbc = NULL;
2218
2219 debug = ajDebugTest("ensRegistryLoadServername");
2220
2221 if (debug)
2222 ajDebug("ensRegistryLoadServername\n"
2223 " servername '%S'\n",
2224 servername);
2225
2226 /*
2227 ** Since the AJAX String objects on the AJAX String List objects for
2228 ** server and database names are not owned by the caller, the AJAX String
2229 ** List objects must be re-created and freed for each server.
2230 */
2231
2232 source = ajStrNew();
2233 value = ajStrNew();
2234
2235 svrnames = ajListstrNew();
2236
2237 if ((servername != NULL) && (ajStrGetLen(servername) > 0))
2238 ajListstrPushAppend(svrnames, servername);
2239 else
2240 ajNamListListServers(svrnames);
2241
2242 svriter = ajListIterNewread(svrnames);
2243
2244 while (!ajListIterDone(svriter))
2245 {
2246 svrname = ajListstrIterGet(svriter);
2247
2248 /*
2249 ** Only AJAX Server definitions with
2250 ** attribute key "method" and
2251 ** attribute value "ensembl" are relevant.
2252 */
2253
2254 if (!ajNamSvrGetAttrC(svrname, "method", &value))
2255 {
2256 ajWarn("ensRegistryLoadServername could not get "
2257 "attribute key 'method' for server name '%S'.",
2258 svrname);
2259 continue;
2260 }
2261
2262 if (debug)
2263 ajDebug("ensRegistryLoadServername got "
2264 "server name '%S' method '%S'.\n",
2265 svrname, value);
2266
2267 if (!ajStrMatchC(value, "ensembl"))
2268 continue;
2269
2270 /* Register the AJAX Server as Registry Source entry via an URL. */
2271
2272 ajStrAssignC(&source, "file:///");
2273 if (ajNamSvrGetAttrC(svrname, "cachedirectory", &value))
2274 {
2275 /*
2276 ** FIXME: It would be good if the namSvrCacheOpen function
2277 ** in the ajnam module could populate the "cachedirectory"
2278 ** attribute somehow. This would also no longer reqiuire
2279 ** another namSvrCacheOpen in ajNamSvrDetails, as the
2280 ** full path would be available.
2281 */
2282 ajStrAppendS(&source, value);
2283 ajStrAppendC(&source, "/");
2284 }
2285 if (ajNamSvrGetAttrC(svrname, "cachefile", &value))
2286 ajStrAppendS(&source, value);
2287 else
2288 {
2289 ajWarn("ensRegistryLoadServername could not get "
2290 "attribute key 'cachefile' for server name '%S'.",
2291 svrname);
2292 continue;
2293 }
2294
2295 if (debug)
2296 ajDebug("ensRegistryLoadServername register '%S' from "
2297 "source '%S'.\n",
2298 svrname, source);
2299
2300 if ((Presult = ajTablestrFetchS(registryGSource, source)))
2301 {
2302 if (debug)
2303 ajDebug("ensRegistryLoadServername '%S' already "
2304 "registered via source '%S'.\n",
2305 svrname, source);
2306 result += *Presult;
2307 continue;
2308 }
2309
2310 /*
2311 ** Create an Ensembl Database Connection to the AJAX Server for
2312 ** stream-lining subsequent SQL requests.
2313 */
2314
2315 if (!ajNamSvrGetAttrC(svrname, "url", &value))
2316 {
2317 ajWarn("ensRegistryLoadServername could not get "
2318 "attribute key 'url' for server name '%S'.",
2319 svrname);
2320 continue;
2321 }
2322
2323 dbc = ensDatabaseconnectionNewUrl(value);
2324
2325 if (!dbc)
2326 {
2327 ajDebug("ensRegistryLoadServer could not create an "
2328 "Ensembl Database Connection for server name '%S' "
2329 "and URL '%S'.\n",
2330 svrname, value);
2331 continue;
2332 }
2333
2334 ajStrAssignS(&urlpfx, value);
2335
2336 if (ajStrGetCharLast(urlpfx) != '/')
2337 ajStrAppendK(&urlpfx, '/');
2338
2339 /* Get all database names for this AJAX Server. */
2340
2341 adaptors = 0U;
2342
2343 dbnames = ajListstrNew();
2344
2345 ajNamSvrListListDatabases(svrname, dbnames);
2346
2347 dbniter = ajListIterNew(dbnames);
2348
2349 while (!ajListIterDone(dbniter))
2350 {
2351 dbname = ajListstrIterGet(dbniter);
2352
2353 if (!ajNamSvrGetdbAttrC(svrname, dbname, "dbalias", &value))
2354 {
2355 ajWarn("ensRegistryLoadServername could not get "
2356 "attribute key 'dbalias' for "
2357 "database name '%S' and "
2358 "server name '%S'.",
2359 dbname, svrname);
2360 continue;
2361 }
2362
2363 ajStrInsertS(&value, 0, urlpfx);
2364
2365 dba = ensDatabaseadaptorNewUrl(value);
2366
2367 if (ensDatabaseadaptorGetMultispecies(dba) == ajTrue)
2368 {
2369 /*
2370 ** For Ensembl Database Adaptor objects representing
2371 ** collection databases, the species name needs resetting
2372 ** to the AJAX database name and the species identifier
2373 ** needs parsing from the "special" field of the AJAX
2374 ** server database definition.
2375 */
2376
2377 ensDatabaseadaptorSetSpecies(dba, dbname);
2378
2379 if (ajNamSvrGetdbAttrSpecialC(
2380 svrname, dbname, "SpeciesIdentifier", &value) == 1)
2381 {
2382 /* Trim a trailing ';' character. */
2383
2384 if (ajStrGetCharLast(value) == ';')
2385 ajStrCutEnd(&value, 1);
2386
2387 dbid = 0U;
2388
2389 if (ajStrToUint(value, &dbid))
2390 ensDatabaseadaptorSetIdentifier(dba, dbid);
2391 else
2392 {
2393 ajDebug("ensRegistryLoadServer could not parse a "
2394 "valid unsigned integer from the "
2395 "\"SpeciesIdentifer=INTEGER\" expression "
2396 "'%S' in the \"special\" field of AJAX "
2397 "database definition for "
2398 "Ensembl collection database '%S'.\n",
2399 value, dbname);
2400
2401 ensDatabaseadaptorDel(&dba);
2402
2403 continue;
2404 }
2405 }
2406 else
2407 {
2408 ajDebug("ensRegistryLoadServer could not find a "
2409 "\"SpeciesIdentifer=INTEGER\" entry in the "
2410 "\"special\" field of AJAX database "
2411 "definition for "
2412 "Ensembl collection database '%S'.\n",
2413 dbname);
2414
2415 ensDatabaseadaptorDel(&dba);
2416
2417 continue;
2418 }
2419 }
2420
2421 if (ensRegistryAddDatabaseadaptor(dba) == ajTrue)
2422 {
2423 /* Get and add the stable identifier prefix. */
2424
2425 if (ajNamSvrGetdbAttrSpecialC(
2426 svrname, dbname, "SpeciesPrefix", &value) == 1)
2427 ensRegistryAddStableidentifierprefix(dba, value);
2428
2429 adaptors++;
2430 }
2431 else
2432 ensDatabaseadaptorDel(&dba);
2433 }
2434
2435 ajListIterDel(&dbniter);
2436 ajListstrFree(&dbnames);
2437
2438 ensDatabaseconnectionDel(&dbc);
2439
2440 /* Register this source. */
2441
2442 AJNEW0(Presult);
2443 *Presult = adaptors;
2444 ajTablePut(registryGSource,
2445 (void *) ajStrNewS(source),
2446 (void *) Presult);
2447
2448 result += adaptors;
2449 }
2450
2451 ajListIterDel(&svriter);
2452 ajListstrFree(&svrnames);
2453
2454 ajStrDel(&source);
2455 ajStrDel(&value);
2456
2457 if (debug)
2458 {
2459 ajDebug("ensRegistryLoadServername\n");
2460
2461 ensRegistryAliasTrace(1U);
2462 ensRegistryEntryTrace(1U);
2463 ensRegistrySourceTrace(1U);
2464 }
2465
2466 return result;
2467 }
2468
2469
2470
2471
2472 /* @section retrieve **********************************************************
2473 **
2474 ** @fdata [none]
2475 **
2476 ** @nam3rule Retrieve Retrieve objects from the Ensembl Registry
2477 ** @nam4rule All Retrieve all objects
2478 ** @nam5rule Species Retrieve all species names
2479 **
2480 ** @argrule Species species [AjPList]
2481 ** AJAX List of AJAX String (species name) objects
2482 **
2483 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
2484 **
2485 ** @fcategory internals
2486 ******************************************************************************/
2487
2488
2489
2490
2491 /* @funcstatic registryStringCompareCase **************************************
2492 **
2493 ** Comparison function to sort AJAX String objects case-insensitively in
2494 ** ascending order.
2495 **
2496 ** @param [r] item1 [const void*] AJAX String 1
2497 ** @param [r] item2 [const void*] AJAX String 2
2498 ** @see ajListSortUnique
2499 **
2500 ** @return [int] The comparison function returns an integer less than,
2501 ** equal to, or greater than zero if the first argument is
2502 ** considered to be respectively less than, equal to, or
2503 ** greater than the second.
2504 **
2505 ** @release 6.4.0
2506 ** @@
2507 ******************************************************************************/
2508
registryStringCompareCase(const void * item1,const void * item2)2509 static int registryStringCompareCase(
2510 const void *item1,
2511 const void *item2)
2512 {
2513 AjPStr string1 = *(AjOStr *const *) item1;
2514 AjPStr string2 = *(AjOStr *const *) item2;
2515
2516 #if defined(AJ_DEBUG) && AJ_DEBUG >= 2
2517 if (ajDebugTest("registryStringCompareCase"))
2518 ajDebug("registryStringCompareCase\n"
2519 " string1 %u\n"
2520 " string2 %u\n",
2521 string1,
2522 string2);
2523 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */
2524
2525 return ajStrCmpCaseS(string1, string2);
2526 }
2527
2528
2529
2530
2531 /* @funcstatic registryStringDelete *******************************************
2532 **
2533 ** ajListSortUnique "itemdel" function to delete AJAX String objects
2534 ** that are redundant.
2535 **
2536 ** @param [r] Pitem [void**] AJAX String address
2537 ** @param [r] cl [void*] Standard. Passed in from ajListSortUnique
2538 ** @see ajListSortUnique
2539 **
2540 ** @return [void]
2541 **
2542 ** @release 6.4.0
2543 ** @@
2544 ******************************************************************************/
2545
registryStringDelete(void ** Pitem,void * cl)2546 static void registryStringDelete(void **Pitem, void *cl)
2547 {
2548 if (!Pitem)
2549 return;
2550
2551 (void) cl;
2552
2553 ajStrDel((AjPStr *) Pitem);
2554
2555 return;
2556 }
2557
2558
2559
2560
2561 /* @func ensRegistryRetrieveAllSpecies ****************************************
2562 **
2563 ** Retrieve all species names from the Ensembl Registry.
2564 **
2565 ** @param [u] species [AjPList] AJAX List of AJAX String (species name) objects
2566 **
2567 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2568 **
2569 ** @release 6.4.0
2570 ** @@
2571 ******************************************************************************/
2572
ensRegistryRetrieveAllSpecies(AjPList species)2573 AjBool ensRegistryRetrieveAllSpecies(AjPList species)
2574 {
2575 void **keyarray = NULL;
2576
2577 register ajuint i = 0U;
2578
2579 if (!species)
2580 return ajFalse;
2581
2582 ajTableToarrayKeys(registryGEntry, &keyarray);
2583
2584 for (i = 0U; keyarray[i]; i++)
2585 ajListstrPushAppend(species, ajStrNewS((AjPStr) keyarray[i]));
2586
2587 AJFREE(keyarray);
2588
2589 ajListSortUnique(species,
2590 ®istryStringCompareCase,
2591 ®istryStringDelete);
2592
2593 return ajTrue;
2594 }
2595
2596
2597
2598
2599 /* @section Alias *************************************************************
2600 **
2601 ** @fdata [none]
2602 **
2603 ** @nam3rule Alias Functions for manipulating Registry Alias entries
2604 ** @nam4rule Add Add a Registry Alias entry
2605 ** @nam4rule Clear Clear all Registry Alias entries
2606 ** @nam4rule Fetch Fetch aliases (AJAX String objects) from the
2607 ** Ensembl Registry
2608 ** @nam5rule Allby Fetch all aliases (AJAX String objects)) by a criterion
2609 ** @nam6rule Species Fetch all by a species name
2610 ** @nam4rule Load Load Registry Alias entries
2611 ** @nam5rule File Load from an EMBOSS data file
2612 ** @nam4rule Remove Remove a Registry Alias entry
2613 ** @nam4rule Resolve Resolve a Registry Alias entry into an
2614 ** Ensembl Database Adaptor species
2615 ** @nam4rule Trace Trace Registry Alias entries
2616 **
2617 ** @argrule Add species [const AjPStr] Species name
2618 ** @argrule Add alias [const AjPStr] Alias name
2619 ** @argrule Species species [const AjPStr] Species name
2620 ** @argrule Allby aliases [AjPList] AJAX List of AJAX String (alias) objects
2621 ** @argrule LoadFile filename [const AjPStr] EMBOSS data file name
2622 ** @argrule Remove alias [const AjPStr] Alias name
2623 ** @argrule Resolve alias [const AjPStr] Alias name
2624 ** @argrule Resolve Pspecies [AjPStr*] Species name address
2625 ** @argrule Trace level [ajuint] Indentation level
2626 **
2627 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
2628 **
2629 ** @fcategory internals
2630 ******************************************************************************/
2631
2632
2633
2634
2635 /* @func ensRegistryAliasAdd **************************************************
2636 **
2637 ** Add a Registry Alias entry to the Ensembl Registry.
2638 **
2639 ** @param [r] species [const AjPStr] Species name
2640 ** @param [r] alias [const AjPStr] Alias name
2641 **
2642 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2643 **
2644 ** @release 6.4.0
2645 ** @@
2646 ******************************************************************************/
2647
ensRegistryAliasAdd(const AjPStr species,const AjPStr alias)2648 AjBool ensRegistryAliasAdd(const AjPStr species, const AjPStr alias)
2649 {
2650 AjBool debug = AJFALSE;
2651
2652 AjPStr current = NULL;
2653
2654 debug = ajDebugTest("ensRegistryAliasAdd");
2655
2656 if (debug)
2657 ajDebug("ensRegistryAliasAdd\n"
2658 " species '%S'\n"
2659 " alias '%S'\n",
2660 species,
2661 alias);
2662
2663 if (!species)
2664 return ajFalse;
2665
2666 if (!alias)
2667 return ajFalse;
2668
2669 current = (AjPStr) ajTableFetchmodV(registryGAlias, (const void *) alias);
2670
2671 if (current)
2672 {
2673 if (ajStrMatchCaseS(current, species))
2674 {
2675 if (debug)
2676 ajDebug("ensRegistryAliasAdd has already added alias '%S' for "
2677 "this species '%S'.\n", alias, current);
2678
2679 return ajTrue;
2680 }
2681 else
2682 {
2683 if (debug)
2684 ajDebug("ensRegistryAliasAdd has already added alias '%S' for "
2685 "a different species '%S'.\n", alias, current);
2686
2687 return ajFalse;
2688 }
2689 }
2690
2691 ajTablePut(registryGAlias,
2692 (void *) ajStrNewS(alias),
2693 (void *) ajStrNewS(species));
2694
2695 if (debug)
2696 ajDebug("ensRegistryAliasAdd added alias '%S' for species '%S'.\n",
2697 alias, species);
2698
2699 return ajTrue;
2700 }
2701
2702
2703
2704
2705 /* @func ensRegistryAliasClear ************************************************
2706 **
2707 ** Clear all Registry Alias entries from the Ensembl Registry.
2708 **
2709 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2710 **
2711 ** @release 6.4.0
2712 ** @@
2713 ******************************************************************************/
2714
ensRegistryAliasClear(void)2715 AjBool ensRegistryAliasClear(void)
2716 {
2717 if (!registryGAlias)
2718 return ajFalse;
2719
2720 ajTableClearDelete(registryGAlias);
2721
2722 return ajTrue;
2723 }
2724
2725
2726
2727
2728 /* @func ensRegistryAliasFetchAllbySpecies ************************************
2729 **
2730 ** Fetch all aliases (AJAX String objects) from the Ensembl Registry by a
2731 ** species name.
2732 **
2733 ** The caller is responsible for deleting the AJAX String objects before
2734 ** deleting the AJAX List.
2735 **
2736 ** @param [rN] species [const AjPStr] Species name
2737 ** @param [u] aliases [AjPList] AJAX List of AJAX String (alias) objects
2738 **
2739 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2740 **
2741 ** @release 6.4.0
2742 ** @@
2743 ******************************************************************************/
2744
ensRegistryAliasFetchAllbySpecies(const AjPStr species,AjPList aliases)2745 AjBool ensRegistryAliasFetchAllbySpecies(const AjPStr species,
2746 AjPList aliases)
2747 {
2748 void **keyarray = NULL;
2749 void **valarray = NULL;
2750
2751 register ajuint i = 0U;
2752
2753 if (!aliases)
2754 return ajFalse;
2755
2756 ajTableToarrayKeysValues(registryGAlias, &keyarray, &valarray);
2757
2758 for (i = 0U; keyarray[i]; i++)
2759 {
2760 /* If a species name has been passed in, skip non-matching ones. */
2761 if ((species != NULL) &&
2762 (ajStrMatchS(species, (AjPStr) valarray[i]) == ajFalse))
2763 continue;
2764
2765 /* Skip identical species and alias names. */
2766 if (ajStrMatchS((AjPStr) keyarray[i], (AjPStr) valarray[i]) == ajTrue)
2767 continue;
2768
2769 ajListstrPushAppend(aliases, ajStrNewS((AjPStr) keyarray[i]));
2770 }
2771
2772 AJFREE(keyarray);
2773 AJFREE(valarray);
2774
2775 return ajTrue;
2776 }
2777
2778
2779
2780
2781 /* @funcstatic registryAliasLoadDatabaseconnection ****************************
2782 **
2783 ** Load Registry Alias entries from an Ensembl Database Connection into the
2784 ** Ensembl Registry.
2785 **
2786 ** @cc Bio::EnsEMBL::Registry::ind_and_add_aliases
2787 ** @param [u] dbc [EnsPDatabaseconnection] Ensembl Database Connection
2788 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
2789 **
2790 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2791 **
2792 ** @release 6.4.0
2793 ** @@
2794 ** NOTE: This function uses the Ensembl Database Connection to avoid
2795 ** connecting and disconnecting for each database.
2796 ******************************************************************************/
2797
registryAliasLoadDatabaseconnection(EnsPDatabaseconnection dbc,EnsPDatabaseadaptor dba)2798 static AjBool registryAliasLoadDatabaseconnection(
2799 EnsPDatabaseconnection dbc,
2800 EnsPDatabaseadaptor dba)
2801 {
2802 char *txtdbname = NULL;
2803
2804 register ajuint i = 0U;
2805
2806 AjPSqlstatement sqls = NULL;
2807 AjISqlrow sqli = NULL;
2808 AjPSqlrow sqlr = NULL;
2809
2810 AjPStr metavalue = NULL;
2811 AjPStr dbname = NULL;
2812 AjPStr statement = NULL;
2813
2814 if (!dbc)
2815 return ajFalse;
2816
2817 if (!dba)
2818 return ajFalse;
2819
2820 switch (ensDatabaseadaptorGetGroup(dba))
2821 {
2822 case ensEDatabaseadaptorGroupCore:
2823
2824 case ensEDatabaseadaptorGroupVega:
2825
2826 case ensEDatabaseadaptorGroupOtherFeatures:
2827
2828 case ensEDatabaseadaptorGroupCopyDNA:
2829
2830 /* Database Adaptor groups with a 'meta' table. */
2831
2832 dbname = ensDatabaseconnectionGetDatabasename(
2833 ensDatabaseadaptorGetDatabaseconnection(dba));
2834
2835 ensDatabaseconnectionEscapeC(dbc, &txtdbname, dbname);
2836
2837 for (i = 0U; registryKAliasMetaKey[i]; i++)
2838 {
2839 statement = ajFmtStr(
2840 "SELECT "
2841 "%s.meta.meta_value "
2842 "FROM "
2843 "%s.meta "
2844 "WHERE "
2845 "%s.meta.meta_key = '%s' "
2846 "AND "
2847 "%s.meta.species_id = %u",
2848 txtdbname,
2849 txtdbname,
2850 txtdbname, registryKAliasMetaKey[i],
2851 txtdbname, ensDatabaseadaptorGetIdentifier(dba));
2852
2853 sqls = ensDatabaseconnectionSqlstatementNew(dbc, statement);
2854
2855 sqli = ajSqlrowiterNew(sqls);
2856
2857 while (!ajSqlrowiterDone(sqli))
2858 {
2859 metavalue = ajStrNew();
2860
2861 sqlr = ajSqlrowiterGet(sqli);
2862
2863 ajSqlcolumnToStr(sqlr, &metavalue);
2864
2865 if (ajCharMatchC(registryKAliasMetaKey[i],
2866 "species.stable_id_prefix"))
2867 ensRegistryAddStableidentifierprefix(dba, metavalue);
2868 else
2869 ensRegistryAliasAdd(ensDatabaseadaptorGetSpecies(dba),
2870 metavalue);
2871
2872 ajStrDel(&metavalue);
2873 }
2874
2875 ajSqlrowiterDel(&sqli);
2876
2877 ensDatabaseconnectionSqlstatementDel(dbc, &sqls);
2878
2879 ajStrDel(&statement);
2880 }
2881
2882 /* Load the Ensembl stable identifier prefix. */
2883
2884 ajCharDel(&txtdbname);
2885
2886 break;
2887
2888 case ensEDatabaseadaptorGroupGeneticVariation:
2889
2890 case ensEDatabaseadaptorGroupFunctionalGenomics:
2891
2892 case ensEDatabaseadaptorGroupComparativeGenomics:
2893
2894 case ensEDatabaseadaptorGroupOntology:
2895
2896 case ensEDatabaseadaptorGroupQualityCheck:
2897
2898 case ensEDatabaseadaptorGroupPipeline:
2899
2900 case ensEDatabaseadaptorGroupHive:
2901
2902 case ensEDatabaseadaptorGroupCoreExpressionEST:
2903
2904 case ensEDatabaseadaptorGroupCoreExpressionGNF:
2905
2906 case ensEDatabaseadaptorGroupAncestral:
2907
2908 case ensEDatabaseadaptorGroupWebsite:
2909
2910 case ensEDatabaseadaptorGroupProduction:
2911
2912 /* Ensembl Database Adaptor groups without a 'meta' table. */
2913
2914 break;
2915
2916 default:
2917
2918 ajWarn("registryLoadAlises got an "
2919 "Ensembl Database Adaptor "
2920 "with an unexpected group %d.\n",
2921 ensDatabaseadaptorGetGroup(dba));
2922 }
2923
2924 return ajTrue;
2925 }
2926
2927
2928
2929
2930 /* @func ensRegistryAliasLoadFile *********************************************
2931 **
2932 ** Load Registry Alias entries from an EMBOSS data file into the
2933 ** Ensembl Registry. If no EMBOSS data file name has been specified,
2934 ** the default is "EnsemblAliases.dat".
2935 **
2936 ** @param [rN] filename [const AjPStr] EMBOSS data file name
2937 **
2938 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2939 **
2940 ** @release 6.4.0
2941 ** @@
2942 ******************************************************************************/
2943
ensRegistryAliasLoadFile(const AjPStr filename)2944 AjBool ensRegistryAliasLoadFile(const AjPStr filename)
2945 {
2946 const char *txtname = "EnsemblAliases.dat";
2947
2948 AjBool block = AJFALSE;
2949 AjBool debug = AJFALSE;
2950
2951 AjPFile infile = NULL;
2952
2953 AjPStr line = NULL;
2954 AjPStr species = NULL;
2955
2956 debug = ajDebugTest("ensRegistryAliasLoadFile");
2957
2958 if (debug)
2959 ajDebug("ensRegistryAliasLoadFile\n"
2960 " filename: '%S'\n",
2961 filename);
2962
2963 if (filename && ajStrGetLen(filename))
2964 infile = ajDatafileNewInNameS(filename);
2965 else
2966 infile = ajDatafileNewInNameC(txtname);
2967
2968 if (!infile)
2969 {
2970 ajWarn("ensRegistryAliasLoadFile could not load "
2971 "Ensembl Registry Aliases data file '%s'.",
2972 (filename && ajStrGetLen(filename)) ?
2973 ajStrGetPtr(filename) : txtname);
2974
2975 return ajFalse;
2976 }
2977
2978 line = ajStrNew();
2979
2980 species = ajStrNew();
2981
2982 while (ajReadlineTrim(infile, &line))
2983 {
2984 /*
2985 ** Remove excess white space and ignore all lines that start with
2986 ** a '#' sign. Commented out lines, however, should not break blocks.
2987 */
2988
2989 ajStrRemoveWhiteSpaces(&line);
2990
2991 if (ajStrGetCharFirst(line) == '#')
2992 continue;
2993
2994 /*
2995 ** Remove comments on the same line as an alias, before again removing
2996 ** excess white space. Finally, remove the quotes, if any, and
2997 ** register the remaining string as alias.
2998 */
2999
3000 ajStrCutComments(&line);
3001
3002 ajStrQuoteStrip(&line);
3003
3004 ajStrRemoveWhiteSpaces(&line);
3005
3006 if (!ajStrGetLen(line))
3007 {
3008 /* An empty line indicates the end of a block. */
3009
3010 block = ajFalse;
3011
3012 continue;
3013 }
3014
3015 if (block)
3016 {
3017 /* This is a subsequent line of a block, which is an alias. */
3018
3019 ensRegistryAliasAdd(species, line);
3020 }
3021 else
3022 {
3023 /* This is the first line of a block, which is the species. */
3024
3025 ajStrAssignS(&species, line);
3026
3027 block = ajTrue;
3028 }
3029 }
3030
3031 ajStrDel(&species);
3032 ajStrDel(&line);
3033
3034 ajFileClose(&infile);
3035
3036 if (debug)
3037 {
3038 ajDebug("ensRegistryAliasLoadFile\n");
3039
3040 ensRegistryAliasTrace(1);
3041 }
3042
3043 return ajTrue;
3044 }
3045
3046
3047
3048
3049 /* @func ensRegistryAliasRemove ***********************************************
3050 **
3051 ** Remove a Registry Alias entry from the Ensembl Registry.
3052 **
3053 ** @param [r] alias [const AjPStr] Alias name
3054 **
3055 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3056 **
3057 ** @release 6.4.0
3058 ** @@
3059 ******************************************************************************/
3060
ensRegistryAliasRemove(const AjPStr alias)3061 AjBool ensRegistryAliasRemove(const AjPStr alias)
3062 {
3063 AjPStr value = NULL;
3064
3065 if (!alias)
3066 return ajFalse;
3067
3068 value = (AjPStr) ajTableRemove(registryGAlias, (const void *) alias);
3069
3070 ajStrDel(&value);
3071
3072 return ajTrue;
3073 }
3074
3075
3076
3077
3078 /* @func ensRegistryAliasResolve **********************************************
3079 **
3080 ** Resolve an alias name into an Ensembl Database Adaptor species.
3081 **
3082 ** @param [r] alias [const AjPStr] Alias name
3083 ** @param [wP] Pspecies [AjPStr*] Species name adress or NULL
3084 **
3085 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3086 **
3087 ** @release 6.4.0
3088 ** @@
3089 ******************************************************************************/
3090
ensRegistryAliasResolve(const AjPStr alias,AjPStr * Pspecies)3091 AjBool ensRegistryAliasResolve(const AjPStr alias, AjPStr *Pspecies)
3092 {
3093 if (!alias)
3094 return ajFalse;
3095
3096 if (!Pspecies)
3097 return ajFalse;
3098
3099 *Pspecies = (AjPStr) ajTableFetchmodV(registryGAlias, (const void *) alias);
3100
3101 return ajTrue;
3102 }
3103
3104
3105
3106
3107 /* @func ensRegistryAliasTrace ************************************************
3108 **
3109 ** Trace Ensembl Registry Alias entries.
3110 **
3111 ** @param [r] level [ajuint] Indentation level
3112 **
3113 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3114 **
3115 ** @release 6.4.0
3116 ** @@
3117 ******************************************************************************/
3118
ensRegistryAliasTrace(ajuint level)3119 AjBool ensRegistryAliasTrace(ajuint level)
3120 {
3121 AjPStr indent = NULL;
3122
3123 indent = ajStrNew();
3124
3125 ajStrAppendCountK(&indent, ' ', level * 2);
3126
3127 ajDebug("%SensRegistryAliasTrace %p\n",
3128 indent, registryGAlias);
3129
3130 ajTablestrTrace(registryGAlias);
3131
3132 ajStrDel(&indent);
3133
3134 return ajTrue;
3135 }
3136
3137
3138
3139
3140 /* @section Identifier ********************************************************
3141 **
3142 ** @fdata [none]
3143 **
3144 ** @nam3rule Identifier Functions for manipulating Registry Identifier entries
3145 ** @nam4rule Add Add a Registry Identifier entry
3146 ** @nam4rule Clear Clear all Registry Identifier entries
3147 ** @nam4rule Load Load Registry Identifier entries
3148 ** @nam5rule File Load from an EMBOSS data file
3149 ** @nam4rule Remove Remove a Registry Identifier entry
3150 ** @nam4rule Resolve Resolve a Registry Identifier to an
3151 ** Ensembl Database Adaptor species and group
3152 ** @nam4rule Trace Trace Registry Identifier entries
3153 **
3154 ** @argrule LoadFile filename [const AjPStr] EMBOSS data file name
3155 ** @argrule Resolve identifier [const AjPStr] Ensembl stable identifier
3156 ** @argrule Resolve Pspecies [AjPStr*] Ensembl Database Adaptor species
3157 ** @argrule Resolve Pdbag [EnsEDatabaseadaptorGroup*]
3158 ** Ensembl Database Adaptor Group enumeration address
3159 ** @argrule Trace level [ajuint] Indentation level
3160 **
3161 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3162 **
3163 ** @fcategory internals
3164 ******************************************************************************/
3165
3166
3167
3168
3169 /* @func ensRegistryIdentifierClear *******************************************
3170 **
3171 ** Clear all Registry Identifier entries from the Ensembl Registry.
3172 **
3173 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3174 **
3175 ** @release 6.4.0
3176 ** @@
3177 ******************************************************************************/
3178
ensRegistryIdentifierClear(void)3179 AjBool ensRegistryIdentifierClear(void)
3180 {
3181 RegistryPIdentifier ri = NULL;
3182
3183 if (!registryGIdentifier)
3184 return ajFalse;
3185
3186 while (ajListPop(registryGIdentifier, (void **) &ri))
3187 registryIdentifierDel(&ri);
3188
3189 return ajTrue;
3190 }
3191
3192
3193
3194
3195 /* @func ensRegistryIdentifierLoadFile ****************************************
3196 **
3197 ** Load Registry Identifier entries from an EMBOSS data file into the
3198 ** Ensembl Registry. If no EMBOSS data file name has been specified,
3199 ** the default is "EnsemblIdentifiers.dat".
3200 **
3201 ** @param [rN] filename [const AjPStr] EMBOSS data file name
3202 **
3203 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3204 **
3205 ** @release 6.4.0
3206 ** @@
3207 ******************************************************************************/
3208
ensRegistryIdentifierLoadFile(const AjPStr filename)3209 AjBool ensRegistryIdentifierLoadFile(const AjPStr filename)
3210 {
3211 const char *txtname = "EnsemblIdentifiers.dat";
3212
3213 AjBool debug = AJFALSE;
3214
3215 AjPFile infile = NULL;
3216
3217 AjPStr line = NULL;
3218 AjPStr expression = NULL;
3219 AjPStr alias = NULL;
3220 AjPStr group = NULL;
3221 AjPStr space = NULL;
3222 AjPStr species = NULL;
3223
3224 AjPStrTok token = NULL;
3225
3226 EnsEDatabaseadaptorGroup dbag = ensEDatabaseadaptorGroupNULL;
3227
3228 RegistryPIdentifier ri = NULL;
3229
3230 debug = ajDebugTest("ensRegistryIdentifierLoadFile");
3231
3232 if (debug)
3233 ajDebug("ensRegistryIdentifierLoadFile\n");
3234
3235 if (filename && ajStrGetLen(filename))
3236 infile = ajDatafileNewInNameS(filename);
3237 else
3238 infile = ajDatafileNewInNameC(txtname);
3239
3240 if (!infile)
3241 {
3242 ajWarn("ensRegistryIdentifierLoadFile could not load "
3243 "Ensembl Registry Identifiers data file '%s'.",
3244 (filename && ajStrGetLen(filename)) ?
3245 ajStrGetPtr(filename) : txtname);
3246
3247 return ajFalse;
3248 }
3249
3250 line = ajStrNew();
3251
3252 expression = ajStrNew();
3253
3254 alias = ajStrNew();
3255 group = ajStrNew();
3256 space = ajStrNew();
3257
3258 while (ajReadlineTrim(infile, &line))
3259 {
3260 if (debug)
3261 ajDebug("ensRegistryIdentifierLoadFile original line '%S'\n",
3262 line);
3263
3264 if (!ajStrCutComments(&line))
3265 continue;
3266
3267 ajStrTokenAssignC(&token, line, "\"");
3268
3269 if (!ajStrTokenNextFind(token, &expression))
3270 ajWarn("ensRegistryIdentifierLoadFile could not parse "
3271 "regular expression from line '%S'.\n", line);
3272
3273 if (!ajStrTokenNextFind(token, &space))
3274 ajWarn("ensRegistryIdentifierLoadFile could not parse "
3275 "begin of species from line '%S'.\n", line);
3276
3277 if (!ajStrTokenNextFind(token, &alias))
3278 ajWarn("ensRegistryIdentifierLoadFile could not parse "
3279 "species from line '%S'.\n", line);
3280
3281 if (!ajStrTokenNextFind(token, &space))
3282 ajWarn("ensRegistryIdentifierLoadFile could not parse "
3283 "begin of group from line '%S'.\n", line);
3284
3285 if (!ajStrTokenNextFind(token, &group))
3286 ajWarn("ensRegistryIdentifierLoadFile could not parse "
3287 "group from line '%S'.\n", line);
3288
3289 ajStrTokenDel(&token);
3290
3291 if (debug)
3292 ajDebug("ensRegistryIdentifierLoadFile "
3293 "regular expression '%S' "
3294 "alias '%S' "
3295 "group '%S'\n",
3296 expression,
3297 alias,
3298 group);
3299
3300 ensRegistryAliasResolve(alias, &species);
3301
3302 if (!species)
3303 {
3304 ajWarn("ensRegistryIdentifierLoadFile could not resolve '%S' "
3305 "to valid species name.\n", alias);
3306
3307 continue;
3308 }
3309
3310 dbag = ensDatabaseadaptorGroupFromStr(group);
3311
3312 if (!dbag)
3313 {
3314 ajWarn("ensRegistryIdentifierLoadFile could not get group for "
3315 "string '%S'.\n", group);
3316
3317 continue;
3318 }
3319
3320 ri = registryIdentifierNew(expression, species , dbag);
3321
3322 ajListPushAppend(registryGIdentifier, (void *) ri);
3323 }
3324
3325 ajStrDel(&expression);
3326 ajStrDel(&alias);
3327 ajStrDel(&group);
3328 ajStrDel(&space);
3329 ajStrDel(&line);
3330
3331 ajFileClose(&infile);
3332
3333 return ajTrue;
3334 }
3335
3336
3337
3338
3339 /* @func ensRegistryIdentifierResolve *****************************************
3340 **
3341 ** Resolve an Ensembl stable identifier into Ensembl Database Adaptor species
3342 ** and group members.
3343 **
3344 ** @param [r] identifier [const AjPStr] Ensembl stable identifier
3345 ** @param [u] Pspecies [AjPStr*] Ensembl Database Adaptor species
3346 ** @param [w] Pdbag [EnsEDatabaseadaptorGroup*]
3347 ** Ensembl Database Adaptor Group enumeration address
3348 **
3349 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3350 **
3351 ** @release 6.4.0
3352 ** @@
3353 ******************************************************************************/
3354
ensRegistryIdentifierResolve(const AjPStr identifier,AjPStr * Pspecies,EnsEDatabaseadaptorGroup * Pdbag)3355 AjBool ensRegistryIdentifierResolve(const AjPStr identifier,
3356 AjPStr *Pspecies,
3357 EnsEDatabaseadaptorGroup *Pdbag)
3358 {
3359 AjIList iter = NULL;
3360
3361 AjPRegexp re = NULL;
3362
3363 RegistryPIdentifier ri = NULL;
3364
3365 if (!identifier)
3366 return ajFalse;
3367
3368 if (!Pspecies)
3369 return ajFalse;
3370
3371 if (!Pdbag)
3372 return ajFalse;
3373
3374 ajStrAssignClear(Pspecies);
3375
3376 *Pdbag = ensEDatabaseadaptorGroupNULL;
3377
3378 iter = ajListIterNew(registryGIdentifier);
3379
3380 while (!ajListIterDone(iter))
3381 {
3382 ri = (RegistryPIdentifier) ajListIterGet(iter);
3383
3384 re = ajRegComp(ri->RegularExpression);
3385
3386 if (ajRegExec(re, identifier))
3387 {
3388 ajStrAssignS(Pspecies, ri->SpeciesName);
3389
3390 *Pdbag = ri->Group;
3391
3392 ajRegFree(&re);
3393
3394 break;
3395 }
3396
3397 ajRegFree(&re);
3398 }
3399
3400 ajListIterDel(&iter);
3401
3402 return ajTrue;
3403 }
3404
3405
3406
3407
3408 /* @section Entry *************************************************************
3409 **
3410 ** @fdata [none]
3411 **
3412 ** @nam3rule Entry Functions for manipulating Registry Entry objects
3413 ** @nam4rule Clear Clear Registry Entry objects
3414 ** @nam4rule Trace Trace Registry Entry objects
3415 **
3416 ** @argrule Trace level [ajuint] Indentation level
3417 **
3418 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3419 **
3420 ** @fcategory internals
3421 ******************************************************************************/
3422
3423
3424
3425
3426 /* @func ensRegistryEntryClear ************************************************
3427 **
3428 ** Clear all Registry Entry objects from the Ensembl Registry.
3429 **
3430 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3431 **
3432 ** @release 6.4.0
3433 ** @@
3434 ******************************************************************************/
3435
ensRegistryEntryClear(void)3436 AjBool ensRegistryEntryClear(void)
3437 {
3438 if (!registryGEntry)
3439 return ajFalse;
3440
3441 ajTableClearDelete(registryGEntry);
3442
3443 return ajTrue;
3444 }
3445
3446
3447
3448
3449 /* @funcstatic registryEntryLoadCollection ************************************
3450 **
3451 ** Load Registry Entry and Registry Alias objects from meta table entries and
3452 ** instantiate Ensembl Database Adaptor objects for each species in an Ensembl
3453 ** Collection database.
3454 **
3455 ** @param [u] dbc [EnsPDatabaseconnection] Ensembl Database Connection
3456 ** @param [u] dbname [AjPStr] Database name
3457 ** @param [u] dbag [EnsEDatabaseadaptorGroup]
3458 ** Ensembl Database Adaptor Group enumeration
3459 **
3460 ** @return [ajuint] Number of Ensembl Database Adaptor objects registered
3461 **
3462 ** @release 6.4.0
3463 ** @@
3464 ******************************************************************************/
3465
registryEntryLoadCollection(EnsPDatabaseconnection dbc,AjPStr dbname,EnsEDatabaseadaptorGroup dbag)3466 static ajuint registryEntryLoadCollection(EnsPDatabaseconnection dbc,
3467 AjPStr dbname,
3468 EnsEDatabaseadaptorGroup dbag)
3469 {
3470 char *txtdbname = NULL;
3471
3472 ajuint identifier = 0U;
3473 ajuint result = 0U;
3474
3475 AjPSqlstatement sqls = NULL;
3476 AjISqlrow sqli = NULL;
3477 AjPSqlrow sqlr = NULL;
3478
3479 AjPStr species = NULL;
3480 AjPStr statement = NULL;
3481
3482 EnsPDatabaseadaptor dba = NULL;
3483
3484 if (!dbc)
3485 return ajFalse;
3486
3487 ensDatabaseconnectionEscapeC(dbc, &txtdbname, dbname);
3488
3489 statement = ajFmtStr(
3490 "SELECT "
3491 "%s.meta.species_id, "
3492 "%s.meta.meta_value "
3493 "FROM "
3494 "%s.meta "
3495 "WHERE "
3496 "%s.meta.meta_key = 'species.db_name'",
3497 txtdbname,
3498 txtdbname,
3499 txtdbname,
3500 txtdbname);
3501
3502 ajCharDel(&txtdbname);
3503
3504 sqls = ensDatabaseconnectionSqlstatementNew(dbc, statement);
3505
3506 sqli = ajSqlrowiterNew(sqls);
3507
3508 while (!ajSqlrowiterDone(sqli))
3509 {
3510 identifier = 0;
3511 species = ajStrNew();
3512
3513 sqlr = ajSqlrowiterGet(sqli);
3514
3515 ajSqlcolumnToUint(sqlr, &identifier);
3516 ajSqlcolumnToStr(sqlr, &species);
3517
3518 dba = ensRegistryNewDatabaseadaptor(dbc,
3519 dbname,
3520 species,
3521 dbag,
3522 ajTrue,
3523 identifier);
3524
3525 if (dba)
3526 {
3527 registryAliasLoadDatabaseconnection(dbc, dba);
3528
3529 result++;
3530 }
3531
3532 ajStrDel(&species);
3533 }
3534
3535 ajSqlrowiterDel(&sqli);
3536
3537 ensDatabaseconnectionSqlstatementDel(dbc, &sqls);
3538
3539 ajStrDel(&statement);
3540
3541 return result;
3542 }
3543
3544
3545
3546
3547 /* @func ensRegistryEntryTrace ************************************************
3548 **
3549 ** Trace Ensembl Registry Entry objects.
3550 **
3551 ** @param [r] level [ajuint] Indentation level
3552 **
3553 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3554 **
3555 ** @release 6.4.0
3556 ** @@
3557 ******************************************************************************/
3558
ensRegistryEntryTrace(ajuint level)3559 AjBool ensRegistryEntryTrace(ajuint level)
3560 {
3561 void **keyarray = NULL;
3562 void **valarray = NULL;
3563
3564 register ajuint i = 0U;
3565
3566 AjPStr indent = NULL;
3567
3568 indent = ajStrNew();
3569
3570 ajStrAppendCountK(&indent, ' ', level * 2);
3571
3572 ajDebug("%SensRegistryEntryTrace %p\n",
3573 indent, registryGEntry);
3574
3575 ajTableToarrayKeysValues(registryGEntry, &keyarray, &valarray);
3576
3577 for (i = 0U; keyarray[i]; i++)
3578 {
3579 ajDebug("%S Species '%S'\n", indent, (AjPStr) keyarray[i]);
3580
3581 registryEntryTrace((RegistryPEntry) valarray[i], level + 2);
3582 }
3583
3584 AJFREE(keyarray);
3585 AJFREE(valarray);
3586
3587 ajStrDel(&indent);
3588
3589 return ajTrue;
3590 }
3591
3592
3593
3594
3595 /* @section Source ************************************************************
3596 **
3597 ** @fdata [none]
3598 **
3599 ** @nam3rule Source Functions for manipulating Registry Source entries
3600 ** @nam4rule Add Add a Registry Source entry
3601 ** @nam4rule Clear Clear all Registry Source entries
3602 ** @nam4rule Register Register a Registy Source entry
3603 ** @nam4rule Remove Remove a Registry Source entry
3604 ** @nam4rule Trace Trace Registry Source entries
3605 **
3606 ** @argrule Trace level [ajuint] Indentation level
3607 **
3608 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3609 **
3610 ** @fcategory internals
3611 ******************************************************************************/
3612
3613
3614
3615
3616 /* @func ensRegistrySourceTrace ***********************************************
3617 **
3618 ** Trace Ensembl Registry Source objects.
3619 **
3620 ** @param [r] level [ajuint] Indentation level
3621 **
3622 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3623 **
3624 ** @release 6.4.0
3625 ** @@
3626 ******************************************************************************/
3627
ensRegistrySourceTrace(ajuint level)3628 AjBool ensRegistrySourceTrace(ajuint level)
3629 {
3630 void **keyarray = NULL;
3631 void **valarray = NULL;
3632
3633 register ajuint i = 0U;
3634
3635 AjPStr indent = NULL;
3636
3637 indent = ajStrNew();
3638
3639 ajStrAppendCountK(&indent, ' ', level * 2);
3640
3641 ajDebug("%SensRegistrySourceTrace %p\n",
3642 indent, registryGSource);
3643
3644 ajTableToarrayKeysValues(registryGSource, &keyarray, &valarray);
3645
3646 for (i = 0U; keyarray[i]; i++)
3647 ajDebug("%S Source URL '%S'\n"
3648 "%S Ensembl Database Adaptor objects '%u'\n",
3649 indent, (AjPStr) keyarray[i],
3650 indent, *((ajuint *) valarray[i]));
3651
3652 AJFREE(keyarray);
3653 AJFREE(valarray);
3654
3655 ajStrDel(&indent);
3656
3657 return ajTrue;
3658 }
3659
3660
3661
3662
3663 /* @datasection [EnsPDatabaseadaptor] Ensembl Registry Database Adaptor *******
3664 **
3665 ** Functions for manipulating Ensembl Database Adaptor objects via the
3666 ** Ensembl Registry.
3667 **
3668 ******************************************************************************/
3669
3670
3671
3672
3673 /* @section constructors ******************************************************
3674 **
3675 ** All constructors return a new Ensembl Database Adaptor by pointer.
3676 ** It is the responsibility of the user to first destroy any previous
3677 ** Database Adaptor. The target pointer does not need to be initialised to
3678 ** NULL, but it is good programming practice to do so anyway.
3679 **
3680 ** @fdata [EnsPDatabaseadaptor]
3681 **
3682 ** @nam3rule New Constructor
3683 ** @nam4rule Databaseadaptor Constructor for an Ensembl Database Adaptor
3684 ** @nam4rule Referenceadaptor Constructor for an Ensembl Database Adaptor as
3685 ** reference sequence adaptor
3686 **
3687 ** @argrule Databaseadaptor dbc [EnsPDatabaseconnection]
3688 ** Ensembl Database Connection
3689 ** @argrule Databaseadaptor database [AjPStr] Database name
3690 ** @argrule Databaseadaptor alias [AjPStr] Species name or alias name
3691 ** @argrule Databaseadaptor dbag [EnsEDatabaseadaptorGroup]
3692 ** Ensembl Database Adaptor Group enumeration
3693 ** @argrule Databaseadaptor multi [AjBool] Multiple species
3694 ** @argrule Databaseadaptor identifier [ajuint] Species identifier
3695 ** @argrule Referenceadaptor dba [EnsPDatabaseadaptor]
3696 ** Ensembl Database Adaptor
3697 ** @argrule Referenceadaptor dbc [EnsPDatabaseconnection]
3698 ** Ensembl Database Connection
3699 ** @argrule Referenceadaptor database [AjPStr] Database name
3700 ** @argrule Referenceadaptor alias [AjPStr] Species name or alias name
3701 ** @argrule Referenceadaptor dbag [EnsEDatabaseadaptorGroup]
3702 ** Ensembl Database Adaptor Group enumeration
3703 ** @argrule Referenceadaptor multi [AjBool] Multiple species
3704 ** @argrule Referenceadaptor identifier [ajuint] Species identifier
3705 **
3706 ** @valrule * [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
3707 **
3708 ** @fcategory new
3709 ******************************************************************************/
3710
3711
3712
3713
3714 /* @func ensRegistryNewDatabaseadaptor ****************************************
3715 **
3716 ** Create an Ensembl Database Adaptor and add it to the Ensembl Registry.
3717 **
3718 ** @param [u] dbc [EnsPDatabaseconnection] Ensembl Database Connection
3719 ** @param [uN] database [AjPStr] Database name (optional). If not provided, the
3720 ** database name in the Database Connection will
3721 ** be used.
3722 ** @param [u] alias [AjPStr] Species name or alias name
3723 ** @param [u] dbag [EnsEDatabaseadaptorGroup]
3724 ** Ensembl Database Adaptor Group enumeration
3725 ** @param [r] multi [AjBool] Multiple species
3726 ** @param [r] identifier [ajuint] Species identifier
3727 **
3728 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
3729 **
3730 ** @release 6.3.0
3731 ** @@
3732 ** This function aims to resolve an eventual alias to a valid species name.
3733 ** If the alias has not been registered before, it will strip underscores from
3734 ** the alias to permit searches for an Ensembl database name prefix, such as
3735 ** "homo_sapiens". If an alias without underscores has also not been registered
3736 ** before, it will register the alias without underscores as species and the
3737 ** the prefix with underscores as alias.
3738 ** Ideally aliases have already been loaded from an Ensembl Database
3739 ** Connection or an Ensembl data file (EnsemblAliases.dat) before.
3740 ******************************************************************************/
3741
ensRegistryNewDatabaseadaptor(EnsPDatabaseconnection dbc,AjPStr database,AjPStr alias,EnsEDatabaseadaptorGroup dbag,AjBool multi,ajuint identifier)3742 EnsPDatabaseadaptor ensRegistryNewDatabaseadaptor(
3743 EnsPDatabaseconnection dbc,
3744 AjPStr database,
3745 AjPStr alias,
3746 EnsEDatabaseadaptorGroup dbag,
3747 AjBool multi,
3748 ajuint identifier)
3749 {
3750 AjPStr species = NULL;
3751
3752 EnsPDatabaseadaptor dba = NULL;
3753
3754 if (ajDebugTest("ensRegistryNewDatabaseadaptor"))
3755 {
3756 ajDebug("ensRegistryNewDatabaseadaptor\n"
3757 " dbc %p\n"
3758 " database '%S'\n"
3759 " alias '%S'\n"
3760 " dbag '%s'\n"
3761 " multi '%B'\n"
3762 " identifier %u\n",
3763 dbc,
3764 database,
3765 alias,
3766 ensDatabaseadaptorGroupToChar(dbag),
3767 multi,
3768 identifier);
3769
3770 ensDatabaseconnectionTrace(dbc, 1);
3771 }
3772
3773 if (!dbc)
3774 return NULL;
3775
3776 if (!database)
3777 return NULL;
3778
3779 if ((alias == NULL) || (ajStrGetLen(alias) == 0))
3780 return NULL;
3781
3782 ensRegistryAliasResolve(alias, &species);
3783
3784 if (species == NULL)
3785 species = alias;
3786
3787 dba = ensDatabaseadaptorNewIni(dbc,
3788 database,
3789 species,
3790 dbag,
3791 multi,
3792 identifier);
3793
3794 if (ensRegistryAddDatabaseadaptor(dba) == ajFalse)
3795 ensDatabaseadaptorDel(&dba);
3796
3797 return dba;
3798 }
3799
3800
3801
3802
3803 /* @func ensRegistryNewReferenceadaptor ***************************************
3804 **
3805 ** Create an Ensembl Database Adaptor and add it to the Ensembl Registry
3806 ** as reference sequence adaptor.
3807 **
3808 ** This function will only return successfully, if the Ensembl Database
3809 ** Adaptor could be created and has not been registered before.
3810 **
3811 ** @cc Bio::EnsEMBL::Registry::add_DNAAdaptor
3812 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3813 ** @param [u] dbc [EnsPDatabaseconnection] Ensembl Database Connection
3814 ** @param [u] database [AjPStr] Database name (optional). If not provided, the
3815 ** database name in the Database Connection will
3816 ** be used.
3817 ** @param [u] alias [AjPStr] Species name or alias name
3818 ** @param [u] dbag [EnsEDatabaseadaptorGroup]
3819 ** Ensembl Database Adaptor Group enumeration
3820 ** @param [r] multi [AjBool] Multiple species
3821 ** @param [r] identifier [ajuint] Species identifier
3822 **
3823 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
3824 **
3825 ** @release 6.3.0
3826 ** @@
3827 ** This function aims to resolve an eventual alias to a valid species name.
3828 ** If the alias has not been registered before, it will strip underscores from
3829 ** the alias to permit searches for an Ensembl database name prefix, such as
3830 ** "homo_sapiens". If an alias without underscores has also not been registered
3831 ** before, it will register the alias without underscores as species and the
3832 ** the prefix with underscores as alias.
3833 ** Ideally aliases have already been loaded from an Ensembl Database
3834 ** Connection or an Ensembl data file (EnsemblAliases.dat) before.
3835 ******************************************************************************/
3836
ensRegistryNewReferenceadaptor(EnsPDatabaseadaptor dba,EnsPDatabaseconnection dbc,AjPStr database,AjPStr alias,EnsEDatabaseadaptorGroup dbag,AjBool multi,ajuint identifier)3837 EnsPDatabaseadaptor ensRegistryNewReferenceadaptor(
3838 EnsPDatabaseadaptor dba,
3839 EnsPDatabaseconnection dbc,
3840 AjPStr database,
3841 AjPStr alias,
3842 EnsEDatabaseadaptorGroup dbag,
3843 AjBool multi,
3844 ajuint identifier)
3845 {
3846 AjPStr species = NULL;
3847
3848 EnsPDatabaseadaptor rsa = NULL;
3849
3850 if (ajDebugTest("ensRegistryNewReferenceadaptor"))
3851 {
3852 ajDebug("ensRegistryNewReferenceadaptor\n"
3853 " dba %p\n"
3854 " dbc %p\n"
3855 " database '%S'\n"
3856 " alias '%S'\n"
3857 " dbag '%s'\n"
3858 " multi '%B'\n"
3859 " identifier %u\n",
3860 dba,
3861 dbc,
3862 database,
3863 alias,
3864 ensDatabaseadaptorGroupToChar(dbag),
3865 multi,
3866 identifier);
3867
3868 ensDatabaseadaptorTrace(dba, 1);
3869
3870 ensDatabaseconnectionTrace(dbc, 1);
3871 }
3872
3873 if (!dba)
3874 return NULL;
3875
3876 if (!dbc)
3877 return NULL;
3878
3879 if (!database)
3880 return NULL;
3881
3882 if (!alias)
3883 return NULL;
3884
3885 ensRegistryAliasResolve(alias, &species);
3886
3887 if (species == NULL)
3888 species = alias;
3889
3890 rsa = ensDatabaseadaptorNewIni(dbc,
3891 database,
3892 species,
3893 dbag,
3894 multi,
3895 identifier);
3896
3897 if (ensRegistryAddReferenceadaptor(dba, rsa) == ajFalse)
3898 ensDatabaseadaptorDel(&rsa);
3899
3900 return rsa;
3901 }
3902
3903
3904
3905
3906 /* @section member addition ***************************************************
3907 **
3908 ** Functions for adding members to the Ensembl Registry.
3909 **
3910 ** @fdata [EnsPDatabaseadaptor]
3911 **
3912 ** @nam3rule Add Add one object to the Ensembl Registry
3913 ** @nam4rule Databaseadaptor Add an Ensembl Database Adaptor
3914 ** @nam4rule Referenceadaptor Add an Ensembl Database Adaptor as reference
3915 ** @nam4rule Stableidentifierprefix Add an Ensembl stable identifier prefix
3916 **
3917 ** @argrule Databaseadaptor dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3918 ** @argrule Referenceadaptor dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3919 ** @argrule Referenceadaptor rsa [EnsPDatabaseadaptor] Reference adaptor
3920 ** @argrule Stableidentifierprefix dba [EnsPDatabaseadaptor]
3921 ** Ensembl Database Adaptor
3922 ** @argrule Stableidentifierprefix prefix [const AjPStr]
3923 ** Stable identifier prefix
3924 **
3925 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3926 **
3927 ** @fcategory modify
3928 ******************************************************************************/
3929
3930
3931
3932
3933 /* @func ensRegistryAddDatabaseadaptor ****************************************
3934 **
3935 ** Add an Ensembl Database Adaptor to the Ensembl Registry.
3936 **
3937 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3938 **
3939 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3940 **
3941 ** @release 6.2.0
3942 ** @@
3943 ******************************************************************************/
3944
ensRegistryAddDatabaseadaptor(EnsPDatabaseadaptor dba)3945 AjBool ensRegistryAddDatabaseadaptor(EnsPDatabaseadaptor dba)
3946 {
3947 AjBool result = AJFALSE;
3948
3949 EnsEDatabaseadaptorGroup dbag = ensEDatabaseadaptorGroupNULL;
3950
3951 RegistryPEntry entry = NULL;
3952 RegistryPCoreStyle rcs = NULL;
3953 RegistryPGeneticVariation rgv = NULL;
3954 RegistryPFunctionalGenomics rfg = NULL;
3955 RegistryPComparativeGenomics rcg = NULL;
3956 RegistryPOntology ro = NULL;
3957
3958 if (ajDebugTest("ensRegistryAddDatabaseadaptor"))
3959 {
3960 ajDebug("ensRegistryAddDatabaseadaptor\n"
3961 " dba %p\n",
3962 dba);
3963
3964 ensDatabaseadaptorTrace(dba, 1);
3965 }
3966
3967 if (!dba)
3968 return ajFalse;
3969
3970 entry = (RegistryPEntry) ajTableFetchmodV(
3971 registryGEntry,
3972 (const void *) ensDatabaseadaptorGetSpecies(dba));
3973
3974 if (!entry)
3975 {
3976 AJNEW0(entry);
3977
3978 ajTablePut(registryGEntry,
3979 (void *) ajStrNewRef(ensDatabaseadaptorGetSpecies(dba)),
3980 (void *) entry);
3981 }
3982
3983 dbag = ensDatabaseadaptorGetGroup(dba);
3984
3985 switch (dbag)
3986 {
3987 case ensEDatabaseadaptorGroupCore:
3988
3989 case ensEDatabaseadaptorGroupVega:
3990
3991 case ensEDatabaseadaptorGroupOtherFeatures:
3992
3993 case ensEDatabaseadaptorGroupCopyDNA:
3994
3995 if (entry->Registry[dbag])
3996 rcs = (RegistryPCoreStyle) entry->Registry[dbag];
3997 else
3998 {
3999 AJNEW0(rcs);
4000
4001 entry->Registry[dbag] = (void *) rcs;
4002 }
4003
4004 if (rcs->Databaseadaptor)
4005 ajWarn("ensRegistryAddDatabaseadaptor already has an "
4006 "Ensembl Database Adaptor of the same "
4007 "species '%S' and group '%s' registered.",
4008 ensDatabaseadaptorGetSpecies(dba),
4009 ensDatabaseadaptorGroupToChar(dbag));
4010 else
4011 {
4012 rcs->Databaseadaptor = dba;
4013
4014 result = ajTrue;
4015 }
4016
4017 break;
4018
4019 case ensEDatabaseadaptorGroupGeneticVariation:
4020
4021 if (entry->Registry[dbag])
4022 rgv = (RegistryPGeneticVariation) entry->Registry[dbag];
4023 else
4024 {
4025 AJNEW0(rgv);
4026
4027 entry->Registry[dbag] = (void *) rgv;
4028 }
4029
4030 if (rgv->Databaseadaptor)
4031 ajWarn("ensRegistryAddDatabaseadaptor already has an "
4032 "Ensembl Database Adaptor of the same "
4033 "species '%S' and group '%s' registered.",
4034 ensDatabaseadaptorGetSpecies(dba),
4035 ensDatabaseadaptorGroupToChar(dbag));
4036 else
4037 {
4038 rgv->Databaseadaptor = dba;
4039
4040 result = ajTrue;
4041 }
4042
4043 break;
4044
4045 case ensEDatabaseadaptorGroupFunctionalGenomics:
4046
4047 if (entry->Registry[dbag])
4048 rfg = (RegistryPFunctionalGenomics) entry->Registry[dbag];
4049 else
4050 {
4051 AJNEW0(rfg);
4052
4053 entry->Registry[dbag] = (void *) rfg;
4054 }
4055
4056 if (rfg->Databaseadaptor)
4057 ajWarn("ensRegistryAddDatabaseadaptor already has an "
4058 "Ensembl Database Adaptor of the same "
4059 "species '%S' and group '%s' registered.",
4060 ensDatabaseadaptorGetSpecies(dba),
4061 ensDatabaseadaptorGroupToChar(dbag));
4062 else
4063 {
4064 rfg->Databaseadaptor = dba;
4065
4066 result = ajTrue;
4067 }
4068
4069 break;
4070
4071 case ensEDatabaseadaptorGroupComparativeGenomics:
4072
4073 if (entry->Registry[dbag])
4074 rcg = (RegistryPComparativeGenomics) entry->Registry[dbag];
4075 else
4076 {
4077 AJNEW0(rcg);
4078
4079 entry->Registry[dbag] = (void *) rcg;
4080 }
4081
4082 if (rcg->Databaseadaptor)
4083 ajWarn("ensRegistryAddDatabaseadaptor already has an "
4084 "Ensembl Database Adaptor of the same "
4085 "species '%S' and group '%s' registered.",
4086 ensDatabaseadaptorGetSpecies(dba),
4087 ensDatabaseadaptorGroupToChar(dbag));
4088 else
4089 {
4090 rcg->Databaseadaptor = dba;
4091
4092 result = ajTrue;
4093 }
4094
4095 break;
4096
4097 case ensEDatabaseadaptorGroupOntology:
4098
4099 if (entry->Registry[dbag])
4100 ro = (RegistryPOntology) entry->Registry[dbag];
4101 else
4102 {
4103 AJNEW0(ro);
4104
4105 entry->Registry[dbag] = (void *) ro;
4106 }
4107
4108 if (ro->Databaseadaptor)
4109 ajWarn("ensRegistryAddDatabaseadaptor already has an "
4110 "Ensembl Database Adaptor of the same "
4111 "species '%S' and group '%s' registered.",
4112 ensDatabaseadaptorGetSpecies(dba),
4113 ensDatabaseadaptorGroupToChar(dbag));
4114 else
4115 {
4116 ro->Databaseadaptor = dba;
4117
4118 result = ajTrue;
4119 }
4120
4121 break;
4122
4123 case ensEDatabaseadaptorGroupQualityCheck:
4124
4125 case ensEDatabaseadaptorGroupPipeline:
4126
4127 case ensEDatabaseadaptorGroupHive:
4128
4129 case ensEDatabaseadaptorGroupCoreExpressionEST:
4130
4131 case ensEDatabaseadaptorGroupCoreExpressionGNF:
4132
4133 case ensEDatabaseadaptorGroupAncestral:
4134
4135 case ensEDatabaseadaptorGroupWebsite:
4136
4137 case ensEDatabaseadaptorGroupProduction:
4138
4139 break;
4140
4141 default:
4142
4143 ajWarn("ensRegistryAddDatabaseadaptor got a request for an "
4144 "Ensembl Database Adaptor "
4145 "with an unexpected group %d.\n", dbag);
4146 }
4147
4148 return result;
4149 }
4150
4151
4152
4153
4154 /* @func ensRegistryAddReferenceadaptor ***************************************
4155 **
4156 ** Add an Ensembl Database Adaptor for the reference sequence to the
4157 ** Ensembl Registry.
4158 **
4159 ** This function will only return successfully, if the Ensembl Database
4160 ** Adaptor has been registered before and if its species and group match the
4161 ** reference sequence adaptor. Also, the reference sequence adaptor must not
4162 ** have been added before.
4163 **
4164 ** @cc Bio::EnsEMBL::Registry::add_DNAAdaptor
4165 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
4166 ** @param [u] rsa [EnsPDatabaseadaptor] Reference sequence adaptor
4167 **
4168 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4169 **
4170 ** @release 6.3.0
4171 ** @@
4172 ******************************************************************************/
4173
ensRegistryAddReferenceadaptor(EnsPDatabaseadaptor dba,EnsPDatabaseadaptor rsa)4174 AjBool ensRegistryAddReferenceadaptor(EnsPDatabaseadaptor dba,
4175 EnsPDatabaseadaptor rsa)
4176 {
4177 AjBool result = AJFALSE;
4178
4179 RegistryPEntry entry = NULL;
4180 RegistryPCoreStyle ecs = NULL;
4181
4182 if (ajDebugTest("ensRegistryAddReferenceAdaptor"))
4183 {
4184 ajDebug("ensRegistryAddReferenceAdaptor\n"
4185 " dba %p\n"
4186 " rsa %p\n",
4187 dba,
4188 rsa);
4189
4190 ensDatabaseadaptorTrace(dba, 1);
4191 ensDatabaseadaptorTrace(rsa, 1);
4192 }
4193
4194 if (!dba)
4195 return result;
4196
4197 if (!rsa)
4198 return result;
4199
4200 entry = (RegistryPEntry) ajTableFetchmodV(
4201 registryGEntry,
4202 (const void *) ensDatabaseadaptorGetSpecies(dba));
4203
4204 if (!entry)
4205 return result;
4206
4207 switch (ensDatabaseadaptorGetGroup(dba))
4208 {
4209 case ensEDatabaseadaptorGroupCore:
4210
4211 case ensEDatabaseadaptorGroupVega:
4212
4213 case ensEDatabaseadaptorGroupOtherFeatures:
4214
4215 case ensEDatabaseadaptorGroupCopyDNA:
4216
4217 ecs = entry->Registry[ensDatabaseadaptorGetGroup(dba)];
4218
4219 if ((ecs != NULL) && (ecs->Referenceadaptor == NULL))
4220 {
4221 ecs->Referenceadaptor = rsa;
4222
4223 result = ajTrue;
4224 }
4225
4226 break;
4227
4228 case ensEDatabaseadaptorGroupQualityCheck:
4229
4230 case ensEDatabaseadaptorGroupPipeline:
4231
4232 case ensEDatabaseadaptorGroupHive:
4233
4234 case ensEDatabaseadaptorGroupCoreExpressionEST:
4235
4236 case ensEDatabaseadaptorGroupCoreExpressionGNF:
4237
4238 case ensEDatabaseadaptorGroupAncestral:
4239
4240 case ensEDatabaseadaptorGroupWebsite:
4241
4242 case ensEDatabaseadaptorGroupProduction:
4243
4244 break;
4245
4246 default:
4247
4248 ajWarn("ensRegistryAddReferenceadaptor got a request for an "
4249 "Ensembl Database Adaptor "
4250 "with an unexpected group %d.\n",
4251 ensDatabaseadaptorGetGroup(dba));
4252 }
4253
4254 return result;
4255 }
4256
4257
4258
4259
4260 /* @func ensRegistryAddStableidentifierprefix *********************************
4261 **
4262 ** Add an Ensembl stable identifier prefix for an Ensembl Database Adaptor
4263 ** to the Ensembl Registry.
4264 **
4265 ** This function will only return successfully, if the Ensembl Database
4266 ** Adaptor has been registered before.
4267 **
4268 ** @cc Bio::EnsEMBL::Registry::*
4269 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
4270 ** @param [r] prefix [const AjPStr] Stable identifier prefix
4271 **
4272 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4273 **
4274 ** @release 6.3.0
4275 ** @@
4276 ******************************************************************************/
4277
ensRegistryAddStableidentifierprefix(EnsPDatabaseadaptor dba,const AjPStr prefix)4278 AjBool ensRegistryAddStableidentifierprefix(EnsPDatabaseadaptor dba,
4279 const AjPStr prefix)
4280 {
4281 AjBool result = AJFALSE;
4282
4283 RegistryPEntry entry = NULL;
4284 RegistryPCoreStyle ecs = NULL;
4285
4286 if (ajDebugTest("ensRegistryAddStableidentifierprefix"))
4287 {
4288 ajDebug("ensRegistryAddStableidentifierprefix\n"
4289 " dba %p\n"
4290 " prefix '%S'\n",
4291 dba,
4292 prefix);
4293
4294 ensDatabaseadaptorTrace(dba, 1);
4295 }
4296
4297 if (!dba)
4298 return result;
4299
4300 if (!(prefix && ajStrGetLen(prefix)))
4301 return result;
4302
4303 entry = (RegistryPEntry) ajTableFetchmodV(
4304 registryGEntry,
4305 (const void *) ensDatabaseadaptorGetSpecies(dba));
4306
4307 if (!entry)
4308 return result;
4309
4310 switch (ensDatabaseadaptorGetGroup(dba))
4311 {
4312 case ensEDatabaseadaptorGroupCore:
4313
4314 case ensEDatabaseadaptorGroupVega:
4315
4316 case ensEDatabaseadaptorGroupOtherFeatures:
4317
4318 case ensEDatabaseadaptorGroupCopyDNA:
4319
4320 ecs = entry->Registry[ensDatabaseadaptorGetGroup(dba)];
4321
4322 if (ecs != NULL)
4323 {
4324 if (ecs->Stableidentifierprefix == NULL)
4325 ecs->Stableidentifierprefix = ajStrNewS(prefix);
4326 else
4327 ajStrAssignS(&ecs->Stableidentifierprefix, prefix);
4328
4329 result = ajTrue;
4330 }
4331
4332 break;
4333
4334 case ensEDatabaseadaptorGroupQualityCheck:
4335
4336 case ensEDatabaseadaptorGroupPipeline:
4337
4338 case ensEDatabaseadaptorGroupHive:
4339
4340 case ensEDatabaseadaptorGroupCoreExpressionEST:
4341
4342 case ensEDatabaseadaptorGroupCoreExpressionGNF:
4343
4344 case ensEDatabaseadaptorGroupAncestral:
4345
4346 case ensEDatabaseadaptorGroupWebsite:
4347
4348 case ensEDatabaseadaptorGroupProduction:
4349
4350 break;
4351
4352 default:
4353
4354 ajWarn("ensRegistryAddStableidentifierprefix got a request for an "
4355 "Ensembl Database Adaptor "
4356 "with an unexpected group %d.\n",
4357 ensDatabaseadaptorGetGroup(dba));
4358 }
4359
4360 return result;
4361 }
4362
4363
4364
4365
4366 /* @section member removal ****************************************************
4367 **
4368 ** Functions for removing members from the Ensembl Registry.
4369 **
4370 ** @fdata [EnsPDatabaseadaptor]
4371 **
4372 ** @nam3rule Remove Remove one object from the Ensembl Registry
4373 ** @nam4rule Databaseadaptor Remove an Ensembl Database Adaptor
4374 **
4375 ** @argrule Databaseadaptor Pdba [EnsPDatabaseadaptor*]
4376 ** Ensembl Database Adaptor address
4377 **
4378 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
4379 **
4380 ** @fcategory modify
4381 ******************************************************************************/
4382
4383
4384
4385
4386 /* @func ensRegistryRemoveDatabaseadaptor *************************************
4387 **
4388 ** Remove an Ensembl Database Adaptor from the Ensembl Registry and delete it.
4389 **
4390 ** @param [d] Pdba [EnsPDatabaseadaptor*] Ensembl Database Adaptor address
4391 **
4392 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4393 **
4394 ** @release 6.2.0
4395 ** @@
4396 ******************************************************************************/
4397
ensRegistryRemoveDatabaseadaptor(EnsPDatabaseadaptor * Pdba)4398 AjBool ensRegistryRemoveDatabaseadaptor(EnsPDatabaseadaptor *Pdba)
4399 {
4400 AjBool registered = AJFALSE;
4401
4402 AjPStr key = NULL;
4403
4404 EnsEDatabaseadaptorGroup dbag = ensEDatabaseadaptorGroupNULL;
4405
4406 RegistryPEntry entry = NULL;
4407 RegistryPCoreStyle rcs = NULL;
4408 RegistryPGeneticVariation rgv = NULL;
4409 RegistryPFunctionalGenomics rfg = NULL;
4410 RegistryPComparativeGenomics rcg = NULL;
4411 RegistryPOntology ro = NULL;
4412
4413 if (!Pdba)
4414 return ajFalse;
4415
4416 if (!*Pdba)
4417 return ajFalse;
4418
4419 key = ajStrNewS(ensDatabaseadaptorGetSpecies(*Pdba));
4420
4421 entry = (RegistryPEntry) ajTableFetchmodV(
4422 registryGEntry,
4423 (const void *) key);
4424
4425 if (!entry)
4426 {
4427 ajWarn("ensRegistryRemoveDatabaseadaptor could not get "
4428 "a Registry Entry for species '%S'.\n",
4429 ensDatabaseadaptorGetSpecies(*Pdba));
4430
4431 *Pdba = NULL;
4432
4433 return ajTrue;
4434 }
4435
4436 dbag = ensDatabaseadaptorGetGroup(*Pdba);
4437
4438 switch (dbag)
4439 {
4440 case ensEDatabaseadaptorGroupCore:
4441
4442 case ensEDatabaseadaptorGroupVega:
4443
4444 case ensEDatabaseadaptorGroupOtherFeatures:
4445
4446 case ensEDatabaseadaptorGroupCopyDNA:
4447
4448 rcs = (RegistryPCoreStyle) entry->Registry[dbag];
4449
4450 if (rcs)
4451 {
4452 if (rcs->Databaseadaptor == *Pdba)
4453 registryCoreStyleDel((RegistryPCoreStyle *)
4454 &entry->Registry[dbag]);
4455 }
4456 else
4457 ajWarn("ensRegistryRemoveDatabaseadaptor got "
4458 "an Ensembl Database Adaptor, which is not "
4459 "registered?\n");
4460
4461 break;
4462
4463 case ensEDatabaseadaptorGroupGeneticVariation:
4464
4465 rgv = (RegistryPGeneticVariation) entry->Registry[dbag];
4466
4467 if (rgv)
4468 {
4469 if (rgv->Databaseadaptor == *Pdba)
4470 registryGeneticVariationDel((RegistryPGeneticVariation *)
4471 &entry->Registry[dbag]);
4472 }
4473 else
4474 ajWarn("ensRegistryRemoveDatabaseadaptor got "
4475 "an Ensembl Database Adaptor, which is not "
4476 "registered?\n");
4477
4478 break;
4479
4480 case ensEDatabaseadaptorGroupFunctionalGenomics:
4481
4482 rfg = (RegistryPFunctionalGenomics) entry->Registry[dbag];
4483
4484 if (rfg)
4485 {
4486 if (rfg->Databaseadaptor == *Pdba)
4487 registryFunctionalGenomicsDel(
4488 (RegistryPFunctionalGenomics *)
4489 &entry->Registry[dbag]);
4490 }
4491 else
4492 ajWarn("ensRegistryRemoveDatabaseadaptor got "
4493 "an Ensembl Database Adaptor, which is not "
4494 "registered?\n");
4495
4496 break;
4497
4498 case ensEDatabaseadaptorGroupComparativeGenomics:
4499
4500 rcg = (RegistryPComparativeGenomics) entry->Registry[dbag];
4501
4502 if (rcg)
4503 {
4504 if (rcg->Databaseadaptor == *Pdba)
4505 registryComparativeGenomicsDel(
4506 (RegistryPComparativeGenomics *)
4507 &entry->Registry[dbag]);
4508 }
4509 else
4510 ajWarn("ensRegistryRemoveDatabaseadaptor got "
4511 "an Ensembl Database Adaptor, which is not "
4512 "registered?\n");
4513
4514 break;
4515
4516 case ensEDatabaseadaptorGroupOntology:
4517
4518 ro = (RegistryPOntology) entry->Registry[dbag];
4519
4520 if (ro)
4521 {
4522 if (ro->Databaseadaptor == *Pdba)
4523 registryOntologyDel((RegistryPOntology *)
4524 &entry->Registry[dbag]);
4525 }
4526 else
4527 ajWarn("ensRegistryRemoveDatabaseadaptor got "
4528 "an Ensembl Database Adaptor, which is not "
4529 "registered?\n");
4530
4531 break;
4532
4533 case ensEDatabaseadaptorGroupQualityCheck:
4534
4535 case ensEDatabaseadaptorGroupPipeline:
4536
4537 case ensEDatabaseadaptorGroupHive:
4538
4539 case ensEDatabaseadaptorGroupCoreExpressionEST:
4540
4541 case ensEDatabaseadaptorGroupCoreExpressionGNF:
4542
4543 case ensEDatabaseadaptorGroupAncestral:
4544
4545 case ensEDatabaseadaptorGroupWebsite:
4546
4547 case ensEDatabaseadaptorGroupProduction:
4548
4549 break;
4550
4551 default:
4552
4553 ajWarn("ensRegistryRemoveDatabaseadaptor got an "
4554 "Ensembl Database Adaptor "
4555 "with an unexpected group %d.\n", dbag);
4556 }
4557
4558 /*
4559 ** Check if this Registry Entry remains completely empty and if so,
4560 ** remove it from the AJAX Table.
4561 */
4562
4563 for (dbag = ensEDatabaseadaptorGroupCore;
4564 dbag < EnsMDatabaseadaptorGroups;
4565 dbag++)
4566 if (entry->Registry[dbag])
4567 registered = ajTrue;
4568
4569 if (!registered)
4570 {
4571 entry = (RegistryPEntry) ajTableRemove(registryGEntry,
4572 (const void *) key);
4573
4574 registryEntryDel(&entry);
4575
4576 ajStrDel(&key);
4577 }
4578
4579 /* Clear the Ensembl Database Adaptor pointer. */
4580
4581 *Pdba = NULL;
4582
4583 return ajTrue;
4584 }
4585
4586
4587
4588
4589 /* @section member retrieval **************************************************
4590 **
4591 ** Functions for returning members from the
4592 ** Ensembl Registry.
4593 **
4594 ** @fdata [EnsPDatabaseadaptor]
4595 **
4596 ** @nam3rule Get Return Registry member(s)
4597 ** @nam4rule All Return all Registry members
4598 ** @nam5rule Databaseadaptors Return all Ensembl Database Adaptors
4599 ** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
4600 ** @nam4rule Referenceadaptor Return the Ensembl Reference Adaptor
4601 **
4602 ** @argrule AllDatabaseadaptors dbag [EnsEDatabaseadaptorGroup]
4603 ** Ensembl Database Adaptor Group enumeration
4604 ** @argrule AllDatabaseadaptors alias [AjPStr]
4605 ** Ensembl Database Adaptor alias name or species name
4606 ** @argrule AllDatabaseadaptors dbas [AjPList] AJAX List of
4607 ** Ensembl Database Adaptor objects
4608 ** @argrule Databaseadaptor dbag [EnsEDatabaseadaptorGroup]
4609 ** Ensembl Database Adaptor Group enumeration
4610 ** @argrule Databaseadaptor alias [AjPStr]
4611 ** Ensembl Database Adaptor alias name or species name
4612 ** @argrule Referenceadaptor dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
4613 **
4614 ** @valrule Databaseadaptors [AjBool] ajTrue upon success, ajFalse otherwise
4615 ** @valrule Databaseadaptor [EnsPDatabaseadaptor]
4616 ** Ensembl Database Adaptor or NULL
4617 ** @valrule Referenceadaptor [EnsPDatabaseadaptor]
4618 ** Ensembl Database Adaptor or NULL
4619 **
4620 ** @fcategory use
4621 ******************************************************************************/
4622
4623
4624
4625
4626 /* @func ensRegistryGetAllDatabaseadaptors ************************************
4627 **
4628 ** Get all Ensembl Database Adaptors from the Ensembl Registry
4629 ** and optionally filter them by species or group members.
4630 **
4631 ** The caller is responsible for deleting the AJAX List, but *must not* delete
4632 ** the Ensembl Database Adaptor objects.
4633 **
4634 ** @param [uN] dbag [EnsEDatabaseadaptorGroup]
4635 ** Ensembl Database Adaptor Group enumeration
4636 ** @param [uN] alias [AjPStr]
4637 ** Ensembl Database Adaptor alias name or species name
4638 ** @param [u] dbas [AjPList] AJAX List of Ensembl Database Adaptor objects
4639 **
4640 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4641 **
4642 ** @release 6.2.0
4643 ** @@
4644 ******************************************************************************/
4645
ensRegistryGetAllDatabaseadaptors(EnsEDatabaseadaptorGroup dbag,AjPStr alias,AjPList dbas)4646 AjBool ensRegistryGetAllDatabaseadaptors(EnsEDatabaseadaptorGroup dbag,
4647 AjPStr alias,
4648 AjPList dbas)
4649 {
4650 void **keyarray = NULL;
4651 void **valarray = NULL;
4652
4653 register ajuint i = 0U;
4654 register EnsEDatabaseadaptorGroup j = ensEDatabaseadaptorGroupNULL;
4655
4656 AjBool debug = AJFALSE;
4657
4658 AjPStr species = NULL;
4659
4660 EnsPDatabaseadaptor dba = NULL;
4661
4662 RegistryPCoreStyle rcs = NULL;
4663 RegistryPGeneticVariation rgv = NULL;
4664 RegistryPFunctionalGenomics rfg = NULL;
4665 RegistryPComparativeGenomics rcg = NULL;
4666 RegistryPOntology ro = NULL;
4667
4668 debug = ajDebugTest("ensRegistryGetAllDatabaseadaptors");
4669
4670 if (debug)
4671 ajDebug("ensRegistryGetAllDatabaseadaptors\n"
4672 " dbag %d\n"
4673 " alias '%S'\n"
4674 " dbas %p\n",
4675 dbag,
4676 alias,
4677 dbas);
4678
4679 if (!dbas)
4680 return ajFalse;
4681
4682 /*
4683 ** Resolve an alias name into a valid species name. If the alias did not
4684 ** resolve into a species name, use the alias directly. If an alias was
4685 ** not passed in, it is still NULL, implying all species.
4686 */
4687
4688 ensRegistryAliasResolve(alias, &species);
4689
4690 if (species == NULL)
4691 species = alias;
4692
4693 ajTableToarrayKeysValues(registryGEntry, &keyarray, &valarray);
4694
4695 for (i = 0U; keyarray[i]; i++)
4696 {
4697 for (j = ensEDatabaseadaptorGroupCore;
4698 j < EnsMDatabaseadaptorGroups;
4699 j++)
4700 {
4701 if (dbag && (dbag != j))
4702 continue;
4703
4704 switch (j)
4705 {
4706 case ensEDatabaseadaptorGroupCore:
4707
4708 case ensEDatabaseadaptorGroupVega:
4709
4710 case ensEDatabaseadaptorGroupOtherFeatures:
4711
4712 case ensEDatabaseadaptorGroupCopyDNA:
4713
4714 rcs = (RegistryPCoreStyle)
4715 (((RegistryPEntry) valarray[i])->Registry[j]);
4716
4717 if (rcs && rcs->Databaseadaptor)
4718 {
4719 dba = rcs->Databaseadaptor;
4720
4721 if (alias)
4722 {
4723 if (ajStrMatchS(species,
4724 ensDatabaseadaptorGetSpecies(dba)))
4725 ajListPushAppend(dbas, (void *) dba);
4726 }
4727 else
4728 ajListPushAppend(dbas, (void *) dba);
4729 }
4730
4731 break;
4732
4733 case ensEDatabaseadaptorGroupGeneticVariation:
4734
4735 rgv = (RegistryPGeneticVariation)
4736 (((RegistryPEntry) valarray[i])->Registry[j]);
4737
4738 if (rgv && rgv->Databaseadaptor)
4739 {
4740 dba = rgv->Databaseadaptor;
4741
4742 if (alias)
4743 {
4744 if (ajStrMatchS(species,
4745 ensDatabaseadaptorGetSpecies(dba)))
4746 ajListPushAppend(dbas, (void *) dba);
4747 }
4748 else
4749 ajListPushAppend(dbas, (void *) dba);
4750 }
4751
4752 break;
4753
4754 case ensEDatabaseadaptorGroupFunctionalGenomics:
4755
4756 rfg = (RegistryPFunctionalGenomics)
4757 (((RegistryPEntry) valarray[i])->Registry[j]);
4758
4759 if (rfg && rfg->Databaseadaptor)
4760 {
4761 dba = rfg->Databaseadaptor;
4762
4763 if (alias)
4764 {
4765 if (ajStrMatchS(species,
4766 ensDatabaseadaptorGetSpecies(dba)))
4767 ajListPushAppend(dbas, (void *) dba);
4768 }
4769 else
4770 ajListPushAppend(dbas, (void *) dba);
4771 }
4772
4773 break;
4774
4775 case ensEDatabaseadaptorGroupComparativeGenomics:
4776
4777 rcg = (RegistryPComparativeGenomics)
4778 (((RegistryPEntry) valarray[i])->Registry[j]);
4779
4780 if (rcg && rcg->Databaseadaptor)
4781 {
4782 dba = rcg->Databaseadaptor;
4783
4784 if (alias)
4785 {
4786 if (ajStrMatchS(species,
4787 ensDatabaseadaptorGetSpecies(dba)))
4788 ajListPushAppend(dbas, (void *) dba);
4789 }
4790 else
4791 ajListPushAppend(dbas, (void *) dba);
4792 }
4793
4794 break;
4795
4796 case ensEDatabaseadaptorGroupOntology:
4797
4798 ro = (RegistryPOntology)
4799 (((RegistryPEntry) valarray[i])->Registry[j]);
4800
4801 if (ro && ro->Databaseadaptor)
4802 {
4803 dba = ro->Databaseadaptor;
4804
4805 if (alias)
4806 {
4807 if (ajStrMatchS(species,
4808 ensDatabaseadaptorGetSpecies(dba)))
4809 ajListPushAppend(dbas, (void *) dba);
4810 }
4811 else
4812 ajListPushAppend(dbas, (void *) dba);
4813 }
4814
4815 break;
4816
4817 case ensEDatabaseadaptorGroupQualityCheck:
4818
4819 case ensEDatabaseadaptorGroupPipeline:
4820
4821 case ensEDatabaseadaptorGroupHive:
4822
4823 case ensEDatabaseadaptorGroupCoreExpressionEST:
4824
4825 case ensEDatabaseadaptorGroupCoreExpressionGNF:
4826
4827 case ensEDatabaseadaptorGroupAncestral:
4828
4829 case ensEDatabaseadaptorGroupWebsite:
4830
4831 case ensEDatabaseadaptorGroupProduction:
4832
4833 break;
4834
4835 default:
4836
4837 ajWarn("ensRegistryGetAllDatabaseadaptors got an "
4838 "unexpected group %d.\n", j);
4839 }
4840 }
4841 }
4842
4843 AJFREE(keyarray);
4844 AJFREE(valarray);
4845
4846 return ajTrue;
4847 }
4848
4849
4850
4851
4852 /* @func ensRegistryGetDatabaseadaptor ****************************************
4853 **
4854 ** Get an Ensembl Database Adaptor from the Ensembl Registry.
4855 **
4856 ** @cc Bio::EnsEMBL::Registry::get_DBAdaptor
4857 ** @param [u] dbag [EnsEDatabaseadaptorGroup]
4858 ** Ensembl Database Adaptor Group enumeration
4859 ** @param [u] alias [AjPStr] Scientific species name or alias name
4860 **
4861 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
4862 **
4863 ** @release 6.2.0
4864 ** @@
4865 ******************************************************************************/
4866
ensRegistryGetDatabaseadaptor(EnsEDatabaseadaptorGroup dbag,AjPStr alias)4867 EnsPDatabaseadaptor ensRegistryGetDatabaseadaptor(
4868 EnsEDatabaseadaptorGroup dbag,
4869 AjPStr alias)
4870 {
4871 AjBool debug = AJFALSE;
4872
4873 AjPStr species = NULL;
4874
4875 RegistryPEntry entry = NULL;
4876 RegistryPCoreStyle rcs = NULL;
4877 RegistryPGeneticVariation rgv = NULL;
4878 RegistryPFunctionalGenomics rfg = NULL;
4879 RegistryPComparativeGenomics rcg = NULL;
4880 RegistryPOntology ro = NULL;
4881
4882 debug = ajDebugTest("ensRegistryGetDatabaseadaptor");
4883
4884 if (debug)
4885 ajDebug("ensRegistryGetDatabaseadaptor\n"
4886 " dbag %d\n"
4887 " alias '%S'\n",
4888 dbag,
4889 alias);
4890
4891 if (!dbag)
4892 return NULL;
4893
4894 if (!alias)
4895 return NULL;
4896
4897 /*
4898 ** Resolve an alias name into a valid species name. If the alias did not
4899 ** resolve into a species name, use the alias directly.
4900 */
4901
4902 ensRegistryAliasResolve(alias, &species);
4903
4904 if (species == NULL)
4905 species = alias;
4906
4907 if (debug)
4908 ajDebug("ensRegistryGetDatabaseadaptor resolved alias '%S' "
4909 "into species '%S'.\n",
4910 alias, species);
4911
4912 entry = (RegistryPEntry) ajTableFetchmodV(
4913 registryGEntry,
4914 (const void *) species);
4915
4916 if (!entry)
4917 {
4918 ajDebug("ensRegistryGetDatabaseadaptor could not get a "
4919 "Registry Entry for group '%s' and species '%S'.\n",
4920 ensDatabaseadaptorGroupToChar(dbag), species);
4921
4922 return NULL;
4923 }
4924
4925 switch (dbag)
4926 {
4927 case ensEDatabaseadaptorGroupCore:
4928
4929 case ensEDatabaseadaptorGroupVega:
4930
4931 case ensEDatabaseadaptorGroupOtherFeatures:
4932
4933 case ensEDatabaseadaptorGroupCopyDNA:
4934
4935 rcs = (RegistryPCoreStyle) entry->Registry[dbag];
4936
4937 if (rcs)
4938 return rcs->Databaseadaptor;
4939 else
4940 {
4941 ajDebug("ensRegistryGetDatabaseadaptor could not get an "
4942 "Ensembl Database Adaptor for group '%s' and "
4943 "species '%S'.\n",
4944 ensDatabaseadaptorGroupToChar(dbag), species);
4945
4946 return NULL;
4947 }
4948
4949 break;
4950
4951 case ensEDatabaseadaptorGroupGeneticVariation:
4952
4953 rgv = (RegistryPGeneticVariation) entry->Registry[dbag];
4954
4955 if (rgv)
4956 return rgv->Databaseadaptor;
4957 else
4958 {
4959 ajDebug("ensRegistryGetDatabaseadaptor could not get an "
4960 "Ensembl Database Adaptor for group '%s' and "
4961 "species '%S'.\n",
4962 ensDatabaseadaptorGroupToChar(dbag), species);
4963
4964 return NULL;
4965 }
4966
4967 break;
4968
4969 case ensEDatabaseadaptorGroupFunctionalGenomics:
4970
4971 rfg = (RegistryPFunctionalGenomics) entry->Registry[dbag];
4972
4973 if (rfg)
4974 return rfg->Databaseadaptor;
4975 else
4976 {
4977 ajDebug("ensRegistryGetDatabaseadaptor could not get an "
4978 "Ensembl Database Adaptor for group '%s' and "
4979 "species '%S'.\n",
4980 ensDatabaseadaptorGroupToChar(dbag), species);
4981
4982 return NULL;
4983 }
4984
4985 break;
4986
4987 case ensEDatabaseadaptorGroupComparativeGenomics:
4988
4989 rcg = (RegistryPComparativeGenomics) entry->Registry[dbag];
4990
4991 if (rcg)
4992 return rcg->Databaseadaptor;
4993 else
4994 {
4995 ajDebug("ensRegistryGetDatabaseadaptor could not get an "
4996 "Ensembl Database Adaptor for group '%s' and "
4997 "species '%S'.\n",
4998 ensDatabaseadaptorGroupToChar(dbag), species);
4999
5000 return NULL;
5001 }
5002
5003 break;
5004
5005 case ensEDatabaseadaptorGroupOntology:
5006
5007 ro = (RegistryPOntology) entry->Registry[dbag];
5008
5009 if (ro)
5010 return ro->Databaseadaptor;
5011 else
5012 {
5013 ajDebug("ensRegistryGetDatabaseadaptor could not get an "
5014 "Ensembl Database Adaptor for group '%s' and "
5015 "species '%S'.\n",
5016 ensDatabaseadaptorGroupToChar(dbag), species);
5017
5018 return NULL;
5019 }
5020
5021 break;
5022
5023 case ensEDatabaseadaptorGroupQualityCheck:
5024
5025 case ensEDatabaseadaptorGroupPipeline:
5026
5027 case ensEDatabaseadaptorGroupHive:
5028
5029 case ensEDatabaseadaptorGroupCoreExpressionEST:
5030
5031 case ensEDatabaseadaptorGroupCoreExpressionGNF:
5032
5033 case ensEDatabaseadaptorGroupAncestral:
5034
5035 case ensEDatabaseadaptorGroupWebsite:
5036
5037 case ensEDatabaseadaptorGroupProduction:
5038
5039 break;
5040
5041 default:
5042
5043 ajWarn("ensRegistryGetDatabaseadaptor got an "
5044 "Ensembl Database Adaptor "
5045 "with an unexpected group %d.\n", dbag);
5046 }
5047
5048 return NULL;
5049 }
5050
5051
5052
5053
5054 /* @func ensRegistryGetReferenceadaptor ***************************************
5055 **
5056 ** Get an Ensembl Reference Adaptor from the Ensembl Registry.
5057 **
5058 ** An Ensembl Reference Adaptor is an Ensembl Database Adaptor that is
5059 ** connected to an Ensembl core-style database that serves as the reference
5060 ** for a particular species.
5061 ** Reference databases have the rather large sequence and assembly tables
5062 ** populated, backing the following adaptors. In the set of release databases,
5063 ** the core database serve as the reference. Other core-style databases
5064 ** (e.g. cdna, otherfeatures, vega) are linked to the reference database by
5065 ** setting the Reference Adaptor and thus avoiding redundant storage of large
5066 ** data sets.
5067 **
5068 ** This function will return the following Database Adaptors ordered by
5069 ** precedence.
5070 ** * Reference Adaptor of this group
5071 ** * Reference Adaptor of the core group
5072 ** * Database Adaptor of the core group
5073 ** * Database Adaptor of this group
5074 **
5075 ** @see ensRegistryGetAssemblyexceptionadaptor
5076 ** @see ensRegistryGetAssemblyexceptionfeatureadaptor
5077 ** @see ensRegistryGetAssemblymapperadaptor
5078 ** @see ensRegistryGetCoordsystemadaptor
5079 ** @see ensRegistryGetKaryotypebandadaptor
5080 ** @see ensRegistryGetRepeatconsensusadaptor
5081 ** @see ensRegistryGetRepeatfeatureadaptor
5082 ** @see ensRegistryGetSequenceadaptor
5083 **
5084 ** @cc Bio::EnsEMBL::Registry::get_DNAAdaptor
5085 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5086 **
5087 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
5088 **
5089 ** @release 6.3.0
5090 ** @@
5091 ******************************************************************************/
5092
ensRegistryGetReferenceadaptor(EnsPDatabaseadaptor dba)5093 EnsPDatabaseadaptor ensRegistryGetReferenceadaptor(EnsPDatabaseadaptor dba)
5094 {
5095 AjBool debug = AJFALSE;
5096
5097 EnsPDatabaseadaptor rsa = NULL;
5098
5099 RegistryPEntry entry = NULL;
5100 RegistryPCoreStyle rcs = NULL;
5101 RegistryPGeneticVariation rgv = NULL;
5102
5103 debug = ajDebugTest("ensRegistryGetReferenceadaptor");
5104
5105 if (debug)
5106 {
5107 ajDebug("ensRegistryGetReferenceadaptor\n"
5108 " dba %p\n",
5109 dba);
5110
5111 ensDatabaseadaptorTrace(dba, 1);
5112 }
5113
5114 if (!dba)
5115 return NULL;
5116
5117 entry = (RegistryPEntry) ajTableFetchmodV(
5118 registryGEntry,
5119 (const void *) ensDatabaseadaptorGetSpecies(dba));
5120
5121 if (!entry)
5122 return NULL;
5123
5124 switch (ensDatabaseadaptorGetGroup(dba))
5125 {
5126 case ensEDatabaseadaptorGroupCore:
5127
5128 rcs = (RegistryPCoreStyle)
5129 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
5130
5131 if (!rcs)
5132 break;
5133
5134 rsa = (rcs->Referenceadaptor) ?
5135 rcs->Referenceadaptor :
5136 rcs->Databaseadaptor;
5137
5138 break;
5139
5140 case ensEDatabaseadaptorGroupVega:
5141
5142 case ensEDatabaseadaptorGroupOtherFeatures:
5143
5144 case ensEDatabaseadaptorGroupCopyDNA:
5145
5146 rcs = (RegistryPCoreStyle)
5147 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
5148
5149 if (!rcs)
5150 break;
5151
5152 if (rcs->Referenceadaptor)
5153 rsa = rcs->Referenceadaptor;
5154 else
5155 {
5156 /*
5157 ** If a Reference Adaptor has not been set for this group,
5158 ** return the Reference Adaptor for the core group.
5159 */
5160
5161 rcs = (RegistryPCoreStyle)
5162 entry->Registry[ensEDatabaseadaptorGroupCore];
5163
5164 if (rcs)
5165 {
5166 rsa = ensRegistryGetReferenceadaptor(rcs->Databaseadaptor);
5167
5168 if (!rsa)
5169 {
5170 /*
5171 ** If neither Reference nor Database Adaptor for the
5172 ** core group has been set, return the Database
5173 ** Adaptor for this group and hope for the best.
5174 */
5175
5176 rcs = (RegistryPCoreStyle)
5177 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
5178
5179 if (rcs)
5180 rsa = rcs->Databaseadaptor;
5181 }
5182 }
5183 }
5184
5185 break;
5186
5187 case ensEDatabaseadaptorGroupGeneticVariation:
5188
5189 rgv = (RegistryPGeneticVariation)
5190 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
5191
5192 if (!rgv)
5193 break;
5194
5195 rcs = (RegistryPCoreStyle)
5196 entry->Registry[ensEDatabaseadaptorGroupCore];
5197
5198 if (rcs)
5199 rsa = ensRegistryGetReferenceadaptor(rcs->Databaseadaptor);
5200
5201 default:
5202
5203 ajWarn("ensRegistryGetReferenceadaptor got an "
5204 "Ensembl Database Adaptor "
5205 "with an unexpected group %d.\n",
5206 ensDatabaseadaptorGetGroup(dba));
5207 }
5208
5209 if (debug)
5210 {
5211 ajDebug("ensRegistryGetReferenceadaptor dba %p rsa %p\n", dba, rsa);
5212
5213 ensDatabaseadaptorTrace(rsa, 1);
5214 }
5215
5216 return rsa;
5217 }
5218
5219
5220
5221
5222 /* @section Ensembl Core-Style Adaptor retrieval ******************************
5223 **
5224 ** Functions for returning Ensembl Core-Style Adaptor objects from the
5225 ** Ensembl Registry.
5226 **
5227 ** @fdata [EnsPDatabaseadaptor]
5228 **
5229 ** @nam3rule Get Return Registry attribute(s)
5230 ** @nam4rule Analysisadaptor
5231 ** Return the Ensembl Analysis Adaptor
5232 ** @nam4rule Assemblyexceptionadaptor
5233 ** Return the Ensembl Assembly Exception Adaptor
5234 ** @nam4rule Assemblyexceptionfeatureadaptor
5235 ** Return the Ensembl Assembly Exception Feature Adaptor
5236 ** @nam4rule Assemblymapperadaptor
5237 ** Return the Ensembl Assembly Mapper Adaptor
5238 ** @nam4rule Attributeadaptor
5239 ** Return the Ensembl Attribute Adaptor
5240 ** @nam4rule Attributetypeadaptor
5241 ** Return the Ensembl Attribute Type Adaptor
5242 ** @nam4rule Coordsystemadaptor
5243 ** Return the Ensembl Coordinate System Adaptor
5244 ** @nam4rule Databaseentryadaptor
5245 ** Return the Ensembl Database Entry Adaptor
5246 ** @nam4rule Densityfeatureadaptor
5247 ** Return the Ensembl Density Feature Adaptor
5248 ** @nam4rule Densitytypeadaptor
5249 ** Return the Ensembl Density Type Adaptor
5250 ** @nam4rule Ditagadaptor
5251 ** Return the Ensembl Ditag Adaptor
5252 ** @nam4rule Ditagfeatureadaptor
5253 ** Return the Ensembl Ditag Feature Adaptor
5254 ** @nam4rule Dnaalignfeatureadaptor
5255 ** Return the Ensembl DNA Align Feature Adaptor
5256 ** @nam4rule Exonadaptor
5257 ** Return the Ensembl Exon Adaptor
5258 ** @nam4rule Externaldatabaseadaptor
5259 ** Return the Ensembl External Database Adaptor
5260 ** @nam4rule Geneadaptor
5261 ** Return the Ensembl Gene Adaptor
5262 ** @nam4rule Intronsupportingevidenceadaptor
5263 ** Return the Ensembl Intron Supporting Evidence Adaptor
5264 ** @nam4rule Karyotypebandadaptor
5265 ** Return the Ensembl Karyotype Band Adaptor
5266 ** @nam4rule Markeradaptor
5267 ** Return the Ensembl Marker Adaptor
5268 ** @nam4rule Markerfeatureadaptor
5269 ** Return the Ensembl Marker Feature Adaptor
5270 ** @nam4rule Markermaplocationadaptor
5271 ** Return the Ensembl Marker Map Location Adaptor
5272 ** @nam4rule Markersynonymadaptor
5273 ** Return the Ensembl Marker Synonym Adaptor
5274 ** @nam4rule Metacoordinateadaptor
5275 ** Return the Ensembl Meta-Coordinate Adaptor
5276 ** @nam4rule Metainformationadaptor
5277 ** Return the Ensembl Meta-Information Adaptor
5278 ** @nam4rule Miscellaneousfeatureadaptor
5279 ** Return the Ensembl Miscellaneous Feature Adaptor
5280 ** @nam4rule Miscellaneoussetadaptor
5281 ** Return the Ensembl Miscellaneous Set Adaptor
5282 ** @nam4rule Operonadaptor
5283 ** Return the Ensembl Operon Adaptor
5284 ** @nam4rule Operontranscriptadaptor
5285 ** Return the Ensembl Operon Transcript Adaptor
5286 ** @nam4rule Predictionexonadaptor
5287 ** Return the Ensembl Prediction Exon Adaptor
5288 ** @nam4rule Predictiontranscriptadaptor
5289 ** Return the Ensembl Prediction Transcript Adaptor
5290 ** @nam4rule Proteinalignfeatureadaptor
5291 ** Return the Ensembl Protein Align Feature Adaptor
5292 ** @nam4rule Proteinfeatureadaptor
5293 ** Return the Ensembl Protein Feature Adaptor
5294 ** @nam4rule Repeatconsensusadaptor
5295 ** Return the Ensembl Repeat Consensus Adaptor
5296 ** @nam4rule Repeatfeatureadaptor
5297 ** Return the Ensembl Repeat Feature Adaptor
5298 ** @nam4rule Seqregionadaptor
5299 ** Return the Ensembl Sequence Region Adaptor
5300 ** @nam4rule Seqregionsynonymadaptor
5301 ** Return the Ensembl Sequence Region Synonym Adaptor
5302 ** @nam4rule Sequenceadaptor
5303 ** Return the Ensembl Sequence Adaptor
5304 ** @nam4rule Simplefeatureadaptor
5305 ** Return the Ensembl Simple Feature Adaptor
5306 ** @nam4rule Sliceadaptor
5307 ** Return the Ensembl Slice Adaptor
5308 ** @nam4rule Stableidentifierprefix
5309 ** Return the Ensembl stable identifier prefix
5310 ** @nam4rule Supportingfeatureadaptor
5311 ** Return the Ensembl Supporting Feature Adaptor
5312 ** @nam4rule Transcriptadaptor
5313 ** Return the Ensembl Transcript Adaptor
5314 ** @nam4rule Translationadaptor
5315 ** Return the Ensembl Translation Adaptor
5316 **
5317 ** @argrule * dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5318 **
5319 ** @valrule Analysisadaptor [EnsPAnalysisadaptor]
5320 ** Ensembl Analysis Adaptor or NULL
5321 ** @valrule Assemblyexceptionadaptor [EnsPAssemblyexceptionadaptor]
5322 ** Ensembl Assembly Exception Adaptor or NULL
5323 ** @valrule Assemblyexceptionfeatureadaptor [EnsPAssemblyexceptionfeatureadaptor]
5324 ** Ensembl Assembly Exception Feature Adaptor or NULL
5325 ** @valrule Assemblymapperadaptor [EnsPAssemblymapperadaptor]
5326 ** Ensembl Assembly Mapper Adaptor or NULL
5327 ** @valrule Attributeadaptor [EnsPAttributeadaptor]
5328 ** Ensembl Attribute Adaptor or NULL
5329 ** @valrule Attributetypeadaptor [EnsPAttributetypeadaptor]
5330 ** Ensembl Attribute Type Adaptor or NULL
5331 ** @valrule Coordsystemadaptor [EnsPCoordsystemadaptor]
5332 ** Ensembl Coordinate System Adaptor or NULL
5333 ** @valrule Databaseentryadaptor [EnsPDatabaseentryadaptor]
5334 ** Ensembl Database Entry Adaptor or NULL
5335 ** @valrule Densityfeatureadaptor [EnsPDensityfeatureadaptor]
5336 ** Ensembl Density Feature Adaptor or NULL
5337 ** @valrule Densitytypeadaptor [EnsPDensitytypeadaptor]
5338 ** Ensembl Density Type Adaptor or NULL
5339 ** @valrule Ditagadaptor [EnsPDitagadaptor]
5340 ** Ensembl Ditag Adaptor or NULL
5341 ** @valrule Ditagfeatureadaptor [EnsPDitagfeatureadaptor]
5342 ** Ensembl Ditag Feature Adaptor or NULL
5343 ** @valrule Dnaalignfeatureadaptor [EnsPDnaalignfeatureadaptor]
5344 ** Ensembl DNA Align Feature Adaptor or NULL
5345 ** @valrule Exonadaptor [EnsPExonadaptor]
5346 ** Ensembl Exon Adaptor or NULL
5347 ** @valrule Externaldatabaseadaptor [EnsPExternaldatabaseadaptor]
5348 ** Ensembl External Database Adaptor or NULL
5349 ** @valrule Geneadaptor [EnsPGeneadaptor]
5350 ** Ensembl Gene Adaptor or NULL
5351 ** @valrule Intronsupportingevidenceadaptor [EnsPIntronsupportingevidenceadaptor]
5352 ** Ensembl Intron Supporting Evidence Adaptor or NULL
5353 ** @valrule Karyotypebandadaptor [EnsPKaryotypebandadaptor]
5354 ** Ensembl Karyotype Band Adaptor or NULL
5355 ** @valrule Markeradaptor [EnsPMarkeradaptor]
5356 ** Ensembl Marker Adaptor or NULL
5357 ** @valrule Markerfeatureadaptor [EnsPMarkerfeatureadaptor]
5358 ** Ensembl Marker Feature Adaptor or NULL
5359 ** @valrule Markermaplocationadaptor [EnsPMarkermaplocationadaptor]
5360 ** Ensembl Marker Map Location Adaptor or NULL
5361 ** @valrule Markersynonymadaptor [EnsPMarkersynonymadaptor]
5362 ** Ensembl Marker Synonym Adaptor or NULL
5363 ** @valrule Metacoordinateadaptor [EnsPMetacoordinateadaptor]
5364 ** Ensembl Meta-Coordinate Adaptor or NULL
5365 ** @valrule Metainformationadaptor [EnsPMetainformationadaptor]
5366 ** Ensembl Meta-Information Adaptor or NULL
5367 ** @valrule Miscellaneousfeatureadaptor [EnsPMiscellaneousfeatureadaptor]
5368 ** Ensembl Miscellaneous Feature Adaptor or NULL
5369 ** @valrule Miscellaneoussetadaptor [EnsPMiscellaneoussetadaptor]
5370 ** Ensembl Miscellaneous Set Adaptor or NULL
5371 ** @valrule Operonadaptor [EnsPOperonadaptor]
5372 ** Ensembl Operon Adaptor or NULL
5373 ** @valrule Operontranscriptadaptor [EnsPOperontranscriptadaptor]
5374 ** Ensembl Operon Transcript Adaptor or NULL
5375 ** @valrule Predictionexonadaptor [EnsPPredictionexonadaptor]
5376 ** Ensembl Prediction Exon Adaptor or NULL
5377 ** @valrule Predictiontranscriptadaptor [EnsPPredictiontranscriptadaptor]
5378 ** Ensembl Prediction Transcript Adaptor or NULL
5379 ** @valrule Proteinalignfeatureadaptor [EnsPProteinalignfeatureadaptor]
5380 ** Ensembl Protein Align Feature Adaptor or NULL
5381 ** @valrule Proteinfeatureadaptor [EnsPProteinfeatureadaptor]
5382 ** Ensembl Protein Feature Adaptor or NULL
5383 ** @valrule Repeatconsensusadaptor [EnsPRepeatconsensusadaptor]
5384 ** Ensembl Repeat Consensus Adaptor or NULL
5385 ** @valrule Repeatfeatureadaptor [EnsPRepeatfeatureadaptor]
5386 ** Ensembl Repeat Feature Adaptor or NULL
5387 ** @valrule Seqregionadaptor [EnsPSeqregionadaptor]
5388 ** Ensembl Sequence Region Adaptor or NULL
5389 ** @valrule Seqregionsynonymadaptor [EnsPSeqregionsynonymadaptor]
5390 ** Ensembl Sequence Region Synonym Adaptor or NULL
5391 ** @valrule Sequenceadaptor [EnsPSequenceadaptor]
5392 ** Ensembl Sequence Adaptor or NULL
5393 ** @valrule Simplefeatureadaptor [EnsPSimplefeatureadaptor]
5394 ** Ensembl Simple Feature Adaptor or NULL
5395 ** @valrule Sliceadaptor [EnsPSliceadaptor]
5396 ** Ensembl Slice Adaptor or NULL
5397 ** @valrule Stableidentifierprefix [AjPStr]
5398 ** Ensembl stable identifier prefix or NULL
5399 ** @valrule Supportingfeatureadaptor [EnsPSupportingfeatureadaptor]
5400 ** Ensembl Supporting Feature Adaptor or NULL
5401 ** @valrule Transcriptadaptor [EnsPTranscriptadaptor]
5402 ** Ensembl Transcript Adaptor or NULL
5403 ** @valrule Translationadaptor [EnsPTranslationadaptor]
5404 ** Ensembl Translation Adaptor or NULL
5405 **
5406 ** @fcategory use
5407 ******************************************************************************/
5408
5409
5410
5411
5412 /* @func ensRegistryGetAnalysisadaptor ****************************************
5413 **
5414 ** Get an Ensembl Analysis Adaptor from the Ensembl Registry.
5415 **
5416 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5417 **
5418 ** @return [EnsPAnalysisadaptor]
5419 ** Ensembl Analysis Adaptor or NULL
5420 **
5421 ** @release 6.2.0
5422 ** @@
5423 ******************************************************************************/
5424
ensRegistryGetAnalysisadaptor(EnsPDatabaseadaptor dba)5425 EnsPAnalysisadaptor ensRegistryGetAnalysisadaptor(EnsPDatabaseadaptor dba)
5426 {
5427 RegistryPEntry entry = NULL;
5428 RegistryPCoreStyle rcs = NULL;
5429
5430 if (!dba)
5431 return NULL;
5432
5433 entry = (RegistryPEntry) ajTableFetchmodV(
5434 registryGEntry,
5435 (const void *) ensDatabaseadaptorGetSpecies(dba));
5436
5437 if (!entry)
5438 return NULL;
5439
5440 switch (ensDatabaseadaptorGetGroup(dba))
5441 {
5442 case ensEDatabaseadaptorGroupCore:
5443
5444 case ensEDatabaseadaptorGroupVega:
5445
5446 case ensEDatabaseadaptorGroupOtherFeatures:
5447
5448 case ensEDatabaseadaptorGroupCopyDNA:
5449
5450 rcs = (RegistryPCoreStyle)
5451 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
5452
5453 if (!rcs)
5454 break;
5455
5456 if (!rcs->Analysisadaptor)
5457 rcs->Analysisadaptor =
5458 ensAnalysisadaptorNew(dba);
5459
5460 return rcs->Analysisadaptor;
5461
5462 break;
5463
5464 default:
5465
5466 ajWarn("ensRegistryGetAnalysisadaptor got an "
5467 "Ensembl Database Adaptor "
5468 "with an unexpected group %d.\n",
5469 ensDatabaseadaptorGetGroup(dba));
5470 }
5471
5472 return NULL;
5473 }
5474
5475
5476
5477
5478 /* @func ensRegistryGetAssemblyexceptionadaptor *******************************
5479 **
5480 ** Get an Ensembl Assembly Exception Adaptor from the Ensembl Registry.
5481 **
5482 ** If an Ensembl Reference Adaptor has been set for this database, the adaptor
5483 ** returned will be based on the Ensembl Reference Adaptor rather than the
5484 ** Ensembl Database Adaptor that was passed in.
5485 **
5486 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5487 **
5488 ** @return [EnsPAssemblyexceptionadaptor]
5489 ** Ensembl Assembly Exception Adaptor or NULL
5490 **
5491 ** @release 6.2.0
5492 ** @@
5493 ******************************************************************************/
5494
ensRegistryGetAssemblyexceptionadaptor(EnsPDatabaseadaptor dba)5495 EnsPAssemblyexceptionadaptor ensRegistryGetAssemblyexceptionadaptor(
5496 EnsPDatabaseadaptor dba)
5497 {
5498 EnsPDatabaseadaptor rsa = NULL;
5499
5500 RegistryPEntry entry = NULL;
5501 RegistryPCoreStyle rcs = NULL;
5502
5503 if (!dba)
5504 return NULL;
5505
5506 rsa = ensRegistryGetReferenceadaptor(dba);
5507
5508 entry = (RegistryPEntry) ajTableFetchmodV(
5509 registryGEntry,
5510 (const void *) ensDatabaseadaptorGetSpecies(rsa));
5511
5512 if (!entry)
5513 return NULL;
5514
5515 switch (ensDatabaseadaptorGetGroup(rsa))
5516 {
5517 case ensEDatabaseadaptorGroupCore:
5518
5519 case ensEDatabaseadaptorGroupVega:
5520
5521 case ensEDatabaseadaptorGroupOtherFeatures:
5522
5523 case ensEDatabaseadaptorGroupCopyDNA:
5524
5525 rcs = (RegistryPCoreStyle)
5526 entry->Registry[ensDatabaseadaptorGetGroup(rsa)];
5527
5528 if (!rcs)
5529 break;
5530
5531 if (!rcs->Assemblyexceptionadaptor)
5532 rcs->Assemblyexceptionadaptor =
5533 ensAssemblyexceptionadaptorNew(rsa);
5534
5535 return rcs->Assemblyexceptionadaptor;
5536
5537 break;
5538
5539 default:
5540
5541 ajWarn("ensRegistryGetAssemblyexceptionadaptor got an "
5542 "Ensembl Database Adaptor "
5543 "with an unexpected group %d.\n",
5544 ensDatabaseadaptorGetGroup(rsa));
5545 }
5546
5547 return NULL;
5548 }
5549
5550
5551
5552
5553 /* @func ensRegistryGetAssemblyexceptionfeatureadaptor ************************
5554 **
5555 ** Get an Ensembl Assembly Exception Feature Adaptor from the Ensembl Registry.
5556 **
5557 ** If an Ensembl Reference Adaptor has been set for this database, the adaptor
5558 ** returned will be based on the Ensembl Reference Adaptor rather than the
5559 ** Ensembl Database Adaptor that was passed in.
5560 **
5561 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5562 **
5563 ** @return [EnsPAssemblyexceptionfeatureadaptor]
5564 ** Ensembl Assembly Exception Feature Adaptor or NULL
5565 **
5566 ** @release 6.2.0
5567 ** @@
5568 ******************************************************************************/
5569
ensRegistryGetAssemblyexceptionfeatureadaptor(EnsPDatabaseadaptor dba)5570 EnsPAssemblyexceptionfeatureadaptor ensRegistryGetAssemblyexceptionfeatureadaptor(
5571 EnsPDatabaseadaptor dba)
5572 {
5573 EnsPDatabaseadaptor rsa = NULL;
5574
5575 RegistryPEntry entry = NULL;
5576 RegistryPCoreStyle rcs = NULL;
5577
5578 if (!dba)
5579 return NULL;
5580
5581 rsa = ensRegistryGetReferenceadaptor(dba);
5582
5583 entry = (RegistryPEntry) ajTableFetchmodV(
5584 registryGEntry,
5585 (const void *) ensDatabaseadaptorGetSpecies(rsa));
5586
5587 if (!entry)
5588 return NULL;
5589
5590 switch (ensDatabaseadaptorGetGroup(rsa))
5591 {
5592 case ensEDatabaseadaptorGroupCore:
5593
5594 case ensEDatabaseadaptorGroupVega:
5595
5596 case ensEDatabaseadaptorGroupOtherFeatures:
5597
5598 case ensEDatabaseadaptorGroupCopyDNA:
5599
5600 rcs = (RegistryPCoreStyle)
5601 entry->Registry[ensDatabaseadaptorGetGroup(rsa)];
5602
5603 if (!rcs)
5604 break;
5605
5606 if (!rcs->Assemblyexceptionfeatureadaptor)
5607 rcs->Assemblyexceptionfeatureadaptor =
5608 ensAssemblyexceptionfeatureadaptorNew(rsa);
5609
5610 return rcs->Assemblyexceptionfeatureadaptor;
5611
5612 break;
5613
5614 default:
5615
5616 ajWarn("ensRegistryGetAssemblyexceptionfeatureadaptor got an "
5617 "Ensembl Database Adaptor "
5618 "with an unexpected group %d.\n",
5619 ensDatabaseadaptorGetGroup(rsa));
5620 }
5621
5622 return NULL;
5623 }
5624
5625
5626
5627
5628 /* @func ensRegistryGetAssemblymapperadaptor **********************************
5629 **
5630 ** Get an Ensembl Assembly Mapper Adaptor from the Ensembl Registry.
5631 **
5632 ** If an Ensembl Reference Adaptor has been set for this database, the adaptor
5633 ** returned will be based on the Ensembl Reference Adaptor rather than the
5634 ** Ensembl Database Adaptor that was passed in.
5635 **
5636 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5637 **
5638 ** @return [EnsPAssemblymapperadaptor]
5639 ** Ensembl Assembly Mapper Adaptor or NULL
5640 **
5641 ** @release 6.2.0
5642 ** @@
5643 ******************************************************************************/
5644
ensRegistryGetAssemblymapperadaptor(EnsPDatabaseadaptor dba)5645 EnsPAssemblymapperadaptor ensRegistryGetAssemblymapperadaptor(
5646 EnsPDatabaseadaptor dba)
5647 {
5648 EnsPDatabaseadaptor rsa = NULL;
5649
5650 RegistryPEntry entry = NULL;
5651 RegistryPCoreStyle rcs = NULL;
5652
5653 if (!dba)
5654 return NULL;
5655
5656 rsa = ensRegistryGetReferenceadaptor(dba);
5657
5658 entry = (RegistryPEntry) ajTableFetchmodV(
5659 registryGEntry,
5660 (const void *) ensDatabaseadaptorGetSpecies(rsa));
5661
5662 if (!entry)
5663 return NULL;
5664
5665 switch (ensDatabaseadaptorGetGroup(rsa))
5666 {
5667 case ensEDatabaseadaptorGroupCore:
5668
5669 case ensEDatabaseadaptorGroupVega:
5670
5671 case ensEDatabaseadaptorGroupOtherFeatures:
5672
5673 case ensEDatabaseadaptorGroupCopyDNA:
5674
5675 rcs = (RegistryPCoreStyle)
5676 entry->Registry[ensDatabaseadaptorGetGroup(rsa)];
5677
5678 if (!rcs)
5679 break;
5680
5681 if (!rcs->Assemblymapperadaptor)
5682 rcs->Assemblymapperadaptor =
5683 ensAssemblymapperadaptorNew(rsa);
5684
5685 return rcs->Assemblymapperadaptor;
5686
5687 break;
5688
5689 default:
5690
5691 ajWarn("ensRegistryGetAssemblymapperadaptor got an "
5692 "Ensembl Database Adaptor "
5693 "with an unexpected group %d.\n",
5694 ensDatabaseadaptorGetGroup(rsa));
5695 }
5696
5697 return NULL;
5698 }
5699
5700
5701
5702
5703 /* @func ensRegistryGetAttributeadaptor ***************************************
5704 **
5705 ** Get an Ensembl Attribute Adaptor from the Ensembl Registry.
5706 ** The Ensembl Attribute Adaptor is an alias for an
5707 ** Ensembl Database Adaptor connected to an Ensembl Core-style database.
5708 **
5709 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5710 **
5711 ** @return [EnsPAttributeadaptor]
5712 ** Ensembl Attribute Adaptor or NULL
5713 **
5714 ** @release 6.3.0
5715 ** @@
5716 ******************************************************************************/
5717
ensRegistryGetAttributeadaptor(EnsPDatabaseadaptor dba)5718 EnsPAttributeadaptor ensRegistryGetAttributeadaptor(
5719 EnsPDatabaseadaptor dba)
5720 {
5721 if (!dba)
5722 return NULL;
5723
5724 switch (ensDatabaseadaptorGetGroup(dba))
5725 {
5726 case ensEDatabaseadaptorGroupCore:
5727
5728 case ensEDatabaseadaptorGroupVega:
5729
5730 case ensEDatabaseadaptorGroupOtherFeatures:
5731
5732 case ensEDatabaseadaptorGroupCopyDNA:
5733
5734 return dba;
5735
5736 break;
5737
5738 default:
5739
5740 ajWarn("ensRegistryGetAttributeadaptor got an "
5741 "Ensembl Database Adaptor "
5742 "with an unexpected group %d.\n",
5743 ensDatabaseadaptorGetGroup(dba));
5744 }
5745
5746 return NULL;
5747 }
5748
5749
5750
5751
5752 /* @func ensRegistryGetAttributetypeadaptor ***********************************
5753 **
5754 ** Get an Ensembl Attribute Type Adaptor from the Ensembl Registry.
5755 **
5756 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5757 **
5758 ** @return [EnsPAttributetypeadaptor]
5759 ** Ensembl Attribute Type Adaptor or NULL
5760 **
5761 ** @release 6.4.0
5762 ** @@
5763 ******************************************************************************/
5764
ensRegistryGetAttributetypeadaptor(EnsPDatabaseadaptor dba)5765 EnsPAttributetypeadaptor ensRegistryGetAttributetypeadaptor(
5766 EnsPDatabaseadaptor dba)
5767 {
5768 RegistryPEntry entry = NULL;
5769 RegistryPCoreStyle rcs = NULL;
5770
5771 if (!dba)
5772 return NULL;
5773
5774 entry = (RegistryPEntry) ajTableFetchmodV(
5775 registryGEntry,
5776 (const void *) ensDatabaseadaptorGetSpecies(dba));
5777
5778 if (!entry)
5779 return NULL;
5780
5781 switch (ensDatabaseadaptorGetGroup(dba))
5782 {
5783 case ensEDatabaseadaptorGroupCore:
5784
5785 case ensEDatabaseadaptorGroupVega:
5786
5787 case ensEDatabaseadaptorGroupOtherFeatures:
5788
5789 case ensEDatabaseadaptorGroupCopyDNA:
5790
5791 case ensEDatabaseadaptorGroupGeneticVariation:
5792
5793 rcs = (RegistryPCoreStyle)
5794 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
5795
5796 if (!rcs)
5797 break;
5798
5799 if (!rcs->Attributetypeadaptor)
5800 rcs->Attributetypeadaptor =
5801 ensAttributetypeadaptorNew(dba);
5802
5803 return rcs->Attributetypeadaptor;
5804
5805 break;
5806
5807 default:
5808
5809 ajWarn("ensRegistryGetAttributetypeadaptor got an "
5810 "Ensembl Database Adaptor "
5811 "with an unexpected group %d.\n",
5812 ensDatabaseadaptorGetGroup(dba));
5813 }
5814
5815 return NULL;
5816 }
5817
5818
5819
5820
5821 /* @func ensRegistryGetCoordsystemadaptor *************************************
5822 **
5823 ** Get an Ensembl Coordinate System Adaptor from the Ensembl Registry.
5824 **
5825 ** If an Ensembl Reference Adaptor has been set for this database, the adaptor
5826 ** returned will be based on the Ensembl Reference Adaptor rather than the
5827 ** Ensembl Database Adaptor that was passed in.
5828 **
5829 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5830 **
5831 ** @return [EnsPCoordsystemadaptor]
5832 ** Ensembl Coordinate System Adaptor or NULL
5833 **
5834 ** @release 6.2.0
5835 ** @@
5836 ******************************************************************************/
5837
ensRegistryGetCoordsystemadaptor(EnsPDatabaseadaptor dba)5838 EnsPCoordsystemadaptor ensRegistryGetCoordsystemadaptor(
5839 EnsPDatabaseadaptor dba)
5840 {
5841 EnsPDatabaseadaptor rsa = NULL;
5842
5843 RegistryPEntry entry = NULL;
5844 RegistryPCoreStyle rcs = NULL;
5845
5846 if (!dba)
5847 return NULL;
5848
5849 rsa = ensRegistryGetReferenceadaptor(dba);
5850
5851 entry = (RegistryPEntry) ajTableFetchmodV(
5852 registryGEntry,
5853 (const void *) ensDatabaseadaptorGetSpecies(rsa));
5854
5855 if (!entry)
5856 return NULL;
5857
5858 switch (ensDatabaseadaptorGetGroup(rsa))
5859 {
5860 case ensEDatabaseadaptorGroupCore:
5861
5862 case ensEDatabaseadaptorGroupVega:
5863
5864 case ensEDatabaseadaptorGroupOtherFeatures:
5865
5866 case ensEDatabaseadaptorGroupCopyDNA:
5867
5868 rcs = (RegistryPCoreStyle)
5869 entry->Registry[ensDatabaseadaptorGetGroup(rsa)];
5870
5871 if (!rcs)
5872 break;
5873
5874 if (!rcs->Coordsystemadaptor)
5875 rcs->Coordsystemadaptor =
5876 ensCoordsystemadaptorNew(rsa);
5877
5878 return rcs->Coordsystemadaptor;
5879
5880 break;
5881
5882 default:
5883
5884 ajWarn("ensRegistryGetCoordsystemadaptor got an "
5885 "Ensembl Database Adaptor "
5886 "with an unexpected group %d.\n",
5887 ensDatabaseadaptorGetGroup(rsa));
5888 }
5889
5890 return NULL;
5891 }
5892
5893
5894
5895
5896 /* @func ensRegistryGetDatabaseentryadaptor ***********************************
5897 **
5898 ** Get an Ensembl Database Entry Adaptor from the Ensembl Registry.
5899 **
5900 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5901 **
5902 ** @return [EnsPDatabaseentryadaptor]
5903 ** Ensembl Database Entry Adaptor or NULL
5904 **
5905 ** @release 6.2.0
5906 ** @@
5907 ******************************************************************************/
5908
ensRegistryGetDatabaseentryadaptor(EnsPDatabaseadaptor dba)5909 EnsPDatabaseentryadaptor ensRegistryGetDatabaseentryadaptor(
5910 EnsPDatabaseadaptor dba)
5911 {
5912 if (!dba)
5913 return NULL;
5914
5915 switch (ensDatabaseadaptorGetGroup(dba))
5916 {
5917 case ensEDatabaseadaptorGroupCore:
5918
5919 case ensEDatabaseadaptorGroupVega:
5920
5921 case ensEDatabaseadaptorGroupOtherFeatures:
5922
5923 case ensEDatabaseadaptorGroupCopyDNA:
5924
5925 return dba;
5926
5927 break;
5928
5929 default:
5930
5931 ajWarn("ensRegistryGetDatabaseentryadaptor got an "
5932 "Ensembl Database Adaptor "
5933 "with an unexpected group %d.\n",
5934 ensDatabaseadaptorGetGroup(dba));
5935 }
5936
5937 return NULL;
5938 }
5939
5940
5941
5942
5943 /* @func ensRegistryGetDensityfeatureadaptor **********************************
5944 **
5945 ** Get an Ensembl Density Feature Adaptor from the Ensembl Registry.
5946 **
5947 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
5948 **
5949 ** @return [EnsPDensityfeatureadaptor]
5950 ** Ensembl Density Feature Adaptor or NULL
5951 **
5952 ** @release 6.2.0
5953 ** @@
5954 ******************************************************************************/
5955
ensRegistryGetDensityfeatureadaptor(EnsPDatabaseadaptor dba)5956 EnsPDensityfeatureadaptor ensRegistryGetDensityfeatureadaptor(
5957 EnsPDatabaseadaptor dba)
5958 {
5959 RegistryPEntry entry = NULL;
5960 RegistryPCoreStyle rcs = NULL;
5961
5962 if (!dba)
5963 return NULL;
5964
5965 entry = (RegistryPEntry) ajTableFetchmodV(
5966 registryGEntry,
5967 (const void *) ensDatabaseadaptorGetSpecies(dba));
5968
5969 if (!entry)
5970 return NULL;
5971
5972 switch (ensDatabaseadaptorGetGroup(dba))
5973 {
5974 case ensEDatabaseadaptorGroupCore:
5975
5976 case ensEDatabaseadaptorGroupVega:
5977
5978 case ensEDatabaseadaptorGroupOtherFeatures:
5979
5980 case ensEDatabaseadaptorGroupCopyDNA:
5981
5982 rcs = (RegistryPCoreStyle)
5983 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
5984
5985 if (!rcs)
5986 break;
5987
5988 if (!rcs->Densityfeatureadaptor)
5989 rcs->Densityfeatureadaptor =
5990 ensDensityfeatureadaptorNew(dba);
5991
5992 return rcs->Densityfeatureadaptor;
5993
5994 break;
5995
5996 default:
5997
5998 ajWarn("ensRegistryGetDensityfeatureadaptor got an "
5999 "Ensembl Database Adaptor "
6000 "with an unexpected group %d.\n",
6001 ensDatabaseadaptorGetGroup(dba));
6002 }
6003
6004 return NULL;
6005 }
6006
6007
6008
6009
6010 /* @func ensRegistryGetDensitytypeadaptor *************************************
6011 **
6012 ** Get an Ensembl Density Type Adaptor from the Ensembl Registry.
6013 **
6014 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6015 **
6016 ** @return [EnsPDensitytypeadaptor]
6017 ** Ensembl Density Type Adaptor or NULL
6018 **
6019 ** @release 6.2.0
6020 ** @@
6021 ******************************************************************************/
6022
ensRegistryGetDensitytypeadaptor(EnsPDatabaseadaptor dba)6023 EnsPDensitytypeadaptor ensRegistryGetDensitytypeadaptor(
6024 EnsPDatabaseadaptor dba)
6025 {
6026 RegistryPEntry entry = NULL;
6027 RegistryPCoreStyle rcs = NULL;
6028
6029 if (!dba)
6030 return NULL;
6031
6032 entry = (RegistryPEntry) ajTableFetchmodV(
6033 registryGEntry,
6034 (const void *) ensDatabaseadaptorGetSpecies(dba));
6035
6036 if (!entry)
6037 return NULL;
6038
6039 switch (ensDatabaseadaptorGetGroup(dba))
6040 {
6041 case ensEDatabaseadaptorGroupCore:
6042
6043 case ensEDatabaseadaptorGroupVega:
6044
6045 case ensEDatabaseadaptorGroupOtherFeatures:
6046
6047 case ensEDatabaseadaptorGroupCopyDNA:
6048
6049 rcs = (RegistryPCoreStyle)
6050 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6051
6052 if (!rcs)
6053 break;
6054
6055 if (!rcs->Densitytypeadaptor)
6056 rcs->Densitytypeadaptor =
6057 ensDensitytypeadaptorNew(dba);
6058
6059 return rcs->Densitytypeadaptor;
6060
6061 break;
6062
6063 default:
6064
6065 ajWarn("ensRegistryGetDensitytypeadaptor got an "
6066 "Ensembl Database Adaptor "
6067 "with an unexpected group %d.\n",
6068 ensDatabaseadaptorGetGroup(dba));
6069 }
6070
6071 return NULL;
6072 }
6073
6074
6075
6076
6077 /* @func ensRegistryGetDitagadaptor *******************************************
6078 **
6079 ** Get an Ensembl Ditag Adaptor from the Ensembl Registry.
6080 ** The Ensembl Ditag Adaptor is an alias for an
6081 ** Ensembl Database Adaptor connected to an Ensembl Core-style database.
6082 **
6083 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6084 **
6085 ** @return [EnsPDitagadaptor]
6086 ** Ensembl Ditag Adaptor or NULL
6087 **
6088 ** @release 6.3.0
6089 ** @@
6090 ******************************************************************************/
6091
ensRegistryGetDitagadaptor(EnsPDatabaseadaptor dba)6092 EnsPDitagadaptor ensRegistryGetDitagadaptor(
6093 EnsPDatabaseadaptor dba)
6094 {
6095 RegistryPEntry entry = NULL;
6096 RegistryPCoreStyle rcs = NULL;
6097
6098 if (!dba)
6099 return NULL;
6100
6101 entry = (RegistryPEntry) ajTableFetchmodV(
6102 registryGEntry,
6103 (const void *) ensDatabaseadaptorGetSpecies(dba));
6104
6105 if (!entry)
6106 return NULL;
6107
6108 switch (ensDatabaseadaptorGetGroup(dba))
6109 {
6110 case ensEDatabaseadaptorGroupCore:
6111
6112 case ensEDatabaseadaptorGroupVega:
6113
6114 case ensEDatabaseadaptorGroupOtherFeatures:
6115
6116 case ensEDatabaseadaptorGroupCopyDNA:
6117
6118 rcs = (RegistryPCoreStyle)
6119 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6120
6121 if (!rcs)
6122 break;
6123
6124 if (!rcs->Ditagadaptor)
6125 rcs->Ditagadaptor =
6126 ensDitagadaptorNew(dba);
6127
6128 return rcs->Ditagadaptor;
6129
6130 break;
6131
6132 default:
6133
6134 ajWarn("ensRegistryGetDitagadaptor got an "
6135 "Ensembl Database Adaptor "
6136 "with an unexpected group %d.\n",
6137 ensDatabaseadaptorGetGroup(dba));
6138 }
6139
6140 return NULL;
6141 }
6142
6143
6144
6145
6146 /* @func ensRegistryGetDitagfeatureadaptor ************************************
6147 **
6148 ** Get an Ensembl Ditag Feature Adaptor from the Ensembl Registry.
6149 **
6150 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6151 **
6152 ** @return [EnsPDitagfeatureadaptor]
6153 ** Ensembl Ditag Feature Adaptor or NULL
6154 **
6155 ** @release 6.2.0
6156 ** @@
6157 ******************************************************************************/
6158
ensRegistryGetDitagfeatureadaptor(EnsPDatabaseadaptor dba)6159 EnsPDitagfeatureadaptor ensRegistryGetDitagfeatureadaptor(
6160 EnsPDatabaseadaptor dba)
6161 {
6162 RegistryPEntry entry = NULL;
6163 RegistryPCoreStyle rcs = NULL;
6164
6165 if (!dba)
6166 return NULL;
6167
6168 entry = (RegistryPEntry) ajTableFetchmodV(
6169 registryGEntry,
6170 (const void *) ensDatabaseadaptorGetSpecies(dba));
6171
6172 if (!entry)
6173 return NULL;
6174
6175 switch (ensDatabaseadaptorGetGroup(dba))
6176 {
6177 case ensEDatabaseadaptorGroupCore:
6178
6179 case ensEDatabaseadaptorGroupVega:
6180
6181 case ensEDatabaseadaptorGroupOtherFeatures:
6182
6183 case ensEDatabaseadaptorGroupCopyDNA:
6184
6185 rcs = (RegistryPCoreStyle)
6186 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6187
6188 if (!rcs)
6189 break;
6190
6191 if (!rcs->Ditagfeatureadaptor)
6192 rcs->Ditagfeatureadaptor =
6193 ensDitagfeatureadaptorNew(dba);
6194
6195 return rcs->Ditagfeatureadaptor;
6196
6197 break;
6198
6199 default:
6200
6201 ajWarn("ensRegistryGetDitagfeatureadaptor got an "
6202 "Ensembl Database Adaptor "
6203 "with an unexpected group %d.\n",
6204 ensDatabaseadaptorGetGroup(dba));
6205 }
6206
6207 return NULL;
6208 }
6209
6210
6211
6212
6213 /* @func ensRegistryGetDnaalignfeatureadaptor *********************************
6214 **
6215 ** Get an Ensembl DNA Align Feature Adaptor from the Ensembl Registry.
6216 **
6217 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6218 **
6219 ** @return [EnsPDnaalignfeatureadaptor]
6220 ** Ensembl DNA Align Feature Adaptor or NULL
6221 **
6222 ** @release 6.4.0
6223 ** @@
6224 ******************************************************************************/
6225
ensRegistryGetDnaalignfeatureadaptor(EnsPDatabaseadaptor dba)6226 EnsPDnaalignfeatureadaptor ensRegistryGetDnaalignfeatureadaptor(
6227 EnsPDatabaseadaptor dba)
6228 {
6229 RegistryPEntry entry = NULL;
6230 RegistryPCoreStyle rcs = NULL;
6231
6232 if (!dba)
6233 return NULL;
6234
6235 entry = (RegistryPEntry) ajTableFetchmodV(
6236 registryGEntry,
6237 (const void *) ensDatabaseadaptorGetSpecies(dba));
6238
6239 if (!entry)
6240 return NULL;
6241
6242 switch (ensDatabaseadaptorGetGroup(dba))
6243 {
6244 case ensEDatabaseadaptorGroupCore:
6245
6246 case ensEDatabaseadaptorGroupVega:
6247
6248 case ensEDatabaseadaptorGroupOtherFeatures:
6249
6250 case ensEDatabaseadaptorGroupCopyDNA:
6251
6252 rcs = (RegistryPCoreStyle)
6253 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6254
6255 if (!rcs)
6256 break;
6257
6258 if (!rcs->Dnaalignfeatureadaptor)
6259 rcs->Dnaalignfeatureadaptor =
6260 ensDnaalignfeatureadaptorNew(dba);
6261
6262 return rcs->Dnaalignfeatureadaptor;
6263
6264 break;
6265
6266 default:
6267
6268 ajWarn("ensRegistryGetDnaalignfeatureadaptor got an "
6269 "Ensembl Database Adaptor "
6270 "with an unexpected group %d.\n",
6271 ensDatabaseadaptorGetGroup(dba));
6272 }
6273
6274 return NULL;
6275 }
6276
6277
6278
6279
6280 /* @func ensRegistryGetExonadaptor ********************************************
6281 **
6282 ** Get an Ensembl Exon Adaptor from the Ensembl Registry.
6283 **
6284 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6285 **
6286 ** @return [EnsPExonadaptor]
6287 ** Ensembl Exon Adaptor or NULL
6288 **
6289 ** @release 6.2.0
6290 ** @@
6291 ******************************************************************************/
6292
ensRegistryGetExonadaptor(EnsPDatabaseadaptor dba)6293 EnsPExonadaptor ensRegistryGetExonadaptor(
6294 EnsPDatabaseadaptor dba)
6295 {
6296 RegistryPEntry entry = NULL;
6297 RegistryPCoreStyle rcs = NULL;
6298
6299 if (!dba)
6300 return NULL;
6301
6302 entry = (RegistryPEntry) ajTableFetchmodV(
6303 registryGEntry,
6304 (const void *) ensDatabaseadaptorGetSpecies(dba));
6305
6306 if (!entry)
6307 return NULL;
6308
6309 switch (ensDatabaseadaptorGetGroup(dba))
6310 {
6311 case ensEDatabaseadaptorGroupCore:
6312
6313 case ensEDatabaseadaptorGroupVega:
6314
6315 case ensEDatabaseadaptorGroupOtherFeatures:
6316
6317 case ensEDatabaseadaptorGroupCopyDNA:
6318
6319 rcs = (RegistryPCoreStyle)
6320 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6321
6322 if (!rcs)
6323 break;
6324
6325 if (!rcs->Exonadaptor)
6326 rcs->Exonadaptor =
6327 ensExonadaptorNew(dba);
6328
6329 return rcs->Exonadaptor;
6330
6331 break;
6332
6333 default:
6334
6335 ajWarn("ensRegistryGetExonadaptor got an "
6336 "Ensembl Database Adaptor "
6337 "with an unexpected group %d.\n",
6338 ensDatabaseadaptorGetGroup(dba));
6339 }
6340
6341 return NULL;
6342 }
6343
6344
6345
6346
6347 /* @func ensRegistryGetExternaldatabaseadaptor ********************************
6348 **
6349 ** Get an Ensembl External Database Adaptor from the Ensembl Registry.
6350 **
6351 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6352 **
6353 ** @return [EnsPExternaldatabaseadaptor]
6354 ** Ensembl External Database Adaptor or NULL
6355 **
6356 ** @release 6.2.0
6357 ** @@
6358 ******************************************************************************/
6359
ensRegistryGetExternaldatabaseadaptor(EnsPDatabaseadaptor dba)6360 EnsPExternaldatabaseadaptor ensRegistryGetExternaldatabaseadaptor(
6361 EnsPDatabaseadaptor dba)
6362 {
6363 RegistryPEntry entry = NULL;
6364 RegistryPCoreStyle rcs = NULL;
6365
6366 if (!dba)
6367 return NULL;
6368
6369 entry = (RegistryPEntry) ajTableFetchmodV(
6370 registryGEntry,
6371 (const void *) ensDatabaseadaptorGetSpecies(dba));
6372
6373 if (!entry)
6374 return NULL;
6375
6376 switch (ensDatabaseadaptorGetGroup(dba))
6377 {
6378 case ensEDatabaseadaptorGroupCore:
6379
6380 case ensEDatabaseadaptorGroupVega:
6381
6382 case ensEDatabaseadaptorGroupOtherFeatures:
6383
6384 case ensEDatabaseadaptorGroupCopyDNA:
6385
6386 rcs = (RegistryPCoreStyle)
6387 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6388
6389 if (!rcs)
6390 break;
6391
6392 if (!rcs->Externaldatabaseadaptor)
6393 rcs->Externaldatabaseadaptor =
6394 ensExternaldatabaseadaptorNew(dba);
6395
6396 return rcs->Externaldatabaseadaptor;
6397
6398 break;
6399
6400 default:
6401
6402 ajWarn("ensRegistryGetExternaldatabaseadaptor got an "
6403 "Ensembl Database Adaptor "
6404 "with an unexpected group %d.\n",
6405 ensDatabaseadaptorGetGroup(dba));
6406 }
6407
6408 return NULL;
6409 }
6410
6411
6412
6413
6414 /* @func ensRegistryGetGeneadaptor ********************************************
6415 **
6416 ** Get an Ensembl Gene Adaptor from the Ensembl Registry.
6417 **
6418 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6419 **
6420 ** @return [EnsPGeneadaptor]
6421 ** Ensembl Gene Adaptor or NULL
6422 **
6423 ** @release 6.2.0
6424 ** @@
6425 ******************************************************************************/
6426
ensRegistryGetGeneadaptor(EnsPDatabaseadaptor dba)6427 EnsPGeneadaptor ensRegistryGetGeneadaptor(
6428 EnsPDatabaseadaptor dba)
6429 {
6430 RegistryPEntry entry = NULL;
6431 RegistryPCoreStyle rcs = NULL;
6432
6433 if (!dba)
6434 return NULL;
6435
6436 entry = (RegistryPEntry) ajTableFetchmodV(
6437 registryGEntry,
6438 (const void *) ensDatabaseadaptorGetSpecies(dba));
6439
6440 if (!entry)
6441 return NULL;
6442
6443 switch (ensDatabaseadaptorGetGroup(dba))
6444 {
6445 case ensEDatabaseadaptorGroupCore:
6446
6447 case ensEDatabaseadaptorGroupVega:
6448
6449 case ensEDatabaseadaptorGroupOtherFeatures:
6450
6451 case ensEDatabaseadaptorGroupCopyDNA:
6452
6453 rcs = (RegistryPCoreStyle)
6454 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6455
6456 if (!rcs)
6457 break;
6458
6459 if (!rcs->Geneadaptor)
6460 rcs->Geneadaptor =
6461 ensGeneadaptorNew(dba);
6462
6463 return rcs->Geneadaptor;
6464
6465 break;
6466
6467 default:
6468
6469 ajWarn("ensRegistryGetGeneadaptor got an "
6470 "Ensembl Database Adaptor "
6471 "with an unexpected group %d.\n",
6472 ensDatabaseadaptorGetGroup(dba));
6473 }
6474
6475 return NULL;
6476 }
6477
6478
6479
6480
6481 /* @func ensRegistryGetIntronsupportingevidenceadaptor ************************
6482 **
6483 ** Get an Ensembl Intron Supporting Evidence Adaptor from the Ensembl Registry.
6484 **
6485 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6486 **
6487 ** @return [EnsPIntronsupportingevidenceadaptor]
6488 ** Ensembl Intron Supporting Evidence Adaptor or NULL
6489 **
6490 ** @release 6.2.0
6491 ** @@
6492 ******************************************************************************/
6493
ensRegistryGetIntronsupportingevidenceadaptor(EnsPDatabaseadaptor dba)6494 EnsPIntronsupportingevidenceadaptor ensRegistryGetIntronsupportingevidenceadaptor(
6495 EnsPDatabaseadaptor dba)
6496 {
6497 RegistryPEntry entry = NULL;
6498 RegistryPCoreStyle rcs = NULL;
6499
6500 if (!dba)
6501 return NULL;
6502
6503 entry = (RegistryPEntry) ajTableFetchmodV(
6504 registryGEntry,
6505 (const void *) ensDatabaseadaptorGetSpecies(dba));
6506
6507 if (!entry)
6508 return NULL;
6509
6510 switch (ensDatabaseadaptorGetGroup(dba))
6511 {
6512 case ensEDatabaseadaptorGroupCore:
6513
6514 case ensEDatabaseadaptorGroupVega:
6515
6516 case ensEDatabaseadaptorGroupOtherFeatures:
6517
6518 case ensEDatabaseadaptorGroupCopyDNA:
6519
6520 rcs = (RegistryPCoreStyle)
6521 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6522
6523 if (!rcs)
6524 break;
6525
6526 if (!rcs->Intronsupportingevidenceadaptor)
6527 rcs->Intronsupportingevidenceadaptor =
6528 ensIntronsupportingevidenceadaptorNew(dba);
6529
6530 return rcs->Intronsupportingevidenceadaptor;
6531
6532 break;
6533
6534 default:
6535
6536 ajWarn("ensRegistryGetIntronsupportingevidenceadaptor got an "
6537 "Ensembl Database Adaptor "
6538 "with an unexpected group %d.\n",
6539 ensDatabaseadaptorGetGroup(dba));
6540 }
6541
6542 return NULL;
6543 }
6544
6545
6546
6547
6548 /* @func ensRegistryGetKaryotypebandadaptor ***********************************
6549 **
6550 ** Get an Ensembl Karyotype Band Adaptor from the Ensembl Registry.
6551 **
6552 ** If an Ensembl Reference Adaptor has been set for this database, the adaptor
6553 ** returned will be based on the Ensembl Reference Adaptor rather than the
6554 ** Ensembl Database Adaptor that was passed in.
6555 **
6556 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6557 **
6558 ** @return [EnsPKaryotypebandadaptor]
6559 ** Ensembl Karyotype Band Adaptor or NULL
6560 **
6561 ** @release 6.2.0
6562 ** @@
6563 ******************************************************************************/
6564
ensRegistryGetKaryotypebandadaptor(EnsPDatabaseadaptor dba)6565 EnsPKaryotypebandadaptor ensRegistryGetKaryotypebandadaptor(
6566 EnsPDatabaseadaptor dba)
6567 {
6568 EnsPDatabaseadaptor rsa = NULL;
6569
6570 RegistryPEntry entry = NULL;
6571 RegistryPCoreStyle rcs = NULL;
6572
6573 if (!dba)
6574 return NULL;
6575
6576 rsa = ensRegistryGetReferenceadaptor(dba);
6577
6578 entry = (RegistryPEntry) ajTableFetchmodV(
6579 registryGEntry,
6580 (const void *) ensDatabaseadaptorGetSpecies(rsa));
6581
6582 if (!entry)
6583 return NULL;
6584
6585 switch (ensDatabaseadaptorGetGroup(rsa))
6586 {
6587 case ensEDatabaseadaptorGroupCore:
6588
6589 case ensEDatabaseadaptorGroupVega:
6590
6591 case ensEDatabaseadaptorGroupOtherFeatures:
6592
6593 case ensEDatabaseadaptorGroupCopyDNA:
6594
6595 rcs = (RegistryPCoreStyle)
6596 entry->Registry[ensDatabaseadaptorGetGroup(rsa)];
6597
6598 if (!rcs)
6599 break;
6600
6601 if (!rcs->Karyotypebandadaptor)
6602 rcs->Karyotypebandadaptor =
6603 ensKaryotypebandadaptorNew(rsa);
6604
6605 return rcs->Karyotypebandadaptor;
6606
6607 break;
6608
6609 default:
6610
6611 ajWarn("ensRegistryGetKaryotypebandadaptor got an "
6612 "Ensembl Database Adaptor "
6613 "with an unexpected group %d.\n",
6614 ensDatabaseadaptorGetGroup(rsa));
6615 }
6616
6617 return NULL;
6618 }
6619
6620
6621
6622
6623 /* @func ensRegistryGetMarkeradaptor ******************************************
6624 **
6625 ** Get an Ensembl Marker Adaptor from the Ensembl Registry.
6626 **
6627 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6628 **
6629 ** @return [EnsPMarkeradaptor]
6630 ** Ensembl Marker Adaptor or NULL
6631 **
6632 ** @release 6.2.0
6633 ** @@
6634 ******************************************************************************/
6635
ensRegistryGetMarkeradaptor(EnsPDatabaseadaptor dba)6636 EnsPMarkeradaptor ensRegistryGetMarkeradaptor(
6637 EnsPDatabaseadaptor dba)
6638 {
6639 RegistryPEntry entry = NULL;
6640 RegistryPCoreStyle rcs = NULL;
6641
6642 if (!dba)
6643 return NULL;
6644
6645 entry = (RegistryPEntry) ajTableFetchmodV(
6646 registryGEntry,
6647 (const void *) ensDatabaseadaptorGetSpecies(dba));
6648
6649 if (!entry)
6650 return NULL;
6651
6652 switch (ensDatabaseadaptorGetGroup(dba))
6653 {
6654 case ensEDatabaseadaptorGroupCore:
6655
6656 case ensEDatabaseadaptorGroupVega:
6657
6658 case ensEDatabaseadaptorGroupOtherFeatures:
6659
6660 case ensEDatabaseadaptorGroupCopyDNA:
6661
6662 rcs = (RegistryPCoreStyle)
6663 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6664
6665 if (!rcs)
6666 break;
6667
6668 if (!rcs->Markeradaptor)
6669 rcs->Markeradaptor =
6670 ensMarkeradaptorNew(dba);
6671
6672 return rcs->Markeradaptor;
6673
6674 break;
6675
6676 default:
6677
6678 ajWarn("ensRegistryGetMarkeradaptor got an "
6679 "Ensembl Database Adaptor "
6680 "with an unexpected group %d.\n",
6681 ensDatabaseadaptorGetGroup(dba));
6682 }
6683
6684 return NULL;
6685 }
6686
6687
6688
6689
6690 /* @func ensRegistryGetMarkerfeatureadaptor ***********************************
6691 **
6692 ** Get an Ensembl Marker Feature Adaptor from the Ensembl Registry.
6693 **
6694 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6695 **
6696 ** @return [EnsPMarkerfeatureadaptor]
6697 ** Ensembl Marker Feature Adaptor or NULL
6698 **
6699 ** @release 6.2.0
6700 ** @@
6701 ******************************************************************************/
6702
ensRegistryGetMarkerfeatureadaptor(EnsPDatabaseadaptor dba)6703 EnsPMarkerfeatureadaptor ensRegistryGetMarkerfeatureadaptor(
6704 EnsPDatabaseadaptor dba)
6705 {
6706 RegistryPEntry entry = NULL;
6707 RegistryPCoreStyle rcs = NULL;
6708
6709 if (!dba)
6710 return NULL;
6711
6712 entry = (RegistryPEntry) ajTableFetchmodV(
6713 registryGEntry,
6714 (const void *) ensDatabaseadaptorGetSpecies(dba));
6715
6716 if (!entry)
6717 return NULL;
6718
6719 switch (ensDatabaseadaptorGetGroup(dba))
6720 {
6721 case ensEDatabaseadaptorGroupCore:
6722
6723 case ensEDatabaseadaptorGroupVega:
6724
6725 case ensEDatabaseadaptorGroupOtherFeatures:
6726
6727 case ensEDatabaseadaptorGroupCopyDNA:
6728
6729 rcs = (RegistryPCoreStyle)
6730 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6731
6732 if (!rcs)
6733 break;
6734
6735 if (!rcs->Markerfeatureadaptor)
6736 rcs->Markerfeatureadaptor =
6737 ensMarkerfeatureadaptorNew(dba);
6738
6739 return rcs->Markerfeatureadaptor;
6740
6741 break;
6742
6743 default:
6744
6745 ajWarn("ensRegistryGetMarkerfeatureadaptor got an "
6746 "Ensembl Database Adaptor "
6747 "with an unexpected group %d.\n",
6748 ensDatabaseadaptorGetGroup(dba));
6749 }
6750
6751 return NULL;
6752 }
6753
6754
6755
6756
6757 /* @func ensRegistryGetMarkermaplocationadaptor *******************************
6758 **
6759 ** Get an Ensembl Marker Map Location Adaptor from the Ensembl Registry.
6760 **
6761 ** The Ensembl Marker Map Location Adaptor is an alias for an
6762 ** Ensembl Database Adaptor connected to Ensembl Core-Style databases.
6763 **
6764 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6765 **
6766 ** @return [EnsPMarkermaplocationadaptor]
6767 ** Ensembl Marker Map Location Adaptor or NULL
6768 **
6769 ** @release 6.5.0
6770 ** @@
6771 ******************************************************************************/
6772
ensRegistryGetMarkermaplocationadaptor(EnsPDatabaseadaptor dba)6773 EnsPMarkermaplocationadaptor ensRegistryGetMarkermaplocationadaptor(
6774 EnsPDatabaseadaptor dba)
6775 {
6776 if (!dba)
6777 return NULL;
6778
6779 switch (ensDatabaseadaptorGetGroup(dba))
6780 {
6781 case ensEDatabaseadaptorGroupCore:
6782
6783 case ensEDatabaseadaptorGroupVega:
6784
6785 case ensEDatabaseadaptorGroupOtherFeatures:
6786
6787 case ensEDatabaseadaptorGroupCopyDNA:
6788
6789 return dba;
6790
6791 break;
6792
6793 default:
6794
6795 ajWarn("ensRegistryGetMarkermaplocationadaptor got an "
6796 "Ensembl Database Adaptor "
6797 "with an unexpected group %d.\n",
6798 ensDatabaseadaptorGetGroup(dba));
6799 }
6800
6801 return NULL;
6802 }
6803
6804
6805
6806
6807 /* @func ensRegistryGetMarkersynonymadaptor ***********************************
6808 **
6809 ** Get an Ensembl Marker Synonym Adaptor from the Ensembl Registry.
6810 **
6811 ** The Ensembl Marker Synonym Adaptor is an alias for an
6812 ** Ensembl Database Adaptor connected to Ensembl Core-Style databases.
6813 **
6814 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6815 **
6816 ** @return [EnsPMarkersynonymadaptor]
6817 ** Ensembl Marker Synonym Adaptor or NULL
6818 **
6819 ** @release 6.5.0
6820 ** @@
6821 ******************************************************************************/
6822
ensRegistryGetMarkersynonymadaptor(EnsPDatabaseadaptor dba)6823 EnsPMarkersynonymadaptor ensRegistryGetMarkersynonymadaptor(
6824 EnsPDatabaseadaptor dba)
6825 {
6826 if (!dba)
6827 return NULL;
6828
6829 switch (ensDatabaseadaptorGetGroup(dba))
6830 {
6831 case ensEDatabaseadaptorGroupCore:
6832
6833 case ensEDatabaseadaptorGroupVega:
6834
6835 case ensEDatabaseadaptorGroupOtherFeatures:
6836
6837 case ensEDatabaseadaptorGroupCopyDNA:
6838
6839 return dba;
6840
6841 break;
6842
6843 default:
6844
6845 ajWarn("ensRegistryGetMarkersynonymadaptor got an "
6846 "Ensembl Database Adaptor "
6847 "with an unexpected group %d.\n",
6848 ensDatabaseadaptorGetGroup(dba));
6849 }
6850
6851 return NULL;
6852 }
6853
6854
6855
6856
6857 /* @func ensRegistryGetMetacoordinateadaptor **********************************
6858 **
6859 ** Get an Ensembl Meta-Coordinate Adaptor from the Ensembl Registry.
6860 **
6861 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6862 **
6863 ** @return [EnsPMetacoordinateadaptor]
6864 ** Ensembl Meta-Coordinate Adaptor or NULL
6865 **
6866 ** @release 6.2.0
6867 ** @@
6868 ******************************************************************************/
6869
ensRegistryGetMetacoordinateadaptor(EnsPDatabaseadaptor dba)6870 EnsPMetacoordinateadaptor ensRegistryGetMetacoordinateadaptor(
6871 EnsPDatabaseadaptor dba)
6872 {
6873 RegistryPEntry entry = NULL;
6874 RegistryPCoreStyle rcs = NULL;
6875
6876 if (!dba)
6877 return NULL;
6878
6879 entry = (RegistryPEntry) ajTableFetchmodV(
6880 registryGEntry,
6881 (const void *) ensDatabaseadaptorGetSpecies(dba));
6882
6883 if (!entry)
6884 return NULL;
6885
6886 switch (ensDatabaseadaptorGetGroup(dba))
6887 {
6888 case ensEDatabaseadaptorGroupCore:
6889
6890 case ensEDatabaseadaptorGroupVega:
6891
6892 case ensEDatabaseadaptorGroupOtherFeatures:
6893
6894 case ensEDatabaseadaptorGroupCopyDNA:
6895
6896 rcs = (RegistryPCoreStyle)
6897 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6898
6899 if (!rcs)
6900 break;
6901
6902 if (!rcs->Metacoordinateadaptor)
6903 rcs->Metacoordinateadaptor =
6904 ensMetacoordinateadaptorNew(dba);
6905
6906 return rcs->Metacoordinateadaptor;
6907
6908 break;
6909
6910 default:
6911
6912 ajWarn("ensRegistryGetMetacoordinateadaptor got an "
6913 "Ensembl Database Adaptor "
6914 "with an unexpected group %d.\n",
6915 ensDatabaseadaptorGetGroup(dba));
6916 }
6917
6918 return NULL;
6919 }
6920
6921
6922
6923
6924 /* @func ensRegistryGetMetainformationadaptor *********************************
6925 **
6926 ** Get an Ensembl Meta-Information Adaptor from the Ensembl Registry.
6927 **
6928 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6929 **
6930 ** @return [EnsPMetainformationadaptor]
6931 ** Ensembl Meta-Information Adaptor or NULL
6932 **
6933 ** @release 6.2.0
6934 ** @@
6935 ******************************************************************************/
6936
ensRegistryGetMetainformationadaptor(EnsPDatabaseadaptor dba)6937 EnsPMetainformationadaptor ensRegistryGetMetainformationadaptor(
6938 EnsPDatabaseadaptor dba)
6939 {
6940 RegistryPEntry entry = NULL;
6941 RegistryPCoreStyle rcs = NULL;
6942
6943 if (!dba)
6944 return NULL;
6945
6946 entry = (RegistryPEntry) ajTableFetchmodV(
6947 registryGEntry,
6948 (const void *) ensDatabaseadaptorGetSpecies(dba));
6949
6950 if (!entry)
6951 return NULL;
6952
6953 switch (ensDatabaseadaptorGetGroup(dba))
6954 {
6955 case ensEDatabaseadaptorGroupCore:
6956
6957 case ensEDatabaseadaptorGroupVega:
6958
6959 case ensEDatabaseadaptorGroupOtherFeatures:
6960
6961 case ensEDatabaseadaptorGroupCopyDNA:
6962
6963 rcs = (RegistryPCoreStyle)
6964 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
6965
6966 if (!rcs)
6967 break;
6968
6969 if (!rcs->Metainformationadaptor)
6970 rcs->Metainformationadaptor =
6971 ensMetainformationadaptorNew(dba);
6972
6973 return rcs->Metainformationadaptor;
6974
6975 break;
6976
6977 default:
6978
6979 ajWarn("ensRegistryGetMetainformationadaptor got an "
6980 "Ensembl Database Adaptor "
6981 "with an unexpected group %d.\n",
6982 ensDatabaseadaptorGetGroup(dba));
6983 }
6984
6985 return NULL;
6986 }
6987
6988
6989
6990
6991 /* @func ensRegistryGetMiscellaneousfeatureadaptor ****************************
6992 **
6993 ** Get an Ensembl Miscellaneous Feature Adaptor from the Ensembl Registry.
6994 **
6995 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
6996 **
6997 ** @return [EnsPMiscellaneousfeatureadaptor]
6998 ** Ensembl Miscellaneous Feature Adaptor or NULL
6999 **
7000 ** @release 6.2.0
7001 ** @@
7002 ******************************************************************************/
7003
ensRegistryGetMiscellaneousfeatureadaptor(EnsPDatabaseadaptor dba)7004 EnsPMiscellaneousfeatureadaptor ensRegistryGetMiscellaneousfeatureadaptor(
7005 EnsPDatabaseadaptor dba)
7006 {
7007 RegistryPEntry entry = NULL;
7008 RegistryPCoreStyle rcs = NULL;
7009
7010 if (!dba)
7011 return NULL;
7012
7013 entry = (RegistryPEntry) ajTableFetchmodV(
7014 registryGEntry,
7015 (const void *) ensDatabaseadaptorGetSpecies(dba));
7016
7017 if (!entry)
7018 return NULL;
7019
7020 switch (ensDatabaseadaptorGetGroup(dba))
7021 {
7022 case ensEDatabaseadaptorGroupCore:
7023
7024 case ensEDatabaseadaptorGroupVega:
7025
7026 case ensEDatabaseadaptorGroupOtherFeatures:
7027
7028 case ensEDatabaseadaptorGroupCopyDNA:
7029
7030 rcs = (RegistryPCoreStyle)
7031 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7032
7033 if (!rcs)
7034 break;
7035
7036 if (!rcs->Miscellaneousfeatureadaptor)
7037 rcs->Miscellaneousfeatureadaptor =
7038 ensMiscellaneousfeatureadaptorNew(dba);
7039
7040 return rcs->Miscellaneousfeatureadaptor;
7041
7042 break;
7043
7044 default:
7045
7046 ajWarn("ensRegistryGetMiscellaneousfeatureadaptor got an "
7047 "Ensembl Database Adaptor "
7048 "with an unexpected group %d.\n",
7049 ensDatabaseadaptorGetGroup(dba));
7050 }
7051
7052 return NULL;
7053 }
7054
7055
7056
7057
7058 /* @func ensRegistryGetMiscellaneoussetadaptor ********************************
7059 **
7060 ** Get an Ensembl Miscellaneous Set Adaptor from the Ensembl Registry.
7061 **
7062 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7063 **
7064 ** @return [EnsPMiscellaneoussetadaptor]
7065 ** Ensembl Miscellaneous Set Adaptor or NULL
7066 **
7067 ** @release 6.2.0
7068 ** @@
7069 ******************************************************************************/
7070
ensRegistryGetMiscellaneoussetadaptor(EnsPDatabaseadaptor dba)7071 EnsPMiscellaneoussetadaptor ensRegistryGetMiscellaneoussetadaptor(
7072 EnsPDatabaseadaptor dba)
7073 {
7074 RegistryPEntry entry = NULL;
7075 RegistryPCoreStyle rcs = NULL;
7076
7077 if (!dba)
7078 return NULL;
7079
7080 entry = (RegistryPEntry) ajTableFetchmodV(
7081 registryGEntry,
7082 (const void *) ensDatabaseadaptorGetSpecies(dba));
7083
7084 if (!entry)
7085 return NULL;
7086
7087 switch (ensDatabaseadaptorGetGroup(dba))
7088 {
7089 case ensEDatabaseadaptorGroupCore:
7090
7091 case ensEDatabaseadaptorGroupVega:
7092
7093 case ensEDatabaseadaptorGroupOtherFeatures:
7094
7095 case ensEDatabaseadaptorGroupCopyDNA:
7096
7097 rcs = (RegistryPCoreStyle)
7098 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7099
7100 if (!rcs)
7101 break;
7102
7103 if (!rcs->Miscellaneoussetadaptor)
7104 rcs->Miscellaneoussetadaptor =
7105 ensMiscellaneoussetadaptorNew(dba);
7106
7107 return rcs->Miscellaneoussetadaptor;
7108
7109 break;
7110
7111 default:
7112
7113 ajWarn("ensRegistryGetMiscellaneoussetadaptor got an "
7114 "Ensembl Database Adaptor "
7115 "with an unexpected group %d.\n",
7116 ensDatabaseadaptorGetGroup(dba));
7117 }
7118
7119 return NULL;
7120 }
7121
7122
7123
7124
7125 /* @func ensRegistryGetOperonadaptor ******************************************
7126 **
7127 ** Get an Ensembl Operon Adaptor from the Ensembl Registry.
7128 **
7129 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7130 **
7131 ** @return [EnsPOperonadaptor]
7132 ** Ensembl Operon Adaptor or NULL
7133 **
7134 ** @release 6.5.0
7135 ** @@
7136 ******************************************************************************/
7137
ensRegistryGetOperonadaptor(EnsPDatabaseadaptor dba)7138 EnsPOperonadaptor ensRegistryGetOperonadaptor(
7139 EnsPDatabaseadaptor dba)
7140 {
7141 RegistryPEntry entry = NULL;
7142 RegistryPCoreStyle rcs = NULL;
7143
7144 if (!dba)
7145 return NULL;
7146
7147 entry = (RegistryPEntry) ajTableFetchmodV(
7148 registryGEntry,
7149 (const void *) ensDatabaseadaptorGetSpecies(dba));
7150
7151 if (!entry)
7152 return NULL;
7153
7154 switch (ensDatabaseadaptorGetGroup(dba))
7155 {
7156 case ensEDatabaseadaptorGroupCore:
7157
7158 case ensEDatabaseadaptorGroupVega:
7159
7160 case ensEDatabaseadaptorGroupOtherFeatures:
7161
7162 case ensEDatabaseadaptorGroupCopyDNA:
7163
7164 rcs = (RegistryPCoreStyle)
7165 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7166
7167 if (!rcs)
7168 break;
7169
7170 if (!rcs->Operonadaptor)
7171 rcs->Operonadaptor =
7172 ensOperonadaptorNew(dba);
7173
7174 return rcs->Operonadaptor;
7175
7176 break;
7177
7178 default:
7179
7180 ajWarn("ensRegistryGetOperonadaptor got an "
7181 "Ensembl Database Adaptor "
7182 "with an unexpected group %d.\n",
7183 ensDatabaseadaptorGetGroup(dba));
7184 }
7185
7186 return NULL;
7187 }
7188
7189
7190
7191
7192 /* @func ensRegistryGetOperontranscriptadaptor ********************************
7193 **
7194 ** Get an Ensembl Operon Transcript Adaptor from the Ensembl Registry.
7195 **
7196 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7197 **
7198 ** @return [EnsPOperontranscriptadaptor]
7199 ** Ensembl Operon Transcript Adaptor or NULL
7200 **
7201 ** @release 6.5.0
7202 ** @@
7203 ******************************************************************************/
7204
ensRegistryGetOperontranscriptadaptor(EnsPDatabaseadaptor dba)7205 EnsPOperontranscriptadaptor ensRegistryGetOperontranscriptadaptor(
7206 EnsPDatabaseadaptor dba)
7207 {
7208 RegistryPEntry entry = NULL;
7209 RegistryPCoreStyle rcs = NULL;
7210
7211 if (!dba)
7212 return NULL;
7213
7214 entry = (RegistryPEntry) ajTableFetchmodV(
7215 registryGEntry,
7216 (const void *) ensDatabaseadaptorGetSpecies(dba));
7217
7218 if (!entry)
7219 return NULL;
7220
7221 switch (ensDatabaseadaptorGetGroup(dba))
7222 {
7223 case ensEDatabaseadaptorGroupCore:
7224
7225 case ensEDatabaseadaptorGroupVega:
7226
7227 case ensEDatabaseadaptorGroupOtherFeatures:
7228
7229 case ensEDatabaseadaptorGroupCopyDNA:
7230
7231 rcs = (RegistryPCoreStyle)
7232 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7233
7234 if (!rcs)
7235 break;
7236
7237 if (!rcs->Operontranscriptadaptor)
7238 rcs->Operontranscriptadaptor =
7239 ensOperontranscriptadaptorNew(dba);
7240
7241 return rcs->Operontranscriptadaptor;
7242
7243 break;
7244
7245 default:
7246
7247 ajWarn("ensRegistryGetOperontranscriptadaptor got an "
7248 "Ensembl Database Adaptor "
7249 "with an unexpected group %d.\n",
7250 ensDatabaseadaptorGetGroup(dba));
7251 }
7252
7253 return NULL;
7254 }
7255
7256
7257
7258
7259 /* @func ensRegistryGetPredictionexonadaptor **********************************
7260 **
7261 ** Get an Ensembl Prediction Exon Adaptor from the Ensembl Registry.
7262 **
7263 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7264 **
7265 ** @return [EnsPPredictionexonadaptor]
7266 ** Ensembl Prediction Exon Adaptor or NULL
7267 **
7268 ** @release 6.2.0
7269 ** @@
7270 ******************************************************************************/
7271
ensRegistryGetPredictionexonadaptor(EnsPDatabaseadaptor dba)7272 EnsPPredictionexonadaptor ensRegistryGetPredictionexonadaptor(
7273 EnsPDatabaseadaptor dba)
7274 {
7275 RegistryPEntry entry = NULL;
7276 RegistryPCoreStyle rcs = NULL;
7277
7278 if (!dba)
7279 return NULL;
7280
7281 entry = (RegistryPEntry) ajTableFetchmodV(
7282 registryGEntry,
7283 (const void *) ensDatabaseadaptorGetSpecies(dba));
7284
7285 if (!entry)
7286 return NULL;
7287
7288 switch (ensDatabaseadaptorGetGroup(dba))
7289 {
7290 case ensEDatabaseadaptorGroupCore:
7291
7292 case ensEDatabaseadaptorGroupVega:
7293
7294 case ensEDatabaseadaptorGroupOtherFeatures:
7295
7296 case ensEDatabaseadaptorGroupCopyDNA:
7297
7298 rcs = (RegistryPCoreStyle)
7299 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7300
7301 if (!rcs)
7302 break;
7303
7304 if (!rcs->Predictionexonadaptor)
7305 rcs->Predictionexonadaptor =
7306 ensPredictionexonadaptorNew(dba);
7307
7308 return rcs->Predictionexonadaptor;
7309
7310 break;
7311
7312 default:
7313
7314 ajWarn("ensRegistryGetPredictionexonadaptor got an "
7315 "Ensembl Database Adaptor "
7316 "with an unexpected group %d.\n",
7317 ensDatabaseadaptorGetGroup(dba));
7318 }
7319
7320 return NULL;
7321 }
7322
7323
7324
7325
7326 /* @func ensRegistryGetPredictiontranscriptadaptor ****************************
7327 **
7328 ** Get an Ensembl Prediction Transcript Adaptor from the Ensembl Registry.
7329 **
7330 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7331 **
7332 ** @return [EnsPPredictiontranscriptadaptor]
7333 ** Ensembl Prediction Transcript Adaptor or NULL
7334 **
7335 ** @release 6.2.0
7336 ** @@
7337 ******************************************************************************/
7338
ensRegistryGetPredictiontranscriptadaptor(EnsPDatabaseadaptor dba)7339 EnsPPredictiontranscriptadaptor ensRegistryGetPredictiontranscriptadaptor(
7340 EnsPDatabaseadaptor dba)
7341 {
7342 RegistryPEntry entry = NULL;
7343 RegistryPCoreStyle rcs = NULL;
7344
7345 if (!dba)
7346 return NULL;
7347
7348 entry = (RegistryPEntry) ajTableFetchmodV(
7349 registryGEntry,
7350 (const void *) ensDatabaseadaptorGetSpecies(dba));
7351
7352 if (!entry)
7353 return NULL;
7354
7355 switch (ensDatabaseadaptorGetGroup(dba))
7356 {
7357 case ensEDatabaseadaptorGroupCore:
7358
7359 case ensEDatabaseadaptorGroupVega:
7360
7361 case ensEDatabaseadaptorGroupOtherFeatures:
7362
7363 case ensEDatabaseadaptorGroupCopyDNA:
7364
7365 rcs = (RegistryPCoreStyle)
7366 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7367
7368 if (!rcs)
7369 break;
7370
7371 if (!rcs->Predictiontranscriptadaptor)
7372 rcs->Predictiontranscriptadaptor =
7373 ensPredictiontranscriptadaptorNew(dba);
7374
7375 return rcs->Predictiontranscriptadaptor;
7376
7377 break;
7378
7379 default:
7380
7381 ajWarn("ensRegistryGetPredictiontranscriptadaptor got an "
7382 "Ensembl Database Adaptor "
7383 "with an unexpected group %d.\n",
7384 ensDatabaseadaptorGetGroup(dba));
7385 }
7386
7387 return NULL;
7388 }
7389
7390
7391
7392
7393 /* @func ensRegistryGetProteinalignfeatureadaptor *****************************
7394 **
7395 ** Get an Ensembl Protein Align Feature Adaptor from the Ensembl Registry.
7396 **
7397 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7398 **
7399 ** @return [EnsPProteinalignfeatureadaptor]
7400 ** Ensembl Protein Align Feature Adaptor or NULL
7401 **
7402 ** @release 6.2.0
7403 ** @@
7404 ******************************************************************************/
7405
ensRegistryGetProteinalignfeatureadaptor(EnsPDatabaseadaptor dba)7406 EnsPProteinalignfeatureadaptor ensRegistryGetProteinalignfeatureadaptor(
7407 EnsPDatabaseadaptor dba)
7408 {
7409 RegistryPEntry entry = NULL;
7410 RegistryPCoreStyle rcs = NULL;
7411
7412 if (!dba)
7413 return NULL;
7414
7415 entry = (RegistryPEntry) ajTableFetchmodV(
7416 registryGEntry,
7417 (const void *) ensDatabaseadaptorGetSpecies(dba));
7418
7419 if (!entry)
7420 return NULL;
7421
7422 switch (ensDatabaseadaptorGetGroup(dba))
7423 {
7424 case ensEDatabaseadaptorGroupCore:
7425
7426 case ensEDatabaseadaptorGroupVega:
7427
7428 case ensEDatabaseadaptorGroupOtherFeatures:
7429
7430 case ensEDatabaseadaptorGroupCopyDNA:
7431
7432 rcs = (RegistryPCoreStyle)
7433 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7434
7435 if (!rcs)
7436 break;
7437
7438 if (!rcs->Proteinalignfeatureadaptor)
7439 rcs->Proteinalignfeatureadaptor =
7440 ensProteinalignfeatureadaptorNew(dba);
7441
7442 return rcs->Proteinalignfeatureadaptor;
7443
7444 break;
7445
7446 default:
7447
7448 ajWarn("ensRegistryGetProteinalignfeatureadaptor got an "
7449 "Ensembl Database Adaptor "
7450 "with an unexpected group %d.\n",
7451 ensDatabaseadaptorGetGroup(dba));
7452 }
7453
7454 return NULL;
7455 }
7456
7457
7458
7459
7460 /* @func ensRegistryGetProteinfeatureadaptor **********************************
7461 **
7462 ** Get an Ensembl Protein Feature Adaptor from the Ensembl Registry.
7463 **
7464 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7465 **
7466 ** @return [EnsPProteinfeatureadaptor]
7467 ** Ensembl Protein Feature Adaptor or NULL
7468 **
7469 ** @release 6.2.0
7470 ** @@
7471 ******************************************************************************/
7472
ensRegistryGetProteinfeatureadaptor(EnsPDatabaseadaptor dba)7473 EnsPProteinfeatureadaptor ensRegistryGetProteinfeatureadaptor(
7474 EnsPDatabaseadaptor dba)
7475 {
7476 RegistryPEntry entry = NULL;
7477 RegistryPCoreStyle rcs = NULL;
7478
7479 if (!dba)
7480 return NULL;
7481
7482 entry = (RegistryPEntry) ajTableFetchmodV(
7483 registryGEntry,
7484 (const void *) ensDatabaseadaptorGetSpecies(dba));
7485
7486 if (!entry)
7487 return NULL;
7488
7489 switch (ensDatabaseadaptorGetGroup(dba))
7490 {
7491 case ensEDatabaseadaptorGroupCore:
7492
7493 case ensEDatabaseadaptorGroupVega:
7494
7495 case ensEDatabaseadaptorGroupOtherFeatures:
7496
7497 case ensEDatabaseadaptorGroupCopyDNA:
7498
7499 rcs = (RegistryPCoreStyle)
7500 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7501
7502 if (!rcs)
7503 break;
7504
7505 if (!rcs->Proteinfeatureadaptor)
7506 rcs->Proteinfeatureadaptor =
7507 ensProteinfeatureadaptorNew(dba);
7508
7509 return rcs->Proteinfeatureadaptor;
7510
7511 break;
7512
7513 default:
7514
7515 ajWarn("ensRegistryGetProteinfeatureadaptor got an "
7516 "Ensembl Database Adaptor "
7517 "with an unexpected group %d.\n",
7518 ensDatabaseadaptorGetGroup(dba));
7519 }
7520
7521 return NULL;
7522 }
7523
7524
7525
7526
7527 /* @func ensRegistryGetRepeatconsensusadaptor *********************************
7528 **
7529 ** Get an Ensembl Repeat Consensus Adaptor from the Ensembl Registry.
7530 ** The Ensembl Repeat Consensus Adaptor is an alias for an
7531 ** Ensembl Database Adaptor connected to an Ensembl Core-style database.
7532 **
7533 ** If an Ensembl Reference Adaptor has been set for this database, the adaptor
7534 ** returned will be based on the Ensembl Reference Adaptor rather than the
7535 ** Ensembl Database Adaptor that was passed in.
7536 **
7537 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7538 **
7539 ** @return [EnsPRepeatconsensusadaptor]
7540 ** Ensembl Repeat Consensus Adaptor or NULL
7541 **
7542 ** @release 6.3.0
7543 ** @@
7544 ******************************************************************************/
7545
ensRegistryGetRepeatconsensusadaptor(EnsPDatabaseadaptor dba)7546 EnsPRepeatconsensusadaptor ensRegistryGetRepeatconsensusadaptor(
7547 EnsPDatabaseadaptor dba)
7548 {
7549 EnsPDatabaseadaptor rsa = NULL;
7550
7551 RegistryPEntry entry = NULL;
7552 RegistryPCoreStyle rcs = NULL;
7553
7554 if (!dba)
7555 return NULL;
7556
7557 rsa = ensRegistryGetReferenceadaptor(dba);
7558
7559 entry = (RegistryPEntry) ajTableFetchmodV(
7560 registryGEntry,
7561 (const void *) ensDatabaseadaptorGetSpecies(rsa));
7562
7563 if (!entry)
7564 return NULL;
7565
7566 switch (ensDatabaseadaptorGetGroup(rsa))
7567 {
7568 case ensEDatabaseadaptorGroupCore:
7569
7570 case ensEDatabaseadaptorGroupVega:
7571
7572 case ensEDatabaseadaptorGroupOtherFeatures:
7573
7574 case ensEDatabaseadaptorGroupCopyDNA:
7575
7576 rcs = (RegistryPCoreStyle)
7577 entry->Registry[ensDatabaseadaptorGetGroup(rsa)];
7578
7579 if (!rcs)
7580 break;
7581
7582 if (!rcs->Repeatconsensusadaptor)
7583 rcs->Repeatconsensusadaptor =
7584 ensRepeatconsensusadaptorNew(rsa);
7585
7586 return rcs->Repeatconsensusadaptor;
7587
7588 break;
7589
7590 default:
7591
7592 ajWarn("ensRegistryGetRepeatconsensusadaptor got an "
7593 "Ensembl Database Adaptor "
7594 "with an unexpected group %d.\n",
7595 ensDatabaseadaptorGetGroup(rsa));
7596 }
7597
7598 return NULL;
7599 }
7600
7601
7602
7603
7604 /* @func ensRegistryGetRepeatfeatureadaptor ***********************************
7605 **
7606 ** Get an Ensembl Repeat Feature Adaptor from the Ensembl Registry.
7607 **
7608 ** If an Ensembl Reference Adaptor has been set for this database, the adaptor
7609 ** returned will be based on the Ensembl Reference Adaptor rather than the
7610 ** Ensembl Database Adaptor that was passed in.
7611 **
7612 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7613 **
7614 ** @return [EnsPRepeatfeatureadaptor]
7615 ** Ensembl Repeat Feature Adaptor or NULL
7616 **
7617 ** @release 6.2.0
7618 ** @@
7619 ******************************************************************************/
7620
ensRegistryGetRepeatfeatureadaptor(EnsPDatabaseadaptor dba)7621 EnsPRepeatfeatureadaptor ensRegistryGetRepeatfeatureadaptor(
7622 EnsPDatabaseadaptor dba)
7623 {
7624 EnsPDatabaseadaptor rsa = NULL;
7625
7626 RegistryPEntry entry = NULL;
7627 RegistryPCoreStyle rcs = NULL;
7628
7629 if (!dba)
7630 return NULL;
7631
7632 rsa = ensRegistryGetReferenceadaptor(dba);
7633
7634 entry = (RegistryPEntry) ajTableFetchmodV(
7635 registryGEntry,
7636 (const void *) ensDatabaseadaptorGetSpecies(rsa));
7637
7638 if (!entry)
7639 return NULL;
7640
7641 switch (ensDatabaseadaptorGetGroup(rsa))
7642 {
7643 case ensEDatabaseadaptorGroupCore:
7644
7645 case ensEDatabaseadaptorGroupVega:
7646
7647 case ensEDatabaseadaptorGroupOtherFeatures:
7648
7649 case ensEDatabaseadaptorGroupCopyDNA:
7650
7651 rcs = (RegistryPCoreStyle)
7652 entry->Registry[ensDatabaseadaptorGetGroup(rsa)];
7653
7654 if (!rcs)
7655 break;
7656
7657 if (!rcs->Repeatfeatureadaptor)
7658 rcs->Repeatfeatureadaptor =
7659 ensRepeatfeatureadaptorNew(rsa);
7660
7661 return rcs->Repeatfeatureadaptor;
7662
7663 break;
7664
7665 default:
7666
7667 ajWarn("ensRegistryGetRepeatfeatureadaptor got an "
7668 "Ensembl Database Adaptor "
7669 "with an unexpected group %d.\n",
7670 ensDatabaseadaptorGetGroup(rsa));
7671 }
7672
7673 return NULL;
7674 }
7675
7676
7677
7678
7679 /* @func ensRegistryGetSeqregionadaptor ***************************************
7680 **
7681 ** Get an Ensembl Sequence Region Adaptor from the Ensembl Registry.
7682 **
7683 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7684 **
7685 ** @return [EnsPSeqregionadaptor]
7686 ** Ensembl Sequence Region Adaptor or NULL
7687 **
7688 ** @release 6.2.0
7689 ** @@
7690 ******************************************************************************/
7691
ensRegistryGetSeqregionadaptor(EnsPDatabaseadaptor dba)7692 EnsPSeqregionadaptor ensRegistryGetSeqregionadaptor(
7693 EnsPDatabaseadaptor dba)
7694 {
7695 RegistryPEntry entry = NULL;
7696 RegistryPCoreStyle rcs = NULL;
7697
7698 if (!dba)
7699 return NULL;
7700
7701 entry = (RegistryPEntry) ajTableFetchmodV(
7702 registryGEntry,
7703 (const void *) ensDatabaseadaptorGetSpecies(dba));
7704
7705 if (!entry)
7706 return NULL;
7707
7708 switch (ensDatabaseadaptorGetGroup(dba))
7709 {
7710 case ensEDatabaseadaptorGroupCore:
7711
7712 case ensEDatabaseadaptorGroupVega:
7713
7714 case ensEDatabaseadaptorGroupOtherFeatures:
7715
7716 case ensEDatabaseadaptorGroupCopyDNA:
7717
7718 rcs = (RegistryPCoreStyle)
7719 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7720
7721 if (!rcs)
7722 break;
7723
7724 if (!rcs->Seqregionadaptor)
7725 rcs->Seqregionadaptor =
7726 ensSeqregionadaptorNew(dba);
7727
7728 return rcs->Seqregionadaptor;
7729
7730 break;
7731
7732 default:
7733
7734 ajWarn("ensRegistryGetSeqregionadaptor got an "
7735 "Ensembl Database Adaptor "
7736 "with an unexpected group %d.\n",
7737 ensDatabaseadaptorGetGroup(dba));
7738 }
7739
7740 return NULL;
7741 }
7742
7743
7744
7745
7746 /* @func ensRegistryGetSeqregionsynonymadaptor ********************************
7747 **
7748 ** Get an Ensembl Sequence Region Synonym Adaptor from the Ensembl Registry.
7749 **
7750 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7751 **
7752 ** @return [EnsPSeqregionsynonymadaptor]
7753 ** Ensembl Sequence Region Synonym Adaptor or NULL
7754 **
7755 ** @release 6.4.0
7756 ** @@
7757 ******************************************************************************/
7758
ensRegistryGetSeqregionsynonymadaptor(EnsPDatabaseadaptor dba)7759 EnsPSeqregionsynonymadaptor ensRegistryGetSeqregionsynonymadaptor(
7760 EnsPDatabaseadaptor dba)
7761 {
7762 RegistryPEntry entry = NULL;
7763 RegistryPCoreStyle rcs = NULL;
7764
7765 if (!dba)
7766 return NULL;
7767
7768 entry = (RegistryPEntry) ajTableFetchmodV(
7769 registryGEntry,
7770 (const void *) ensDatabaseadaptorGetSpecies(dba));
7771
7772 if (!entry)
7773 return NULL;
7774
7775 switch (ensDatabaseadaptorGetGroup(dba))
7776 {
7777 case ensEDatabaseadaptorGroupCore:
7778
7779 case ensEDatabaseadaptorGroupVega:
7780
7781 case ensEDatabaseadaptorGroupOtherFeatures:
7782
7783 case ensEDatabaseadaptorGroupCopyDNA:
7784
7785 rcs = (RegistryPCoreStyle)
7786 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7787
7788 if (!rcs)
7789 break;
7790
7791 if (!rcs->Seqregionsynonymadaptor)
7792 rcs->Seqregionsynonymadaptor =
7793 ensSeqregionsynonymadaptorNew(dba);
7794
7795 return rcs->Seqregionsynonymadaptor;
7796
7797 break;
7798
7799 default:
7800
7801 ajWarn("ensRegistryGetSeqregionsynonymadaptor got an "
7802 "Ensembl Database Adaptor "
7803 "with an unexpected group %d.\n",
7804 ensDatabaseadaptorGetGroup(dba));
7805 }
7806
7807 return NULL;
7808 }
7809
7810
7811
7812
7813 /* @func ensRegistryGetSequenceadaptor ****************************************
7814 **
7815 ** Get an Ensembl Sequence Adaptor from the Ensembl Registry.
7816 **
7817 ** If an Ensembl Reference Adaptor has been set for this database, the adaptor
7818 ** returned will be based on the Ensembl Reference Adaptor rather than the
7819 ** Ensembl Database Adaptor that was passed in.
7820 **
7821 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7822 **
7823 ** @return [EnsPSequenceadaptor]
7824 ** Ensembl Sequence Adaptor or NULL
7825 **
7826 ** @release 6.2.0
7827 ** @@
7828 ******************************************************************************/
7829
ensRegistryGetSequenceadaptor(EnsPDatabaseadaptor dba)7830 EnsPSequenceadaptor ensRegistryGetSequenceadaptor(
7831 EnsPDatabaseadaptor dba)
7832 {
7833 EnsPDatabaseadaptor rsa = NULL;
7834
7835 RegistryPEntry entry = NULL;
7836 RegistryPCoreStyle rcs = NULL;
7837
7838 if (!dba)
7839 return NULL;
7840
7841 rsa = ensRegistryGetReferenceadaptor(dba);
7842
7843 entry = (RegistryPEntry) ajTableFetchmodV(
7844 registryGEntry,
7845 (const void *) ensDatabaseadaptorGetSpecies(rsa));
7846
7847 if (!entry)
7848 return NULL;
7849
7850 switch (ensDatabaseadaptorGetGroup(rsa))
7851 {
7852 case ensEDatabaseadaptorGroupCore:
7853
7854 case ensEDatabaseadaptorGroupVega:
7855
7856 case ensEDatabaseadaptorGroupOtherFeatures:
7857
7858 case ensEDatabaseadaptorGroupCopyDNA:
7859
7860 rcs = (RegistryPCoreStyle)
7861 entry->Registry[ensDatabaseadaptorGetGroup(rsa)];
7862
7863 if (!rcs)
7864 break;
7865
7866 if (!rcs->Sequenceadaptor)
7867 rcs->Sequenceadaptor =
7868 ensSequenceadaptorNew(rsa);
7869
7870 return rcs->Sequenceadaptor;
7871
7872 break;
7873
7874 default:
7875
7876 ajWarn("ensRegistryGetSequenceadaptor got an "
7877 "Ensembl Database Adaptor "
7878 "with an unexpected group %d.\n",
7879 ensDatabaseadaptorGetGroup(rsa));
7880 }
7881
7882 return NULL;
7883 }
7884
7885
7886
7887
7888 /* @func ensRegistryGetSimplefeatureadaptor ***********************************
7889 **
7890 ** Get an Ensembl Simple Feature Adaptor from the Ensembl Registry.
7891 **
7892 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7893 **
7894 ** @return [EnsPSimplefeatureadaptor]
7895 ** Ensembl Simple Feature Adaptor or NULL
7896 **
7897 ** @release 6.2.0
7898 ** @@
7899 ******************************************************************************/
7900
ensRegistryGetSimplefeatureadaptor(EnsPDatabaseadaptor dba)7901 EnsPSimplefeatureadaptor ensRegistryGetSimplefeatureadaptor(
7902 EnsPDatabaseadaptor dba)
7903 {
7904 RegistryPEntry entry = NULL;
7905 RegistryPCoreStyle rcs = NULL;
7906
7907 if (!dba)
7908 return NULL;
7909
7910 entry = (RegistryPEntry) ajTableFetchmodV(
7911 registryGEntry,
7912 (const void *) ensDatabaseadaptorGetSpecies(dba));
7913
7914 if (!entry)
7915 return NULL;
7916
7917 switch (ensDatabaseadaptorGetGroup(dba))
7918 {
7919 case ensEDatabaseadaptorGroupCore:
7920
7921 case ensEDatabaseadaptorGroupVega:
7922
7923 case ensEDatabaseadaptorGroupOtherFeatures:
7924
7925 case ensEDatabaseadaptorGroupCopyDNA:
7926
7927 rcs = (RegistryPCoreStyle)
7928 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7929
7930 if (!rcs)
7931 break;
7932
7933 if (!rcs->Simplefeatureadaptor)
7934 rcs->Simplefeatureadaptor =
7935 ensSimplefeatureadaptorNew(dba);
7936
7937 return rcs->Simplefeatureadaptor;
7938
7939 break;
7940
7941 default:
7942
7943 ajWarn("ensRegistryGetSimplefeatureadaptor got an "
7944 "Ensembl Database Adaptor "
7945 "with an unexpected group %d.\n",
7946 ensDatabaseadaptorGetGroup(dba));
7947 }
7948
7949 return NULL;
7950 }
7951
7952
7953
7954
7955 /* @func ensRegistryGetSliceadaptor *******************************************
7956 **
7957 ** Get an Ensembl Slice Adaptor from the Ensembl Registry.
7958 **
7959 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
7960 **
7961 ** @return [EnsPSliceadaptor]
7962 ** Ensembl Slice Adaptor or NULL
7963 **
7964 ** @release 6.2.0
7965 ** @@
7966 ******************************************************************************/
7967
ensRegistryGetSliceadaptor(EnsPDatabaseadaptor dba)7968 EnsPSliceadaptor ensRegistryGetSliceadaptor(
7969 EnsPDatabaseadaptor dba)
7970 {
7971 RegistryPEntry entry = NULL;
7972 RegistryPCoreStyle rcs = NULL;
7973
7974 if (!dba)
7975 return NULL;
7976
7977 entry = (RegistryPEntry) ajTableFetchmodV(
7978 registryGEntry,
7979 (const void *) ensDatabaseadaptorGetSpecies(dba));
7980
7981 if (!entry)
7982 return NULL;
7983
7984 switch (ensDatabaseadaptorGetGroup(dba))
7985 {
7986 case ensEDatabaseadaptorGroupCore:
7987
7988 case ensEDatabaseadaptorGroupVega:
7989
7990 case ensEDatabaseadaptorGroupOtherFeatures:
7991
7992 case ensEDatabaseadaptorGroupCopyDNA:
7993
7994 rcs = (RegistryPCoreStyle)
7995 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
7996
7997 if (!rcs)
7998 break;
7999
8000 if (!rcs->Sliceadaptor)
8001 rcs->Sliceadaptor =
8002 ensSliceadaptorNew(dba);
8003
8004 return rcs->Sliceadaptor;
8005
8006 break;
8007
8008 default:
8009
8010 ajWarn("ensRegistryGetSliceadaptor got an "
8011 "Ensembl Database Adaptor "
8012 "with an unexpected group %d.\n",
8013 ensDatabaseadaptorGetGroup(dba));
8014 }
8015
8016 return NULL;
8017 }
8018
8019
8020
8021
8022 /* @func ensRegistryGetStableidentifierprefix *********************************
8023 **
8024 ** Get an Ensembl stable identifier prefix from the Ensembl Registry.
8025 **
8026 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8027 **
8028 ** @return [AjPStr]
8029 ** Ensembl stable identifier prefix or NULL
8030 **
8031 ** @release 6.3.0
8032 ** @@
8033 ******************************************************************************/
8034
ensRegistryGetStableidentifierprefix(EnsPDatabaseadaptor dba)8035 AjPStr ensRegistryGetStableidentifierprefix(
8036 EnsPDatabaseadaptor dba)
8037 {
8038 RegistryPEntry entry = NULL;
8039 RegistryPCoreStyle rcs = NULL;
8040
8041 if (!dba)
8042 return NULL;
8043
8044 entry = (RegistryPEntry) ajTableFetchmodV(
8045 registryGEntry,
8046 (const void *) ensDatabaseadaptorGetSpecies(dba));
8047
8048 if (!entry)
8049 return NULL;
8050
8051 switch (ensDatabaseadaptorGetGroup(dba))
8052 {
8053 case ensEDatabaseadaptorGroupCore:
8054
8055 case ensEDatabaseadaptorGroupVega:
8056
8057 case ensEDatabaseadaptorGroupOtherFeatures:
8058
8059 case ensEDatabaseadaptorGroupCopyDNA:
8060
8061 rcs = (RegistryPCoreStyle)
8062 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8063
8064 if (!rcs)
8065 break;
8066
8067 return rcs->Stableidentifierprefix;
8068
8069 break;
8070
8071 default:
8072
8073 ajWarn("ensRegistryGetStableidentifierprefix got an "
8074 "Ensembl Database Adaptor "
8075 "with an unexpected group %d.\n",
8076 ensDatabaseadaptorGetGroup(dba));
8077 }
8078
8079 return NULL;
8080 }
8081
8082
8083
8084
8085 /* @func ensRegistryGetSupportingfeatureadaptor *******************************
8086 **
8087 ** Get an Ensembl Supporting Feature Adaptor from the Ensembl Registry.
8088 ** The Ensembl Supporting Feature Adaptor is an alias for an
8089 ** Ensembl Database Adaptor connected to an Ensembl Core-style database.
8090 **
8091 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8092 **
8093 ** @return [EnsPSupportingfeatureadaptor]
8094 ** Ensembl Supporting Feature Adaptor or NULL
8095 **
8096 ** @release 6.5.0
8097 ** @@
8098 ******************************************************************************/
8099
ensRegistryGetSupportingfeatureadaptor(EnsPDatabaseadaptor dba)8100 EnsPSupportingfeatureadaptor ensRegistryGetSupportingfeatureadaptor(
8101 EnsPDatabaseadaptor dba)
8102 {
8103 if (!dba)
8104 return NULL;
8105
8106 switch (ensDatabaseadaptorGetGroup(dba))
8107 {
8108 case ensEDatabaseadaptorGroupCore:
8109
8110 case ensEDatabaseadaptorGroupVega:
8111
8112 case ensEDatabaseadaptorGroupOtherFeatures:
8113
8114 case ensEDatabaseadaptorGroupCopyDNA:
8115
8116 return dba;
8117
8118 break;
8119
8120 default:
8121
8122 ajWarn("ensRegistryGetSupportingfeatureeadaptor got an "
8123 "Ensembl Database Adaptor "
8124 "with an unexpected group %d.\n",
8125 ensDatabaseadaptorGetGroup(dba));
8126 }
8127
8128 return NULL;
8129 }
8130
8131
8132
8133
8134 /* @func ensRegistryGetTranscriptadaptor **************************************
8135 **
8136 ** Get an Ensembl Transcript Adaptor from the Ensembl Registry.
8137 **
8138 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8139 **
8140 ** @return [EnsPTranscriptadaptor]
8141 ** Ensembl Transcript Adaptor or NULL
8142 **
8143 ** @release 6.2.0
8144 ** @@
8145 ******************************************************************************/
8146
ensRegistryGetTranscriptadaptor(EnsPDatabaseadaptor dba)8147 EnsPTranscriptadaptor ensRegistryGetTranscriptadaptor(
8148 EnsPDatabaseadaptor dba)
8149 {
8150 RegistryPEntry entry = NULL;
8151 RegistryPCoreStyle rcs = NULL;
8152
8153 if (!dba)
8154 return NULL;
8155
8156 entry = (RegistryPEntry) ajTableFetchmodV(
8157 registryGEntry,
8158 (const void *) ensDatabaseadaptorGetSpecies(dba));
8159
8160 if (!entry)
8161 return NULL;
8162
8163 switch (ensDatabaseadaptorGetGroup(dba))
8164 {
8165 case ensEDatabaseadaptorGroupCore:
8166
8167 case ensEDatabaseadaptorGroupVega:
8168
8169 case ensEDatabaseadaptorGroupOtherFeatures:
8170
8171 case ensEDatabaseadaptorGroupCopyDNA:
8172
8173 rcs = (RegistryPCoreStyle)
8174 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8175
8176 if (!rcs)
8177 break;
8178
8179 if (!rcs->Transcriptadaptor)
8180 rcs->Transcriptadaptor =
8181 ensTranscriptadaptorNew(dba);
8182
8183 return rcs->Transcriptadaptor;
8184
8185 break;
8186
8187 default:
8188
8189 ajWarn("ensRegistryGetTranscriptadaptor got an "
8190 "Ensembl Database Adaptor "
8191 "with an unexpected group %d.\n",
8192 ensDatabaseadaptorGetGroup(dba));
8193 }
8194
8195 return NULL;
8196 }
8197
8198
8199
8200
8201 /* @func ensRegistryGetTranslationadaptor *************************************
8202 **
8203 ** Get an Ensembl Translation Adaptor from the Ensembl Registry.
8204 **
8205 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8206 **
8207 ** @return [EnsPTranslationadaptor]
8208 ** Ensembl Translation Adaptor or NULL
8209 **
8210 ** @release 6.2.0
8211 ** @@
8212 ******************************************************************************/
8213
ensRegistryGetTranslationadaptor(EnsPDatabaseadaptor dba)8214 EnsPTranslationadaptor ensRegistryGetTranslationadaptor(
8215 EnsPDatabaseadaptor dba)
8216 {
8217 RegistryPEntry entry = NULL;
8218 RegistryPCoreStyle rcs = NULL;
8219
8220 if (!dba)
8221 return NULL;
8222
8223 entry = (RegistryPEntry) ajTableFetchmodV(
8224 registryGEntry,
8225 (const void *) ensDatabaseadaptorGetSpecies(dba));
8226
8227 if (!entry)
8228 return NULL;
8229
8230 switch (ensDatabaseadaptorGetGroup(dba))
8231 {
8232 case ensEDatabaseadaptorGroupCore:
8233
8234 case ensEDatabaseadaptorGroupVega:
8235
8236 case ensEDatabaseadaptorGroupOtherFeatures:
8237
8238 case ensEDatabaseadaptorGroupCopyDNA:
8239
8240 rcs = (RegistryPCoreStyle)
8241 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8242
8243 if (!rcs)
8244 break;
8245
8246 if (!rcs->Translationadaptor)
8247 rcs->Translationadaptor =
8248 ensTranslationadaptorNew(dba);
8249
8250 return rcs->Translationadaptor;
8251
8252 break;
8253
8254 default:
8255
8256 ajWarn("ensRegistryGetTranslationadaptor got an "
8257 "Ensembl Database Adaptor "
8258 "with an unexpected group %d.\n",
8259 ensDatabaseadaptorGetGroup(dba));
8260 }
8261
8262 return NULL;
8263 }
8264
8265
8266
8267
8268 /* @section Ensembl Ontology Adaptor retrieval ********************************
8269 **
8270 ** Functions for returning Ensembl Ontology Adaptor objects from the
8271 ** Ensembl Registry.
8272 **
8273 ** @fdata [EnsPDatabaseadaptor]
8274 **
8275 ** @nam3rule Get Return Registry attribute(s)
8276 ** @nam4rule Ontologyadaptor
8277 ** Return the Ensembl Ontology Adaptor
8278 ** @nam4rule Ontologytermadaptor
8279 ** Return the Ensembl Ontology Term Adaptor
8280 **
8281 ** @argrule * dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8282 **
8283 ** @valrule Ontologyadaptor [EnsPOntologyadaptor]
8284 ** Ensembl Ontology Adaptor or NULL
8285 ** @valrule Ontologytermadaptor [EnsPOntologytermadaptor]
8286 ** Ensembl Ontology Term Adaptor or NULL
8287 **
8288 ** @fcategory use
8289 ******************************************************************************/
8290
8291
8292
8293
8294 /* @func ensRegistryGetOntologyadaptor ****************************************
8295 **
8296 ** Get an Ensembl Ontology Adaptor from the Ensembl Registry.
8297 **
8298 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8299 **
8300 ** @return [EnsPOntologyadaptor]
8301 ** Ensembl Ontology Adaptor or NULL
8302 **
8303 ** @release 6.5.0
8304 ** @@
8305 ******************************************************************************/
8306
ensRegistryGetOntologyadaptor(EnsPDatabaseadaptor dba)8307 EnsPOntologyadaptor ensRegistryGetOntologyadaptor(
8308 EnsPDatabaseadaptor dba)
8309 {
8310 RegistryPEntry entry = NULL;
8311 RegistryPOntology ro = NULL;
8312
8313 if (!dba)
8314 return NULL;
8315
8316 entry = (RegistryPEntry) ajTableFetchmodV(
8317 registryGEntry,
8318 (const void *) ensDatabaseadaptorGetSpecies(dba));
8319
8320 if (!entry)
8321 return NULL;
8322
8323 switch (ensDatabaseadaptorGetGroup(dba))
8324 {
8325 case ensEDatabaseadaptorGroupOntology:
8326
8327 ro = (RegistryPOntology)
8328 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8329
8330 if (!ro)
8331 break;
8332
8333 if (!ro->Ontologyadaptor)
8334 ro->Ontologyadaptor =
8335 ensOntologyadaptorNew(dba);
8336
8337 return ro->Ontologyadaptor;
8338
8339 break;
8340
8341 default:
8342
8343 ajWarn("ensRegistryGetOntologyadaptor got an "
8344 "Ensembl Database Adaptor "
8345 "with an unexpected group %d.\n",
8346 ensDatabaseadaptorGetGroup(dba));
8347 }
8348
8349 return NULL;
8350 }
8351
8352
8353
8354
8355 /* @func ensRegistryGetOntologytermadaptor ************************************
8356 **
8357 ** Get an Ensembl Ontology Term Adaptor from the Ensembl Registry.
8358 **
8359 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8360 **
8361 ** @return [EnsPOntologytermadaptor]
8362 ** Ensembl Ontology Term Adaptor or NULL
8363 **
8364 ** @release 6.5.0
8365 ** @@
8366 ******************************************************************************/
8367
ensRegistryGetOntologytermadaptor(EnsPDatabaseadaptor dba)8368 EnsPOntologytermadaptor ensRegistryGetOntologytermadaptor(
8369 EnsPDatabaseadaptor dba)
8370 {
8371 RegistryPEntry entry = NULL;
8372 RegistryPOntology ro = NULL;
8373
8374 if (!dba)
8375 return NULL;
8376
8377 entry = (RegistryPEntry) ajTableFetchmodV(
8378 registryGEntry,
8379 (const void *) ensDatabaseadaptorGetSpecies(dba));
8380
8381 if (!entry)
8382 return NULL;
8383
8384 switch (ensDatabaseadaptorGetGroup(dba))
8385 {
8386 case ensEDatabaseadaptorGroupOntology:
8387
8388 ro = (RegistryPOntology)
8389 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8390
8391 if (!ro)
8392 break;
8393
8394 if (!ro->Ontologytermadaptor)
8395 ro->Ontologytermadaptor =
8396 ensOntologytermadaptorNew(dba);
8397
8398 return ro->Ontologytermadaptor;
8399
8400 break;
8401
8402 default:
8403
8404 ajWarn("ensRegistryGetOntologytermadaptor got an "
8405 "Ensembl Database Adaptor "
8406 "with an unexpected group %d.\n",
8407 ensDatabaseadaptorGetGroup(dba));
8408 }
8409
8410 return NULL;
8411 }
8412
8413
8414
8415
8416 /* @section Ensembl Quality Check Adaptor retrieval ***************************
8417 **
8418 ** Functions for returning Ensembl Quality Check Adaptor objects from the
8419 ** Ensembl Registry.
8420 **
8421 ** @fdata [EnsPDatabaseadaptor]
8422 **
8423 ** @nam3rule Get Return Registry attribute(s)
8424 ** @nam4rule Qcdatabaseadaptor
8425 ** Return the Ensembl Quality Check Database Adaptor
8426 ** @nam4rule Qcsequenceadaptor
8427 ** Return the Ensembl Quality Check Sequence Adaptor
8428 ** @nam4rule Qcalignmentadaptor
8429 ** Return the Ensembl Quality Check Alignment Adaptor
8430 ** @nam4rule Qcdasfeatureadaptor
8431 ** Return the Ensembl Quality Check DAS Feature Adaptor
8432 ** @nam4rule Qcsubmissionadaptor
8433 ** Return the Ensembl Quality Check Submission Adaptor
8434 ** @nam4rule Qcvariationadaptor
8435 ** Return the Ensembl Quality Check Variation Adaptor
8436 **
8437 ** @argrule * dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8438 **
8439 ** @valrule Qcdatabaseadaptor [EnsPQcdatabaseadaptor]
8440 ** Ensembl Quality Check Database Adaptor or NULL
8441 ** @valrule Qcsequenceadaptor [EnsPQcsequenceadaptor]
8442 ** Ensembl Quality Check Sequence Adaptor or NULL
8443 ** @valrule Qcalignmentadaptor [EnsPQcalignmentadaptor]
8444 ** Ensembl Quality Check Alignment Adaptor or NULL
8445 ** @valrule Qcdasfeatureadaptor [EnsPQcdasfeatureadaptor]
8446 ** Ensembl Quality Check DAS Feature Adaptor or NULL
8447 ** @valrule Qcsubmissionadaptor [EnsPQcsubmissionadaptor]
8448 ** Ensembl Quality Check Submission Adaptor or NULL
8449 ** @valrule Qcvariationadaptor [EnsPQcvariationadaptor]
8450 ** Ensembl Quality Check Variation Adaptor or NULL
8451 **
8452 ** @fcategory use
8453 ******************************************************************************/
8454
8455
8456
8457
8458 /* @func ensRegistryGetQcalignmentadaptor *************************************
8459 **
8460 ** Get an Ensembl Quality Check Alignment Adaptor from the Ensembl Registry.
8461 **
8462 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8463 **
8464 ** @return [EnsPQcalignmentadaptor]
8465 ** Ensembl Quality Check Alignment Adaptor or NULL
8466 **
8467 ** @release 6.2.0
8468 ** @@
8469 ******************************************************************************/
8470
ensRegistryGetQcalignmentadaptor(EnsPDatabaseadaptor dba)8471 EnsPQcalignmentadaptor ensRegistryGetQcalignmentadaptor(
8472 EnsPDatabaseadaptor dba)
8473 {
8474 RegistryPEntry entry = NULL;
8475 RegistryPQualityCheck rqc = NULL;
8476
8477 if (!dba)
8478 return NULL;
8479
8480 entry = (RegistryPEntry) ajTableFetchmodV(
8481 registryGEntry,
8482 (const void *) ensDatabaseadaptorGetSpecies(dba));
8483
8484 if (!entry)
8485 return NULL;
8486
8487 switch (ensDatabaseadaptorGetGroup(dba))
8488 {
8489 case ensEDatabaseadaptorGroupQualityCheck:
8490
8491 rqc = (RegistryPQualityCheck)
8492 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8493
8494 if (!rqc)
8495 break;
8496
8497 if (!rqc->Qcalignmentadaptor)
8498 rqc->Qcalignmentadaptor =
8499 ensQcalignmentadaptorNew(dba);
8500
8501 return rqc->Qcalignmentadaptor;
8502
8503 break;
8504
8505 default:
8506
8507 ajWarn("ensRegistryGetQcalignmentadaptor got an "
8508 "Ensembl Database Adaptor "
8509 "with an unexpected group %d.\n",
8510 ensDatabaseadaptorGetGroup(dba));
8511 }
8512
8513 return NULL;
8514 }
8515
8516
8517
8518
8519 /* @func ensRegistryGetQcdasfeatureadaptor ************************************
8520 **
8521 ** Get an Ensembl Quality Check DAS Feature Adaptor from the Ensembl Registry.
8522 **
8523 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8524 **
8525 ** @return [EnsPQcdasfeatureadaptor]
8526 ** Ensembl Quality Check DAS Feature Adaptor or NULL
8527 **
8528 ** @release 6.2.0
8529 ** @@
8530 ******************************************************************************/
8531
ensRegistryGetQcdasfeatureadaptor(EnsPDatabaseadaptor dba)8532 EnsPQcdasfeatureadaptor ensRegistryGetQcdasfeatureadaptor(
8533 EnsPDatabaseadaptor dba)
8534 {
8535 RegistryPEntry entry = NULL;
8536 RegistryPQualityCheck rqc = NULL;
8537
8538 if (!dba)
8539 return NULL;
8540
8541 entry = (RegistryPEntry) ajTableFetchmodV(
8542 registryGEntry,
8543 (const void *) ensDatabaseadaptorGetSpecies(dba));
8544
8545 if (!entry)
8546 return NULL;
8547
8548 switch (ensDatabaseadaptorGetGroup(dba))
8549 {
8550 case ensEDatabaseadaptorGroupQualityCheck:
8551
8552 rqc = (RegistryPQualityCheck)
8553 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8554
8555 if (!rqc)
8556 break;
8557
8558 if (!rqc->Qcdasfeatureadaptor)
8559 rqc->Qcdasfeatureadaptor =
8560 ensQcdasfeatureadaptorNew(dba);
8561
8562 return rqc->Qcdasfeatureadaptor;
8563
8564 break;
8565
8566 default:
8567
8568 ajWarn("ensRegistryGetQcdasfeatureadaptor got an "
8569 "Ensembl Database Adaptor "
8570 "with an unexpected group %d.\n",
8571 ensDatabaseadaptorGetGroup(dba));
8572 }
8573
8574 return NULL;
8575 }
8576
8577
8578
8579
8580 /* @func ensRegistryGetQcdatabaseadaptor **************************************
8581 **
8582 ** Get an Ensembl Quality Check Database Adaptor from the Ensembl Registry.
8583 **
8584 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8585 **
8586 ** @return [EnsPQcdatabaseadaptor]
8587 ** Ensembl Quality Check Database Adaptor or NULL
8588 **
8589 ** @release 6.2.0
8590 ** @@
8591 ******************************************************************************/
8592
ensRegistryGetQcdatabaseadaptor(EnsPDatabaseadaptor dba)8593 EnsPQcdatabaseadaptor ensRegistryGetQcdatabaseadaptor(
8594 EnsPDatabaseadaptor dba)
8595 {
8596 RegistryPEntry entry = NULL;
8597 RegistryPQualityCheck rqc = NULL;
8598
8599 if (!dba)
8600 return NULL;
8601
8602 entry = (RegistryPEntry) ajTableFetchmodV(
8603 registryGEntry,
8604 (const void *) ensDatabaseadaptorGetSpecies(dba));
8605
8606 if (!entry)
8607 return NULL;
8608
8609 switch (ensDatabaseadaptorGetGroup(dba))
8610 {
8611 case ensEDatabaseadaptorGroupQualityCheck:
8612
8613 rqc = (RegistryPQualityCheck)
8614 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8615
8616 if (!rqc)
8617 break;
8618
8619 if (!rqc->Databaseadaptor)
8620 rqc->Qcdatabaseadaptor =
8621 ensQcdatabaseadaptorNew(dba);
8622
8623 return rqc->Qcdatabaseadaptor;
8624
8625 break;
8626
8627 default:
8628
8629 ajWarn("ensRegistryGetQcdatabaseadaptor got an "
8630 "Ensembl Database Adaptor "
8631 "with an unexpected group %d.\n",
8632 ensDatabaseadaptorGetGroup(dba));
8633 }
8634
8635 return NULL;
8636 }
8637
8638
8639
8640
8641 /* @func ensRegistryGetQcsequenceadaptor **************************************
8642 **
8643 ** Get an Ensembl Quality Check Sequence Adaptor from the Ensembl Registry.
8644 **
8645 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8646 **
8647 ** @return [EnsPQcsequenceadaptor]
8648 ** Ensembl Quality Check Sequence Adaptor or NULL
8649 **
8650 ** @release 6.2.0
8651 ** @@
8652 ******************************************************************************/
8653
ensRegistryGetQcsequenceadaptor(EnsPDatabaseadaptor dba)8654 EnsPQcsequenceadaptor ensRegistryGetQcsequenceadaptor(
8655 EnsPDatabaseadaptor dba)
8656 {
8657 RegistryPEntry entry = NULL;
8658 RegistryPQualityCheck rqc = NULL;
8659
8660 if (!dba)
8661 return NULL;
8662
8663 entry = (RegistryPEntry) ajTableFetchmodV(
8664 registryGEntry,
8665 (const void *) ensDatabaseadaptorGetSpecies(dba));
8666
8667 if (!entry)
8668 return NULL;
8669
8670 switch (ensDatabaseadaptorGetGroup(dba))
8671 {
8672 case ensEDatabaseadaptorGroupQualityCheck:
8673
8674 rqc = (RegistryPQualityCheck)
8675 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8676
8677 if (!rqc)
8678 break;
8679
8680 if (!rqc->Qcsequenceadaptor)
8681 rqc->Qcsequenceadaptor =
8682 ensQcsequenceadaptorNew(dba);
8683
8684 return rqc->Qcsequenceadaptor;
8685
8686 break;
8687
8688 default:
8689
8690 ajWarn("ensRegistryGetQcsequenceadaptor got an "
8691 "Ensembl Database Adaptor "
8692 "with an unexpected group %d.\n",
8693 ensDatabaseadaptorGetGroup(dba));
8694 }
8695
8696 return NULL;
8697 }
8698
8699
8700
8701
8702 /* @func ensRegistryGetQcsubmissionadaptor ************************************
8703 **
8704 ** Get an Ensembl Quality Check Submission Adaptor from the Ensembl Registry.
8705 **
8706 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8707 **
8708 ** @return [EnsPQcsubmissionadaptor]
8709 ** Ensembl Quality Check Submission Adaptor or NULL
8710 **
8711 ** @release 6.2.0
8712 ** @@
8713 ******************************************************************************/
8714
ensRegistryGetQcsubmissionadaptor(EnsPDatabaseadaptor dba)8715 EnsPQcsubmissionadaptor ensRegistryGetQcsubmissionadaptor(
8716 EnsPDatabaseadaptor dba)
8717 {
8718 RegistryPEntry entry = NULL;
8719 RegistryPQualityCheck rqc = NULL;
8720
8721 if (!dba)
8722 return NULL;
8723
8724 entry = (RegistryPEntry) ajTableFetchmodV(
8725 registryGEntry,
8726 (const void *) ensDatabaseadaptorGetSpecies(dba));
8727
8728 if (!entry)
8729 return NULL;
8730
8731 switch (ensDatabaseadaptorGetGroup(dba))
8732 {
8733 case ensEDatabaseadaptorGroupQualityCheck:
8734
8735 rqc = (RegistryPQualityCheck)
8736 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8737
8738 if (!rqc)
8739 break;
8740
8741 if (!rqc->Qcsubmissionadaptor)
8742 rqc->Qcsubmissionadaptor =
8743 ensQcsubmissionadaptorNew(dba);
8744
8745 return rqc->Qcsubmissionadaptor;
8746
8747 break;
8748
8749 default:
8750
8751 ajWarn("ensRegistryGetQcsubmissionadaptor got an "
8752 "Ensembl Database Adaptor "
8753 "with an unexpected group %d.\n",
8754 ensDatabaseadaptorGetGroup(dba));
8755 }
8756
8757 return NULL;
8758 }
8759
8760
8761
8762
8763 /* @func ensRegistryGetQcvariationadaptor *************************************
8764 **
8765 ** Get an Ensembl Quality Check Variation Adaptor from the Ensembl Registry.
8766 **
8767 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8768 **
8769 ** @return [EnsPQcvariationadaptor]
8770 ** Ensembl Quality Check Variation Adaptor or NULL
8771 **
8772 ** @release 6.2.0
8773 ** @@
8774 ******************************************************************************/
8775
ensRegistryGetQcvariationadaptor(EnsPDatabaseadaptor dba)8776 EnsPQcvariationadaptor ensRegistryGetQcvariationadaptor(
8777 EnsPDatabaseadaptor dba)
8778 {
8779 RegistryPEntry entry = NULL;
8780 RegistryPQualityCheck rqc = NULL;
8781
8782 if (!dba)
8783 return NULL;
8784
8785 entry = (RegistryPEntry) ajTableFetchmodV(
8786 registryGEntry,
8787 (const void *) ensDatabaseadaptorGetSpecies(dba));
8788
8789 if (!entry)
8790 return NULL;
8791
8792 switch (ensDatabaseadaptorGetGroup(dba))
8793 {
8794 case ensEDatabaseadaptorGroupQualityCheck:
8795
8796 rqc = (RegistryPQualityCheck)
8797 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8798
8799 if (!rqc)
8800 break;
8801
8802 if (!rqc->Qcvariationadaptor)
8803 rqc->Qcvariationadaptor =
8804 ensQcvariationadaptorNew(dba);
8805
8806 return rqc->Qcvariationadaptor;
8807
8808 break;
8809
8810 default:
8811
8812 ajWarn("ensRegistryGetQcvariationadaptor got an "
8813 "Ensembl Database Adaptor "
8814 "with an unexpected group %d.\n",
8815 ensDatabaseadaptorGetGroup(dba));
8816 }
8817
8818 return NULL;
8819 }
8820
8821
8822
8823
8824 /* @section Ensembl Genetic Variation Adaptor retrieval ***********************
8825 **
8826 ** Functions for returning Ensembl Genetic Variation Adaptor objects from the
8827 ** Ensembl Registry.
8828 **
8829 ** @fdata [EnsPDatabaseadaptor]
8830 **
8831 ** @nam3rule Get Return Registry attribute(s)
8832 ** @nam4rule Gvalleleadaptor
8833 ** Return the Ensembl Genetic Variation Allele Adaptor
8834 ** @nam4rule Gvattributeadaptor
8835 ** Return the Ensembl Genetic Variation Attribute Adaptor
8836 ** @nam4rule Gvdatabaseadaptor
8837 ** Return the Ensembl Genetic Variation Database Adaptor
8838 ** @nam4rule Gvgenotypeadaptor
8839 ** Return the Ensembl Genetic Variation Genotype Adaptor
8840 ** @nam4rule Gvgenotypecodeadaptor
8841 ** Return the Ensembl Genetic Variation Genotype Code Adaptor
8842 ** @nam4rule Gvindividualadaptor
8843 ** Return the Ensembl Genetic Variation Individual Adaptor
8844 ** @nam4rule Gvpopulationadaptor
8845 ** Return the Ensembl Genetic Variation Population Adaptor
8846 ** @nam4rule Gvpopulationgenotypeadaptor
8847 ** Return the Ensembl Genetic Variation Population Genotype Adaptor
8848 ** @nam4rule Gvsampleadaptor
8849 ** Return the Ensembl Genetic Variation Sample Adaptor
8850 ** @nam4rule Gvsourceadaptor
8851 ** Return the Ensembl Genetic Variation Source Adaptor
8852 ** @nam4rule Gvsynonymadaptor
8853 ** Return the Ensembl Genetic Variation Synonym Adaptor
8854 ** @nam4rule Gvtranscriptvariationadaptor
8855 ** Return the Ensembl Genetic Variation Transcript Variation Adaptor
8856 ** @nam4rule Gvvariationadaptor
8857 ** Return the Ensembl Genetic Variation Variation Adaptor
8858 ** @nam4rule Gvvariationfeatureadaptor
8859 ** Return the Ensembl Genetic Variation Variation Feature Adaptor
8860 ** @nam4rule Gvvariationsetadaptor
8861 ** Return the Ensembl Genetic Variation Variation Set Adaptor
8862 **
8863 ** @argrule * dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8864 **
8865 ** @valrule Gvalleleadaptor [EnsPGvalleleadaptor]
8866 ** Ensembl Genetic Variation Allele Adaptor or NULL
8867 ** @valrule Gvattributeadaptor [EnsPGvattributeadaptor]
8868 ** Ensembl Genetic Variation Attribute Adaptor or NULL
8869 ** @valrule Gvdatabaseadaptor [EnsPGvdatabaseadaptor]
8870 ** Ensembl Genetic Variation Database Adaptor or NULL
8871 ** @valrule Gvgenotypeadaptor [EnsPGvgenotypeadaptor]
8872 ** Ensembl Genetic Variation Genotype Adaptor or NULL
8873 ** @valrule Gvgenotypecodeadaptor [EnsPGvgenotypecodeadaptor]
8874 ** Ensembl Genetic Variation Genotype Code Adaptor or NULL
8875 ** @valrule Gvindividualadaptor [EnsPGvindividualadaptor]
8876 ** Ensembl Genetic Variation Individual Adaptor or NULL
8877 ** @valrule Gvpopulationadaptor [EnsPGvpopulationadaptor]
8878 ** Ensembl Genetic Variation Population Adaptor or NULL
8879 ** @valrule Gvpopulationgenotypeadaptor [EnsPGvpopulationgenotypeadaptor]
8880 ** Ensembl Genetic Variation Population Genotype Adaptor or NULL
8881 ** @valrule Gvsampleadaptor [EnsPGvsampleadaptor]
8882 ** Ensembl Genetic Variation Sample Adaptor or NULL
8883 ** @valrule Gvsourceadaptor [EnsPGvsourceadaptor]
8884 ** Ensembl Genetic Variation Source Adaptor or NULL
8885 ** @valrule Gvsynonymadaptor [EnsPGvsynonymadaptor]
8886 ** Ensembl Genetic Variation Synonym Adaptor or NULL
8887 ** @valrule Gvtranscriptvariationadaptor [EnsPGvtranscriptvariationadaptor]
8888 ** Ensembl Genetic Variation Transcript Variation Adaptor or NULL
8889 ** @valrule Gvvariationadaptor [EnsPGvvariationadaptor]
8890 ** Ensembl Genetic Variation Variation Adaptor or NULL
8891 ** @valrule Gvvariationfeatureadaptor [EnsPGvvariationfeatureadaptor]
8892 ** Ensembl Genetic Variation Variation Feature Adaptor or NULL
8893 ** @valrule Gvvariationsetadaptor [EnsPGvvariationsetadaptor]
8894 ** Ensembl Genetic Variation Variation Set Adaptor or NULL
8895 **
8896 ** @fcategory use
8897 ******************************************************************************/
8898
8899
8900
8901
8902 /* @func ensRegistryGetGvalleleadaptor ****************************************
8903 **
8904 ** Get an Ensembl Genetic Variation Allele Adaptor from the
8905 ** Ensembl Registry.
8906 ** The Ensembl Genetic Variation Allele Adaptor is an alias for an
8907 ** Ensembl Database Adaptor connected to an Ensembl Variation database.
8908 **
8909 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8910 **
8911 ** @return [EnsPGvalleleadaptor]
8912 ** Ensembl Genetic Variation Allele Adaptor or NULL
8913 **
8914 ** @release 6.2.0
8915 ** @@
8916 ******************************************************************************/
8917
ensRegistryGetGvalleleadaptor(EnsPDatabaseadaptor dba)8918 EnsPGvalleleadaptor ensRegistryGetGvalleleadaptor(
8919 EnsPDatabaseadaptor dba)
8920 {
8921 RegistryPEntry entry = NULL;
8922 RegistryPGeneticVariation rgv = NULL;
8923
8924 if (!dba)
8925 return NULL;
8926
8927 entry = (RegistryPEntry) ajTableFetchmodV(
8928 registryGEntry,
8929 (const void *) ensDatabaseadaptorGetSpecies(dba));
8930
8931 if (!entry)
8932 return NULL;
8933
8934 switch (ensDatabaseadaptorGetGroup(dba))
8935 {
8936 case ensEDatabaseadaptorGroupGeneticVariation:
8937
8938 rgv = (RegistryPGeneticVariation)
8939 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
8940
8941 if (!rgv)
8942 break;
8943
8944 if (!rgv->Gvalleleadaptor)
8945 rgv->Gvalleleadaptor =
8946 ensGvalleleadaptorNew(dba);
8947
8948 return rgv->Gvalleleadaptor;
8949
8950 break;
8951
8952 default:
8953
8954 ajWarn("ensRegistryGetGvalleleadaptor got an "
8955 "Ensembl Database Adaptor "
8956 "with an unexpected group %d.\n",
8957 ensDatabaseadaptorGetGroup(dba));
8958 }
8959
8960 return NULL;
8961 }
8962
8963
8964
8965
8966 /* @func ensRegistryGetGvattributeadaptor *************************************
8967 **
8968 ** Get an Ensembl Genetic Variation Attribute Adaptor from the
8969 ** Ensembl Registry.
8970 ** The Ensembl Genetic Variation Attribute Adaptor is an alias for an
8971 ** Ensembl Database Adaptor connected to an Ensembl Variation database.
8972 **
8973 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
8974 **
8975 ** @return [EnsPGvattributeadaptor]
8976 ** Ensembl Genetic Variation Attribute Adaptor or NULL
8977 **
8978 ** @release 6.4.0
8979 ** @@
8980 ******************************************************************************/
8981
ensRegistryGetGvattributeadaptor(EnsPDatabaseadaptor dba)8982 EnsPGvattributeadaptor ensRegistryGetGvattributeadaptor(
8983 EnsPDatabaseadaptor dba)
8984 {
8985 RegistryPEntry entry = NULL;
8986 RegistryPGeneticVariation rgv = NULL;
8987
8988 if (!dba)
8989 return NULL;
8990
8991 entry = (RegistryPEntry) ajTableFetchmodV(
8992 registryGEntry,
8993 (const void *) ensDatabaseadaptorGetSpecies(dba));
8994
8995 if (!entry)
8996 return NULL;
8997
8998 switch (ensDatabaseadaptorGetGroup(dba))
8999 {
9000 case ensEDatabaseadaptorGroupGeneticVariation:
9001
9002 rgv = (RegistryPGeneticVariation)
9003 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9004
9005 if (!rgv)
9006 break;
9007
9008 if (!rgv->Gvattributeadaptor)
9009 rgv->Gvattributeadaptor =
9010 ensGvattributeadaptorNew(dba);
9011
9012 return rgv->Gvattributeadaptor;
9013
9014 break;
9015
9016 default:
9017
9018 ajWarn("ensRegistryGetGvattributeadaptor got an "
9019 "Ensembl Database Adaptor "
9020 "with an unexpected group %d.\n",
9021 ensDatabaseadaptorGetGroup(dba));
9022 }
9023
9024 return NULL;
9025 }
9026
9027
9028
9029
9030 /* @func ensRegistryGetGvdatabaseadaptor **************************************
9031 **
9032 ** Get an Ensembl Genetic Variation Database Adaptor from the
9033 ** Ensembl Registry.
9034 **
9035 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9036 **
9037 ** @return [EnsPGvdatabaseadaptor]
9038 ** Ensembl Genetic Variation Database Adaptor or NULL
9039 **
9040 ** @release 6.4.0
9041 ** @@
9042 ******************************************************************************/
9043
ensRegistryGetGvdatabaseadaptor(EnsPDatabaseadaptor dba)9044 EnsPGvdatabaseadaptor ensRegistryGetGvdatabaseadaptor(
9045 EnsPDatabaseadaptor dba)
9046 {
9047 RegistryPEntry entry = NULL;
9048 RegistryPGeneticVariation rgv = NULL;
9049
9050 if (!dba)
9051 return NULL;
9052
9053 entry = (RegistryPEntry) ajTableFetchmodV(
9054 registryGEntry,
9055 (const void *) ensDatabaseadaptorGetSpecies(dba));
9056
9057 if (!entry)
9058 return NULL;
9059
9060 switch (ensDatabaseadaptorGetGroup(dba))
9061 {
9062 case ensEDatabaseadaptorGroupGeneticVariation:
9063
9064 rgv = (RegistryPGeneticVariation)
9065 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9066
9067 if (!rgv)
9068 break;
9069
9070 if (!rgv->Gvdatabaseadaptor)
9071 rgv->Gvdatabaseadaptor =
9072 ensGvdatabaseadaptorNewIni(dba);
9073
9074 return rgv->Gvdatabaseadaptor;
9075
9076 break;
9077
9078 default:
9079
9080 ajWarn("ensRegistryGetGvdatabaseadaptor got an "
9081 "Ensembl Database Adaptor "
9082 "with an unexpected group %d.\n",
9083 ensDatabaseadaptorGetGroup(dba));
9084 }
9085
9086 return NULL;
9087 }
9088
9089
9090
9091
9092 /* @func ensRegistryGetGvgenotypeadaptor **************************************
9093 **
9094 ** Get an Ensembl Genetic Variation Genotype Adaptor from the
9095 ** Ensembl Registry.
9096 ** The Ensembl Genetic Variation Genotype Adaptor is an alias for an
9097 ** Ensembl Database Adaptor connected to an Ensembl Variation database.
9098 **
9099 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9100 **
9101 ** @return [EnsPGvgenotypeadaptor]
9102 ** Ensembl Genetic Variation Genotype Adaptor or NULL
9103 **
9104 ** @release 6.3.0
9105 ** @@
9106 ******************************************************************************/
9107
ensRegistryGetGvgenotypeadaptor(EnsPDatabaseadaptor dba)9108 EnsPGvgenotypeadaptor ensRegistryGetGvgenotypeadaptor(
9109 EnsPDatabaseadaptor dba)
9110 {
9111 if (!dba)
9112 return NULL;
9113
9114 switch (ensDatabaseadaptorGetGroup(dba))
9115 {
9116 case ensEDatabaseadaptorGroupGeneticVariation:
9117
9118 return dba;
9119
9120 break;
9121
9122 default:
9123
9124 ajWarn("ensRegistryGetGvgenotypeAdaptor got an "
9125 "Ensembl Database Adaptor "
9126 "with an unexpected group %d.\n",
9127 ensDatabaseadaptorGetGroup(dba));
9128 }
9129
9130 return NULL;
9131 }
9132
9133
9134
9135
9136 /* @func ensRegistryGetGvgenotypecodeadaptor **********************************
9137 **
9138 ** Get an Ensembl Genetic Variation Genotype Code Adaptor from the
9139 ** Ensembl Registry.
9140 **
9141 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9142 **
9143 ** @return [EnsPGvgenotypecodeadaptor]
9144 ** Ensembl Genetic Variation Genotype Code Adaptor or NULL
9145 **
9146 ** @release 6.5.0
9147 ** @@
9148 ******************************************************************************/
9149
ensRegistryGetGvgenotypecodeadaptor(EnsPDatabaseadaptor dba)9150 EnsPGvgenotypecodeadaptor ensRegistryGetGvgenotypecodeadaptor(
9151 EnsPDatabaseadaptor dba)
9152 {
9153 RegistryPEntry entry = NULL;
9154 RegistryPGeneticVariation rgv = NULL;
9155
9156 if (!dba)
9157 return NULL;
9158
9159 entry = (RegistryPEntry) ajTableFetchmodV(
9160 registryGEntry,
9161 (const void *) ensDatabaseadaptorGetSpecies(dba));
9162
9163 if (!entry)
9164 return NULL;
9165
9166 switch (ensDatabaseadaptorGetGroup(dba))
9167 {
9168 case ensEDatabaseadaptorGroupGeneticVariation:
9169
9170 rgv = (RegistryPGeneticVariation)
9171 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9172
9173 if (!rgv)
9174 break;
9175
9176 if (!rgv->Gvgenotypecodeadaptor)
9177 rgv->Gvgenotypecodeadaptor =
9178 ensGvgenotypecodeadaptorNew(dba);
9179
9180 return rgv->Gvgenotypecodeadaptor;
9181
9182 break;
9183
9184 default:
9185
9186 ajWarn("ensRegistryGetGvgenotypecodeadaptor got an "
9187 "Ensembl Database Adaptor "
9188 "with an unexpected group %d.\n",
9189 ensDatabaseadaptorGetGroup(dba));
9190 }
9191
9192 return NULL;
9193 }
9194
9195
9196
9197
9198 /* @func ensRegistryGetGvindividualadaptor ************************************
9199 **
9200 ** Get an Ensembl Genetic Variation Individual Adaptor from the
9201 ** Ensembl Registry.
9202 **
9203 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9204 **
9205 ** @return [EnsPGvindividualadaptor]
9206 ** Ensembl Genetic Variation Individual Adaptor or NULL
9207 **
9208 ** @release 6.2.0
9209 ** @@
9210 ******************************************************************************/
9211
ensRegistryGetGvindividualadaptor(EnsPDatabaseadaptor dba)9212 EnsPGvindividualadaptor ensRegistryGetGvindividualadaptor(
9213 EnsPDatabaseadaptor dba)
9214 {
9215 RegistryPEntry entry = NULL;
9216 RegistryPGeneticVariation rgv = NULL;
9217
9218 if (!dba)
9219 return NULL;
9220
9221 entry = (RegistryPEntry) ajTableFetchmodV(
9222 registryGEntry,
9223 (const void *) ensDatabaseadaptorGetSpecies(dba));
9224
9225 if (!entry)
9226 return NULL;
9227
9228 switch (ensDatabaseadaptorGetGroup(dba))
9229 {
9230 case ensEDatabaseadaptorGroupGeneticVariation:
9231
9232 rgv = (RegistryPGeneticVariation)
9233 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9234
9235 if (!rgv)
9236 break;
9237
9238 if (!rgv->Gvindividualadaptor)
9239 rgv->Gvindividualadaptor =
9240 ensGvindividualadaptorNew(dba);
9241
9242 return rgv->Gvindividualadaptor;
9243
9244 break;
9245
9246 default:
9247
9248 ajWarn("ensRegistryGetGvindividualadaptor got an "
9249 "Ensembl Database Adaptor "
9250 "with an unexpected group %d.\n",
9251 ensDatabaseadaptorGetGroup(dba));
9252 }
9253
9254 return NULL;
9255 }
9256
9257
9258
9259
9260 /* @func ensRegistryGetGvpopulationadaptor ************************************
9261 **
9262 ** Get an Ensembl Genetic Variation Population Adaptor from the
9263 ** Ensembl Registry.
9264 **
9265 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9266 **
9267 ** @return [EnsPGvpopulationadaptor]
9268 ** Ensembl Genetic Variation Population Adaptor or NULL
9269 **
9270 ** @release 6.2.0
9271 ** @@
9272 ******************************************************************************/
9273
ensRegistryGetGvpopulationadaptor(EnsPDatabaseadaptor dba)9274 EnsPGvpopulationadaptor ensRegistryGetGvpopulationadaptor(
9275 EnsPDatabaseadaptor dba)
9276 {
9277 RegistryPEntry entry = NULL;
9278 RegistryPGeneticVariation rgv = NULL;
9279
9280 if (!dba)
9281 return NULL;
9282
9283 entry = (RegistryPEntry) ajTableFetchmodV(
9284 registryGEntry,
9285 (const void *) ensDatabaseadaptorGetSpecies(dba));
9286
9287 if (!entry)
9288 return NULL;
9289
9290 switch (ensDatabaseadaptorGetGroup(dba))
9291 {
9292 case ensEDatabaseadaptorGroupGeneticVariation:
9293
9294 rgv = (RegistryPGeneticVariation)
9295 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9296
9297 if (!rgv)
9298 break;
9299
9300 if (!rgv->Gvpopulationadaptor)
9301 rgv->Gvpopulationadaptor =
9302 ensGvpopulationadaptorNew(dba);
9303
9304 return rgv->Gvpopulationadaptor;
9305
9306 break;
9307
9308 default:
9309
9310 ajWarn("ensRegistryGetGvpopulationadaptor got an "
9311 "Ensembl Database Adaptor "
9312 "with an unexpected group %d.\n",
9313 ensDatabaseadaptorGetGroup(dba));
9314 }
9315
9316 return NULL;
9317 }
9318
9319
9320
9321
9322 /* @func ensRegistryGetGvpopulationgenotypeadaptor ****************************
9323 **
9324 ** Get an Ensembl Genetic Variation Population Genotype Adaptor from the
9325 ** Ensembl Registry.
9326 **
9327 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9328 **
9329 ** @return [EnsPGvpopulationgenotypeadaptor]
9330 ** Ensembl Genetic Variation Population Genotype Adaptor or NULL
9331 **
9332 ** @release 6.4.0
9333 ** @@
9334 ******************************************************************************/
9335
ensRegistryGetGvpopulationgenotypeadaptor(EnsPDatabaseadaptor dba)9336 EnsPGvpopulationgenotypeadaptor ensRegistryGetGvpopulationgenotypeadaptor(
9337 EnsPDatabaseadaptor dba)
9338 {
9339 RegistryPEntry entry = NULL;
9340 RegistryPGeneticVariation rgv = NULL;
9341
9342 if (!dba)
9343 return NULL;
9344
9345 entry = (RegistryPEntry) ajTableFetchmodV(
9346 registryGEntry,
9347 (const void *) ensDatabaseadaptorGetSpecies(dba));
9348
9349 if (!entry)
9350 return NULL;
9351
9352 switch (ensDatabaseadaptorGetGroup(dba))
9353 {
9354 case ensEDatabaseadaptorGroupGeneticVariation:
9355
9356 rgv = (RegistryPGeneticVariation)
9357 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9358
9359 if (!rgv)
9360 break;
9361
9362 if (!rgv->Gvpopulationgenotypeadaptor)
9363 rgv->Gvpopulationgenotypeadaptor =
9364 ensGvpopulationgenotypeadaptorNew(dba);
9365
9366 return rgv->Gvpopulationgenotypeadaptor;
9367
9368 break;
9369
9370 default:
9371
9372 ajWarn("ensRegistryGetGvpopulationgenotypeadaptor got an "
9373 "Ensembl Database Adaptor "
9374 "with an unexpected group %d.\n",
9375 ensDatabaseadaptorGetGroup(dba));
9376 }
9377
9378 return NULL;
9379 }
9380
9381
9382
9383
9384 /* @func ensRegistryGetGvsampleadaptor ****************************************
9385 **
9386 ** Get an Ensembl Genetic Variation Sample Adaptor from the
9387 ** Ensembl Registry.
9388 **
9389 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9390 **
9391 ** @return [EnsPGvsampleadaptor]
9392 ** Ensembl Genetic Variation Sample Adaptor or NULL
9393 **
9394 ** @release 6.2.0
9395 ** @@
9396 ******************************************************************************/
9397
ensRegistryGetGvsampleadaptor(EnsPDatabaseadaptor dba)9398 EnsPGvsampleadaptor ensRegistryGetGvsampleadaptor(
9399 EnsPDatabaseadaptor dba)
9400 {
9401 RegistryPEntry entry = NULL;
9402 RegistryPGeneticVariation rgv = NULL;
9403
9404 if (!dba)
9405 return NULL;
9406
9407 entry = (RegistryPEntry) ajTableFetchmodV(
9408 registryGEntry,
9409 (const void *) ensDatabaseadaptorGetSpecies(dba));
9410
9411 if (!entry)
9412 return NULL;
9413
9414 switch (ensDatabaseadaptorGetGroup(dba))
9415 {
9416 case ensEDatabaseadaptorGroupGeneticVariation:
9417
9418 rgv = (RegistryPGeneticVariation)
9419 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9420
9421 if (!rgv)
9422 break;
9423
9424 if (!rgv->Gvsampleadaptor)
9425 rgv->Gvsampleadaptor =
9426 ensGvsampleadaptorNew(dba);
9427
9428 return rgv->Gvsampleadaptor;
9429
9430 break;
9431
9432 default:
9433
9434 ajWarn("ensRegistryGetGvsampleadaptor got an "
9435 "Ensembl Database Adaptor "
9436 "with an unexpected group %d.\n",
9437 ensDatabaseadaptorGetGroup(dba));
9438 }
9439
9440 return NULL;
9441 }
9442
9443
9444
9445
9446 /* @func ensRegistryGetGvsourceadaptor ****************************************
9447 **
9448 ** Get an Ensembl Genetic Variation Source Adaptor from the
9449 ** Ensembl Registry.
9450 **
9451 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9452 **
9453 ** @return [EnsPGvsourceadaptor]
9454 ** Ensembl Genetic Variation Source Adaptor or NULL
9455 **
9456 ** @release 6.3.0
9457 ** @@
9458 ******************************************************************************/
9459
ensRegistryGetGvsourceadaptor(EnsPDatabaseadaptor dba)9460 EnsPGvsourceadaptor ensRegistryGetGvsourceadaptor(
9461 EnsPDatabaseadaptor dba)
9462 {
9463 RegistryPEntry entry = NULL;
9464 RegistryPGeneticVariation rgv = NULL;
9465
9466 if (!dba)
9467 return NULL;
9468
9469 entry = (RegistryPEntry) ajTableFetchmodV(
9470 registryGEntry,
9471 (const void *) ensDatabaseadaptorGetSpecies(dba));
9472
9473 if (!entry)
9474 return NULL;
9475
9476 switch (ensDatabaseadaptorGetGroup(dba))
9477 {
9478 case ensEDatabaseadaptorGroupGeneticVariation:
9479
9480 rgv = (RegistryPGeneticVariation)
9481 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9482
9483 if (!rgv)
9484 break;
9485
9486 if (!rgv->Gvsourceadaptor)
9487 rgv->Gvsourceadaptor =
9488 ensGvsourceadaptorNew(dba);
9489
9490 return rgv->Gvsourceadaptor;
9491
9492 break;
9493
9494 default:
9495
9496 ajWarn("ensRegistryGetGvsourceadaptor got an "
9497 "Ensembl Database Adaptor "
9498 "with an unexpected group %d.\n",
9499 ensDatabaseadaptorGetGroup(dba));
9500 }
9501
9502 return NULL;
9503 }
9504
9505
9506
9507
9508 /* @func ensRegistryGetGvsynonymadaptor ***************************************
9509 **
9510 ** Get an Ensembl Genetic Variation Synonym Adaptor from the
9511 ** Ensembl Registry.
9512 ** The Ensembl Genetic Variation Synonym Adaptor is an alias for an
9513 ** Ensembl Database Adaptor connected to an Ensembl Variation database.
9514 **
9515 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9516 **
9517 ** @return [EnsPGvsynonymadaptor]
9518 ** Ensembl Genetic Variation Synonym Adaptor or NULL
9519 **
9520 ** @release 6.4.0
9521 ** @@
9522 ******************************************************************************/
9523
ensRegistryGetGvsynonymadaptor(EnsPDatabaseadaptor dba)9524 EnsPGvsynonymadaptor ensRegistryGetGvsynonymadaptor(
9525 EnsPDatabaseadaptor dba)
9526 {
9527 if (!dba)
9528 return NULL;
9529
9530 switch (ensDatabaseadaptorGetGroup(dba))
9531 {
9532 case ensEDatabaseadaptorGroupGeneticVariation:
9533
9534 return dba;
9535
9536 break;
9537
9538 default:
9539
9540 ajWarn("ensRegistryGetGvsynonymadaptor got an "
9541 "Ensembl Database Adaptor "
9542 "with an unexpected group %d.\n",
9543 ensDatabaseadaptorGetGroup(dba));
9544 }
9545
9546 return NULL;
9547 }
9548
9549
9550
9551
9552 /* @func ensRegistryGetGvtranscriptvariationadaptor ***************************
9553 **
9554 ** Get an Ensembl Genetic Variation Transcript Variation Adaptor from the
9555 ** Ensembl Registry.
9556 **
9557 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9558 **
9559 ** @return [EnsPGvtranscriptvariationadaptor]
9560 ** Ensembl Genetic Variation Transcript Variation Adaptor or NULL
9561 **
9562 ** @release 6.4.0
9563 ** @@
9564 ******************************************************************************/
9565
ensRegistryGetGvtranscriptvariationadaptor(EnsPDatabaseadaptor dba)9566 EnsPGvtranscriptvariationadaptor ensRegistryGetGvtranscriptvariationadaptor(
9567 EnsPDatabaseadaptor dba)
9568 {
9569 RegistryPEntry entry = NULL;
9570 RegistryPGeneticVariation rgv = NULL;
9571
9572 if (!dba)
9573 return NULL;
9574
9575 entry = (RegistryPEntry) ajTableFetchmodV(
9576 registryGEntry,
9577 (const void *) ensDatabaseadaptorGetSpecies(dba));
9578
9579 if (!entry)
9580 return NULL;
9581
9582 switch (ensDatabaseadaptorGetGroup(dba))
9583 {
9584 case ensEDatabaseadaptorGroupGeneticVariation:
9585
9586 rgv = (RegistryPGeneticVariation)
9587 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9588
9589 if (!rgv)
9590 break;
9591
9592 if (!rgv->Gvtranscriptvariationadaptor)
9593 rgv->Gvtranscriptvariationadaptor =
9594 ensGvtranscriptvariationadaptorNew(dba);
9595
9596 return rgv->Gvtranscriptvariationadaptor;
9597
9598 break;
9599
9600 default:
9601
9602 ajWarn("ensRegistryGetGvtranscriptvariationadaptor got an "
9603 "Ensembl Database Adaptor "
9604 "with an unexpected group %d.\n",
9605 ensDatabaseadaptorGetGroup(dba));
9606 }
9607
9608 return NULL;
9609 }
9610
9611
9612
9613
9614 /* @func ensRegistryGetGvvariationadaptor *************************************
9615 **
9616 ** Get an Ensembl Genetic Variation Variation Adaptor from the
9617 ** Ensembl Registry.
9618 ** The Ensembl Genetic Variation Variation Adaptor is an alias for an
9619 ** Ensembl Genetic Variation Database Adaptor.
9620 **
9621 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9622 **
9623 ** @return [EnsPGvvariationadaptor]
9624 ** Ensembl Genetic Variation Variation Adaptor or NULL
9625 **
9626 ** @release 6.2.0
9627 ** @@
9628 ******************************************************************************/
9629
ensRegistryGetGvvariationadaptor(EnsPDatabaseadaptor dba)9630 EnsPGvvariationadaptor ensRegistryGetGvvariationadaptor(
9631 EnsPDatabaseadaptor dba)
9632 {
9633 RegistryPEntry entry = NULL;
9634 RegistryPGeneticVariation rgv = NULL;
9635
9636 if (!dba)
9637 return NULL;
9638
9639 entry = (RegistryPEntry) ajTableFetchmodV(
9640 registryGEntry,
9641 (const void *) ensDatabaseadaptorGetSpecies(dba));
9642
9643 if (!entry)
9644 return NULL;
9645
9646 switch (ensDatabaseadaptorGetGroup(dba))
9647 {
9648 case ensEDatabaseadaptorGroupGeneticVariation:
9649
9650 rgv = (RegistryPGeneticVariation)
9651 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9652
9653 if (!rgv)
9654 break;
9655
9656 if (!rgv->Gvvariationadaptor)
9657 rgv->Gvvariationadaptor =
9658 ensGvvariationadaptorNew(dba);
9659
9660 return rgv->Gvvariationadaptor;
9661
9662 break;
9663
9664 default:
9665
9666 ajWarn("ensRegistryGetGvvariationadaptor got an "
9667 "Ensembl Database Adaptor "
9668 "with an unexpected group %d.\n",
9669 ensDatabaseadaptorGetGroup(dba));
9670 }
9671
9672 return NULL;
9673 }
9674
9675
9676
9677
9678 /* @func ensRegistryGetGvvariationfeatureadaptor ******************************
9679 **
9680 ** Get an Ensembl Genetic Variation Variation Feature Adaptor from the
9681 ** Ensembl Registry.
9682 **
9683 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9684 **
9685 ** @return [EnsPGvvariationfeatureadaptor]
9686 ** Ensembl Genetic Variation Variation Feature Adaptor or NULL
9687 **
9688 ** @release 6.4.0
9689 ** @@
9690 ******************************************************************************/
9691
ensRegistryGetGvvariationfeatureadaptor(EnsPDatabaseadaptor dba)9692 EnsPGvvariationfeatureadaptor ensRegistryGetGvvariationfeatureadaptor(
9693 EnsPDatabaseadaptor dba)
9694 {
9695 RegistryPEntry entry = NULL;
9696 RegistryPGeneticVariation rgv = NULL;
9697
9698 if (!dba)
9699 return NULL;
9700
9701 entry = (RegistryPEntry) ajTableFetchmodV(
9702 registryGEntry,
9703 (const void *) ensDatabaseadaptorGetSpecies(dba));
9704
9705 if (!entry)
9706 return NULL;
9707
9708 switch (ensDatabaseadaptorGetGroup(dba))
9709 {
9710 case ensEDatabaseadaptorGroupGeneticVariation:
9711
9712 rgv = (RegistryPGeneticVariation)
9713 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9714
9715 if (!rgv)
9716 break;
9717
9718 if (!rgv->Gvvariationfeatureadaptor)
9719 rgv->Gvvariationfeatureadaptor =
9720 ensGvvariationfeatureadaptorNew(dba);
9721
9722 return rgv->Gvvariationfeatureadaptor;
9723
9724 break;
9725
9726 default:
9727
9728 ajWarn("ensRegistryGetGvvariationfeatureadaptor got an "
9729 "Ensembl Database Adaptor "
9730 "with an unexpected group %d.\n",
9731 ensDatabaseadaptorGetGroup(dba));
9732 }
9733
9734 return NULL;
9735 }
9736
9737
9738
9739
9740 /* @func ensRegistryGetGvvariationsetadaptor **********************************
9741 **
9742 ** Get an Ensembl Genetic Variation Variation Set Adaptor from the
9743 ** Ensembl Registry.
9744 **
9745 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
9746 **
9747 ** @return [EnsPGvvariationsetadaptor]
9748 ** Ensembl Genetic Variation Variation Set Adaptor or NULL
9749 **
9750 ** @release 6.4.0
9751 ** @@
9752 ******************************************************************************/
9753
ensRegistryGetGvvariationsetadaptor(EnsPDatabaseadaptor dba)9754 EnsPGvvariationsetadaptor ensRegistryGetGvvariationsetadaptor(
9755 EnsPDatabaseadaptor dba)
9756 {
9757 RegistryPEntry entry = NULL;
9758 RegistryPGeneticVariation rgv = NULL;
9759
9760 if (!dba)
9761 return NULL;
9762
9763 entry = (RegistryPEntry) ajTableFetchmodV(
9764 registryGEntry,
9765 (const void *) ensDatabaseadaptorGetSpecies(dba));
9766
9767 if (!entry)
9768 return NULL;
9769
9770 switch (ensDatabaseadaptorGetGroup(dba))
9771 {
9772 case ensEDatabaseadaptorGroupGeneticVariation:
9773
9774 rgv = (RegistryPGeneticVariation)
9775 entry->Registry[ensDatabaseadaptorGetGroup(dba)];
9776
9777 if (!rgv)
9778 break;
9779
9780 if (!rgv->Gvvariationsetadaptor)
9781 rgv->Gvvariationsetadaptor =
9782 ensGvvariationsetadaptorNew(dba);
9783
9784 return rgv->Gvvariationsetadaptor;
9785
9786 break;
9787
9788 default:
9789
9790 ajWarn("ensRegistryGetGvvariationsetadaptor got an "
9791 "Ensembl Database Adaptor "
9792 "with an unexpected group %d.\n",
9793 ensDatabaseadaptorGetGroup(dba));
9794 }
9795
9796 return NULL;
9797 }
9798