1 /* @source ensalign ***********************************************************
2 **
3 ** Ensembl Alignment functions
4 **
5 ** @author Copyright (C) 1999 Ensembl Developers
6 ** @author Copyright (C) 2006 Michael K. Schuster
7 ** @version $Revision: 1.24 $
8 ** @modified 2009 by Alan Bleasby for incorporation into EMBOSS core
9 ** @modified $Date: 2013/02/17 13:02:10 $ by $Author: mks $
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 "ensalign.h"
34 #include "ensexon.h"
35 #include "ensexternaldatabase.h"
36 #include "enstranscript.h"
37
38
39
40
41 /* ========================================================================= */
42 /* =============================== constants =============================== */
43 /* ========================================================================= */
44
45
46
47
48 /* ========================================================================= */
49 /* =========================== global variables ============================ */
50 /* ========================================================================= */
51
52
53
54
55 /* ========================================================================= */
56 /* ============================= private data ============================== */
57 /* ========================================================================= */
58
59
60
61
62 /* ========================================================================= */
63 /* =========================== private constants =========================== */
64 /* ========================================================================= */
65
66 /* @conststatic dnaalignfeatureadaptorKTablenames *****************************
67 **
68 ** Array of Ensembl DNA Align Feature Adaptor SQL table names
69 **
70 ******************************************************************************/
71
72 static const char *const dnaalignfeatureadaptorKTablenames[] =
73 {
74 "dna_align_feature",
75 (const char *) NULL
76 };
77
78
79
80
81 /* @conststatic dnaalignfeatureadaptorKColumnnames ****************************
82 **
83 ** Array of Ensembl DNA Align Feature Adaptor SQL column names
84 **
85 ******************************************************************************/
86
87 static const char *const dnaalignfeatureadaptorKColumnnames[] =
88 {
89 "dna_align_feature.dna_align_feature_id",
90 "dna_align_feature.seq_region_id",
91 "dna_align_feature.seq_region_start",
92 "dna_align_feature.seq_region_end",
93 "dna_align_feature.seq_region_strand",
94 "dna_align_feature.hit_start",
95 "dna_align_feature.hit_end",
96 "dna_align_feature.hit_strand",
97 "dna_align_feature.hit_name",
98 "dna_align_feature.analysis_id",
99 "dna_align_feature.cigar_line",
100 "dna_align_feature.score",
101 "dna_align_feature.evalue",
102 "dna_align_feature.perc_ident",
103 "dna_align_feature.external_db_id",
104 "dna_align_feature.hcoverage",
105 "dna_align_feature.external_data",
106 "dna_align_feature.pair_dna_align_feature_id",
107 (const char *) NULL
108 };
109
110
111
112
113 /* @conststatic proteinalignfeatureadaptorKTablenames *************************
114 **
115 ** Array of Ensembl DNA Align Feature Adaptor SQL table names
116 **
117 ******************************************************************************/
118
119 static const char *const proteinalignfeatureadaptorKTablenames[] =
120 {
121 "protein_align_feature",
122 (const char *) NULL
123 };
124
125
126
127
128 /* @conststatic proteinalignfeatureadaptorKColumnnames ************************
129 **
130 ** Array of Ensembl DNA Align Feature Adaptor SQL column names
131 **
132 ******************************************************************************/
133
134 static const char *const proteinalignfeatureadaptorKColumnnames[] =
135 {
136 "protein_align_feature.protein_align_feature_id",
137 "protein_align_feature.seq_region_id",
138 "protein_align_feature.seq_region_start",
139 "protein_align_feature.seq_region_end",
140 "protein_align_feature.seq_region_strand",
141 "protein_align_feature.hit_start",
142 "protein_align_feature.hit_end",
143 "protein_align_feature.hit_name",
144 "protein_align_feature.analysis_id",
145 "protein_align_feature.cigar_line",
146 "protein_align_feature.score",
147 "protein_align_feature.evalue",
148 "protein_align_feature.perc_ident",
149 "protein_align_feature.external_db_id",
150 "protein_align_feature.hcoverage",
151 (const char *) NULL
152 };
153
154
155
156
157 /* ========================================================================= */
158 /* =========================== private variables =========================== */
159 /* ========================================================================= */
160
161
162
163
164 /* ========================================================================= */
165 /* =========================== private functions =========================== */
166 /* ========================================================================= */
167
168 static AjBool basealignfeatureParseFeaturepairs(EnsPBasealignfeature baf,
169 AjPList objects);
170
171 static AjBool basealignfeatureParseCigar(const EnsPBasealignfeature baf,
172 AjPList fps);
173
174 static int listBasealignfeatureCompareIdentifierAscending(
175 const void *item1,
176 const void *item2);
177
178 static int listBasealignfeatureCompareSourceEndAscending(
179 const void *item1,
180 const void *item2);
181
182 static int listBasealignfeatureCompareSourceEndDescending(
183 const void *item1,
184 const void *item2);
185
186 static int listBasealignfeatureCompareSourceStartAscending(
187 const void *item1,
188 const void *item2);
189
190 static int listBasealignfeatureCompareSourceStartDescending(
191 const void *item1,
192 const void *item2);
193
194 static AjBool dnaalignfeatureadaptorFetchAllbyStatement(
195 EnsPBaseadaptor ba,
196 const AjPStr statement,
197 EnsPAssemblymapper am,
198 EnsPSlice slice,
199 AjPList bafs);
200
201 static AjBool proteinalignfeatureadaptorFetchAllbyStatement(
202 EnsPBaseadaptor ba,
203 const AjPStr statement,
204 EnsPAssemblymapper am,
205 EnsPSlice slice,
206 AjPList bafs);
207
208
209
210
211 /* ========================================================================= */
212 /* ======================= All functions by section ======================== */
213 /* ========================================================================= */
214
215
216
217
218 /* @filesection ensalign ******************************************************
219 **
220 ** @nam1rule ens Function belongs to the Ensembl library
221 **
222 ******************************************************************************/
223
224
225
226
227 /* @datasection [EnsPBasealignfeature] Ensembl Base Align Feature *************
228 **
229 ** @nam2rule Basealignfeature Functions for manipulating
230 ** Ensembl Base Align Feature objects
231 **
232 ** @cc Bio::EnsEMBL::BaseAlignFeature
233 ** @cc CVS Revision: 1.65
234 ** @cc CVS Tag: branch-ensembl-68
235 **
236 ** @cc Bio::EnsEMBL::DnaDnaAlignFeature
237 ** @cc CVS Revision: 1.27
238 ** @cc CVS Tag: branch-ensembl-68
239 **
240 ** @cc Bio::EnsEMBL::DnaPepAlignFeature
241 ** @cc CVS Revision: 1.18
242 ** @cc CVS Tag: branch-ensembl-68
243 **
244 ** @cc Bio::EnsEMBL::PepDnaAlignFeature
245 ** @cc CVS Revision: 1.13
246 ** @cc CVS Tag: branch-ensembl-68
247 **
248 ******************************************************************************/
249
250
251
252
253 /* @funcstatic basealignfeatureParseFeaturepairs ******************************
254 **
255 ** Parse Ensembl Base Align Feature objects from an AJAX List of
256 ** Ensembl Objects based on Ensembl Feature Pair objects.
257 ** This function creates an internal CIGAR string and sets internal alignment
258 ** coordinates.
259 **
260 ** @param [u] baf [EnsPBasealignfeature] Ensembl Base Align Feature
261 ** @param [u] objects [AjPList]
262 ** AJAX List of Ensembl Objects based on Ensembl Feature Pair objects
263 **
264 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
265 **
266 ** @release 6.4.0
267 ** @@
268 ******************************************************************************/
269
basealignfeatureParseFeaturepairs(EnsPBasealignfeature baf,AjPList objects)270 static AjBool basealignfeatureParseFeaturepairs(EnsPBasealignfeature baf,
271 AjPList objects)
272 {
273 void *Pobject = NULL;
274
275 ajint srcstart = 0;
276 ajint trgstart = 0;
277
278 ajint srcend = 0;
279 ajint trgend = 0;
280
281 ajint srcgap = 0;
282 ajint trggap = 0;
283
284 ajint srclength = 0;
285 ajint trglength = 0;
286
287 ajint srcpos = 0; /* where last feature q part ended */
288 ajint trgpos = 0; /* where last feature s part ended */
289
290 ajint match = 0;
291
292 ajuint srcunit = 0U;
293 ajuint trgunit = 0U;
294
295 AjBool insertion = AJFALSE;
296 AjBool warning = AJFALSE;
297
298 AjIList iter = NULL;
299 AjPList fps = NULL;
300
301 EnsPFeature srcfeature = NULL;
302 EnsPFeature trgfeature = NULL;
303
304 EnsPFeature csf = NULL; /* Current source Feature */
305 EnsPFeature ctf = NULL; /* Current target Feature */
306 EnsPFeature fsf = NULL; /* First source Feature */
307 EnsPFeature ftf = NULL; /* First target Feature */
308 EnsPFeature lsf = NULL; /* Last source Feature */
309 EnsPFeature ltf = NULL; /* Last target Feature */
310
311 EnsPFeaturepair cfp = NULL; /* Current Feature Pair */
312 EnsPFeaturepair ffp = NULL; /* First Feature Pair */
313 EnsPFeaturepair lfp = NULL; /* Last Feature Pair */
314
315 if (!baf)
316 return ajFalse;
317
318 if (!objects)
319 return ajFalse;
320
321 if (!ajListGetLength(objects))
322 return ajTrue;
323
324 srcunit = ensBasealignfeatureCalculateUnitSource(baf);
325 trgunit = ensBasealignfeatureCalculateUnitTarget(baf);
326
327 if (baf->Cigar)
328 ajStrAssignClear(&baf->Cigar);
329 else
330 baf->Cigar = ajStrNew();
331
332 /* Extract Ensembl Feature Pair objects from Ensembl Objects. */
333
334 iter = ajListIterNew(objects);
335
336 while (!ajListIterDone(iter))
337 {
338 Pobject = ajListIterGet(iter);
339
340 ajListPushAppend(fps,
341 (void *) (*baf->FobjectGetFeaturepair) (Pobject));
342 }
343
344 ajListIterDel(&iter);
345
346 /*
347 ** Sort the AJAX List of Ensembl Feature Pair objects on their source
348 ** Ensembl Feature start member in ascending order on the positive strand
349 ** and descending order on the negative strand.
350 */
351
352 ajListPeekFirst(fps, (void **) &ffp);
353
354 fsf = ensFeaturepairGetSourceFeature(ffp);
355
356 if (ensFeatureGetStrand(fsf) >= 0)
357 ensListFeaturepairSortSourceStartAscending(fps);
358 else
359 ensListFeaturepairSortSourceStartDescending(fps);
360
361 /*
362 ** Use strandedness info of source and target to make sure both sets of
363 ** start and end coordinates are oriented the right way around.
364 */
365
366 ajListPeekFirst(fps, (void **) &ffp);
367 ajListPeekLast(fps, (void **) &lfp);
368
369 fsf = ensFeaturepairGetSourceFeature(ffp);
370 ftf = ensFeaturepairGetTargetFeature(ffp);
371 lsf = ensFeaturepairGetSourceFeature(lfp);
372 ltf = ensFeaturepairGetTargetFeature(lfp);
373
374 if (ensFeatureGetStrand(fsf) >= 0)
375 {
376 srcstart = ensFeatureGetStart(fsf);
377 srcend = ensFeatureGetEnd(lsf);
378 }
379 else
380 {
381 srcstart = ensFeatureGetStart(lsf);
382 srcend = ensFeatureGetEnd(fsf);
383 }
384
385 if (ensFeatureGetStrand(ftf) >= 0)
386 {
387 trgstart = ensFeatureGetStart(ftf);
388 trgend = ensFeatureGetEnd(ltf);
389 }
390 else
391 {
392 trgstart = ensFeatureGetStart(ltf);
393 trgend = ensFeatureGetEnd(ftf);
394 }
395
396 /*
397 ** Loop through each portion of the alignment (Feature Pair) and
398 ** construct a CIGAR string.
399 */
400
401 iter = ajListIterNew(fps);
402
403 while (!ajListIterDone(iter))
404 {
405 cfp = (EnsPFeaturepair) ajListIterGet(iter);
406
407 csf = ensFeaturepairGetSourceFeature(cfp);
408 ctf = ensFeaturepairGetTargetFeature(cfp);
409
410 /* Sanity checks */
411
412 if (ensFeatureGetSlice(csf) &&
413 ensFeatureGetSlice(fsf) &&
414 (!ensSliceMatch(ensFeatureGetSlice(csf),
415 ensFeatureGetSlice(fsf))))
416 ajFatal("basealignfeatureParseFeaturepairs found inconsistent "
417 "source Feature Slice members between the "
418 "current and first Ensembl Feature Pair.\n");
419
420 if (ensFeatureGetSequencename(csf) &&
421 ensFeatureGetSequencename(fsf) &&
422 (!ajStrMatchS(ensFeatureGetSequencename(csf),
423 ensFeatureGetSequencename(fsf))))
424 ajFatal("basealignfeatureParseFeaturepairs found inconsistent "
425 "source Feature sequence name members between the "
426 "current and first Ensembl Feature Pair.\n");
427
428 if (ensFeatureGetStrand(csf) != ensFeatureGetStrand(fsf))
429 ajFatal("basealignfeatureParseFeaturepairs found inconsistent "
430 "source Feature strand members between the "
431 "current and first Ensembl Feature Pair.\n");
432
433 if (ensFeatureGetSlice(ctf) &&
434 ensFeatureGetSlice(ftf) &&
435 (!ensSliceMatch(ensFeatureGetSlice(ctf),
436 ensFeatureGetSlice(ftf))))
437 ajFatal("basealignfeatureParseFeaturepairs found inconsistent "
438 "target Feature Slice members between the "
439 "current and first Ensembl Feature Pair.\n");
440
441 if (ensFeatureGetSequencename(ctf) &&
442 ensFeatureGetSequencename(ftf) &&
443 (!ajStrMatchCaseS(ensFeatureGetSequencename(ctf),
444 ensFeatureGetSequencename(ftf))))
445 ajFatal("basealignfeatureParseFeaturepairs found inconsistent "
446 "target Feature sequence name members between the "
447 "current and first Ensembl Feature Pair.\n");
448
449 if (ensFeatureGetStrand(ctf) != ensFeatureGetStrand(ftf))
450 ajFatal("basealignfeatureParseFeaturepairs found inconsistent "
451 "target Feature strand members between the "
452 "current and first Ensembl Feature Pair.\n");
453
454 if (ensFeaturepairGetSourceSpecies(cfp) &&
455 ensFeaturepairGetSourceSpecies(ffp) &&
456 (!ajStrMatchS(ensFeaturepairGetSourceSpecies(cfp),
457 ensFeaturepairGetSourceSpecies(ffp))))
458 ajFatal("basealignfeatureParseFeaturepairs found inconsistent "
459 "source species members between the "
460 "current and first Ensembl Feature Pair.\n");
461
462 if (ensFeaturepairGetTargetSpecies(cfp) &&
463 ensFeaturepairGetTargetSpecies(ffp) &&
464 (!ajStrMatchS(ensFeaturepairGetTargetSpecies(cfp),
465 ensFeaturepairGetTargetSpecies(ffp))))
466 ajFatal("basealignfeatureParseFeaturepairs found inconsistent "
467 "target species members between the "
468 "current and first Ensembl Feature Pair.\n");
469
470 /*
471 ** NOTE: The score, percent identity and P-values are not tested for
472 ** equality as this is unreliable for float and double types.
473 **
474 ** More sanity checking
475 */
476
477 if (srcpos)
478 {
479 if (ensFeatureGetStrand(csf) >= 0)
480 {
481 if (ensFeatureGetStart(csf) < srcpos)
482 ajFatal("Inconsistent coordinates in "
483 "Ensembl Feature Pair List (forward strand).\n"
484 "Start (%d) of current Feature Pair should be "
485 "greater than previous Feature Pair end (%d).\n",
486 ensFeatureGetStart(csf), srcpos);
487 }
488 else
489 {
490 if (ensFeatureGetEnd(csf) > srcpos)
491 ajFatal("Inconsistent coordinates in "
492 "Ensembl Feature Pair List (reverse strand).\n"
493 "End (%d) of current Feature Pair should be "
494 "less than previous Feature Pair start (%d).\n",
495 ensFeatureGetEnd(csf), srcpos);
496 }
497 }
498
499 srclength = ensFeatureCalculateLength(csf);
500 trglength = ensFeatureCalculateLength(ctf);
501
502 /*
503 ** using multiplication to avoid rounding errors, hence the
504 ** switch from source to target for the ratios
505 */
506
507 /* Yet more sanity checking */
508
509 if (srcunit > trgunit)
510 {
511 /*
512 ** I am going to make the assumption here that this situation
513 ** will only occur with DnaPepAlignFeatures, this may not be true
514 */
515
516 if ((srclength / srcunit) != (trglength * trgunit))
517 ajFatal("Feature Pair lengths not comparable "
518 "Lengths: %d %d "
519 "Ratios: %u %u.\n",
520 srclength, trglength,
521 srcunit, trgunit);
522 }
523 else
524 {
525 if ((srclength * trgunit) != (trglength * srcunit))
526 ajFatal("Feature Pair lengths not comparable "
527 "Lengths: %d %d "
528 "Ratios: %u %u.\n",
529 srclength, trglength,
530 srcunit, trgunit);
531 }
532
533 /*
534 ** Check to see if there is an I type (insertion) gap:
535 ** If there is a space between the end of the last source sequence
536 ** alignment and the start of this one, then this is an insertion
537 */
538
539 insertion = ajFalse;
540
541 if (ensFeatureGetStrand(fsf) >= 0)
542 {
543 if (srcpos && (ensFeatureGetStart(csf) > (srcpos + 1)))
544 {
545 /* there is an insertion */
546
547 insertion = ajTrue;
548
549 srcgap = ensFeatureGetStart(csf) - srcpos - 1;
550
551 /* no need for a number if gap length is 1 */
552
553 if (srcgap == 1)
554 ajStrAppendK(&baf->Cigar, 'I');
555 else
556 ajFmtPrintAppS(&baf->Cigar, "%dI", srcgap);
557 }
558
559 /* shift our position in the source sequence alignment */
560
561 srcpos = ensFeatureGetEnd(csf);
562 }
563 else
564 {
565 if (srcpos && ((ensFeatureGetEnd(csf) + 1) < srcpos))
566 {
567 /* there is an insertion */
568
569 insertion = ajTrue;
570
571 srcgap = srcpos - ensFeatureGetEnd(csf) - 1;
572
573 /* no need for a number if gap length is 1 */
574
575 if (srcgap == 1)
576 ajStrAppendK(&baf->Cigar, 'I');
577 else
578 ajFmtPrintAppS(&baf->Cigar, "%dI", srcgap);
579 }
580
581 /* shift our position in the source sequence alignment */
582
583 srcpos = ensFeatureGetStart(csf);
584 }
585
586 /*
587 ** Check to see if there is a D type (deletion) gap
588 ** There is a deletion gap if there is a space between the end of the
589 ** last portion of the hit sequence alignment and this one
590 */
591
592 if (ensFeatureGetStrand(ctf) >= 0)
593 {
594 if (trgpos && (ensFeatureGetStart(ctf) > (trgpos + 1)))
595 {
596 /* there is a deletion */
597
598 srcgap = ensFeatureGetStart(ctf) - trgpos - 1;
599
600 trggap = (ajint) (srcgap * srcunit / trgunit + 0.5);
601
602 /* no need for a number if gap length is 1 */
603
604 if (trggap == 1)
605 ajStrAppendK(&baf->Cigar, 'D');
606 else
607 ajFmtPrintAppS(&baf->Cigar, "%dD", trggap);
608
609 /* sanity check, should not be an insertion and deletion */
610
611 if (insertion)
612 {
613 if (!warning)
614 {
615 ajWarn("Should not be an deletion and insertion on "
616 "the same alignment region. "
617 "CIGAR line '%S'\n", baf->Cigar);
618
619 warning = ajTrue;
620 }
621 }
622 }
623
624 /* shift our position in the target sequence alignment */
625
626 trgpos = ensFeatureGetEnd(ctf);
627 }
628 else
629 {
630 if (trgpos && ((ensFeatureGetEnd(ctf) + 1) < trgpos))
631 {
632 /* there is a deletion */
633
634 srcgap = trgpos - ensFeatureGetEnd(ctf) - 1;
635
636 trggap = (ajint) (srcgap * srcunit / trgunit + 0.5);
637
638 /* no need for a number if gap length is 1 */
639
640 if (trggap == 1)
641 ajStrAppendK(&baf->Cigar, 'D');
642 else
643 ajFmtPrintAppS(&baf->Cigar, "%dD", trggap);
644
645 /* sanity check, should not be an insertion and deletion */
646
647 if (insertion)
648 {
649 if (!warning)
650 {
651 ajWarn("Should not be an deletion and insertion on "
652 "the same alignment region. "
653 "target position %d "
654 "target end %d "
655 "CIGAR line '%S'\n",
656 trgpos,
657 ensFeatureGetEnd(ctf),
658 baf->Cigar);
659
660 warning = ajTrue;
661 }
662 }
663 }
664
665 /* shift our position in the target sequence alignment */
666
667 trgpos = ensFeatureGetStart(ctf);
668 }
669
670 match = ensFeatureCalculateLength(csf);
671
672 if (match == 1)
673 ajStrAppendK(&baf->Cigar, 'M');
674 else
675 ajFmtPrintAppS(&baf->Cigar, "%dM", match);
676 }
677
678 /* Replace the Feature Pair in the Base Align Feature. */
679
680 ensFeaturepairDel(&baf->Featurepair);
681
682 /* Clone the source Feature and set the new coordinates. */
683
684 srcfeature = ensFeatureNewCpy(ffp->SourceFeature);
685
686 ensFeatureSetStart(srcfeature, srcstart);
687 ensFeatureSetEnd(srcfeature, srcend);
688
689 /* Clone the target Feature and set the new coordinates. */
690
691 trgfeature = ensFeatureNewCpy(ffp->TargetFeature);
692
693 ensFeatureSetStart(trgfeature, trgstart);
694 ensFeatureSetEnd(trgfeature, trgend);
695
696 /*
697 ** Clone the Ensembl Feature Pair and set new Ensembl Feature objects for
698 ** the source and target.
699 */
700
701 baf->Featurepair = ensFeaturepairNewCpy(ffp);
702
703 ensFeaturepairSetSourceFeature(baf->Featurepair, srcfeature);
704 ensFeaturepairSetTargetFeature(baf->Featurepair, trgfeature);
705
706 /* Delete the cloned Ensembl Feature objects for the source and target. */
707
708 ensFeatureDel(&srcfeature);
709 ensFeatureDel(&trgfeature);
710
711 return ajTrue;
712 }
713
714
715
716
717 /* @funcstatic basealignfeatureParseCigar *************************************
718 **
719 ** Convert an Ensembl Base Align Feature CIGAR line member into an
720 ** AJAX List of Ensembl Feature Pair objects.
721 **
722 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
723 ** @param [u] fps [AjPList] AJAX List of Ensembl Feature Pair objects
724 **
725 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
726 **
727 ** @release 6.3.0
728 ** @@
729 ******************************************************************************/
730
basealignfeatureParseCigar(const EnsPBasealignfeature baf,AjPList fps)731 static AjBool basealignfeatureParseCigar(const EnsPBasealignfeature baf,
732 AjPList fps)
733 {
734 ajint fpsrcstart = 0;
735 ajint fptrgstart = 0;
736
737 ajint srcstart = 0;
738 ajint trgstart = 0;
739
740 ajint srcend = 0;
741 ajint trgend = 0;
742
743 ajint tlength = 0;
744 ajint mlength = 0;
745
746 ajuint srcunit = 0U;
747 ajuint trgunit = 0U;
748
749 const AjPStr token = NULL;
750
751 EnsPFeature srcfeature = NULL;
752 EnsPFeature trgfeature = NULL;
753
754 EnsPFeaturepair fp = NULL;
755
756 if (!baf)
757 return ajFalse;
758
759 if (!fps)
760 return ajFalse;
761
762 if ((!baf->Cigar) && (!ajStrGetLen(baf->Cigar)))
763 ajFatal("basealignfeatureParseCigar no CIGAR string defined!\n");
764
765 if (!baf->Featurepair)
766 ajFatal("basealignfeatureParseCigar got an Ensembl Base Align Feature "
767 "without an Ensembl Feature Pair.\n");
768
769 if (ensFeaturepairGetSourceFeature(baf->Featurepair) == NULL)
770 ajFatal("basealignfeatureParseCigar got an Ensembl Base Align Feature "
771 "without a source Ensembl Feature in the "
772 "Ensembl Feature Pair.\n");
773
774 if (ensFeaturepairGetTargetFeature(baf->Featurepair) == NULL)
775 ajFatal("basealignfeatureParseCigar got an Ensembl Base Align Feature "
776 "without a target Ensembl Feature in the "
777 "Ensembl Feature Pair.\n");
778
779 srcunit = ensBasealignfeatureCalculateUnitSource(baf);
780 trgunit = ensBasealignfeatureCalculateUnitTarget(baf);
781
782 if (ensFeaturepairGetSourceStrand(baf->Featurepair) > 0)
783 fpsrcstart = ensFeaturepairGetSourceStart(baf->Featurepair);
784 else
785 fpsrcstart = ensFeaturepairGetSourceEnd(baf->Featurepair);
786
787 if (ensFeaturepairGetTargetStrand(baf->Featurepair) > 0)
788 fptrgstart = ensFeaturepairGetTargetStart(baf->Featurepair);
789 else
790 fptrgstart = ensFeaturepairGetTargetEnd(baf->Featurepair);
791
792 /* Construct ungapped blocks as Feature Pair objects for each MATCH. */
793
794 while ((token = ajStrParseC(baf->Cigar, "MDI")))
795 {
796 ajStrToInt(token, &tlength);
797
798 tlength = (tlength) ? tlength : 1;
799
800 if ((srcunit == 1) && (trgunit == 3))
801 mlength = tlength * 3;
802 else if ((srcunit == 3) && (trgunit == 1))
803 mlength = tlength / 3;
804 else if ((srcunit == 1) && (trgunit == 1))
805 mlength = tlength;
806 else
807 ajFatal("basealignfeatureParseCigar got "
808 "Base Align Feature source unit %u "
809 "Base Align Feature target unit %u, "
810 "but currently only 1 or 3 are allowed.\n",
811 srcunit,
812 trgunit);
813
814 if (ajStrMatchC(token, "M"))
815 {
816 /* MATCH */
817
818 if (ensFeaturepairGetSourceStrand(baf->Featurepair) > 0)
819 {
820 srcstart = fpsrcstart;
821 srcend = fpsrcstart + tlength - 1;
822
823 fpsrcstart = srcend + 1;
824 }
825 else
826 {
827 srcend = fpsrcstart;
828 srcstart = fpsrcstart - tlength + 1;
829
830 fpsrcstart = srcstart - 1;
831 }
832
833 if (ensFeaturepairGetTargetStrand(baf->Featurepair) > 0)
834 {
835 trgstart = fptrgstart;
836 trgend = fptrgstart + mlength - 1;
837
838 fptrgstart = trgend + 1;
839 }
840 else
841 {
842 trgend = fptrgstart;
843 trgstart = fptrgstart - mlength + 1;
844
845 fptrgstart = trgstart - 1;
846 }
847
848 /* Clone the source Feature and set the new coordinates. */
849
850 srcfeature = ensFeatureNewCpy(
851 ensFeaturepairGetSourceFeature(baf->Featurepair));
852
853 ensFeatureSetStart(srcfeature, srcstart);
854 ensFeatureSetEnd(srcfeature, srcend);
855
856 /* Clone the target Feature and set the new coordinates. */
857
858 trgfeature = ensFeatureNewCpy(
859 ensFeaturepairGetTargetFeature(baf->Featurepair));
860
861 ensFeatureSetStart(trgfeature, trgstart);
862 ensFeatureSetEnd(trgfeature, trgend);
863
864 /*
865 ** Clone the Ensembl Feature Pair and set the new
866 ** Ensembl Feature objects for the source and target.
867 */
868
869 fp = ensFeaturepairNewCpy(baf->Featurepair);
870
871 ensFeaturepairSetSourceFeature(baf->Featurepair, srcfeature);
872 ensFeaturepairSetTargetFeature(baf->Featurepair, trgfeature);
873
874 /* Delete the Ensembl Feature objects for the source and target. */
875
876 ensFeatureDel(&srcfeature);
877 ensFeatureDel(&trgfeature);
878
879 ajListPushAppend(fps, (void *) fp);
880 }
881 else if (ajStrMatchC(token, "I"))
882 {
883 /* INSERT */
884
885 if (ensFeaturepairGetSourceStrand(baf->Featurepair) > 0)
886 fpsrcstart += tlength;
887 else
888 fpsrcstart -= tlength;
889 }
890
891 else if (ajStrMatchC(token, "D"))
892 {
893 /* DELETION */
894
895 if (ensFeaturepairGetTargetStrand(baf->Featurepair) > 0)
896 fptrgstart += mlength;
897 else
898 fptrgstart -= mlength;
899 }
900 else
901 ajFatal("basealignfeatureParseCigar "
902 "illegal CIGAR line token '%S'\n",
903 token);
904 }
905
906 return ajTrue;
907 }
908
909
910
911
912 /* @section constructors ******************************************************
913 **
914 ** All constructors return a new Ensembl Base Align Feature by pointer.
915 ** It is the responsibility of the user to first destroy any previous
916 ** Base Align Feature. The target pointer does not need to be initialised to
917 ** NULL, but it is good programming practice to do so anyway.
918 **
919 ** @fdata [EnsPBasealignfeature]
920 **
921 ** @nam3rule New Constructor
922 ** @nam4rule Cpy Constructor with existing object
923 ** @nam4rule Fps Constructor from Ensembl Feature Pair objects
924 ** @nam4rule Ini Constructor with initial values
925 ** @nam4rule Ref Constructor by incrementing the reference counter
926 **
927 ** @suffix D Constructor for a Base Align Feature of type 'DNA'
928 ** @suffix P Constructor for a Base Align Feature of type 'Protein'
929 **
930 ** @argrule Cpy baf [const EnsPBasealignfeature] Ensembl Base Align Feature
931 ** @argrule Fps fp [EnsPFeaturepair] Ensembl Feature Pair
932 ** @argrule Fps cigar [AjPStr] CIGAR line
933 ** @argrule Fps fps [AjPList] AJAX List of Ensembl Feature Pair objects
934 ** @argrule Fps type [EnsEBasealignfeatureType]
935 ** Ensembl Base Align Feature Type enumeration
936 ** @argrule Fps pair [ajuint] Pair DNA Align Feature identifier
937 ** @argrule IniD dafa [EnsPDnaalignfeatureadaptor]
938 ** Ensembl DNA Align Feature Adaptor
939 ** @argrule IniD identifier [ajuint] SQL database-internal identifier
940 ** @argrule IniD fp [EnsPFeaturepair] Ensembl Feature Pair
941 ** @argrule IniD cigar [AjPStr] CIGAR line
942 ** @argrule IniD pair [ajuint] Pair DNA Align Feature identifier
943 ** @argrule IniP pafa [EnsPProteinalignfeatureadaptor]
944 ** Ensembl Protein Align Feature Adaptor
945 ** @argrule IniP identifier [ajuint] SQL database-internal identifier
946 ** @argrule IniP fp [EnsPFeaturepair] Ensembl Feature Pair
947 ** @argrule IniP cigar [AjPStr] CIGAR line
948 ** @argrule Ref baf [EnsPBasealignfeature] Ensembl Base Align Feature
949 **
950 ** @valrule * [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
951 **
952 ** @fcategory new
953 ******************************************************************************/
954
955
956
957
958 /* @func ensBasealignfeatureNewCpy ********************************************
959 **
960 ** Object-based constructor function, which returns an independent object.
961 **
962 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
963 **
964 ** @return [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
965 **
966 ** @release 6.4.0
967 ** @@
968 ******************************************************************************/
969
ensBasealignfeatureNewCpy(const EnsPBasealignfeature baf)970 EnsPBasealignfeature ensBasealignfeatureNewCpy(
971 const EnsPBasealignfeature baf)
972 {
973 EnsPBasealignfeature pthis = NULL;
974
975 if (!baf)
976 return NULL;
977
978 AJNEW0(pthis);
979
980 pthis->Use = 1U;
981
982 pthis->Identifier = baf->Identifier;
983 pthis->Dnaalignfeatureadaptor = baf->Dnaalignfeatureadaptor;
984 pthis->Proteinalignfeatureadaptor = baf->Proteinalignfeatureadaptor;
985 pthis->Featurepair = ensFeaturepairNewRef(baf->Featurepair);
986 pthis->FobjectGetFeaturepair = baf->FobjectGetFeaturepair;
987
988 if (baf->Cigar)
989 pthis->Cigar = ajStrNewRef(baf->Cigar);
990
991 pthis->Type = baf->Type;
992
993 pthis->Alignmentlength = baf->Alignmentlength;
994
995 pthis->Pairdnaalignfeatureidentifier = baf->Pairdnaalignfeatureidentifier;
996
997 return pthis;
998 }
999
1000
1001
1002
1003 /* @func ensBasealignfeatureNewFps ********************************************
1004 **
1005 ** Constructor for an Ensembl Base Align Feature with
1006 ** Ensembl Feature Pair objects.
1007 **
1008 ** @cc Bio::EnsEMBL::FeaturePair
1009 ** @param [u] fp [EnsPFeaturepair] Ensembl Feature Pair
1010 ** @cc Bio::EnsEMBL::BaseAlignFeature
1011 ** @param [u] cigar [AjPStr] CIGAR line
1012 ** @param [u] fps [AjPList] AJAX List of Ensembl Feature Pair objects
1013 ** @param [u] type [EnsEBasealignfeatureType]
1014 ** Ensembl Base Align Feature Type enumeration
1015 ** @param [r] pair [ajuint] Pair DNA Align Feature identifier
1016 **
1017 ** @return [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
1018 **
1019 ** @release 6.4.0
1020 ** @@
1021 ******************************************************************************/
1022
ensBasealignfeatureNewFps(EnsPFeaturepair fp,AjPStr cigar,AjPList fps,EnsEBasealignfeatureType type,ajuint pair)1023 EnsPBasealignfeature ensBasealignfeatureNewFps(
1024 EnsPFeaturepair fp,
1025 AjPStr cigar,
1026 AjPList fps,
1027 EnsEBasealignfeatureType type,
1028 ajuint pair)
1029 {
1030 EnsPBasealignfeature baf = NULL;
1031
1032 if (!fp)
1033 return NULL;
1034
1035 if ((type < ensEBasealignfeatureTypeDNA) ||
1036 (type > ensEBasealignfeatureTypeProtein))
1037 {
1038 ajDebug("ensBasealignfeatureNewFps got illegal type (%d).\n",
1039 type);
1040
1041 return NULL;
1042 }
1043
1044 AJNEW0(baf);
1045
1046 baf->Use = 1U;
1047
1048 baf->Featurepair = ensFeaturepairNewRef(fp);
1049 baf->FobjectGetFeaturepair = (EnsPFeaturepair (*) (const void*))
1050 &ensBasealignfeatureGetFeaturepair;
1051
1052 if (cigar && ajStrGetLen(cigar) && fps && ajListGetLength(fps))
1053 {
1054 ajDebug("ensBasealignfeatureNewFps requires a CIGAR line "
1055 "or an AJAX List of Ensembl Feature Pair objects, "
1056 "not both.\n");
1057
1058 AJFREE(baf);
1059
1060 return NULL;
1061 }
1062 else if (cigar && ajStrGetLen(cigar))
1063 baf->Cigar = ajStrNewRef(cigar);
1064 else if (fps && ajListGetLength(fps))
1065 basealignfeatureParseFeaturepairs(baf, fps);
1066 else
1067 ajDebug("ensBasealignfeatureNewFps requires either a CIGAR line or "
1068 "an AJAX List of Ensembl Feature Pair objects.\n");
1069
1070 baf->Type = type;
1071
1072 baf->Pairdnaalignfeatureidentifier = pair;
1073
1074 return baf;
1075 }
1076
1077
1078
1079
1080 /* @func ensBasealignfeatureNewIniD *******************************************
1081 **
1082 ** Constructor for an Ensembl Base Align Feature of type "DNA"
1083 ** with initial values.
1084 **
1085 ** @cc Bio::EnsEMBL::Storable::new
1086 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
1087 ** Ensembl DNA Align Feature Adaptor
1088 ** @param [r] identifier [ajuint] SQL database-internal identifier
1089 ** @cc Bio::EnsEMBL::FeaturePair
1090 ** @param [u] fp [EnsPFeaturepair] Ensembl Feature Pair
1091 ** @cc Bio::EnsEMBL::BaseAlignFeature
1092 ** @param [u] cigar [AjPStr] CIGAR line
1093 ** @param [r] pair [ajuint] Pair DNA Align Feature identifier
1094 **
1095 ** @return [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
1096 **
1097 ** @release 6.4.0
1098 ** @@
1099 ******************************************************************************/
1100
ensBasealignfeatureNewIniD(EnsPDnaalignfeatureadaptor dafa,ajuint identifier,EnsPFeaturepair fp,AjPStr cigar,ajuint pair)1101 EnsPBasealignfeature ensBasealignfeatureNewIniD(
1102 EnsPDnaalignfeatureadaptor dafa,
1103 ajuint identifier,
1104 EnsPFeaturepair fp,
1105 AjPStr cigar,
1106 ajuint pair)
1107 {
1108 EnsPBasealignfeature baf = NULL;
1109
1110 if (!fp)
1111 return NULL;
1112
1113 if (!cigar)
1114 return NULL;
1115
1116 AJNEW0(baf);
1117
1118 baf->Use = 1U;
1119
1120 baf->Identifier = identifier;
1121
1122 baf->Dnaalignfeatureadaptor = dafa;
1123
1124 baf->Featurepair = ensFeaturepairNewRef(fp);
1125
1126 baf->FobjectGetFeaturepair = (EnsPFeaturepair (*) (const void*))
1127 &ensBasealignfeatureGetFeaturepair;
1128
1129 if (cigar)
1130 baf->Cigar = ajStrNewRef(cigar);
1131
1132 baf->Type = ensEBasealignfeatureTypeDNA;
1133
1134 baf->Pairdnaalignfeatureidentifier = pair;
1135
1136 return baf;
1137 }
1138
1139
1140
1141
1142 /* @func ensBasealignfeatureNewIniP *******************************************
1143 **
1144 ** Constructor for an Ensembl Base Align Feature of type "Protein"
1145 ** with initial values.
1146 **
1147 ** @cc Bio::EnsEMBL::Storable::new
1148 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
1149 ** Ensembl Protein Align Feature Adaptor
1150 ** @param [r] identifier [ajuint] SQL database-internal identifier
1151 ** @cc Bio::EnsEMBL::FeaturePair
1152 ** @param [u] fp [EnsPFeaturepair] Ensembl Feature Pair
1153 ** @cc Bio::EnsEMBL::BaseAlignFeature
1154 ** @param [u] cigar [AjPStr] CIGAR line
1155 **
1156 ** @return [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
1157 **
1158 ** @release 6.4.0
1159 ** @@
1160 ******************************************************************************/
1161
ensBasealignfeatureNewIniP(EnsPProteinalignfeatureadaptor pafa,ajuint identifier,EnsPFeaturepair fp,AjPStr cigar)1162 EnsPBasealignfeature ensBasealignfeatureNewIniP(
1163 EnsPProteinalignfeatureadaptor pafa,
1164 ajuint identifier,
1165 EnsPFeaturepair fp,
1166 AjPStr cigar)
1167 {
1168 EnsPBasealignfeature baf = NULL;
1169
1170 if (!fp)
1171 return NULL;
1172
1173 if (!cigar)
1174 return NULL;
1175
1176 AJNEW0(baf);
1177
1178 baf->Use = 1U;
1179
1180 baf->Identifier = identifier;
1181
1182 baf->Proteinalignfeatureadaptor = pafa;
1183
1184 baf->Featurepair = ensFeaturepairNewRef(fp);
1185
1186 baf->FobjectGetFeaturepair = (EnsPFeaturepair (*) (const void*))
1187 &ensBasealignfeatureGetFeaturepair;
1188
1189 if (cigar)
1190 baf->Cigar = ajStrNewRef(cigar);
1191
1192 baf->Type = ensEBasealignfeatureTypeProtein;
1193
1194 baf->Pairdnaalignfeatureidentifier = 0;
1195
1196 return baf;
1197 }
1198
1199
1200
1201
1202 /* @func ensBasealignfeatureNewRef ********************************************
1203 **
1204 ** Ensembl Object referencing function, which returns a pointer to the
1205 ** Ensembl Object passed in and increases its reference count.
1206 **
1207 ** @param [u] baf [EnsPBasealignfeature] Ensembl Base Align Feature
1208 **
1209 ** @return [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
1210 **
1211 ** @release 6.2.0
1212 ** @@
1213 ******************************************************************************/
1214
ensBasealignfeatureNewRef(EnsPBasealignfeature baf)1215 EnsPBasealignfeature ensBasealignfeatureNewRef(
1216 EnsPBasealignfeature baf)
1217 {
1218 if (!baf)
1219 return NULL;
1220
1221 baf->Use++;
1222
1223 return baf;
1224 }
1225
1226
1227
1228
1229 /* @section destructors *******************************************************
1230 **
1231 ** Destruction destroys all internal data structures and frees the memory
1232 ** allocated for an Ensembl Base Align Feature object.
1233 **
1234 ** @fdata [EnsPBasealignfeature]
1235 **
1236 ** @nam3rule Del Destroy (free) an Ensembl Base Align Feature
1237 **
1238 ** @argrule * Pbaf [EnsPBasealignfeature*] Ensembl Base Align Feature address
1239 **
1240 ** @valrule * [void]
1241 **
1242 ** @fcategory delete
1243 ******************************************************************************/
1244
1245
1246
1247
1248 /* @func ensBasealignfeatureDel ***********************************************
1249 **
1250 ** Default destructor for an Ensembl Base Align Feature.
1251 **
1252 ** @param [d] Pbaf [EnsPBasealignfeature*] Ensembl Base Align Feature address
1253 **
1254 ** @return [void]
1255 **
1256 ** @release 6.2.0
1257 ** @@
1258 ******************************************************************************/
1259
ensBasealignfeatureDel(EnsPBasealignfeature * Pbaf)1260 void ensBasealignfeatureDel(
1261 EnsPBasealignfeature *Pbaf)
1262 {
1263 EnsPBasealignfeature pthis = NULL;
1264
1265 if (!Pbaf)
1266 return;
1267
1268 #if defined(AJ_DEBUG) && AJ_DEBUG >= 1
1269 if (ajDebugTest("ensBasealignfeatureDel"))
1270 {
1271 ajDebug("ensBasealignfeatureDel\n"
1272 " *Pbaf %p\n",
1273 *Pbaf);
1274
1275 ensBasealignfeatureTrace(*Pbaf, 1);
1276 }
1277 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
1278
1279 if (!(pthis = *Pbaf) || --pthis->Use)
1280 {
1281 *Pbaf = NULL;
1282
1283 return;
1284 }
1285
1286 ensFeaturepairDel(&pthis->Featurepair);
1287
1288 ajStrDel(&pthis->Cigar);
1289
1290 ajMemFree((void **) Pbaf);
1291
1292 return;
1293 }
1294
1295
1296
1297
1298 /* @section member retrieval **************************************************
1299 **
1300 ** Functions for returning members of an Ensembl Base Align Feature object.
1301 **
1302 ** @fdata [EnsPBasealignfeature]
1303 **
1304 ** @nam3rule Get Return Base Align Feature attribute(s)
1305 ** @nam4rule Cigar Return the CIGAR line
1306 ** @nam4rule Dnaalignfeatureadaptor
1307 ** Return the Ensembl DNA Align Feature Adaptor
1308 ** @nam4rule Featurepair Return the Ensembl Feature Pair
1309 ** @nam4rule Identifier Return the SQL database-internal identifier
1310 ** @nam4rule Pairdnaalignfeatureidentifier
1311 ** Return the pair DNA Align Feature identifier
1312 ** @nam4rule Proteinalignfeatureadaptor
1313 ** Return the Ensembl Protein Align Feature Adaptor
1314 ** @nam4rule Type Return the type
1315 **
1316 ** @argrule * baf [const EnsPBasealignfeature] Base Align Feature
1317 **
1318 ** @valrule Cigar [AjPStr] CIGAR line or NULL
1319 ** @valrule Dnaalignfeatureadaptor [EnsPDnaalignfeatureadaptor]
1320 ** Ensembl DNA Align Feature Adaptor or NULL
1321 ** @valrule Featurepair [EnsPFeaturepair] Ensembl Feature Pair or NULL
1322 ** @valrule Identifier [ajuint] SQL database-internal identifier or 0
1323 ** @valrule Pairdnaalignfeatureidentifier [ajuint]
1324 ** Pair Ensembl DNA Align Feature identifier or 0
1325 ** @valrule Proteinalignfeatureadaptor [EnsPProteinalignfeatureadaptor]
1326 ** Ensembl Protein Align Feature Adaptor or NULL
1327 ** @valrule Type [EnsEBasealignfeatureType]
1328 ** Ensembl Base Align Feature Type enumeration or ensEBasealignfeatureTypeNULL
1329 **
1330 ** @fcategory use
1331 ******************************************************************************/
1332
1333
1334
1335
1336 /* @func ensBasealignfeatureGetCigar ******************************************
1337 **
1338 ** Get the CIGAR line member of an Ensembl Base Align Feature.
1339 **
1340 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1341 **
1342 ** @return [AjPStr] CIGAR line or NULL
1343 **
1344 ** @release 6.4.0
1345 ** @@
1346 ******************************************************************************/
1347
ensBasealignfeatureGetCigar(const EnsPBasealignfeature baf)1348 AjPStr ensBasealignfeatureGetCigar(
1349 const EnsPBasealignfeature baf)
1350 {
1351 return (baf) ? baf->Cigar : NULL;
1352 }
1353
1354
1355
1356
1357 /* @func ensBasealignfeatureGetDnaalignfeatureadaptor *************************
1358 **
1359 ** Get the Ensembl DNA Align Feature Adaptor member of an
1360 ** Ensembl Base Align Feature.
1361 **
1362 ** @cc Bio::EnsEMBL::Storable::adaptor
1363 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1364 **
1365 ** @return [EnsPDnaalignfeatureadaptor]
1366 ** Ensembl DNA Align Feature Adaptor or NULL
1367 **
1368 ** @release 6.4.0
1369 ** @@
1370 ******************************************************************************/
1371
ensBasealignfeatureGetDnaalignfeatureadaptor(const EnsPBasealignfeature baf)1372 EnsPDnaalignfeatureadaptor ensBasealignfeatureGetDnaalignfeatureadaptor(
1373 const EnsPBasealignfeature baf)
1374 {
1375 return (baf) ? baf->Dnaalignfeatureadaptor : NULL;
1376 }
1377
1378
1379
1380
1381 /* @func ensBasealignfeatureGetFeaturepair ************************************
1382 **
1383 ** Get the Ensembl Feature Pair member of an Ensembl Base Align Feature.
1384 **
1385 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1386 **
1387 ** @return [EnsPFeaturepair] Ensembl Feature Pair or NULL
1388 **
1389 ** @release 6.2.0
1390 ** @@
1391 ******************************************************************************/
1392
ensBasealignfeatureGetFeaturepair(const EnsPBasealignfeature baf)1393 EnsPFeaturepair ensBasealignfeatureGetFeaturepair(
1394 const EnsPBasealignfeature baf)
1395 {
1396 return (baf) ? baf->Featurepair : NULL;
1397 }
1398
1399
1400
1401
1402 /* @func ensBasealignfeatureGetIdentifier *************************************
1403 **
1404 ** Get the SQL database-internal identifier member of an
1405 ** Ensembl Base Align Feature.
1406 **
1407 ** @cc Bio::EnsEMBL::Storable::dbID
1408 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1409 **
1410 ** @return [ajuint] SQL database-internal identifier or 0U
1411 **
1412 ** @release 6.2.0
1413 ** @@
1414 ******************************************************************************/
1415
ensBasealignfeatureGetIdentifier(const EnsPBasealignfeature baf)1416 ajuint ensBasealignfeatureGetIdentifier(
1417 const EnsPBasealignfeature baf)
1418 {
1419 return (baf) ? baf->Identifier : 0U;
1420 }
1421
1422
1423
1424
1425 /* @func ensBasealignfeatureGetPairdnaalignfeatureidentifier ******************
1426 **
1427 ** Get the pair Ensembl DNA Align Feature identifier member of an
1428 ** Ensembl Base Align Feature.
1429 **
1430 ** @cc Bio::EnsEMBL::DnaDnaAlignFeature::pair_dna_align_feature_id
1431 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1432 **
1433 ** @return [ajuint]
1434 ** Pair Ensembl DNA Align Feature identifier or 0U
1435 ** @@
1436 ******************************************************************************/
1437
ensBasealignfeatureGetPairdnaalignfeatureidentifier(const EnsPBasealignfeature baf)1438 ajuint ensBasealignfeatureGetPairdnaalignfeatureidentifier(
1439 const EnsPBasealignfeature baf)
1440 {
1441 return (baf) ? baf->Pairdnaalignfeatureidentifier : 0U;
1442 }
1443
1444
1445
1446
1447 /* @func ensBasealignfeatureGetProteinalignfeatureadaptor *********************
1448 **
1449 ** Get the Ensembl Protein Align Feature Adaptor member of an
1450 ** Ensembl Base Align Feature.
1451 **
1452 ** @cc Bio::EnsEMBL::Storable::adaptor
1453 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1454 **
1455 ** @return [EnsPProteinalignfeatureadaptor]
1456 ** Ensembl Protein Align Feature Adaptor or NULL
1457 **
1458 ** @release 6.2.0
1459 ** @@
1460 ******************************************************************************/
1461
ensBasealignfeatureGetProteinalignfeatureadaptor(const EnsPBasealignfeature baf)1462 EnsPProteinalignfeatureadaptor ensBasealignfeatureGetProteinalignfeatureadaptor(
1463 const EnsPBasealignfeature baf)
1464 {
1465 return (baf) ? baf->Proteinalignfeatureadaptor : NULL;
1466 }
1467
1468
1469
1470
1471 /* @func ensBasealignfeatureGetType *******************************************
1472 **
1473 ** Get the Base Align Feature Type enumeration member of an
1474 ** Ensembl Base Align Feature.
1475 **
1476 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1477 **
1478 ** @return [EnsEBasealignfeatureType]
1479 ** Ensembl Base Align Feature Type enumeration or ensEBasealignfeatureTypeNULL
1480 ** @@
1481 ******************************************************************************/
1482
ensBasealignfeatureGetType(const EnsPBasealignfeature baf)1483 EnsEBasealignfeatureType ensBasealignfeatureGetType(
1484 const EnsPBasealignfeature baf)
1485 {
1486 return (baf) ? baf->Type : ensEBasealignfeatureTypeNULL;
1487 }
1488
1489
1490
1491
1492 /* @section member assignment *************************************************
1493 **
1494 ** Functions for assigning members of an Ensembl Base Align Feature object.
1495 **
1496 ** @fdata [EnsPBasealignfeature]
1497 **
1498 ** @nam3rule Set Set one member of a Base Align Feature
1499 ** @nam4rule Featurepair Set the Ensembl Feature Pair
1500 **
1501 ** @argrule * baf [EnsPBasealignfeature] Ensembl Base Align Feature object
1502 ** @argrule Featurepair fp [EnsPFeaturepair] Ensembl Feature Pair
1503 **
1504 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
1505 **
1506 ** @fcategory modify
1507 ******************************************************************************/
1508
1509
1510
1511
1512 /* @func ensBasealignfeatureSetFeaturepair ************************************
1513 **
1514 ** Set the Ensembl Feature Pair member of an Ensembl Base Align Feature.
1515 **
1516 ** @param [u] baf [EnsPBasealignfeature] Ensembl Base Align Feature
1517 ** @param [u] fp [EnsPFeaturepair] Ensembl Feature Pair
1518 **
1519 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
1520 **
1521 ** @release 6.2.0
1522 ** @@
1523 ******************************************************************************/
1524
ensBasealignfeatureSetFeaturepair(EnsPBasealignfeature baf,EnsPFeaturepair fp)1525 AjBool ensBasealignfeatureSetFeaturepair(EnsPBasealignfeature baf,
1526 EnsPFeaturepair fp)
1527 {
1528 if (ajDebugTest("ensBasealignfeatureSetFeaturepair"))
1529 {
1530 ajDebug("ensBasealignfeatureSetFeaturepair\n"
1531 " baf %p\n"
1532 " fp %p\n",
1533 baf,
1534 fp);
1535
1536 ensBasealignfeatureTrace(baf, 1);
1537
1538 ensFeaturepairTrace(fp, 1);
1539 }
1540
1541 if (!baf)
1542 return ajFalse;
1543
1544 if (!fp)
1545 return ajFalse;
1546
1547 /* Replace the current Feature Pair. */
1548
1549 ensFeaturepairDel(&baf->Featurepair);
1550
1551 baf->Featurepair = ensFeaturepairNewRef(fp);
1552
1553 return ajTrue;
1554 }
1555
1556
1557
1558
1559 /* @section convenience functions *********************************************
1560 **
1561 ** Ensembl Base Align Feature convenience functions
1562 **
1563 ** @fdata [EnsPBasealignfeature]
1564 **
1565 ** @nam3rule Get Get member(s) of associated objects
1566 ** @nam4rule Feature Get the (source) Ensembl Feature
1567 **
1568 ** @argrule * baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1569 **
1570 ** @valrule Feature [EnsPFeature] Ensembl Feature
1571 **
1572 ** @fcategory use
1573 ******************************************************************************/
1574
1575
1576
1577
1578 /* @func ensBasealignfeatureGetFeature ****************************************
1579 **
1580 ** Get the (source) Ensembl Feature member of an Ensembl Feature Pair member
1581 ** of an Ensembl Base Align Feature.
1582 **
1583 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1584 **
1585 ** @return [EnsPFeature] Ensembl Feature
1586 **
1587 ** @release 6.2.0
1588 ** @@
1589 ******************************************************************************/
1590
ensBasealignfeatureGetFeature(const EnsPBasealignfeature baf)1591 EnsPFeature ensBasealignfeatureGetFeature(const EnsPBasealignfeature baf)
1592 {
1593 if (!baf)
1594 return NULL;
1595
1596 return ensFeaturepairGetSourceFeature(baf->Featurepair);
1597 }
1598
1599
1600
1601
1602 /* @section calculate *********************************************************
1603 **
1604 ** Functions for calculating information from an
1605 ** Ensembl Base Align Feature object.
1606 **
1607 ** @fdata [EnsPBasealignfeature]
1608 **
1609 ** @nam3rule Calculate Calculate Ensembl Base Align Feature information
1610 ** @nam4rule Adaptor Calculate the adaptor
1611 ** @nam4rule Alignmentlength Calculate the alignment length
1612 ** @nam4rule Memsize Calculate the memory size in bytes
1613 ** @nam4rule Unit Calculate an alignment unit
1614 ** @nam5rule Source Calculate the source unit
1615 ** @nam5rule Target Calculate the target unit
1616 **
1617 ** @argrule Adaptor baf [const EnsPBasealignfeature]
1618 ** Ensembl Base Align Feature
1619 ** @argrule Alignmentlength baf [EnsPBasealignfeature]
1620 ** Ensembl Base Align Feature
1621 ** @argrule Memsize baf [const EnsPBasealignfeature]
1622 ** Ensembl Base Align Feature
1623 ** @argrule UnitSource baf [const EnsPBasealignfeature]
1624 ** Ensembl Base Align Feature
1625 ** @argrule UnitTarget baf [const EnsPBasealignfeature]
1626 ** Ensembl Base Align Feature
1627 **
1628 ** @valrule Adaptor [void*]
1629 ** Ensembl DNA or Protein Align Feature Adaptor or NULL
1630 ** @valrule Alignmentlength [ajuint] Alignment length or 0U
1631 ** @valrule Memsize [size_t] Memory size in bytes or 0
1632 ** @valrule UnitSource [ajuint] Alignment unit for the source part or 0U
1633 ** @valrule UnitTarget [ajuint] Alignment unit for the target part or 0U
1634 **
1635 ** @fcategory misc
1636 ******************************************************************************/
1637
1638
1639
1640
1641 /* @func ensBasealignfeatureCalculateAdaptor **********************************
1642 **
1643 ** Calculate the Adaptor member of an Ensembl Base Align Feature.
1644 ** This will return an EnsPDnaalignfeatureadaptor for an Ensembl Base Align
1645 ** Feature of type ensEBasealignfeatureTypeDNA and an
1646 ** EnsPProteinalignfeatureadaptor for a feature of type
1647 ** ensEBasealignfeatureTypeProtein.
1648 **
1649 ** @cc Bio::EnsEMBL::Storable::adaptor
1650 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1651 **
1652 ** @return [void*] Ensembl DNA or Protein Align Feature Adaptor or NULL
1653 **
1654 ** @release 6.4.0
1655 ** @@
1656 ******************************************************************************/
1657
ensBasealignfeatureCalculateAdaptor(const EnsPBasealignfeature baf)1658 void* ensBasealignfeatureCalculateAdaptor(const EnsPBasealignfeature baf)
1659 {
1660 void *Padaptor = NULL;
1661
1662 if (!baf)
1663 return NULL;
1664
1665 switch (baf->Type)
1666 {
1667 case ensEBasealignfeatureTypeDNA:
1668
1669 Padaptor = (void *) baf->Dnaalignfeatureadaptor;
1670
1671 break;
1672
1673 case ensEBasealignfeatureTypeProtein:
1674
1675 Padaptor = (void *) baf->Proteinalignfeatureadaptor;
1676
1677 break;
1678
1679 default:
1680
1681 ajWarn("ensBasealignfeatureCalculateAdaptor got an "
1682 "Ensembl Base Align Feature with unexpected type %d.",
1683 baf->Type);
1684 }
1685
1686 return Padaptor;
1687 }
1688
1689
1690
1691
1692 /* @func ensBasealignfeatureCalculateAlignmentlength **************************
1693 **
1694 ** Calculate the alignment length member of an Ensembl Base Align Feature.
1695 **
1696 ** @param [u] baf [EnsPBasealignfeature] Ensembl Base Align Feature
1697 **
1698 ** @return [ajuint] Alignment length or 0U
1699 **
1700 ** @release 6.4.0
1701 ** @@
1702 ******************************************************************************/
1703
ensBasealignfeatureCalculateAlignmentlength(EnsPBasealignfeature baf)1704 ajuint ensBasealignfeatureCalculateAlignmentlength(EnsPBasealignfeature baf)
1705 {
1706 ajint tlength = 0;
1707
1708 const AjPStr token = NULL;
1709
1710 if (!baf)
1711 return 0U;
1712
1713 if (!baf->Alignmentlength && baf->Cigar)
1714 {
1715 while ((token = ajStrParseC(baf->Cigar, "MDI")))
1716 {
1717 ajStrToInt(token, &tlength);
1718
1719 tlength = tlength ? tlength : 1;
1720
1721 baf->Alignmentlength += tlength;
1722 }
1723 }
1724
1725 return baf->Alignmentlength;
1726 }
1727
1728
1729
1730
1731 /* @func ensBasealignfeatureCalculateMemsize **********************************
1732 **
1733 ** Get the memory size in bytes of an Ensembl Base Align Feature.
1734 **
1735 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1736 **
1737 ** @return [size_t] Memory size in bytes or 0
1738 **
1739 ** @release 6.4.0
1740 ** @@
1741 ******************************************************************************/
1742
ensBasealignfeatureCalculateMemsize(const EnsPBasealignfeature baf)1743 size_t ensBasealignfeatureCalculateMemsize(const EnsPBasealignfeature baf)
1744 {
1745 size_t size = 0;
1746
1747 if (!baf)
1748 return 0;
1749
1750 size += sizeof (EnsOBasealignfeature);
1751
1752 size += ensFeaturepairCalculateMemsize(baf->Featurepair);
1753
1754 if (baf->Cigar)
1755 {
1756 size += sizeof (AjOStr);
1757
1758 size += ajStrGetRes(baf->Cigar);
1759 }
1760
1761 return size;
1762 }
1763
1764
1765
1766
1767 /* @func ensBasealignfeatureCalculateUnitSource *******************************
1768 **
1769 ** Get the alignment unit for the source part of an Ensembl Base Align Feature.
1770 **
1771 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1772 **
1773 ** @return [ajuint] Alignment unit for the source part or 0U
1774 **
1775 ** @release 6.4.0
1776 ** @@
1777 ******************************************************************************/
1778
ensBasealignfeatureCalculateUnitSource(const EnsPBasealignfeature baf)1779 ajuint ensBasealignfeatureCalculateUnitSource(const EnsPBasealignfeature baf)
1780 {
1781 ajuint unit = 0U;
1782
1783 if (!baf)
1784 return 0U;
1785
1786 switch (baf->Type)
1787 {
1788 case ensEBasealignfeatureTypeDNA:
1789
1790 unit = 1U;
1791
1792 break;
1793
1794 case ensEBasealignfeatureTypeProtein:
1795
1796 unit = 3U;
1797
1798 break;
1799
1800 default:
1801
1802 ajWarn("ensBasealignfeatureCalculateUnitSource got an "
1803 "Ensembl Base Align Feature with unexpected type %d.",
1804 baf->Type);
1805 }
1806
1807 return unit;
1808 }
1809
1810
1811
1812
1813 /* @func ensBasealignfeatureCalculateUnitTarget *******************************
1814 **
1815 ** Get the alignment unit for the target part of an Ensembl Base Align Feature.
1816 **
1817 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1818 **
1819 ** @return [ajuint] Alignment unit for the target part or 0U
1820 **
1821 ** @release 6.4.0
1822 ** @@
1823 ******************************************************************************/
1824
ensBasealignfeatureCalculateUnitTarget(const EnsPBasealignfeature baf)1825 ajuint ensBasealignfeatureCalculateUnitTarget(const EnsPBasealignfeature baf)
1826 {
1827 ajuint unit = 0U;
1828
1829 if (!baf)
1830 return 0U;
1831
1832 switch (baf->Type)
1833 {
1834 case ensEBasealignfeatureTypeDNA:
1835
1836 unit = 1U;
1837
1838 break;
1839
1840 case ensEBasealignfeatureTypeProtein:
1841
1842 unit = 1U;
1843
1844 break;
1845
1846 default:
1847
1848 ajWarn("ensBasealignfeatureCalculateUnitTarget got an "
1849 "Ensembl Base Align Feature with unexpected type %d.",
1850 baf->Type);
1851 }
1852
1853 return unit;
1854 }
1855
1856
1857
1858
1859 /* @section map ***************************************************************
1860 **
1861 ** Functions for mapping Ensembl Base Align Feature objects between
1862 ** Ensembl Coordinate System objects.
1863 **
1864 ** @fdata [EnsPBasealignfeature]
1865 **
1866 ** @nam3rule Transfer Transfer an Ensembl Base Align Feature
1867 ** @nam3rule Transform Transform an Ensembl Base Align Feature
1868 **
1869 ** @argrule * baf [EnsPBasealignfeature] Ensembl Base Align Feature
1870 ** @argrule Transfer slice [EnsPSlice] Ensembl Slice
1871 ** @argrule Transform csname [const AjPStr] Ensembl Coordinate System name
1872 ** @argrule Transform csversion [const AjPStr]
1873 ** Ensembl Coordinate System version
1874 **
1875 ** @valrule * [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
1876 **
1877 ** @fcategory misc
1878 ******************************************************************************/
1879
1880
1881
1882
1883 /* @func ensBasealignfeatureTransfer ******************************************
1884 **
1885 ** Transfer an Ensembl Base Align Feature onto another Ensembl Slice.
1886 **
1887 ** @cc Bio::EnsEMBL::Feature::transfer
1888 ** @param [u] baf [EnsPBasealignfeature] Ensembl Base Align Feature
1889 ** @param [u] slice [EnsPSlice] Ensembl Slice
1890 ** @see ensFeatureTransfer
1891 **
1892 ** @return [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
1893 **
1894 ** @release 6.2.0
1895 ** @@
1896 ******************************************************************************/
1897
ensBasealignfeatureTransfer(EnsPBasealignfeature baf,EnsPSlice slice)1898 EnsPBasealignfeature ensBasealignfeatureTransfer(
1899 EnsPBasealignfeature baf,
1900 EnsPSlice slice)
1901 {
1902 EnsPBasealignfeature newbaf = NULL;
1903
1904 EnsPFeaturepair newfp = NULL;
1905
1906 if (!baf)
1907 return NULL;
1908
1909 if (!slice)
1910 return NULL;
1911
1912 newfp = ensFeaturepairTransfer(baf->Featurepair, slice);
1913
1914 if (!newfp)
1915 return NULL;
1916
1917 newbaf = ensBasealignfeatureNewCpy(baf);
1918
1919 ensBasealignfeatureSetFeaturepair(newbaf, newfp);
1920
1921 ensFeaturepairDel(&newfp);
1922
1923 return newbaf;
1924 }
1925
1926
1927
1928
1929 /* @func ensBasealignfeatureTransform *****************************************
1930 **
1931 ** Transform an Ensembl Base Align Feature into another
1932 ** Ensembl Coordinate System.
1933 **
1934 ** @cc Bio::EnsEMBL::Feature::transform
1935 ** @param [u] baf [EnsPBasealignfeature] Ensembl Base Align Feature
1936 ** @param [r] csname [const AjPStr] Ensembl Coordinate System name
1937 ** @param [r] csversion [const AjPStr] Ensembl Coordinate System version
1938 ** @see ensFeatureTransform
1939 **
1940 ** @return [EnsPBasealignfeature] Ensembl Base Align Feature or NULL
1941 **
1942 ** @release 6.2.0
1943 ** @@
1944 ******************************************************************************/
1945
ensBasealignfeatureTransform(EnsPBasealignfeature baf,const AjPStr csname,const AjPStr csversion)1946 EnsPBasealignfeature ensBasealignfeatureTransform(
1947 EnsPBasealignfeature baf,
1948 const AjPStr csname,
1949 const AjPStr csversion)
1950 {
1951 EnsPFeaturepair nfp = NULL;
1952
1953 EnsPBasealignfeature nbaf = NULL;
1954
1955 if (!baf)
1956 return NULL;
1957
1958 if (!csname)
1959 return NULL;
1960
1961 if (!csversion)
1962 return NULL;
1963
1964 nfp = ensFeaturepairTransform(baf->Featurepair, csname, csversion);
1965
1966 if (!nfp)
1967 return NULL;
1968
1969 nbaf = ensBasealignfeatureNewCpy(baf);
1970
1971 ensBasealignfeatureSetFeaturepair(nbaf, nfp);
1972
1973 ensFeaturepairDel(&nfp);
1974
1975 return nbaf;
1976 }
1977
1978
1979
1980
1981 /* @section debugging *********************************************************
1982 **
1983 ** Functions for reporting of an Ensembl Base Align Feature object.
1984 **
1985 ** @fdata [EnsPBasealignfeature]
1986 **
1987 ** @nam3rule Trace Report Ensembl Base Align Feature members to debug file
1988 **
1989 ** @argrule Trace baf [const EnsPBasealignfeature] Ensembl Base Align Feature
1990 ** @argrule Trace level [ajuint] Indentation level
1991 **
1992 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
1993 **
1994 ** @fcategory misc
1995 ******************************************************************************/
1996
1997
1998
1999
2000 /* @func ensBasealignfeatureTrace *********************************************
2001 **
2002 ** Trace an Ensembl Base Align Feature.
2003 **
2004 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
2005 ** @param [r] level [ajuint] Indentation level
2006 **
2007 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2008 **
2009 ** @release 6.2.0
2010 ** @@
2011 ******************************************************************************/
2012
ensBasealignfeatureTrace(const EnsPBasealignfeature baf,ajuint level)2013 AjBool ensBasealignfeatureTrace(const EnsPBasealignfeature baf, ajuint level)
2014 {
2015 AjPStr indent = NULL;
2016
2017 if (!baf)
2018 return ajFalse;
2019
2020 indent = ajStrNew();
2021
2022 ajStrAppendCountK(&indent, ' ', level * 2);
2023
2024 ajDebug("ensBasealignfeatureTrace %p\n"
2025 "%S Dnaalignfeatureadaptor %p\n"
2026 "%S Proteinalignfeatureadaptor %p\n"
2027 "%S Identifier %u\n"
2028 "%S Featurepair %p\n"
2029 "%S Cigar '%S'\n"
2030 "%S FobjectGetFeaturepair %p\n"
2031 "%S Type %d\n"
2032 "%S Alignmentlength %u\n"
2033 "%S Pairdnaalignfeatureidentifier %u\n"
2034 "%S Use %u\n",
2035 indent, baf,
2036 indent, baf->Dnaalignfeatureadaptor,
2037 indent, baf->Proteinalignfeatureadaptor,
2038 indent, baf->Identifier,
2039 indent, baf->Featurepair,
2040 indent, baf->Cigar,
2041 indent, baf->FobjectGetFeaturepair,
2042 indent, baf->Type,
2043 indent, baf->Alignmentlength,
2044 indent, baf->Pairdnaalignfeatureidentifier,
2045 indent, baf->Use);
2046
2047 ensFeaturepairTrace(baf->Featurepair, level + 1);
2048
2049 ajStrDel(&indent);
2050
2051 return ajTrue;
2052 }
2053
2054
2055
2056
2057 /* @section fetch *************************************************************
2058 **
2059 ** Functions for fetching objects of an
2060 ** Ensembl Base Align Feature object.
2061 **
2062 ** @fdata [EnsPBasealignfeature]
2063 **
2064 ** @nam3rule Fetch Fetch objects from an Ensembl Base Align Feature
2065 ** @nam4rule All Fetch all objects from an Ensembl Base Apign Feature
2066 ** @nam5rule Featurepairs Fetch all Ensembl Feature Pair objects
2067 **
2068 ** @argrule * baf [const EnsPBasealignfeature] Ensembl Base Align Feature
2069 ** @argrule Featurepairs fps [AjPList]
2070 ** AJAX List of Ensembl Feature Pair objects
2071 **
2072 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
2073 **
2074 ** @fcategory misc
2075 ******************************************************************************/
2076
2077
2078
2079
2080 /* @func ensBasealignfeatureFetchAllFeaturepairs ******************************
2081 **
2082 ** Fetch all (ungapped) Ensembl Feature Pair objects of an
2083 ** Ensembl Base Align Feature.
2084 **
2085 ** The caller is responsible for deleting the Ensembl Feature Pair objects
2086 ** before deleting the AJAX List.
2087 **
2088 ** @param [r] baf [const EnsPBasealignfeature] Ensembl Base Align Feature
2089 ** @param [u] fps [AjPList] AJAX List of Ensembl Feature Pair objects
2090 **
2091 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2092 **
2093 ** @release 6.2.0
2094 ** @@
2095 ******************************************************************************/
2096
ensBasealignfeatureFetchAllFeaturepairs(const EnsPBasealignfeature baf,AjPList fps)2097 AjBool ensBasealignfeatureFetchAllFeaturepairs(const EnsPBasealignfeature baf,
2098 AjPList fps)
2099 {
2100 return basealignfeatureParseCigar(baf, fps);
2101 }
2102
2103
2104
2105
2106 /* @datasection [AjPList] AJAX List *******************************************
2107 **
2108 ** @nam2rule List Functions for manipulating AJAX List objects
2109 **
2110 ******************************************************************************/
2111
2112
2113
2114
2115 /* @funcstatic listBasealignfeatureCompareIdentifierAscending *****************
2116 **
2117 ** AJAX List of Ensembl Base Align Feature objects comparison function to
2118 ** sort by identifier in ascending order.
2119 **
2120 ** @param [r] item1 [const void*] Ensembl Base Align Feature address 1
2121 ** @param [r] item2 [const void*] Ensembl Base Align Feature address 2
2122 ** @see ajListSort
2123 **
2124 ** @return [int] The comparison function returns an integer less than,
2125 ** equal to, or greater than zero if the first argument is
2126 ** considered to be respectively less than, equal to, or
2127 ** greater than the second.
2128 **
2129 ** @release 6.4.0
2130 ** @@
2131 ******************************************************************************/
2132
listBasealignfeatureCompareIdentifierAscending(const void * item1,const void * item2)2133 static int listBasealignfeatureCompareIdentifierAscending(
2134 const void *item1,
2135 const void *item2)
2136 {
2137 EnsPBasealignfeature baf1 = *(EnsOBasealignfeature *const *) item1;
2138 EnsPBasealignfeature baf2 = *(EnsOBasealignfeature *const *) item2;
2139
2140 #if defined(AJ_DEBUG) && AJ_DEBUG >= 2
2141 if (ajDebugTest("listBasealignfeatureCompareIdentifierAscending"))
2142 {
2143 ajDebug("listBasealignfeatureCompareIdentifierAscending\n"
2144 " baf1 %p\n"
2145 " baf2 %p\n",
2146 baf1,
2147 baf2);
2148
2149 ensBasealignfeatureTrace(baf1, 1);
2150 ensBasealignfeatureTrace(baf2, 1);
2151 }
2152 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */
2153
2154 /* Sort empty values towards the end of the AJAX List. */
2155
2156 if (baf1 && (!baf2))
2157 return -1;
2158
2159 if ((!baf1) && (!baf2))
2160 return 0;
2161
2162 if ((!baf1) && baf2)
2163 return +1;
2164
2165 if (baf1->Identifier < baf2->Identifier)
2166 return -1;
2167
2168 if (baf1->Identifier > baf2->Identifier)
2169 return +1;
2170
2171 return 0;
2172 }
2173
2174
2175
2176
2177 /* @funcstatic listBasealignfeatureCompareSourceEndAscending ******************
2178 **
2179 ** AJAX List of Ensembl Base Align Feature objects comparison function to
2180 ** sort by source Ensembl Feature end coordinate in ascending order.
2181 **
2182 ** @param [r] item1 [const void*] Ensembl Base Align Feature address 1
2183 ** @param [r] item2 [const void*] Ensembl Base Align Feature address 2
2184 ** @see ajListSort
2185 **
2186 ** @return [int] The comparison function returns an integer less than,
2187 ** equal to, or greater than zero if the first argument is
2188 ** considered to be respectively less than, equal to, or
2189 ** greater than the second.
2190 **
2191 ** @release 6.4.0
2192 ** @@
2193 ******************************************************************************/
2194
listBasealignfeatureCompareSourceEndAscending(const void * item1,const void * item2)2195 static int listBasealignfeatureCompareSourceEndAscending(
2196 const void *item1,
2197 const void *item2)
2198 {
2199 EnsPBasealignfeature baf1 = *(EnsOBasealignfeature *const *) item1;
2200 EnsPBasealignfeature baf2 = *(EnsOBasealignfeature *const *) item2;
2201
2202 #if defined(AJ_DEBUG) && AJ_DEBUG >= 2
2203 if (ajDebugTest("listBasealignfeatureCompareSourceEndAscending"))
2204 {
2205 ajDebug("listBasealignfeatureCompareSourceEndAscending\n"
2206 " baf1 %p\n"
2207 " baf2 %p\n",
2208 baf1,
2209 baf2);
2210
2211 ensBasealignfeatureTrace(baf1, 1);
2212 ensBasealignfeatureTrace(baf2, 1);
2213 }
2214 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */
2215
2216 /* Sort empty values towards the end of the AJAX List. */
2217
2218 if (baf1 && (!baf2))
2219 return -1;
2220
2221 if ((!baf1) && (!baf2))
2222 return 0;
2223
2224 if ((!baf1) && baf2)
2225 return +1;
2226
2227 return ensFeaturepairCompareSourceEndAscending(
2228 baf1->Featurepair,
2229 baf2->Featurepair);
2230 }
2231
2232
2233
2234
2235 /* @funcstatic listBasealignfeatureCompareSourceEndDescending *****************
2236 **
2237 ** AJAX List of Ensembl Base Align Feature objects comparison function to
2238 ** sort by source Ensembl Feature end coordinate in descending order.
2239 **
2240 ** @param [r] item1 [const void*] Ensembl Base Align Feature address 1
2241 ** @param [r] item2 [const void*] Ensembl Base Align Feature address 2
2242 ** @see ajListSort
2243 **
2244 ** @return [int] The comparison function returns an integer less than,
2245 ** equal to, or greater than zero if the first argument is
2246 ** considered to be respectively less than, equal to, or
2247 ** greater than the second.
2248 **
2249 ** @release 6.4.0
2250 ** @@
2251 ******************************************************************************/
2252
listBasealignfeatureCompareSourceEndDescending(const void * item1,const void * item2)2253 static int listBasealignfeatureCompareSourceEndDescending(
2254 const void *item1,
2255 const void *item2)
2256 {
2257 EnsPBasealignfeature baf1 = *(EnsOBasealignfeature *const *) item1;
2258 EnsPBasealignfeature baf2 = *(EnsOBasealignfeature *const *) item2;
2259
2260 #if defined(AJ_DEBUG) && AJ_DEBUG >= 2
2261 if (ajDebugTest("listBasealignfeatureCompareSourceEndDescending"))
2262 {
2263 ajDebug("listBasealignfeatureCompareSourceEndDescending\n"
2264 " baf1 %p\n"
2265 " baf2 %p\n",
2266 baf1,
2267 baf2);
2268
2269 ensBasealignfeatureTrace(baf1, 1);
2270 ensBasealignfeatureTrace(baf2, 1);
2271 }
2272 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */
2273
2274 /* Sort empty values towards the end of the AJAX List. */
2275
2276 if (baf1 && (!baf2))
2277 return -1;
2278
2279 if ((!baf1) && (!baf2))
2280 return 0;
2281
2282 if ((!baf1) && baf2)
2283 return +1;
2284
2285 return ensFeaturepairCompareSourceEndDescending(
2286 baf1->Featurepair,
2287 baf2->Featurepair);
2288 }
2289
2290
2291
2292
2293 /* @funcstatic listBasealignfeatureCompareSourceStartAscending ****************
2294 **
2295 ** AJAX List of Ensembl Base Align Feature objects comparison function to
2296 ** sort by source Ensembl Feature start coordinate in ascending order.
2297 **
2298 ** @param [r] item1 [const void*] Ensembl Base Align Feature address 1
2299 ** @param [r] item2 [const void*] Ensembl Base Align Feature address 2
2300 ** @see ajListSort
2301 **
2302 ** @return [int] The comparison function returns an integer less than,
2303 ** equal to, or greater than zero if the first argument is
2304 ** considered to be respectively less than, equal to, or
2305 ** greater than the second.
2306 **
2307 ** @release 6.4.0
2308 ** @@
2309 ******************************************************************************/
2310
listBasealignfeatureCompareSourceStartAscending(const void * item1,const void * item2)2311 static int listBasealignfeatureCompareSourceStartAscending(
2312 const void *item1,
2313 const void *item2)
2314 {
2315 EnsPBasealignfeature baf1 = *(EnsOBasealignfeature *const *) item1;
2316 EnsPBasealignfeature baf2 = *(EnsOBasealignfeature *const *) item2;
2317
2318 #if defined(AJ_DEBUG) && AJ_DEBUG >= 2
2319 if (ajDebugTest("listBasealignfeatureCompareSourceStartAscending"))
2320 {
2321 ajDebug("listBasealignfeatureCompareSourceStartAscending\n"
2322 " baf1 %p\n"
2323 " baf2 %p\n",
2324 baf1,
2325 baf2);
2326
2327 ensBasealignfeatureTrace(baf1, 1);
2328 ensBasealignfeatureTrace(baf2, 1);
2329 }
2330 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */
2331
2332 /* Sort empty values towards the end of the AJAX List. */
2333
2334 if (baf1 && (!baf2))
2335 return -1;
2336
2337 if ((!baf1) && (!baf2))
2338 return 0;
2339
2340 if ((!baf1) && baf2)
2341 return +1;
2342
2343 return ensFeaturepairCompareSourceStartAscending(
2344 baf1->Featurepair,
2345 baf2->Featurepair);
2346 }
2347
2348
2349
2350
2351 /* @funcstatic listBasealignfeatureCompareSourceStartDescending ***************
2352 **
2353 ** AJAX List of Ensembl Base Align Feature objects comparison function to
2354 ** sort by source Ensembl Feature start coordinate in descending order.
2355 **
2356 ** @param [r] item1 [const void*] Ensembl Base Align Feature address 1
2357 ** @param [r] item2 [const void*] Ensembl Base Align Feature address 2
2358 ** @see ajListSort
2359 **
2360 ** @return [int] The comparison function returns an integer less than,
2361 ** equal to, or greater than zero if the first argument is
2362 ** considered to be respectively less than, equal to, or
2363 ** greater than the second.
2364 **
2365 ** @release 6.4.0
2366 ** @@
2367 ******************************************************************************/
2368
listBasealignfeatureCompareSourceStartDescending(const void * item1,const void * item2)2369 static int listBasealignfeatureCompareSourceStartDescending(
2370 const void *item1,
2371 const void *item2)
2372 {
2373 EnsPBasealignfeature baf1 = *(EnsOBasealignfeature *const *) item1;
2374 EnsPBasealignfeature baf2 = *(EnsOBasealignfeature *const *) item2;
2375
2376 #if defined(AJ_DEBUG) && AJ_DEBUG >= 2
2377 if (ajDebugTest("listBasealignfeatureCompareSourceStartDescending"))
2378 {
2379 ajDebug("listBasealignfeatureCompareSourceStartDescending\n"
2380 " baf1 %p\n"
2381 " baf2 %p\n",
2382 baf1,
2383 baf2);
2384
2385 ensBasealignfeatureTrace(baf1, 1);
2386 ensBasealignfeatureTrace(baf2, 1);
2387 }
2388 #endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */
2389
2390 /* Sort empty values towards the end of the AJAX List. */
2391
2392 if (baf1 && (!baf2))
2393 return -1;
2394
2395 if ((!baf1) && (!baf2))
2396 return 0;
2397
2398 if ((!baf1) && baf2)
2399 return +1;
2400
2401 return ensFeaturepairCompareSourceStartDescending(
2402 baf1->Featurepair,
2403 baf2->Featurepair);
2404 }
2405
2406
2407
2408
2409 /* @section list **************************************************************
2410 **
2411 ** Functions for manipulating AJAX List objects.
2412 **
2413 ** @fdata [AjPList]
2414 **
2415 ** @nam3rule Basealignfeature Functions for manipulating AJAX List objects of
2416 ** Ensembl Base Align Feature objects
2417 ** @nam4rule Sort Sort functions
2418 ** @nam5rule Source Sort by source Ensembl Feature member
2419 ** @nam5rule Target Sort by target Ensembl feature member
2420 ** @nam6rule End Sort by Ensembl Feature end member
2421 ** @nam6rule Start Sort by Ensembl Feature start member
2422 ** @nam7rule Ascending Sort in ascending order
2423 ** @nam7rule Descending Sort in descending order
2424 **
2425 ** @argrule * bafs [AjPList]
2426 ** AJAX List of Ensembl Base Align Feature objects
2427 **
2428 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
2429 **
2430 ** @fcategory misc
2431 ******************************************************************************/
2432
2433
2434
2435
2436 /* @func ensListBasealignfeatureSortSourceEndAscending ************************
2437 **
2438 ** Sort Ensembl Base Align Feature objects by the source Ensembl Feature
2439 ** end member in ascending order.
2440 **
2441 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
2442 **
2443 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2444 **
2445 ** @release 6.4.0
2446 ** @@
2447 ******************************************************************************/
2448
ensListBasealignfeatureSortSourceEndAscending(AjPList bafs)2449 AjBool ensListBasealignfeatureSortSourceEndAscending(AjPList bafs)
2450 {
2451 if (!bafs)
2452 return ajFalse;
2453
2454 ajListSortTwoThree(bafs,
2455 &listBasealignfeatureCompareSourceEndAscending,
2456 &listBasealignfeatureCompareSourceStartAscending,
2457 &listBasealignfeatureCompareIdentifierAscending);
2458
2459 return ajTrue;
2460 }
2461
2462
2463
2464
2465 /* @func ensListBasealignfeatureSortSourceEndDescending ***********************
2466 **
2467 ** Sort Ensembl Base Align Feature objects by the source Ensembl Feature
2468 ** start member in descending order.
2469 **
2470 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
2471 **
2472 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2473 **
2474 ** @release 6.4.0
2475 ** @@
2476 ******************************************************************************/
2477
ensListBasealignfeatureSortSourceEndDescending(AjPList bafs)2478 AjBool ensListBasealignfeatureSortSourceEndDescending(AjPList bafs)
2479 {
2480 if (!bafs)
2481 return ajFalse;
2482
2483 ajListSortTwoThree(bafs,
2484 &listBasealignfeatureCompareSourceEndDescending,
2485 &listBasealignfeatureCompareSourceStartDescending,
2486 &listBasealignfeatureCompareIdentifierAscending);
2487
2488 return ajTrue;
2489 }
2490
2491
2492
2493
2494 /* @func ensListBasealignfeatureSortSourceStartAscending **********************
2495 **
2496 ** Sort Ensembl Base Align Feature objects by the source Ensembl Feature
2497 ** start member in ascending order.
2498 **
2499 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
2500 **
2501 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2502 **
2503 ** @release 6.4.0
2504 ** @@
2505 ******************************************************************************/
2506
ensListBasealignfeatureSortSourceStartAscending(AjPList bafs)2507 AjBool ensListBasealignfeatureSortSourceStartAscending(AjPList bafs)
2508 {
2509 if (!bafs)
2510 return ajFalse;
2511
2512 ajListSortTwoThree(bafs,
2513 &listBasealignfeatureCompareSourceStartAscending,
2514 &listBasealignfeatureCompareSourceEndAscending,
2515 &listBasealignfeatureCompareIdentifierAscending);
2516
2517 return ajTrue;
2518 }
2519
2520
2521
2522
2523 /* @func ensListBasealignfeatureSortSourceStartDescending *********************
2524 **
2525 ** Sort Ensembl Base Align Feature objects by the source Ensembl Feature
2526 ** start member in descending order.
2527 **
2528 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
2529 **
2530 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2531 **
2532 ** @release 6.4.0
2533 ** @@
2534 ******************************************************************************/
2535
ensListBasealignfeatureSortSourceStartDescending(AjPList bafs)2536 AjBool ensListBasealignfeatureSortSourceStartDescending(AjPList bafs)
2537 {
2538 if (!bafs)
2539 return ajFalse;
2540
2541 ajListSortTwoThree(bafs,
2542 &listBasealignfeatureCompareSourceStartDescending,
2543 &listBasealignfeatureCompareSourceEndDescending,
2544 &listBasealignfeatureCompareIdentifierAscending);
2545
2546 return ajTrue;
2547 }
2548
2549
2550
2551
2552 /* @datasection [EnsPDnaalignfeatureadaptor] Ensembl DNA Align Feature Adaptor
2553 **
2554 ** @nam2rule Dnaalignfeatureadaptor Functions for manipulating
2555 ** Ensembl DNA Align Feature Adaptor objects
2556 **
2557 ** @cc Bio::EnsEMBL::DBSQL::BaseAlignFeatureAdaptor
2558 ** @cc CVS Revision: 1.36
2559 ** @cc CVS Tag: branch-ensembl-68
2560 **
2561 ** @cc Bio::EnsEMBL::DBSQL::DnaAlignFeatureAdaptor
2562 ** @cc CVS Revision: 1.77
2563 ** @cc CVS Tag: branch-ensembl-68
2564 **
2565 ** NOTE: The Ensembl External Database Adaptor has an internal cache of all
2566 ** Ensembl External Database objects. Therefore, the same set of objects can be
2567 ** simply fetched by their SQL identifier and the "external_db" table does not
2568 ** need joining.
2569 **
2570 ******************************************************************************/
2571
2572
2573
2574
2575 /* @funcstatic dnaalignfeatureadaptorFetchAllbyStatement **********************
2576 **
2577 ** Run a SQL statement against an Ensembl Database Adaptor and consolidate the
2578 ** results into an AJAX List of Ensembl Base Align Feature objects.
2579 **
2580 ** The caller is responsible for deleting the Ensembl Base Align Feature
2581 ** objects before deleting the AJAX List.
2582 **
2583 ** @param [u] ba [EnsPBaseadaptor] Ensembl Base Adaptor
2584 ** @param [r] statement [const AjPStr] SQL statement
2585 ** @param [uN] am [EnsPAssemblymapper] Ensembl Assembly Mapper
2586 ** @param [uN] slice [EnsPSlice] Ensembl Slice
2587 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
2588 **
2589 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
2590 **
2591 ** @release 6.4.0
2592 ** @@
2593 ******************************************************************************/
2594
dnaalignfeatureadaptorFetchAllbyStatement(EnsPBaseadaptor ba,const AjPStr statement,EnsPAssemblymapper am,EnsPSlice slice,AjPList bafs)2595 static AjBool dnaalignfeatureadaptorFetchAllbyStatement(
2596 EnsPBaseadaptor ba,
2597 const AjPStr statement,
2598 EnsPAssemblymapper am,
2599 EnsPSlice slice,
2600 AjPList bafs)
2601 {
2602 double evalue = 0.0;
2603 double score = 0.0;
2604
2605 float identity = 0.0F;
2606 float hitcoverage = 0.0F;
2607
2608 ajuint identifier = 0U;
2609 ajuint srid = 0U;
2610 ajuint srstart = 0U;
2611 ajuint srend = 0U;
2612 ajint srstrand = 0;
2613 ajuint hitstart = 0U;
2614 ajuint hitend = 0U;
2615 ajint hitstrand = 0;
2616 ajuint analysisid = 0U;
2617 ajuint edbid = 0U;
2618 ajuint pairdafid = 0U;
2619
2620 AjPSqlstatement sqls = NULL;
2621 AjISqlrow sqli = NULL;
2622 AjPSqlrow sqlr = NULL;
2623
2624 AjPStr hitname = NULL;
2625 AjPStr cigar = NULL;
2626 AjPStr extra = NULL;
2627
2628 EnsPBasealignfeature baf = NULL;
2629
2630 EnsPDatabaseadaptor dba = NULL;
2631
2632 EnsPDnaalignfeatureadaptor dafa = NULL;
2633
2634 EnsPExternaldatabase edb = NULL;
2635 EnsPExternaldatabaseadaptor edba = NULL;
2636
2637 EnsPFeature srcfeature = NULL;
2638 EnsPFeature trgfeature = NULL;
2639
2640 EnsPFeaturepair fp = NULL;
2641
2642 if (ajDebugTest("dnaalignfeatureadaptorFetchAllbyStatement"))
2643 ajDebug("dnaalignfeatureadaptorFetchAllbyStatement\n"
2644 " ba %p\n"
2645 " statement %p\n"
2646 " am %p\n"
2647 " slice %p\n"
2648 " bafs %p\n",
2649 ba,
2650 statement,
2651 am,
2652 slice,
2653 bafs);
2654
2655 if (!ba)
2656 return ajFalse;
2657
2658 if (!statement)
2659 return ajFalse;
2660
2661 if (!bafs)
2662 return ajFalse;
2663
2664 dba = ensBaseadaptorGetDatabaseadaptor(ba);
2665
2666 dafa = ensRegistryGetDnaalignfeatureadaptor(dba);
2667 edba = ensRegistryGetExternaldatabaseadaptor(dba);
2668
2669 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
2670
2671 sqli = ajSqlrowiterNew(sqls);
2672
2673 while (!ajSqlrowiterDone(sqli))
2674 {
2675 identifier = 0U;
2676 srid = 0U;
2677 srstart = 0U;
2678 srend = 0U;
2679 srstrand = 0;
2680 hitstart = 0U;
2681 hitend = 0U;
2682 hitstrand = 0;
2683 hitname = ajStrNew();
2684 analysisid = 0U;
2685 cigar = ajStrNew();
2686 score = 0.0;
2687 evalue = 0.0;
2688 identity = 0.0F;
2689 edbid = 0U;
2690 hitcoverage = 0.0F;
2691 extra = ajStrNew();
2692 pairdafid = 0U;
2693
2694 sqlr = ajSqlrowiterGet(sqli);
2695
2696 ajSqlcolumnToUint(sqlr, &identifier);
2697 ajSqlcolumnToUint(sqlr, &srid);
2698 ajSqlcolumnToUint(sqlr, &srstart);
2699 ajSqlcolumnToUint(sqlr, &srend);
2700 ajSqlcolumnToInt(sqlr, &srstrand);
2701 ajSqlcolumnToUint(sqlr, &hitstart);
2702 ajSqlcolumnToUint(sqlr, &hitend);
2703 ajSqlcolumnToInt(sqlr, &hitstrand);
2704 ajSqlcolumnToStr(sqlr, &hitname);
2705 ajSqlcolumnToUint(sqlr, &analysisid);
2706 ajSqlcolumnToStr(sqlr, &cigar);
2707 ajSqlcolumnToDouble(sqlr, &score);
2708 ajSqlcolumnToDouble(sqlr, &evalue);
2709 ajSqlcolumnToFloat(sqlr, &identity);
2710 ajSqlcolumnToUint(sqlr, &edbid);
2711 ajSqlcolumnToFloat(sqlr, &hitcoverage);
2712 ajSqlcolumnToStr(sqlr, &extra);
2713 ajSqlcolumnToUint(sqlr, &pairdafid);
2714
2715 ensBaseadaptorRetrieveFeature(ba,
2716 analysisid,
2717 srid,
2718 srstart,
2719 srend,
2720 srstrand,
2721 am,
2722 slice,
2723 &srcfeature);
2724
2725 if (!srcfeature)
2726 {
2727 ajStrDel(&hitname);
2728 ajStrDel(&cigar);
2729
2730 continue;
2731 }
2732
2733 ensExternaldatabaseadaptorFetchByIdentifier(edba, edbid, &edb);
2734
2735 trgfeature = ensFeatureNewIniN((EnsPAnalysis) NULL,
2736 hitname,
2737 hitstart,
2738 hitend,
2739 hitstrand);
2740
2741 fp = ensFeaturepairNewIni(srcfeature,
2742 trgfeature,
2743 edb,
2744 extra,
2745 (AjPStr) NULL, /* srcspecies */
2746 (AjPStr) NULL, /* trgspecies */
2747 0U, /* groupid */
2748 0U, /* levelid */
2749 evalue,
2750 score,
2751 0.0F, /* srccoverage */
2752 hitcoverage,
2753 identity);
2754
2755 /*
2756 ** Finally, create a Base Align Feature object of type
2757 ** ensEBasealignfeatureTypeDNA.
2758 */
2759
2760 baf = ensBasealignfeatureNewIniD(dafa,
2761 identifier,
2762 fp,
2763 cigar,
2764 pairdafid);
2765
2766 ajListPushAppend(bafs, (void *) baf);
2767
2768 ensFeaturepairDel(&fp);
2769
2770 ensFeatureDel(&srcfeature);
2771 ensFeatureDel(&trgfeature);
2772
2773 ensExternaldatabaseDel(&edb);
2774
2775 ajStrDel(&hitname);
2776 ajStrDel(&cigar);
2777 }
2778
2779 ajSqlrowiterDel(&sqli);
2780
2781 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
2782
2783 return ajTrue;
2784 }
2785
2786
2787
2788
2789 /* @section constructors ******************************************************
2790 **
2791 ** All constructors return a new Ensembl DNA Align Feature Adaptor by pointer.
2792 ** It is the responsibility of the user to first destroy any previous
2793 ** DNA Align Feature Adaptor. The target pointer does not need to be
2794 ** initialised to NULL, but it is good programming practice to do so anyway.
2795 **
2796 ** @fdata [EnsPDnaalignfeatureadaptor]
2797 **
2798 ** @nam3rule New Constructor
2799 **
2800 ** @argrule New dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
2801 **
2802 ** @valrule * [EnsPDnaalignfeatureadaptor]
2803 ** Ensembl DNA Align Feature Adaptor or NULL
2804 **
2805 ** @fcategory new
2806 ******************************************************************************/
2807
2808
2809
2810
2811 /* @func ensDnaalignfeatureadaptorNew *****************************************
2812 **
2813 ** Default constructor for an Ensembl DNA Align Feature Adaptor.
2814 **
2815 ** Ensembl Object Adaptors are singleton objects in the sense that a single
2816 ** instance of an Ensembl Object Adaptor connected to a particular database is
2817 ** sufficient to instantiate any number of Ensembl Objects from the database.
2818 ** Each Ensembl Object will have a weak reference to the Object Adaptor that
2819 ** instantiated it. Therefore, Ensembl Object Adaptors should not be
2820 ** instantiated directly, but rather obtained from the Ensembl Registry,
2821 ** which will in turn call this function if neccessary.
2822 **
2823 ** @see ensRegistryGetDatabaseadaptor
2824 ** @see ensRegistryGetDnaalignfeatureadaptor
2825 **
2826 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
2827 **
2828 ** @return [EnsPDnaalignfeatureadaptor]
2829 ** Ensembl DNA Align Feature Adaptor or NULL
2830 **
2831 ** @release 6.4.0
2832 ** @@
2833 ******************************************************************************/
2834
ensDnaalignfeatureadaptorNew(EnsPDatabaseadaptor dba)2835 EnsPDnaalignfeatureadaptor ensDnaalignfeatureadaptorNew(
2836 EnsPDatabaseadaptor dba)
2837 {
2838 return ensFeatureadaptorNew(
2839 dba,
2840 dnaalignfeatureadaptorKTablenames,
2841 dnaalignfeatureadaptorKColumnnames,
2842 (const EnsPBaseadaptorLeftjoin) NULL,
2843 (const char *) NULL,
2844 (const char *) NULL,
2845 &dnaalignfeatureadaptorFetchAllbyStatement,
2846 (void *(*)(const void *)) NULL,
2847 (void *(*)(void *)) &ensBasealignfeatureNewRef,
2848 (AjBool (*)(const void *)) NULL,
2849 (void (*)(void **)) &ensBasealignfeatureDel,
2850 (size_t (*)(const void *)) &ensBasealignfeatureCalculateMemsize,
2851 (EnsPFeature (*)(const void *)) &ensBasealignfeatureGetFeature,
2852 "DNA Align Feature");
2853 }
2854
2855
2856
2857
2858 /* @section destructors *******************************************************
2859 **
2860 ** Destruction destroys all internal data structures and frees the memory
2861 ** allocated for an Ensembl DNA Align Feature Adaptor object.
2862 **
2863 ** @fdata [EnsPDnaalignfeatureadaptor]
2864 **
2865 ** @nam3rule Del Destroy (free) an Ensembl DNA Align Feature Adaptor
2866 **
2867 ** @argrule * Pdafa [EnsPDnaalignfeatureadaptor*]
2868 ** Ensembl DNA Align Feature Adaptor address
2869 **
2870 ** @valrule * [void]
2871 **
2872 ** @fcategory delete
2873 ******************************************************************************/
2874
2875
2876
2877
2878 /* @func ensDnaalignfeatureadaptorDel *****************************************
2879 **
2880 ** Default destructor for an Ensembl DNA Align Feature Adaptor.
2881 **
2882 ** Ensembl Object Adaptors are singleton objects that are registered in the
2883 ** Ensembl Registry and weakly referenced by Ensembl Objects that have been
2884 ** instantiated by it. Therefore, Ensembl Object Adaptors should never be
2885 ** destroyed directly. Upon exit, the Ensembl Registry will call this function
2886 ** if required.
2887 **
2888 ** @param [d] Pdafa [EnsPDnaalignfeatureadaptor*]
2889 ** Ensembl DNA Align Feature Adaptor address
2890 **
2891 ** @return [void]
2892 **
2893 ** @release 6.4.0
2894 ** @@
2895 ******************************************************************************/
2896
ensDnaalignfeatureadaptorDel(EnsPDnaalignfeatureadaptor * Pdafa)2897 void ensDnaalignfeatureadaptorDel(
2898 EnsPDnaalignfeatureadaptor *Pdafa)
2899 {
2900 ensFeatureadaptorDel(Pdafa);
2901
2902 return;
2903 }
2904
2905
2906
2907
2908 /* @section member retrieval **************************************************
2909 **
2910 ** Functions for returning members of an
2911 ** Ensembl DNA Align Feature Adaptor object.
2912 **
2913 ** @fdata [EnsPDnaalignfeatureadaptor]
2914 **
2915 ** @nam3rule Get Return Ensembl DNA Align Feature Adaptor attribute(s)
2916 ** @nam4rule Baseadaptor Return the Ensembl Base Adaptor
2917 ** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
2918 ** @nam4rule Featureadaptor Return the Ensembl Feature Adaptor
2919 **
2920 ** @argrule * dafa [EnsPDnaalignfeatureadaptor]
2921 ** Ensembl DNA Align Feature Adaptor
2922 **
2923 ** @valrule Baseadaptor [EnsPBaseadaptor]
2924 ** Ensembl Base Adaptor or NULL
2925 ** @valrule Databaseadaptor [EnsPDatabaseadaptor]
2926 ** Ensembl Database Adaptor or NULL
2927 ** @valrule Featureadaptor [EnsPFeatureadaptor]
2928 ** Ensembl Feature Adaptor or NULL
2929 **
2930 ** @fcategory use
2931 ******************************************************************************/
2932
2933
2934
2935
2936 /* @func ensDnaalignfeatureadaptorGetBaseadaptor ******************************
2937 **
2938 ** Get the Ensembl Base Adaptor member of an
2939 ** Ensembl DNA Align Feature Adaptor.
2940 **
2941 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
2942 ** Ensembl DNA Align Feature Adaptor
2943 **
2944 ** @return [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
2945 **
2946 ** @release 6.4.0
2947 ** @@
2948 ******************************************************************************/
2949
ensDnaalignfeatureadaptorGetBaseadaptor(EnsPDnaalignfeatureadaptor dafa)2950 EnsPBaseadaptor ensDnaalignfeatureadaptorGetBaseadaptor(
2951 EnsPDnaalignfeatureadaptor dafa)
2952 {
2953 return ensFeatureadaptorGetBaseadaptor(
2954 ensDnaalignfeatureadaptorGetFeatureadaptor(dafa));
2955 }
2956
2957
2958
2959
2960 /* @func ensDnaalignfeatureadaptorGetDatabaseadaptor **************************
2961 **
2962 ** Get the Ensembl Database Adaptor member of an
2963 ** Ensembl DNA Align Feature Adaptor.
2964 **
2965 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
2966 ** Ensembl DNA Align Feature Adaptor
2967 **
2968 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
2969 **
2970 ** @release 6.4.0
2971 ** @@
2972 ******************************************************************************/
2973
ensDnaalignfeatureadaptorGetDatabaseadaptor(EnsPDnaalignfeatureadaptor dafa)2974 EnsPDatabaseadaptor ensDnaalignfeatureadaptorGetDatabaseadaptor(
2975 EnsPDnaalignfeatureadaptor dafa)
2976 {
2977 return ensFeatureadaptorGetDatabaseadaptor(
2978 ensDnaalignfeatureadaptorGetFeatureadaptor(dafa));
2979 }
2980
2981
2982
2983
2984 /* @func ensDnaalignfeatureadaptorGetFeatureadaptor ***************************
2985 **
2986 ** Get the Ensembl Feature Adaptor member of an
2987 ** Ensembl DNA Align Feature Adaptor.
2988 **
2989 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
2990 ** Ensembl DNA Align Feature Adaptor
2991 **
2992 ** @return [EnsPFeatureadaptor] Ensembl Feature Adaptor or NULL
2993 **
2994 ** @release 6.4.0
2995 ** @@
2996 ******************************************************************************/
2997
ensDnaalignfeatureadaptorGetFeatureadaptor(EnsPDnaalignfeatureadaptor dafa)2998 EnsPFeatureadaptor ensDnaalignfeatureadaptorGetFeatureadaptor(
2999 EnsPDnaalignfeatureadaptor dafa)
3000 {
3001 return dafa;
3002 }
3003
3004
3005
3006
3007 /* @section object retrieval **************************************************
3008 **
3009 ** Functions for fetching Ensembl Base Align Feature objects (type dna)
3010 ** from an Ensembl SQL database.
3011 **
3012 ** @fdata [EnsPDnaalignfeatureadaptor]
3013 **
3014 ** @nam3rule Fetch
3015 ** Fetch Ensembl Base Align Feature object(s)
3016 ** @nam4rule All
3017 ** Fetch all Ensembl Base Align Feature objects
3018 ** @nam4rule Allby
3019 ** Fetch all Ensembl Base Align Feature objects matching a criterion
3020 ** @nam5rule Hitname Fetch all by hit name
3021 ** @nam5rule Hitunversioned Fetch all by unversioned hit name
3022 ** @nam5rule Slicecoverage Fetch all by an Ensembl Slice and sequence coverage
3023 ** @nam5rule Sliceexternaldatabasename
3024 ** Fetch all by an Ensembl Slice and Ensembl External Database name
3025 ** @nam5rule Sliceidentity Fetch all by an Ensembl Slice and sequence identity
3026 ** @nam4rule By
3027 ** Fetch one Ensembl Base Align Feature object matching a criterion
3028 ** @nam5rule Identifier Fetch by a SQL database-internal identifier
3029 **
3030 ** @argrule * dafa [EnsPDnaalignfeatureadaptor]
3031 ** Ensembl DNA Align Feature Adaptor
3032 ** @argrule AllbyHitname hitname [const AjPStr] Hit (target) sequence name
3033 ** @argrule AllbyHitname anname [const AjPStr] Ensembl Analysis name
3034 ** @argrule AllbyHitname bafs [AjPList]
3035 ** AJAX List of Ensembl Base Align Feature objects
3036 ** @argrule AllbyHitunversioned hitname [const AjPStr]
3037 ** Hit (target) sequence name
3038 ** @argrule AllbyHitunversioned anname [const AjPStr] Ensembl Analysis name
3039 ** @argrule AllbyHitunversioned bafs [AjPList]
3040 ** AJAX List of Ensembl Base Align Feature objects
3041 ** @argrule AllbySlicecoverage slice [EnsPSlice] Ensembl Slice
3042 ** @argrule AllbySlicecoverage coverage [float]
3043 ** Alignment target coverage threshold
3044 ** @argrule AllbySlicecoverage anname [const AjPStr] Ensembl Analysis name
3045 ** @argrule AllbySlicecoverage bafs [AjPList]
3046 ** AJAX List of Ensembl Base Align Feature objects
3047 ** @argrule AllbySliceexternaldatabasename slice [EnsPSlice] Ensembl Slice
3048 ** @argrule AllbySliceexternaldatabasename edbname [const AjPStr]
3049 ** Ensembl External Database name
3050 ** @argrule AllbySliceexternaldatabasename anname [const AjPStr]
3051 ** Ensembl Analysis name
3052 ** @argrule AllbySliceexternaldatabasename bafs [AjPList]
3053 ** AJAX List of Ensembl Base Align Feature objects
3054 ** @argrule AllbySliceidentity slice [EnsPSlice] Ensembl Slice
3055 ** @argrule AllbySliceidentity identity [float] Alignment identity threshold
3056 ** @argrule AllbySliceidentity anname [const AjPStr] Ensembl Analysis name
3057 ** @argrule AllbySliceidentity bafs [AjPList]
3058 ** AJAX List of Ensembl Base Align Feature objects
3059 ** @argrule ByIdentifier identifier [ajuint] SQL database-internal identifier
3060 ** @argrule ByIdentifier Pbaf [EnsPBasealignfeature*]
3061 ** Ensembl Base Align Feature address
3062 **
3063 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3064 **
3065 ** @fcategory use
3066 ******************************************************************************/
3067
3068
3069
3070
3071 /* @func ensDnaalignfeatureadaptorFetchAllbyHitname ***************************
3072 **
3073 ** Fetch Ensembl DNA Align Feature objects via a hit name.
3074 **
3075 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
3076 ** Ensembl DNA Align Feature Adaptor
3077 ** @param [r] hitname [const AjPStr] Hit (target) sequence name
3078 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
3079 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
3080 **
3081 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3082 **
3083 ** @release 6.4.0
3084 ** @@
3085 ******************************************************************************/
3086
ensDnaalignfeatureadaptorFetchAllbyHitname(EnsPDnaalignfeatureadaptor dafa,const AjPStr hitname,const AjPStr anname,AjPList bafs)3087 AjBool ensDnaalignfeatureadaptorFetchAllbyHitname(
3088 EnsPDnaalignfeatureadaptor dafa,
3089 const AjPStr hitname,
3090 const AjPStr anname,
3091 AjPList bafs)
3092 {
3093 char *txthitname = NULL;
3094
3095 AjBool result = AJFALSE;
3096
3097 AjPStr constraint = NULL;
3098
3099 EnsPBaseadaptor ba = NULL;
3100
3101 if (!dafa)
3102 return ajFalse;
3103
3104 if (!hitname)
3105 return ajFalse;
3106
3107 if (!bafs)
3108 return ajFalse;
3109
3110 ba = ensDnaalignfeatureadaptorGetBaseadaptor(dafa);
3111
3112 ensBaseadaptorEscapeC(ba, &txthitname, hitname);
3113
3114 constraint = ajFmtStr("dna_align_feature.hit_name = '%s'", txthitname);
3115
3116 ajCharDel(&txthitname);
3117
3118 /* Add the Ensembl Analysis name constraint. */
3119
3120 if (anname && ajStrGetLen(anname))
3121 ensFeatureadaptorConstraintAppendAnalysisname(
3122 ensDnaalignfeatureadaptorGetFeatureadaptor(dafa),
3123 &constraint,
3124 anname);
3125
3126 result = ensBaseadaptorFetchAllbyConstraint(
3127 ba,
3128 constraint,
3129 (EnsPAssemblymapper) NULL,
3130 (EnsPSlice) NULL,
3131 bafs);
3132
3133 ajStrDel(&constraint);
3134
3135 return result;
3136 }
3137
3138
3139
3140
3141 /* @func ensDnaalignfeatureadaptorFetchAllbyHitunversioned ********************
3142 **
3143 ** Fetch Ensembl DNA Align Feature objects via an unversioned hit name.
3144 **
3145 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
3146 ** Ensembl DNA Align Feature Adaptor
3147 ** @param [r] hitname [const AjPStr] Hit (target) sequence name
3148 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
3149 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
3150 **
3151 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3152 **
3153 ** @release 6.4.0
3154 ** @@
3155 ******************************************************************************/
3156
ensDnaalignfeatureadaptorFetchAllbyHitunversioned(EnsPDnaalignfeatureadaptor dafa,const AjPStr hitname,const AjPStr anname,AjPList bafs)3157 AjBool ensDnaalignfeatureadaptorFetchAllbyHitunversioned(
3158 EnsPDnaalignfeatureadaptor dafa,
3159 const AjPStr hitname,
3160 const AjPStr anname,
3161 AjPList bafs)
3162 {
3163 AjBool result = AJFALSE;
3164
3165 AjPStr constraint = NULL;
3166 AjPStr modhitname = NULL;
3167
3168 EnsPBaseadaptor ba = NULL;
3169
3170 if (!dafa)
3171 return ajFalse;
3172
3173 if (!hitname)
3174 return ajFalse;
3175
3176 if (!bafs)
3177 return ajFalse;
3178
3179 ba = ensDnaalignfeatureadaptorGetBaseadaptor(dafa);
3180
3181 ensBaseadaptorEscapeS(ba, &modhitname, hitname);
3182
3183 /* Escape expensive SQL wilcard characters. */
3184 ajStrExchangeCC(&modhitname, "_", "\\_");
3185
3186 constraint = ajFmtStr("dna_align_feature.hit_name LIKE '%S.%%'",
3187 modhitname);
3188
3189 ajStrDel(&modhitname);
3190
3191 /* Add the Ensembl Analysis name constraint. */
3192
3193 if (anname && ajStrGetLen(anname))
3194 ensFeatureadaptorConstraintAppendAnalysisname(
3195 ensDnaalignfeatureadaptorGetFeatureadaptor(dafa),
3196 &constraint,
3197 anname);
3198
3199 result = ensBaseadaptorFetchAllbyConstraint(
3200 ba,
3201 constraint,
3202 (EnsPAssemblymapper) NULL,
3203 (EnsPSlice) NULL,
3204 bafs);
3205
3206 ajStrDel(&constraint);
3207
3208 return result;
3209 }
3210
3211
3212
3213
3214 /* @func ensDnaalignfeatureadaptorFetchAllbySlicecoverage *********************
3215 **
3216 ** Fetch Ensembl DNA Align Feature objects via an Ensembl Slice and
3217 ** an alignment target coverage.
3218 **
3219 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
3220 ** Ensembl DNA Align Feature Adaptor
3221 ** @param [u] slice [EnsPSlice] Ensembl Slice
3222 ** @param [r] coverage [float] Alignment coverage threshold
3223 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
3224 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
3225 **
3226 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3227 **
3228 ** @release 6.4.0
3229 ** @@
3230 ******************************************************************************/
3231
ensDnaalignfeatureadaptorFetchAllbySlicecoverage(EnsPDnaalignfeatureadaptor dafa,EnsPSlice slice,float coverage,const AjPStr anname,AjPList bafs)3232 AjBool ensDnaalignfeatureadaptorFetchAllbySlicecoverage(
3233 EnsPDnaalignfeatureadaptor dafa,
3234 EnsPSlice slice,
3235 float coverage,
3236 const AjPStr anname,
3237 AjPList bafs)
3238 {
3239 AjBool result = AJFALSE;
3240
3241 AjPStr constraint = NULL;
3242
3243 if (!dafa)
3244 return ajFalse;
3245
3246 if (!slice)
3247 return ajFalse;
3248
3249 if (!bafs)
3250 return ajFalse;
3251
3252 if (coverage > 0.0F)
3253 constraint = ajFmtStr("dna_align_feature.hcoverage > %f", coverage);
3254
3255 result = ensFeatureadaptorFetchAllbySlice(
3256 ensDnaalignfeatureadaptorGetFeatureadaptor(dafa),
3257 slice,
3258 constraint,
3259 anname,
3260 bafs);
3261
3262 ajStrDel(&constraint);
3263
3264 return result;
3265 }
3266
3267
3268
3269
3270 /* @func ensDnaalignfeatureadaptorFetchAllbySliceexternaldatabasename *********
3271 **
3272 ** Fetch Ensembl DNA Align Feature objects via an Ensembl Slice and
3273 ** an Ensembl External Database name.
3274 **
3275 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
3276 ** Ensembl DNA Align Feature Adaptor
3277 ** @param [u] slice [EnsPSlice] Ensembl Slice
3278 ** @param [r] edbname [const AjPStr] Ensembl External Database name
3279 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
3280 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
3281 **
3282 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3283 **
3284 ** @release 6.4.0
3285 ** @@
3286 ******************************************************************************/
3287
ensDnaalignfeatureadaptorFetchAllbySliceexternaldatabasename(EnsPDnaalignfeatureadaptor dafa,EnsPSlice slice,const AjPStr edbname,const AjPStr anname,AjPList bafs)3288 AjBool ensDnaalignfeatureadaptorFetchAllbySliceexternaldatabasename(
3289 EnsPDnaalignfeatureadaptor dafa,
3290 EnsPSlice slice,
3291 const AjPStr edbname,
3292 const AjPStr anname,
3293 AjPList bafs)
3294 {
3295 char *txtname = NULL;
3296
3297 AjBool result = AJFALSE;
3298
3299 AjPStr constraint = NULL;
3300
3301 EnsPFeatureadaptor fa = NULL;
3302
3303 if (!dafa)
3304 return ajFalse;
3305
3306 if (!slice)
3307 return ajFalse;
3308
3309 if (!edbname)
3310 return ajFalse;
3311
3312 if (!bafs)
3313 return ajFalse;
3314
3315 fa = ensDnaalignfeatureadaptorGetFeatureadaptor(dafa);
3316
3317 ensFeatureadaptorEscapeC(fa, &txtname, edbname);
3318
3319 constraint = ajFmtStr("external_db.db_name = %s", txtname);
3320
3321 ajCharDel(&txtname);
3322
3323 result = ensFeatureadaptorFetchAllbySlice(
3324 fa,
3325 slice,
3326 constraint,
3327 anname,
3328 bafs);
3329
3330 ajStrDel(&constraint);
3331
3332 return result;
3333 }
3334
3335
3336
3337
3338 /* @func ensDnaalignfeatureadaptorFetchAllbySliceidentity *********************
3339 **
3340 ** Fetch Ensembl DNA Align Feature objects via an Ensembl Slice and
3341 ** an alignment identity threshold.
3342 **
3343 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
3344 ** Ensembl DNA Align Feature Adaptor
3345 ** @param [u] slice [EnsPSlice] Ensembl Slice
3346 ** @param [r] identity [float] Alignment identity threshold
3347 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
3348 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
3349 **
3350 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3351 **
3352 ** @release 6.4.0
3353 ** @@
3354 ******************************************************************************/
3355
ensDnaalignfeatureadaptorFetchAllbySliceidentity(EnsPDnaalignfeatureadaptor dafa,EnsPSlice slice,float identity,const AjPStr anname,AjPList bafs)3356 AjBool ensDnaalignfeatureadaptorFetchAllbySliceidentity(
3357 EnsPDnaalignfeatureadaptor dafa,
3358 EnsPSlice slice,
3359 float identity,
3360 const AjPStr anname,
3361 AjPList bafs)
3362 {
3363 AjBool result = AJFALSE;
3364
3365 AjPStr constraint = NULL;
3366
3367 if (!dafa)
3368 return ajFalse;
3369
3370 if (!slice)
3371 return ajFalse;
3372
3373 if (!bafs)
3374 return ajFalse;
3375
3376 if (identity > 0.0F)
3377 constraint = ajFmtStr("dna_align_feature.perc_ident > %f", identity);
3378
3379 result = ensFeatureadaptorFetchAllbySlice(
3380 ensDnaalignfeatureadaptorGetFeatureadaptor(dafa),
3381 slice,
3382 constraint,
3383 anname,
3384 bafs);
3385
3386 ajStrDel(&constraint);
3387
3388 return result;
3389 }
3390
3391
3392
3393
3394 /* @func ensDnaalignfeatureadaptorFetchByIdentifier ***************************
3395 **
3396 ** Fetch an Ensembl DNA Align Feature via its SQL database-internal identifier.
3397 **
3398 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
3399 ** Ensembl DNA Align Feature Adaptor
3400 ** @param [r] identifier [ajuint] SQL database-internal identifier
3401 ** @param [wP] Pbaf [EnsPBasealignfeature*] Ensembl Base Align Feature address
3402 **
3403 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3404 **
3405 ** @release 6.4.0
3406 ** @@
3407 ******************************************************************************/
3408
ensDnaalignfeatureadaptorFetchByIdentifier(EnsPDnaalignfeatureadaptor dafa,ajuint identifier,EnsPBasealignfeature * Pbaf)3409 AjBool ensDnaalignfeatureadaptorFetchByIdentifier(
3410 EnsPDnaalignfeatureadaptor dafa,
3411 ajuint identifier,
3412 EnsPBasealignfeature *Pbaf)
3413 {
3414 return ensBaseadaptorFetchByIdentifier(
3415 ensDnaalignfeatureadaptorGetBaseadaptor(dafa),
3416 identifier,
3417 (void **) Pbaf);
3418 }
3419
3420
3421
3422
3423 /* @section accessory object retrieval ****************************************
3424 **
3425 ** Functions for fetching objects releated to Ensembl DNA Align Feature
3426 ** objects from an Ensembl SQL database.
3427 **
3428 ** @fdata [EnsPDnaalignfeatureadaptor]
3429 **
3430 ** @nam3rule Retrieve Retrieve Ensembl DNA Align Feature-releated object(s)
3431 ** @nam4rule All Retrieve all Ensembl DNA Align Feature-releated objects
3432 ** @nam5rule Identifiers Retrieve all SQL database-internal identifier objects
3433 **
3434 ** @argrule * dafa [EnsPDnaalignfeatureadaptor]
3435 ** Ensembl DNA Align Feature Adaptor
3436 ** @argrule AllIdentifiers identifiers [AjPList]
3437 ** AJAX List of AJAX unsigned integer objects
3438 **
3439 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3440 **
3441 ** @fcategory use
3442 ******************************************************************************/
3443
3444
3445
3446
3447 /* @func ensDnaalignfeatureadaptorRetrieveAllIdentifiers **********************
3448 **
3449 ** Retrieve all SQL database-internal identifier objects of
3450 ** Ensembl DNA Align Feature objects.
3451 **
3452 ** @param [u] dafa [EnsPDnaalignfeatureadaptor]
3453 ** Ensembl DNA Align Feature Adaptor
3454 ** @param [u] identifiers [AjPList]
3455 ** AJAX List of AJAX unsigned integer objects
3456 **
3457 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3458 **
3459 ** @release 6.4.0
3460 ** @@
3461 ******************************************************************************/
3462
ensDnaalignfeatureadaptorRetrieveAllIdentifiers(EnsPDnaalignfeatureadaptor dafa,AjPList identifiers)3463 AjBool ensDnaalignfeatureadaptorRetrieveAllIdentifiers(
3464 EnsPDnaalignfeatureadaptor dafa,
3465 AjPList identifiers)
3466 {
3467 AjBool result = AJFALSE;
3468
3469 AjPStr table = NULL;
3470
3471 if (!dafa)
3472 return ajFalse;
3473
3474 if (!identifiers)
3475 return ajFalse;
3476
3477 table = ajStrNewC("dna_align_feature");
3478
3479 result = ensBaseadaptorRetrieveAllIdentifiers(
3480 ensDnaalignfeatureadaptorGetBaseadaptor(dafa),
3481 table,
3482 (AjPStr) NULL,
3483 identifiers);
3484
3485 ajStrDel(&table);
3486
3487 return result;
3488 }
3489
3490
3491
3492
3493 /* @datasection [EnsPProteinalignfeatureadaptor] Ensembl Protein Align Feature
3494 ** Adaptor
3495 **
3496 ** @nam2rule Proteinalignfeatureadaptor Functions for manipulating
3497 ** Ensembl Protein Align Feature Adaptor objects
3498 **
3499 ** @cc Bio::EnsEMBL::DBSQL::BaseAlignFeatureAdaptor
3500 ** @cc CVS Revision: 1.36
3501 ** @cc CVS Tag: branch-ensembl-68
3502 **
3503 ** @cc Bio::EnsEMBL::BBSQL::ProteinAlignFeatureAdaptor
3504 ** @cc CVS Revision: 1.52
3505 ** @cc CVS Tag: branch-ensembl-68
3506 **
3507 ** NOTE: The Ensembl External Database Adaptor has an internal cache of all
3508 ** Ensembl External Database objects. Therefore, the same set of objects can be
3509 ** simply fetched by their SQL identifier and the "external_db" table does not
3510 ** need joining.
3511 **
3512 ******************************************************************************/
3513
3514
3515
3516
3517 /* @funcstatic proteinalignfeatureadaptorFetchAllbyStatement ******************
3518 **
3519 ** Run a SQL statement against an Ensembl Database Adaptor and consolidate the
3520 ** results into an AJAX List of Ensembl Protein Align Feature objects.
3521 **
3522 ** @param [u] ba [EnsPBaseadaptor] Ensembl Base Adaptor
3523 ** @param [r] statement [const AjPStr] SQL statement
3524 ** @param [uN] am [EnsPAssemblymapper] Ensembl Assembly Mapper
3525 ** @param [uN] slice [EnsPSlice] Ensembl Slice
3526 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
3527 **
3528 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
3529 **
3530 ** @release 6.4.0
3531 ** @@
3532 ******************************************************************************/
3533
proteinalignfeatureadaptorFetchAllbyStatement(EnsPBaseadaptor ba,const AjPStr statement,EnsPAssemblymapper am,EnsPSlice slice,AjPList bafs)3534 static AjBool proteinalignfeatureadaptorFetchAllbyStatement(
3535 EnsPBaseadaptor ba,
3536 const AjPStr statement,
3537 EnsPAssemblymapper am,
3538 EnsPSlice slice,
3539 AjPList bafs)
3540 {
3541 double evalue = 0.0;
3542 double score = 0.0;
3543
3544 float identity = 0.0F;
3545 float hitcoverage = 0.0F;
3546
3547 ajuint identifier = 0U;
3548 ajuint srid = 0U;
3549 ajuint srstart = 0U;
3550 ajuint srend = 0U;
3551 ajint srstrand = 0;
3552 ajuint hitstart = 0U;
3553 ajuint hitend = 0U;
3554 ajuint analysisid = 0U;
3555 ajuint edbid = 0U;
3556
3557 AjPSqlstatement sqls = NULL;
3558 AjISqlrow sqli = NULL;
3559 AjPSqlrow sqlr = NULL;
3560
3561 AjPStr hitname = NULL;
3562 AjPStr cigar = NULL;
3563
3564 EnsPBasealignfeature baf = NULL;
3565
3566 EnsPDatabaseadaptor dba = NULL;
3567
3568 EnsPExternaldatabase edb = NULL;
3569 EnsPExternaldatabaseadaptor edba = NULL;
3570
3571 EnsPFeature srcfeature = NULL;
3572 EnsPFeature trgfeature = NULL;
3573
3574 EnsPFeaturepair fp = NULL;
3575
3576 EnsPProteinalignfeatureadaptor pafa = NULL;
3577
3578 if (ajDebugTest("proteinalignfeatureadaptorFetchAllbyStatement"))
3579 ajDebug("proteinalignfeatureadaptorFetchAllbyStatement\n"
3580 " ba %p\n"
3581 " statement %p\n"
3582 " am %p\n"
3583 " slice %p\n"
3584 " bafs %p\n",
3585 ba,
3586 statement,
3587 am,
3588 slice,
3589 bafs);
3590
3591 if (!ba)
3592 return ajFalse;
3593
3594 if (!statement)
3595 return ajFalse;
3596
3597 if (!bafs)
3598 return ajFalse;
3599
3600 dba = ensBaseadaptorGetDatabaseadaptor(ba);
3601
3602 edba = ensRegistryGetExternaldatabaseadaptor(dba);
3603 pafa = ensRegistryGetProteinalignfeatureadaptor(dba);
3604
3605 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
3606
3607 sqli = ajSqlrowiterNew(sqls);
3608
3609 while (!ajSqlrowiterDone(sqli))
3610 {
3611 identifier = 0U;
3612 srid = 0U;
3613 srstart = 0U;
3614 srend = 0U;
3615 srstrand = 0;
3616 hitstart = 0U;
3617 hitend = 0U;
3618 hitname = ajStrNew();
3619 analysisid = 0U;
3620 cigar = ajStrNew();
3621 score = 0.0;
3622 evalue = 0.0;
3623 identity = 0.0F;
3624 edbid = 0U;
3625 hitcoverage = 0.0F;
3626
3627 sqlr = ajSqlrowiterGet(sqli);
3628
3629 ajSqlcolumnToUint(sqlr, &identifier);
3630 ajSqlcolumnToUint(sqlr, &srid);
3631 ajSqlcolumnToUint(sqlr, &srstart);
3632 ajSqlcolumnToUint(sqlr, &srend);
3633 ajSqlcolumnToInt(sqlr, &srstrand);
3634 ajSqlcolumnToUint(sqlr, &hitstart);
3635 ajSqlcolumnToUint(sqlr, &hitend);
3636 ajSqlcolumnToStr(sqlr, &hitname);
3637 ajSqlcolumnToUint(sqlr, &analysisid);
3638 ajSqlcolumnToStr(sqlr, &cigar);
3639 ajSqlcolumnToDouble(sqlr, &score);
3640 ajSqlcolumnToDouble(sqlr, &evalue);
3641 ajSqlcolumnToFloat(sqlr, &identity);
3642 ajSqlcolumnToUint(sqlr, &edbid);
3643 ajSqlcolumnToFloat(sqlr, &hitcoverage);
3644
3645 ensBaseadaptorRetrieveFeature(ba,
3646 analysisid,
3647 srid,
3648 srstart,
3649 srend,
3650 srstrand,
3651 am,
3652 slice,
3653 &srcfeature);
3654
3655 if (!srcfeature)
3656 {
3657 ajStrDel(&hitname);
3658 ajStrDel(&cigar);
3659
3660 continue;
3661 }
3662
3663 ensExternaldatabaseadaptorFetchByIdentifier(edba, edbid, &edb);
3664
3665 trgfeature = ensFeatureNewIniN((EnsPAnalysis) NULL,
3666 hitname,
3667 hitstart,
3668 hitend,
3669 1);
3670
3671 fp = ensFeaturepairNewIni(srcfeature,
3672 trgfeature,
3673 edb,
3674 (AjPStr) NULL, /* extra data */
3675 (AjPStr) NULL, /* srcspecies */
3676 (AjPStr) NULL, /* trgspecies */
3677 0U, /* groupid */
3678 0U, /* levelid */
3679 evalue,
3680 score,
3681 0.0F, /* srccoverage */
3682 0.0F, /* trgcoverage */
3683 identity);
3684
3685 /*
3686 ** Finally, create a Base Align Feature object of type
3687 ** ensEBasealignfeatureTypeProtein.
3688 */
3689
3690 baf = ensBasealignfeatureNewIniP(pafa, identifier, fp, cigar);
3691
3692 ajListPushAppend(bafs, (void *) baf);
3693
3694 ensFeaturepairDel(&fp);
3695
3696 ensFeatureDel(&srcfeature);
3697 ensFeatureDel(&trgfeature);
3698
3699 ensExternaldatabaseDel(&edb);
3700
3701 ajStrDel(&hitname);
3702 ajStrDel(&cigar);
3703 }
3704
3705 ajSqlrowiterDel(&sqli);
3706
3707 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
3708
3709 return ajTrue;
3710 }
3711
3712
3713
3714
3715 /* @section constructors ******************************************************
3716 **
3717 ** All constructors return a new Ensembl Protein Align Feature Adaptor by
3718 ** pointer.
3719 ** It is the responsibility of the user to first destroy any previous
3720 ** Protein Align Feature Adaptor. The target pointer does not need to be
3721 ** initialised to NULL, but it is good programming practice to do so anyway.
3722 **
3723 ** @fdata [EnsPProteinalignfeatureadaptor]
3724 **
3725 ** @nam3rule New Constructor
3726 **
3727 ** @argrule New dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3728 **
3729 ** @valrule * [EnsPProteinalignfeatureadaptor]
3730 ** Ensembl Protein Align Feature Adaptor or NULL
3731 **
3732 ** @fcategory new
3733 ******************************************************************************/
3734
3735
3736
3737
3738 /* @func ensProteinalignfeatureadaptorNew *************************************
3739 **
3740 ** Default constructor for an Ensembl Protein Align Feature Adaptor.
3741 **
3742 ** Ensembl Object Adaptors are singleton objects in the sense that a single
3743 ** instance of an Ensembl Object Adaptor connected to a particular database is
3744 ** sufficient to instantiate any number of Ensembl Objects from the database.
3745 ** Each Ensembl Object will have a weak reference to the Object Adaptor that
3746 ** instantiated it. Therefore, Ensembl Object Adaptors should not be
3747 ** instantiated directly, but rather obtained from the Ensembl Registry,
3748 ** which will in turn call this function if neccessary.
3749 **
3750 ** @see ensRegistryGetDatabaseadaptor
3751 ** @see ensRegistryGetProteinalignfeatureadaptor
3752 **
3753 ** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
3754 **
3755 ** @return [EnsPProteinalignfeatureadaptor]
3756 ** Ensembl Protein Align Feature Adaptor or NULL
3757 **
3758 ** @release 6.2.0
3759 ** @@
3760 ******************************************************************************/
3761
ensProteinalignfeatureadaptorNew(EnsPDatabaseadaptor dba)3762 EnsPProteinalignfeatureadaptor ensProteinalignfeatureadaptorNew(
3763 EnsPDatabaseadaptor dba)
3764 {
3765 return ensFeatureadaptorNew(
3766 dba,
3767 proteinalignfeatureadaptorKTablenames,
3768 proteinalignfeatureadaptorKColumnnames,
3769 (const EnsPBaseadaptorLeftjoin) NULL,
3770 (const char *) NULL,
3771 (const char *) NULL,
3772 &proteinalignfeatureadaptorFetchAllbyStatement,
3773 (void *(*)(const void *)) NULL,
3774 (void *(*)(void *)) &ensBasealignfeatureNewRef,
3775 (AjBool (*)(const void *)) NULL,
3776 (void (*)(void **)) &ensBasealignfeatureDel,
3777 (size_t (*)(const void *)) &ensBasealignfeatureCalculateMemsize,
3778 (EnsPFeature (*)(const void *)) &ensBasealignfeatureGetFeature,
3779 "Protein Align Feature");
3780 }
3781
3782
3783
3784
3785 /* @section destructors *******************************************************
3786 **
3787 ** Destruction destroys all internal data structures and frees the memory
3788 ** allocated for an Ensembl Protein Align Feature Adaptor object.
3789 **
3790 ** @fdata [EnsPProteinalignfeatureadaptor]
3791 **
3792 ** @nam3rule Del Destroy (free) an Ensembl Protein Align Feature Adaptor
3793 **
3794 ** @argrule * Ppafa [EnsPProteinalignfeatureadaptor*]
3795 ** Ensembl Protein Align Feature Adaptor address
3796 **
3797 ** @valrule * [void]
3798 **
3799 ** @fcategory delete
3800 ******************************************************************************/
3801
3802
3803
3804
3805 /* @func ensProteinalignfeatureadaptorDel *************************************
3806 **
3807 ** Default destructor for an Ensembl Protein Align Feature Adaptor.
3808 **
3809 ** Ensembl Object Adaptors are singleton objects that are registered in the
3810 ** Ensembl Registry and weakly referenced by Ensembl Objects that have been
3811 ** instantiated by it. Therefore, Ensembl Object Adaptors should never be
3812 ** destroyed directly. Upon exit, the Ensembl Registry will call this function
3813 ** if required.
3814 **
3815 ** @param [d] Ppafa [EnsPProteinalignfeatureadaptor*]
3816 ** Ensembl Protein Align Feature Adaptor address
3817 **
3818 ** @return [void]
3819 **
3820 ** @release 6.2.0
3821 ** @@
3822 ******************************************************************************/
3823
ensProteinalignfeatureadaptorDel(EnsPProteinalignfeatureadaptor * Ppafa)3824 void ensProteinalignfeatureadaptorDel(
3825 EnsPProteinalignfeatureadaptor *Ppafa)
3826 {
3827 ensFeatureadaptorDel(Ppafa);
3828
3829 return;
3830 }
3831
3832
3833
3834
3835 /* @section member retrieval **************************************************
3836 **
3837 ** Functions for returning members of an
3838 ** Ensembl Protein Align Feature Adaptor object.
3839 **
3840 ** @fdata [EnsPProteinalignfeatureadaptor]
3841 **
3842 ** @nam3rule Get Return Ensembl Protein Align Feature Adaptor attribute(s)
3843 ** @nam4rule Baseadaptor Return the Ensembl Base Adaptor
3844 ** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
3845 ** @nam4rule Featureadaptor Return the Ensembl Feature Adaptor
3846 **
3847 ** @argrule * pafa [EnsPProteinalignfeatureadaptor]
3848 ** Ensembl Protein Align Feature Adaptor
3849 **
3850 ** @valrule Baseadaptor [EnsPBaseadaptor]
3851 ** Ensembl Base Adaptor or NULL
3852 ** @valrule Databaseadaptor [EnsPDatabaseadaptor]
3853 ** Ensembl Database Adaptor or NULL
3854 ** @valrule Featureadaptor [EnsPFeatureadaptor]
3855 ** Ensembl Feature Adaptor or NULL
3856 **
3857 ** @fcategory use
3858 ******************************************************************************/
3859
3860
3861
3862
3863 /* @func ensProteinalignfeatureadaptorGetBaseadaptor **************************
3864 **
3865 ** Get the Ensembl Base Adaptor member of an
3866 ** Ensembl Protein Align Feature Adaptor.
3867 **
3868 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
3869 ** Ensembl Protein Align Feature Adaptor
3870 **
3871 ** @return [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
3872 **
3873 ** @release 6.4.0
3874 ** @@
3875 ******************************************************************************/
3876
ensProteinalignfeatureadaptorGetBaseadaptor(EnsPProteinalignfeatureadaptor pafa)3877 EnsPBaseadaptor ensProteinalignfeatureadaptorGetBaseadaptor(
3878 EnsPProteinalignfeatureadaptor pafa)
3879 {
3880 return ensFeatureadaptorGetBaseadaptor(
3881 ensProteinalignfeatureadaptorGetFeatureadaptor(pafa));
3882 }
3883
3884
3885
3886
3887 /* @func ensProteinalignfeatureadaptorGetDatabaseadaptor **********************
3888 **
3889 ** Get the Ensembl Database Adaptor member of an
3890 ** Ensembl Protein Align Feature Adaptor.
3891 **
3892 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
3893 ** Ensembl Protein Align Feature Adaptor
3894 **
3895 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
3896 **
3897 ** @release 6.4.0
3898 ** @@
3899 ******************************************************************************/
3900
ensProteinalignfeatureadaptorGetDatabaseadaptor(EnsPProteinalignfeatureadaptor pafa)3901 EnsPDatabaseadaptor ensProteinalignfeatureadaptorGetDatabaseadaptor(
3902 EnsPProteinalignfeatureadaptor pafa)
3903 {
3904 return ensFeatureadaptorGetDatabaseadaptor(
3905 ensProteinalignfeatureadaptorGetFeatureadaptor(pafa));
3906 }
3907
3908
3909
3910
3911 /* @func ensProteinalignfeatureadaptorGetFeatureadaptor ***********************
3912 **
3913 ** Get the Ensembl Feature Adaptor member of an
3914 ** Ensembl Protein Align Feature Adaptor.
3915 **
3916 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
3917 ** Ensembl Protein Align Feature Adaptor
3918 **
3919 ** @return [EnsPFeatureadaptor] Ensembl Feature Adaptor or NULL
3920 **
3921 ** @release 6.5.0
3922 ** @@
3923 ******************************************************************************/
3924
ensProteinalignfeatureadaptorGetFeatureadaptor(EnsPProteinalignfeatureadaptor pafa)3925 EnsPFeatureadaptor ensProteinalignfeatureadaptorGetFeatureadaptor(
3926 EnsPProteinalignfeatureadaptor pafa)
3927 {
3928 return pafa;
3929 }
3930
3931
3932
3933
3934 /* @section object retrieval **************************************************
3935 **
3936 ** Functions for fetching Ensembl Base Align Feature objects (type protein)
3937 ** from an Ensembl SQL database.
3938 **
3939 ** @fdata [EnsPProteinalignfeatureadaptor]
3940 **
3941 ** @nam3rule Fetch
3942 ** Fetch Ensembl Base Align Feature object(s)
3943 ** @nam4rule All
3944 ** Fetch all Ensembl Base Align Feature objects
3945 ** @nam4rule Allby
3946 ** Fetch all Ensembl Base Align Feature objects matching a criterion
3947 ** @nam5rule Hitname Fetch all by hit name
3948 ** @nam5rule Hitunversioned Fetch all by unversioned hit name
3949 ** @nam5rule Slicecoverage Fetch all by an Ensembl Slice and sequence coverage
3950 ** @nam5rule Sliceexternaldatabasename
3951 ** Fetch all by an Ensembl Slice and Ensembl External Database name
3952 ** @nam5rule Sliceidentity Fetch all by an Ensembl Slice and sequence identity
3953 ** @nam4rule By
3954 ** Fetch one Ensembl Base Align Feature object matching a criterion
3955 ** @nam5rule Identifier Fetch by a SQL database-internal identifier
3956 **
3957 ** @argrule * pafa [EnsPProteinalignfeatureadaptor]
3958 ** Ensembl Protein Align Feature Adaptor
3959 ** @argrule AllbyHitname hitname [const AjPStr] Hit (target) sequence name
3960 ** @argrule AllbyHitname anname [const AjPStr] Ensembl Analysis name
3961 ** @argrule AllbyHitname bafs [AjPList]
3962 ** AJAX List of Ensembl Base Align Feature objects
3963 ** @argrule AllbyHitunversioned hitname [const AjPStr]
3964 ** Hit (target) sequence name
3965 ** @argrule AllbyHitunversioned anname [const AjPStr] Ensembl Analysis name
3966 ** @argrule AllbyHitunversioned bafs [AjPList]
3967 ** AJAX List of Ensembl Base Align Feature objects
3968 ** @argrule AllbySlicecoverage slice [EnsPSlice] Ensembl Slice
3969 ** @argrule AllbySlicecoverage coverage [float]
3970 ** Alignment target coverage threshold
3971 ** @argrule AllbySlicecoverage anname [const AjPStr] Ensembl Analysis name
3972 ** @argrule AllbySlicecoverage bafs [AjPList]
3973 ** AJAX List of Ensembl Base Align Feature objects
3974 ** @argrule AllbySliceexternaldatabasename slice [EnsPSlice] Ensembl Slice
3975 ** @argrule AllbySliceexternaldatabasename edbname [const AjPStr]
3976 ** Ensembl External Database name
3977 ** @argrule AllbySliceexternaldatabasename anname [const AjPStr]
3978 ** Ensembl Analysis name
3979 ** @argrule AllbySliceexternaldatabasename bafs [AjPList] AJAX List of
3980 ** Ensembl Base Align Feature objects
3981 ** @argrule AllbySliceidentity slice [EnsPSlice] Ensembl Slice
3982 ** @argrule AllbySliceidentity identity [float] Alignment identity threshold
3983 ** @argrule AllbySliceidentity anname [const AjPStr] Ensembl Analysis name
3984 ** @argrule AllbySliceidentity bafs [AjPList]
3985 ** AJAX List of Ensembl Base Align Feature objects
3986 ** @argrule ByIdentifier identifier [ajuint] SQL database-internal identifier
3987 ** @argrule ByIdentifier Pbaf [EnsPBasealignfeature*]
3988 ** Ensembl Base Align Feature address
3989 **
3990 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
3991 **
3992 ** @fcategory use
3993 ******************************************************************************/
3994
3995
3996
3997
3998 /* @func ensProteinalignfeatureadaptorFetchAllbyHitname ***********************
3999 **
4000 ** Fetch Ensembl Base Align Feature objects (type protein) via a hit name.
4001 **
4002 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
4003 ** Ensembl Protein Align Feature Adaptor
4004 ** @param [r] hitname [const AjPStr] Hit (target) sequence name
4005 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
4006 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
4007 **
4008 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4009 **
4010 ** @release 6.4.0
4011 ** @@
4012 ******************************************************************************/
4013
ensProteinalignfeatureadaptorFetchAllbyHitname(EnsPProteinalignfeatureadaptor pafa,const AjPStr hitname,const AjPStr anname,AjPList bafs)4014 AjBool ensProteinalignfeatureadaptorFetchAllbyHitname(
4015 EnsPProteinalignfeatureadaptor pafa,
4016 const AjPStr hitname,
4017 const AjPStr anname,
4018 AjPList bafs)
4019 {
4020 char *txthitname = NULL;
4021
4022 AjBool result = AJFALSE;
4023
4024 AjPStr constraint = NULL;
4025
4026 EnsPBaseadaptor ba = NULL;
4027
4028 if (!pafa)
4029 return ajFalse;
4030
4031 if (!hitname)
4032 return ajFalse;
4033
4034 if (!bafs)
4035 return ajFalse;
4036
4037 ba = ensProteinalignfeatureadaptorGetBaseadaptor(pafa);
4038
4039 ensBaseadaptorEscapeC(ba, &txthitname, hitname);
4040
4041 constraint = ajFmtStr("protein_align_feature.hit_name = '%s'", txthitname);
4042
4043 ajCharDel(&txthitname);
4044
4045 /* Add the Ensembl Analysis name constraint. */
4046
4047 if (anname && ajStrGetLen(anname))
4048 ensFeatureadaptorConstraintAppendAnalysisname(
4049 ensProteinalignfeatureadaptorGetFeatureadaptor(pafa),
4050 &constraint,
4051 anname);
4052
4053 result = ensBaseadaptorFetchAllbyConstraint(
4054 ba,
4055 constraint,
4056 (EnsPAssemblymapper) NULL,
4057 (EnsPSlice) NULL,
4058 bafs);
4059
4060 ajStrDel(&constraint);
4061
4062 return result;
4063 }
4064
4065
4066
4067
4068 /* @func ensProteinalignfeatureadaptorFetchAllbyHitunversioned ****************
4069 **
4070 ** Fetch all Ensembl Base Align Feature objects (type protein) via an
4071 ** unversioned hit name.
4072 **
4073 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
4074 ** Ensembl Protein Align Feature Adaptor
4075 ** @param [r] hitname [const AjPStr] Hit (target) sequence name
4076 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
4077 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
4078 **
4079 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4080 **
4081 ** @release 6.4.0
4082 ** @@
4083 ******************************************************************************/
4084
ensProteinalignfeatureadaptorFetchAllbyHitunversioned(EnsPProteinalignfeatureadaptor pafa,const AjPStr hitname,const AjPStr anname,AjPList bafs)4085 AjBool ensProteinalignfeatureadaptorFetchAllbyHitunversioned(
4086 EnsPProteinalignfeatureadaptor pafa,
4087 const AjPStr hitname,
4088 const AjPStr anname,
4089 AjPList bafs)
4090 {
4091 AjBool result = AJFALSE;
4092
4093 AjPStr constraint = NULL;
4094 AjPStr modhitname = NULL;
4095
4096 EnsPBaseadaptor ba = NULL;
4097
4098 if (!pafa)
4099 return ajFalse;
4100
4101 if (!hitname)
4102 return ajFalse;
4103
4104 if (!bafs)
4105 return ajFalse;
4106
4107 ba = ensProteinalignfeatureadaptorGetBaseadaptor(pafa);
4108
4109 ensBaseadaptorEscapeS(ba, &modhitname, hitname);
4110
4111 /* Escape expensive SQL wilcard characters. */
4112 ajStrExchangeCC(&modhitname, "_", "\\_");
4113
4114 constraint = ajFmtStr(
4115 "protein_align_feature.hit_name LIKE '%S.%%'",
4116 modhitname);
4117
4118 ajStrDel(&modhitname);
4119
4120 /* Add the Ensembl Analysis name constraint. */
4121
4122 if (anname && ajStrGetLen(anname))
4123 ensFeatureadaptorConstraintAppendAnalysisname(
4124 ensProteinalignfeatureadaptorGetFeatureadaptor(pafa),
4125 &constraint,
4126 anname);
4127
4128 result = ensBaseadaptorFetchAllbyConstraint(
4129 ba,
4130 constraint,
4131 (EnsPAssemblymapper) NULL,
4132 (EnsPSlice) NULL,
4133 bafs);
4134
4135 ajStrDel(&constraint);
4136
4137 return result;
4138 }
4139
4140
4141
4142
4143 /* @func ensProteinalignfeatureadaptorFetchAllbySlicecoverage *****************
4144 **
4145 ** Fetch Ensembl Base Align Feature objects (type protein) via an
4146 ** Ensembl Slice and an alignment target coverage.
4147 **
4148 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
4149 ** Ensembl Protein Align Feature Adaptor
4150 ** @param [u] slice [EnsPSlice] Ensembl Slice
4151 ** @param [r] coverage [float] Alignment target coverage threshold
4152 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
4153 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
4154 **
4155 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4156 **
4157 ** @release 6.4.0
4158 ** @@
4159 ******************************************************************************/
4160
ensProteinalignfeatureadaptorFetchAllbySlicecoverage(EnsPProteinalignfeatureadaptor pafa,EnsPSlice slice,float coverage,const AjPStr anname,AjPList bafs)4161 AjBool ensProteinalignfeatureadaptorFetchAllbySlicecoverage(
4162 EnsPProteinalignfeatureadaptor pafa,
4163 EnsPSlice slice,
4164 float coverage,
4165 const AjPStr anname,
4166 AjPList bafs)
4167 {
4168 AjBool result = AJFALSE;
4169
4170 AjPStr constraint = NULL;
4171
4172 if (!pafa)
4173 return ajFalse;
4174
4175 if (!slice)
4176 return ajFalse;
4177
4178 if (!bafs)
4179 return ajFalse;
4180
4181 if (coverage > 0.0F)
4182 constraint = ajFmtStr(
4183 "protein_align_feature.hcoverage > %f",
4184 coverage);
4185
4186 result = ensFeatureadaptorFetchAllbySlice(
4187 ensProteinalignfeatureadaptorGetFeatureadaptor(pafa),
4188 slice,
4189 constraint,
4190 anname,
4191 bafs);
4192
4193 ajStrDel(&constraint);
4194
4195 return result;
4196 }
4197
4198
4199
4200
4201 /* @func ensProteinalignfeatureadaptorFetchAllbySliceexternaldatabasename *****
4202 **
4203 ** Fetch Ensembl Base Align Feature objects (type protein) via an
4204 ** Ensembl Slice and an Ensembl External Database name.
4205 **
4206 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
4207 ** Ensembl Protein Align Feature Adaptor
4208 ** @param [u] slice [EnsPSlice] Ensembl Slice
4209 ** @param [r] edbname [const AjPStr] Ensembl External Database name
4210 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
4211 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
4212 **
4213 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4214 **
4215 ** @release 6.4.0
4216 ** @@
4217 ******************************************************************************/
4218
ensProteinalignfeatureadaptorFetchAllbySliceexternaldatabasename(EnsPProteinalignfeatureadaptor pafa,EnsPSlice slice,const AjPStr edbname,const AjPStr anname,AjPList bafs)4219 AjBool ensProteinalignfeatureadaptorFetchAllbySliceexternaldatabasename(
4220 EnsPProteinalignfeatureadaptor pafa,
4221 EnsPSlice slice,
4222 const AjPStr edbname,
4223 const AjPStr anname,
4224 AjPList bafs)
4225 {
4226 char *txtname = NULL;
4227
4228 AjBool result = AJFALSE;
4229
4230 AjPStr constraint = NULL;
4231
4232 EnsPFeatureadaptor fa = NULL;
4233
4234 if (!pafa)
4235 return ajFalse;
4236
4237 if (!slice)
4238 return ajFalse;
4239
4240 if (!edbname)
4241 return ajFalse;
4242
4243 if (!bafs)
4244 return ajFalse;
4245
4246 fa = ensProteinalignfeatureadaptorGetFeatureadaptor(pafa);
4247
4248 ensFeatureadaptorEscapeC(fa, &txtname, edbname);
4249
4250 constraint = ajFmtStr("external_db.db_name = %s", txtname);
4251
4252 ajCharDel(&txtname);
4253
4254 result = ensFeatureadaptorFetchAllbySlice(
4255 fa,
4256 slice,
4257 constraint,
4258 anname,
4259 bafs);
4260
4261 ajStrDel(&constraint);
4262
4263 return result;
4264 }
4265
4266
4267
4268
4269 /* @func ensProteinalignfeatureadaptorFetchAllbySliceidentity *****************
4270 **
4271 ** Fetch Ensembl Base Align Feature objects (type protein) via an
4272 ** Ensembl Slice and an alignment identity threshold.
4273 **
4274 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
4275 ** Ensembl Protein Align Feature Adaptor
4276 ** @param [u] slice [EnsPSlice] Ensembl Slice
4277 ** @param [r] identity [float] Alignment identity threshold
4278 ** @param [rN] anname [const AjPStr] Ensembl Analysis name
4279 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
4280 **
4281 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4282 **
4283 ** @release 6.4.0
4284 ** @@
4285 ******************************************************************************/
4286
ensProteinalignfeatureadaptorFetchAllbySliceidentity(EnsPProteinalignfeatureadaptor pafa,EnsPSlice slice,float identity,const AjPStr anname,AjPList bafs)4287 AjBool ensProteinalignfeatureadaptorFetchAllbySliceidentity(
4288 EnsPProteinalignfeatureadaptor pafa,
4289 EnsPSlice slice,
4290 float identity,
4291 const AjPStr anname,
4292 AjPList bafs)
4293 {
4294 AjBool result = AJFALSE;
4295
4296 AjPStr constraint = NULL;
4297
4298 if (!pafa)
4299 return ajFalse;
4300
4301 if (!slice)
4302 return ajFalse;
4303
4304 if (!bafs)
4305 return ajFalse;
4306
4307 if (identity > 0.0F)
4308 constraint = ajFmtStr(
4309 "protein_align_feature.perc_ident > %f",
4310 identity);
4311
4312 result = ensFeatureadaptorFetchAllbySlice(
4313 ensProteinalignfeatureadaptorGetFeatureadaptor(pafa),
4314 slice,
4315 constraint,
4316 anname,
4317 bafs);
4318
4319 ajStrDel(&constraint);
4320
4321 return result;
4322 }
4323
4324
4325
4326
4327 /* @func ensProteinalignfeatureadaptorFetchByIdentifier ***********************
4328 **
4329 ** Fetch an Ensembl Base Align Feature (type protein) via its
4330 ** SQL database-internal identifier.
4331 **
4332 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
4333 ** Ensembl Protein Align Feature Adaptor
4334 ** @param [r] identifier [ajuint] SQL database-internal identifier
4335 ** @param [wP] Pbaf [EnsPBasealignfeature*] Ensembl Base Align Feature address
4336 **
4337 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4338 **
4339 ** @release 6.2.0
4340 ** @@
4341 ******************************************************************************/
4342
ensProteinalignfeatureadaptorFetchByIdentifier(EnsPProteinalignfeatureadaptor pafa,ajuint identifier,EnsPBasealignfeature * Pbaf)4343 AjBool ensProteinalignfeatureadaptorFetchByIdentifier(
4344 EnsPProteinalignfeatureadaptor pafa,
4345 ajuint identifier,
4346 EnsPBasealignfeature *Pbaf)
4347 {
4348 return ensBaseadaptorFetchByIdentifier(
4349 ensProteinalignfeatureadaptorGetBaseadaptor(pafa),
4350 identifier,
4351 (void **) Pbaf);
4352 }
4353
4354
4355
4356
4357 /* @section accessory object retrieval ****************************************
4358 **
4359 ** Functions for retrieving objects releated to Ensembl Base Align Feature
4360 ** objects (type protein) from an Ensembl SQL database.
4361 **
4362 ** @fdata [EnsPProteinalignfeatureadaptor]
4363 **
4364 ** @nam3rule Retrieve Retrieve Ensembl Base Align Feature-releated object(s)
4365 ** @nam4rule All Retrieve all Ensembl Base Align Feature-releated objects
4366 ** @nam5rule Identifiers Retrieve all SQL database-internal identifier objects
4367 **
4368 ** @argrule * pafa [EnsPProteinalignfeatureadaptor]
4369 ** Ensembl Protein Align Feature Adaptor
4370 ** @argrule AllIdentifiers identifiers [AjPList]
4371 ** AJAX List of AJAX unsigned integer objects
4372 **
4373 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
4374 **
4375 ** @fcategory use
4376 ******************************************************************************/
4377
4378
4379
4380
4381 /* @func ensProteinalignfeatureadaptorRetrieveAllIdentifiers ******************
4382 **
4383 ** Retrieve all SQL database-internal identifier objects of
4384 ** Ensembl Base Align Feature objects.
4385 **
4386 ** @param [u] pafa [EnsPProteinalignfeatureadaptor]
4387 ** Ensembl Protein Align Feature Adaptor
4388 ** @param [u] identifiers [AjPList] AJAX List of AJAX unsigned integer objects
4389 **
4390 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4391 **
4392 ** @release 6.4.0
4393 ** @@
4394 ******************************************************************************/
4395
ensProteinalignfeatureadaptorRetrieveAllIdentifiers(EnsPProteinalignfeatureadaptor pafa,AjPList identifiers)4396 AjBool ensProteinalignfeatureadaptorRetrieveAllIdentifiers(
4397 EnsPProteinalignfeatureadaptor pafa,
4398 AjPList identifiers)
4399 {
4400 AjBool result = AJFALSE;
4401
4402 AjPStr table = NULL;
4403
4404 if (!pafa)
4405 return ajFalse;
4406
4407 if (!identifiers)
4408 return ajFalse;
4409
4410 table = ajStrNewC("protein_align_feature");
4411
4412 result = ensBaseadaptorRetrieveAllIdentifiers(
4413 ensProteinalignfeatureadaptorGetBaseadaptor(pafa),
4414 table,
4415 (AjPStr) NULL,
4416 identifiers);
4417
4418 ajStrDel(&table);
4419
4420 return result;
4421 }
4422
4423
4424
4425
4426 /* @datasection [EnsPSupportingfeatureadaptor]
4427 ** Ensembl Supporting Feature Adaptor
4428 **
4429 ** @nam2rule Supportingfeatureadaptor Functions for manipulating
4430 ** Ensembl Supporting Feature Adaptor objects
4431 **
4432 ** @cc Bio::EnsEMBL::DBSQL::SupportingFeatureAdaptor
4433 ** @cc CVS Revision: 1.22
4434 ** @cc CVS Tag: branch-ensembl-68
4435 **
4436 ******************************************************************************/
4437
4438
4439
4440
4441 /* @section member retrieval **************************************************
4442 **
4443 ** Functions for returning members of an
4444 ** Ensembl Supporting Feature Adaptor object.
4445 **
4446 ** @fdata [EnsPSupportingfeatureadaptor]
4447 **
4448 ** @nam3rule Get Return Ensembl Supporting Feature Adaptor attribute(s)
4449 ** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
4450 **
4451 ** @argrule * sfa [EnsPSupportingfeatureadaptor]
4452 ** Ensembl Supporting Feature Adaptor
4453 **
4454 ** @valrule Databaseadaptor [EnsPDatabaseadaptor]
4455 ** Ensembl Database Adaptor or NULL
4456 **
4457 ** @fcategory use
4458 ******************************************************************************/
4459
4460
4461
4462
4463 /* @func ensSupportingfeatureadaptorGetDatabaseadaptor ************************
4464 **
4465 ** Get the Ensembl Database Adaptor member of an
4466 ** Ensembl Supporting Feature Adaptor.
4467 **
4468 ** @param [u] sfa [EnsPSupportingfeatureadaptor]
4469 ** Ensembl Supporting Feature Adaptor
4470 **
4471 ** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
4472 **
4473 ** @release 6.5.0
4474 ** @@
4475 ******************************************************************************/
4476
ensSupportingfeatureadaptorGetDatabaseadaptor(EnsPSupportingfeatureadaptor sfa)4477 EnsPDatabaseadaptor ensSupportingfeatureadaptorGetDatabaseadaptor(
4478 EnsPSupportingfeatureadaptor sfa)
4479 {
4480 return sfa;
4481 }
4482
4483
4484
4485
4486 /* @section object retrieval **************************************************
4487 **
4488 ** Functions for fetching Ensembl Base Align Feature objects from an
4489 ** Ensembl SQL database.
4490 **
4491 ** @fdata [EnsPSupportingfeatureadaptor]
4492 **
4493 ** @nam3rule Fetch Fetch Ensembl Base Align Feature object(s)
4494 ** @nam4rule FetchAll Fetch all Ensembl Base Align Feature objects
4495 ** @nam4rule FetchAllby Fetch all Ensembl Base Align Feature objects
4496 ** matching a criterion
4497 ** @nam5rule Exon Fetch all Ensembl Base Align Feature objects
4498 ** by an Ensembl Exon
4499 ** @nam5rule Transcript Fetch all Ensembl Base Align Feature objects
4500 ** by an Ensembl Transcript
4501 ** @nam4rule FetchBy Fetch one Ensembl Base Align Feature object
4502 ** matching a criterion
4503 **
4504 ** @argrule * sfa [EnsPSupportingfeatureadaptor]
4505 ** Ensembl Supporting Feature Adaptor
4506 ** @argrule Exon exon [EnsPExon] Ensembl Exon
4507 ** @argrule Transcript transcript [EnsPTranscript] Ensembl Transcript
4508 ** @argrule Allby bafs [AjPList]
4509 ** AJAX List of Ensembl Base Align Feature objects
4510 **
4511 ** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
4512 **
4513 ** @fcategory use
4514 ******************************************************************************/
4515
4516
4517
4518
4519 /* @func ensSupportingfeatureadaptorFetchAllbyExon ****************************
4520 **
4521 ** Fetch all supporting Ensembl Base Align Feature objects via an Ensembl Exon.
4522 **
4523 ** @param [u] sfa [EnsPSupportingfeatureadaptor]
4524 ** Ensembl Supporting Feature Adaptor
4525 ** @param [u] exon [EnsPExon] Ensembl Exon
4526 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
4527 **
4528 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4529 **
4530 ** @release 6.4.0
4531 ** @@
4532 ******************************************************************************/
4533
ensSupportingfeatureadaptorFetchAllbyExon(EnsPSupportingfeatureadaptor sfa,EnsPExon exon,AjPList bafs)4534 AjBool ensSupportingfeatureadaptorFetchAllbyExon(
4535 EnsPSupportingfeatureadaptor sfa,
4536 EnsPExon exon,
4537 AjPList bafs)
4538 {
4539 ajuint identifier = 0U;
4540
4541 AjPSqlstatement sqls = NULL;
4542 AjISqlrow sqli = NULL;
4543 AjPSqlrow sqlr = NULL;
4544
4545 AjPStr statement = NULL;
4546 AjPStr type = NULL;
4547
4548 EnsPDatabaseadaptor dba = NULL;
4549
4550 EnsPFeature efeature = NULL;
4551 EnsPFeature nfeature = NULL;
4552 EnsPFeature ofeature = NULL;
4553
4554 EnsPSlice eslice = NULL;
4555
4556 EnsPBasealignfeature baf = NULL;
4557
4558 EnsPDnaalignfeatureadaptor dafa = NULL;
4559
4560 EnsPProteinalignfeatureadaptor pafa = NULL;
4561
4562 if (!sfa)
4563 return ajFalse;
4564
4565 if (!exon)
4566 return ajFalse;
4567
4568 if (!bafs)
4569 return ajFalse;
4570
4571 if (ensExonGetIdentifier(exon) == 0)
4572 {
4573 ajDebug("ensSupportingfeatureadaptorFetchAllbyExon cannot get "
4574 "supporting Ensembl Base Align Feature objects for an "
4575 "Ensembl Exon without an identifier.\n");
4576
4577 return ajFalse;
4578 }
4579
4580 dba = ensSupportingfeatureadaptorGetDatabaseadaptor(sfa);
4581
4582 dafa = ensRegistryGetDnaalignfeatureadaptor(dba);
4583 pafa = ensRegistryGetProteinalignfeatureadaptor(dba);
4584
4585 efeature = ensExonGetFeature(exon);
4586
4587 eslice = ensFeatureGetSlice(efeature);
4588
4589 statement = ajFmtStr(
4590 "SELECT "
4591 "supporting_feature.feature_type, "
4592 "supporting_feature.feature_id "
4593 "FROM "
4594 "supporting_feature "
4595 "WHERE "
4596 "supporting_feature.exon_id = %u",
4597 ensExonGetIdentifier(exon));
4598
4599 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
4600
4601 sqli = ajSqlrowiterNew(sqls);
4602
4603 while (!ajSqlrowiterDone(sqli))
4604 {
4605 type = ajStrNew();
4606 identifier = 0U;
4607
4608 sqlr = ajSqlrowiterGet(sqli);
4609
4610 ajSqlcolumnToStr(sqlr, &type);
4611 ajSqlcolumnToUint(sqlr, &identifier);
4612
4613 if (ajStrMatchC(type, "dna_align_feature"))
4614 ensDnaalignfeatureadaptorFetchByIdentifier(
4615 dafa,
4616 identifier,
4617 &baf);
4618 else if (ajStrMatchC(type, "protein_align_feature"))
4619 ensProteinalignfeatureadaptorFetchByIdentifier(
4620 pafa,
4621 identifier,
4622 &baf);
4623 else
4624 ajWarn("ensSupportingfeatureadaptorFetchAllbyExon got "
4625 "unexpected value in supporting_feature.feature_type "
4626 "'%S'.\n", type);
4627
4628 if (baf)
4629 {
4630 ofeature = ensFeaturepairGetSourceFeature(baf->Featurepair);
4631
4632 nfeature = ensFeatureTransfer(ofeature, eslice);
4633
4634 ensFeaturepairSetSourceFeature(baf->Featurepair, nfeature);
4635
4636 ensFeatureDel(&nfeature);
4637
4638 ajListPushAppend(bafs, (void *) baf);
4639 }
4640 else
4641 ajDebug("ensSupportingfeatureadaptorFetchAllbyExon could not "
4642 "retrieve Supporting feature of type '%S' and "
4643 "identifier %u from database.\n", type, identifier);
4644
4645 ajStrDel(&type);
4646 }
4647
4648 ajSqlrowiterDel(&sqli);
4649
4650 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
4651
4652 ajStrDel(&statement);
4653
4654 return ajTrue;
4655 }
4656
4657
4658
4659
4660 /* @func ensSupportingfeatureadaptorFetchAllbyTranscript **********************
4661 **
4662 ** Fetch Ensembl Supporting Feature objects via an Ensembl Transcript.
4663 **
4664 ** @param [u] sfa [EnsPSupportingfeatureadaptor]
4665 ** Ensembl Supporting Feature Adaptor
4666 ** @param [u] transcript [EnsPTranscript] Ensembl Transcript
4667 ** @param [u] bafs [AjPList] AJAX List of Ensembl Base Align Feature objects
4668 **
4669 ** @return [AjBool] ajTrue upon success, ajFalse otherwise
4670 **
4671 ** @release 6.4.0
4672 ** @@
4673 ******************************************************************************/
4674
ensSupportingfeatureadaptorFetchAllbyTranscript(EnsPSupportingfeatureadaptor sfa,EnsPTranscript transcript,AjPList bafs)4675 AjBool ensSupportingfeatureadaptorFetchAllbyTranscript(
4676 EnsPSupportingfeatureadaptor sfa,
4677 EnsPTranscript transcript,
4678 AjPList bafs)
4679 {
4680 ajuint identifier = 0U;
4681
4682 AjPSqlstatement sqls = NULL;
4683 AjISqlrow sqli = NULL;
4684 AjPSqlrow sqlr = NULL;
4685
4686 AjPStr statement = NULL;
4687 AjPStr type = NULL;
4688
4689 EnsPFeature tfeature = NULL;
4690 EnsPFeature nfeature = NULL;
4691 EnsPFeature ofeature = NULL;
4692
4693 EnsPSlice tslice = NULL;
4694
4695 EnsPBasealignfeature baf = NULL;
4696
4697 EnsPDatabaseadaptor dba = NULL;
4698
4699 EnsPDnaalignfeatureadaptor dafa = NULL;
4700
4701 EnsPProteinalignfeatureadaptor pafa = NULL;
4702
4703 if (!sfa)
4704 return ajFalse;
4705
4706 if (!transcript)
4707 return ajFalse;
4708
4709 if (!bafs)
4710 return ajFalse;
4711
4712 if (!ensTranscriptGetIdentifier(transcript))
4713 {
4714 ajDebug("ensSupportingfeatureadaptorFetchAllbyTranscript cannot get "
4715 "Ensembl Supporting Feature objects for an Ensembl Transcript "
4716 "without an identifier.\n");
4717
4718 return ajFalse;
4719 }
4720
4721 dba = ensSupportingfeatureadaptorGetDatabaseadaptor(sfa);
4722
4723 dafa = ensRegistryGetDnaalignfeatureadaptor(dba);
4724 pafa = ensRegistryGetProteinalignfeatureadaptor(dba);
4725
4726 tfeature = ensTranscriptGetFeature(transcript);
4727
4728 tslice = ensFeatureGetSlice(tfeature);
4729
4730 statement = ajFmtStr(
4731 "SELECT "
4732 "transcript_supporting_feature.feature_type, "
4733 "transcript_supporting_feature.feature_id "
4734 "FROM "
4735 "transcript_supporting_feature "
4736 "WHERE "
4737 "transcript_supporting_feature.transcript_id = %u",
4738 ensTranscriptGetIdentifier(transcript));
4739
4740 sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);
4741
4742 sqli = ajSqlrowiterNew(sqls);
4743
4744 while (!ajSqlrowiterDone(sqli))
4745 {
4746 type = ajStrNew();
4747 identifier = 0U;
4748
4749 sqlr = ajSqlrowiterGet(sqli);
4750
4751 ajSqlcolumnToStr(sqlr, &type);
4752 ajSqlcolumnToUint(sqlr, &identifier);
4753
4754 if (ajStrMatchC(type, "dna_align_feature"))
4755 ensDnaalignfeatureadaptorFetchByIdentifier(
4756 dafa,
4757 identifier,
4758 &baf);
4759 else if (ajStrMatchC(type, "protein_align_feature"))
4760 ensProteinalignfeatureadaptorFetchByIdentifier(
4761 pafa,
4762 identifier,
4763 &baf);
4764 else
4765 ajWarn("ensSupportingfeatureadaptorFetchAllbyTranscript got "
4766 "unexpected value in "
4767 "transcript_supporting_feature.feature_type '%S'.\n", type);
4768
4769 if (baf)
4770 {
4771 ofeature = ensFeaturepairGetSourceFeature(baf->Featurepair);
4772
4773 nfeature = ensFeatureTransfer(ofeature, tslice);
4774
4775 ensFeaturepairSetSourceFeature(baf->Featurepair, nfeature);
4776
4777 ensFeatureDel(&nfeature);
4778
4779 ajListPushAppend(bafs, (void *) baf);
4780 }
4781 else
4782 ajDebug("ensSupportingfeatureadaptorFetchAllbyTranscript could "
4783 "not fetch Supporting feature of type '%S' and "
4784 "identifier %u from database.\n", type, identifier);
4785
4786 ajStrDel(&type);
4787 }
4788
4789 ajSqlrowiterDel(&sqli);
4790
4791 ensDatabaseadaptorSqlstatementDel(dba, &sqls);
4792
4793 ajStrDel(&statement);
4794
4795 return ajTrue;
4796 }
4797