src/jalview/analysis/CrossRef.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.analysis;
  22
  23 import jalview.datamodel.AlignedCodonFrame;
  24 import jalview.datamodel.Alignment;
  25 import jalview.datamodel.AlignmentI;
  26 import jalview.datamodel.DBRefEntry;
  27 import jalview.datamodel.DBRefSource;
  28 import jalview.datamodel.Mapping;
  29 import jalview.datamodel.Sequence;
  30 import jalview.datamodel.SequenceFeature;
  31 import jalview.datamodel.SequenceI;
  32 import jalview.util.DBRefUtils;
  33 import jalview.util.MapList;
  34 import jalview.ws.SequenceFetcher;
  35 import jalview.ws.seqfetcher.ASequenceFetcher;
  36
  37 import java.util.ArrayList;
  38 import java.util.List;
  39 import java.util.Vector;
  40
  41 /**
  42  * Functions for cross-referencing sequence databases. user must first specify
  43  * if cross-referencing from protein or dna (set dna==true)
  44  *
  45  * @author JimP
  46  *
  47  */
  48 public class CrossRef
  49 {
  50   /*
  51    * A sub-class that ignores Parent attribute when comparing sequence
  52    * features. This avoids 'duplicate' CDS features that only
  53    * differ in their parent Transcript ids.
  54    */
  55   class MySequenceFeature extends SequenceFeature
  56   {
  57     private SequenceFeature feat;
  58
  59     MySequenceFeature(SequenceFeature sf)
  60     {
  61       this.feat = sf;
  62     }
  63
  64     @Override
  65     public boolean equals(Object o)
  66     {
  67       return feat.equals(o, true);
  68     }
  69   }
  70
  71   /**
  72    * Select just the DNA or protein references for a protein or dna sequence
  73    *
  74    * @param fromDna
  75    *          if true, select references from DNA (i.e. Protein databases), else
  76    *          DNA database references
  77    * @param refs
  78    *          a set of references to select from
  79    * @return
  80    */
  81   public static DBRefEntry[] findXDbRefs(boolean fromDna, DBRefEntry[] refs)
  82   {
  83     return DBRefUtils.selectRefs(refs, fromDna ? DBRefSource.PROTEINDBS
  84             : DBRefSource.DNACODINGDBS);
  85     // could attempt to find other cross
  86     // refs here - ie PDB xrefs
  87     // (not dna, not protein seq)
  88   }
  89
  90   /**
  91    * @param dna
  92    *          true if seqs are DNA seqs
  93    * @param seqs
  94    * @return a list of sequence database cross reference source types
  95    */
  96   public static String[] findSequenceXrefTypes(boolean dna, SequenceI[] seqs)
  97   {
  98     return findSequenceXrefTypes(dna, seqs, null);
  99   }
 100
 101   /**
 102    * Indirect references are references from other sequences from the dataset to
 103    * any of the direct DBRefEntrys on the given sequences.
 104    *
 105    * @param dna
 106    *          true if seqs are DNA seqs
 107    * @param seqs
 108    * @return a list of sequence database cross reference source types
 109    */
 110   public static String[] findSequenceXrefTypes(boolean dna,
 111           SequenceI[] seqs, AlignmentI dataset)
 112   {
 113     String[] dbrefs = null;
 114     List<String> refs = new ArrayList<String>();
 115     for (SequenceI seq : seqs)
 116     {
 117       if (seq != null)
 118       {
 119         SequenceI dss = seq;
 120         while (dss.getDatasetSequence() != null)
 121         {
 122           dss = dss.getDatasetSequence();
 123         }
 124         DBRefEntry[] rfs = findXDbRefs(dna, dss.getDBRefs());
 125         if (rfs != null)
 126         {
 127           for (DBRefEntry ref : rfs)
 128           {
 129             if (!refs.contains(ref.getSource()))
 130             {
 131               refs.add(ref.getSource());
 132             }
 133           }
 134         }
 135         if (dataset != null)
 136         {
 137           // search for references to this sequence's direct references.
 138           DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seq.getDBRefs());
 139           List<SequenceI> rseqs = new ArrayList<SequenceI>();
 140           CrossRef.searchDatasetXrefs(seq, !dna, lrfs, dataset, rseqs,
 141                   null); // don't need to specify codon frame for mapping here
 142           for (SequenceI rs : rseqs)
 143           {
 144             DBRefEntry[] xrs = findXDbRefs(dna, rs.getDBRefs());
 145             if (xrs != null)
 146             {
 147               for (DBRefEntry ref : xrs)
 148               {
 149                 if (!refs.contains(ref.getSource()))
 150                 {
 151                   refs.add(ref.getSource());
 152                 }
 153               }
 154             }
 155             // looks like copy and paste - change rfs to xrs?
 156             // for (int r = 0; rfs != null && r < rfs.length; r++)
 157             // {
 158             // if (!refs.contains(rfs[r].getSource()))
 159             // {
 160             // refs.add(rfs[r].getSource());
 161             // }
 162             // }
 163           }
 164         }
 165       }
 166     }
 167     if (refs.size() > 0)
 168     {
 169       dbrefs = new String[refs.size()];
 170       refs.toArray(dbrefs);
 171     }
 172     return dbrefs;
 173   }
 174
 175   public static boolean hasCdnaMap(SequenceI[] seqs)
 176   {
 177     // TODO unused - remove?
 178     String[] reftypes = findSequenceXrefTypes(false, seqs);
 179     for (int s = 0; s < reftypes.length; s++)
 180     {
 181       if (reftypes.equals(DBRefSource.EMBLCDS))
 182       {
 183         return true;
 184         // no map
 185       }
 186     }
 187     return false;
 188   }
 189
 190   public static SequenceI[] getCdnaMap(SequenceI[] seqs)
 191   {
 192     // TODO unused - remove?
 193     Vector cseqs = new Vector();
 194     for (int s = 0; s < seqs.length; s++)
 195     {
 196       DBRefEntry[] cdna = findXDbRefs(true, seqs[s].getDBRefs());
 197       for (int c = 0; c < cdna.length; c++)
 198       {
 199         if (cdna[c].getSource().equals(DBRefSource.EMBLCDS))
 200         {
 201           System.err
 202                   .println("TODO: unimplemented sequence retrieval for coding region sequence.");
 203           // TODO: retrieve CDS dataset sequences
 204           // need global dataset sequence retriever/resolver to reuse refs
 205           // and construct Mapping entry.
 206           // insert gaps in CDS according to peptide gaps.
 207           // add gapped sequence to cseqs
 208         }
 209       }
 210     }
 211     if (cseqs.size() > 0)
 212     {
 213       SequenceI[] rsqs = new SequenceI[cseqs.size()];
 214       cseqs.copyInto(rsqs);
 215       return rsqs;
 216     }
 217     return null;
 218
 219   }
 220
 221   /**
 222    *
 223    * @param seqs
 224    *          sequences whose xrefs are being retrieved
 225    * @param dna
 226    *          true if sequences are nucleotide
 227    * @param source
 228    * @param al
 229    *          alignment to search for cross-referenced sequences (and possibly
 230    *          add to)
 231    * @param addedPeers
 232    *          a list of sequences to add to if 'peers' to the original sequences
 233    *          are found e.g. alternative protein products for a protein's gene
 234    * @return products (as dataset sequences)
 235    */
 236   public static Alignment findXrefSequences(SequenceI[] seqs,
 237           final boolean dna, final String source, AlignmentI al,
 238           List<SequenceI> addedPeers)
 239   {
 240     AlignmentI dataset = al.getDataset() == null ? al : al.getDataset();
 241     List<SequenceI> rseqs = new ArrayList<SequenceI>();
 242     AlignedCodonFrame cf = new AlignedCodonFrame();
 243     for (SequenceI seq : seqs)
 244     {
 245       SequenceI dss = seq;
 246       while (dss.getDatasetSequence() != null)
 247       {
 248         dss = dss.getDatasetSequence();
 249       }
 250       boolean found = false;
 251       DBRefEntry[] xrfs = CrossRef.findXDbRefs(dna, dss.getDBRefs());
 252       if ((xrfs == null || xrfs.length == 0) && dataset != null)
 253       {
 254         System.out.println("Attempting to find ds Xrefs refs.");
 255         // FIXME should be dss not seq here?
 256         DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seq.getDBRefs());
 257         // less ambiguous would be a 'find primary dbRefEntry' method.
 258         // filter for desired source xref here
 259         found = CrossRef.searchDatasetXrefs(dss, !dna, lrfs, dataset,
 260                 rseqs, cf);
 261       }
 262       for (int r = 0; xrfs != null && r < xrfs.length; r++)
 263       {
 264         DBRefEntry xref = xrfs[r];
 265         if (source != null && !source.equals(xref.getSource()))
 266         {
 267           continue;
 268         }
 269         if (xref.hasMap())
 270         {
 271           if (xref.getMap().getTo() != null)
 272           {
 273             SequenceI rsq = new Sequence(xref.getMap().getTo());
 274             rseqs.add(rsq);
 275             if (xref.getMap().getMap().getFromRatio() != xref
 276                     .getMap().getMap().getToRatio())
 277             {
 278               // get sense of map correct for adding to product alignment.
 279               if (dna)
 280               {
 281                 // map is from dna seq to a protein product
 282                 cf.addMap(dss, rsq, xref.getMap().getMap());
 283               }
 284               else
 285               {
 286                 // map should be from protein seq to its coding dna
 287                 cf.addMap(rsq, dss, xref.getMap().getMap().getInverse());
 288               }
 289             }
 290             found = true;
 291           }
 292         }
 293         if (!found)
 294         {
 295           // do a bit more work - search for sequences with references matching
 296           // xrefs on this sequence.
 297           if (dataset != null)
 298           {
 299             found |= searchDataset(dss, xref, dataset, rseqs, cf, false,
 300                     !dna);
 301             // ,false,!dna);
 302             if (found)
 303             {
 304               xrfs[r] = null; // we've recovered seqs for this one.
 305             }
 306           }
 307         }
 308       }
 309       if (!found)
 310       {
 311         if (xrfs != null && xrfs.length > 0)
 312         {
 313           // Try and get the sequence reference...
 314           /*
 315            * Ideal world - we ask for a sequence fetcher implementation here if
 316            * (jalview.io.RunTimeEnvironment.getSequenceFetcher()) (
 317            */
 318           ASequenceFetcher sftch = new SequenceFetcher();
 319           SequenceI[] retrieved = null;
 320           int l = xrfs.length;
 321           for (int r = 0; r < xrfs.length; r++)
 322           {
 323             // filter out any irrelevant or irretrievable references
 324             if (xrfs[r] == null
 325                     || ((source != null && !source.equals(xrfs[r]
 326                             .getSource())) || !sftch.isFetchable(xrfs[r]
 327                             .getSource())))
 328             {
 329               l--;
 330               xrfs[r] = null;
 331             }
 332           }
 333           if (l > 0)
 334           {
 335             System.out
 336                     .println("Attempting to retrieve cross referenced sequences.");
 337             DBRefEntry[] t = new DBRefEntry[l];
 338             l = 0;
 339             for (int r = 0; r < xrfs.length; r++)
 340             {
 341               if (xrfs[r] != null)
 342               {
 343                 t[l++] = xrfs[r];
 344               }
 345             }
 346             xrfs = t;
 347             try
 348             {
 349               retrieved = sftch.getSequences(xrfs, !dna);
 350               // problem here is we don't know which of xrfs resulted in which
 351               // retrieved element
 352             } catch (Exception e)
 353             {
 354               System.err
 355                       .println("Problem whilst retrieving cross references for Sequence : "
 356                               + seq.getName());
 357               e.printStackTrace();
 358             }
 359
 360             if (retrieved != null)
 361             {
 362               updateDbrefMappings(dna, seq, xrfs, retrieved, cf);
 363
 364               SequenceIdMatcher matcher = new SequenceIdMatcher(
 365                       dataset.getSequences());
 366               matcher.addAll(addedPeers);
 367               List<SequenceFeature> copiedFeatures = new ArrayList<SequenceFeature>();
 368               CrossRef me = new CrossRef();
 369               for (int rs = 0; rs < retrieved.length; rs++)
 370               {
 371                 // TODO: examine each sequence for 'redundancy'
 372                 DBRefEntry[] dbr = retrieved[rs].getDBRefs();
 373                 if (dbr != null && dbr.length > 0)
 374                 {
 375                   for (int di = 0; di < dbr.length; di++)
 376                   {
 377                     // find any entry where we should put in the sequence being
 378                     // cross-referenced into the map
 379                     Mapping map = dbr[di].getMap();
 380                     if (map != null)
 381                     {
 382                       if (map.getTo() != null && map.getMap() != null)
 383                       {
 384                         SequenceI matched = matcher
 385                                 .findIdMatch(map.getTo());
 386                         if (matched != null)
 387                         {
 388                           map.setTo(matched);
 389                         }
 390                         else
 391                         {
 392                           matcher.add(map.getTo());
 393                         }
 394                         try
 395                         {
 396                           // compare ms with dss and replace with dss in mapping
 397                           // if map is congruent
 398                           SequenceI ms = map.getTo();
 399                           int sf = map.getMap().getToLowest();
 400                           int st = map.getMap().getToHighest();
 401                           SequenceI mappedrg = ms.getSubSequence(sf, st);
 402                           // SequenceI loc = dss.getSubSequence(sf, st);
 403                           if (mappedrg.getLength() > 0
 404                                   && ms.getSequenceAsString().equals(
 405                                           dss.getSequenceAsString()))
 406                           // && mappedrg.getSequenceAsString().equals(
 407                           // loc.getSequenceAsString()))
 408                           {
 409                             String msg = "Mapping updated from "
 410                                     + ms.getName()
 411                                     + " to retrieved crossreference "
 412                                     + dss.getName();
 413                             System.out.println(msg);
 414                             // method to update all refs of existing To on
 415                             // retrieved sequence with dss and merge any props
 416                             // on To onto dss.
 417                             map.setTo(dss);
 418                             /*
 419                              * copy sequence features as well, avoiding
 420                              * duplication (e.g. from 2 transcripts)
 421                              */
 422                             SequenceFeature[] sfs = ms
 423                                     .getSequenceFeatures();
 424                             if (sfs != null)
 425                             {
 426                               for (SequenceFeature feat : sfs)
 427                               {
 428                                 /*
 429                                  * we override SequenceFeature.equals here (but
 430                                  * not elsewhere) to ignore Parent attribute
 431                                  * TODO not quite working yet!
 432                                  */
 433                                 if (!copiedFeatures
 434                                         .contains(me.new MySequenceFeature(
 435                                                 feat)))
 436                                 {
 437                                   dss.addSequenceFeature(feat);
 438                                   copiedFeatures.add(feat);
 439                                 }
 440                               }
 441                             }
 442                             cf.addMap(retrieved[rs].getDatasetSequence(),
 443                                     dss, map.getMap());
 444                           }
 445                           else
 446                           {
 447                             if (!addedPeers.contains(map.getTo()))
 448                             {
 449                               addedPeers.add(map.getTo());
 450                             }
 451                             cf.addMap(retrieved[rs].getDatasetSequence(),
 452                                     map.getTo(), map.getMap());
 453                           }
 454                         } catch (Exception e)
 455                         {
 456                           System.err
 457                                   .println("Exception when consolidating Mapped sequence set...");
 458                           e.printStackTrace(System.err);
 459                         }
 460                       }
 461                     }
 462                   }
 463                 }
 464                 retrieved[rs].updatePDBIds();
 465                 rseqs.add(retrieved[rs]);
 466               }
 467             }
 468           }
 469         }
 470       }
 471     }
 472
 473     Alignment ral = null;
 474     if (rseqs.size() > 0)
 475     {
 476       ral = new Alignment(rseqs.toArray(new SequenceI[rseqs.size()]));
 477       if (cf != null && !cf.isEmpty())
 478       {
 479         ral.addCodonFrame(cf);
 480       }
 481     }
 482     return ral;
 483   }
 484
 485   /**
 486    * Updates any empty mappings in the cross-references with one to a compatible
 487    * retrieved sequence if found, and adds any new mappings to the
 488    * AlignedCodonFrame
 489    *
 490    * @param dna
 491    * @param mapFrom
 492    * @param xrefs
 493    * @param retrieved
 494    * @param acf
 495    */
 496   static void updateDbrefMappings(boolean dna, SequenceI mapFrom,
 497           DBRefEntry[] xrefs, SequenceI[] retrieved, AlignedCodonFrame acf)
 498   {
 499     SequenceIdMatcher matcher = new SequenceIdMatcher(retrieved);
 500     for (DBRefEntry xref : xrefs)
 501     {
 502       if (!xref.hasMap())
 503       {
 504         String targetSeqName = xref.getSource() + "|"
 505                 + xref.getAccessionId();
 506         SequenceI[] matches = matcher.findAllIdMatches(targetSeqName);
 507         if (matches == null)
 508         {
 509           return;
 510         }
 511         for (SequenceI seq : matches)
 512         {
 513           MapList mapping = null;
 514           if (dna)
 515           {
 516             mapping = AlignmentUtils.mapCdnaToProtein(seq, mapFrom);
 517           }
 518           else
 519           {
 520             mapping = AlignmentUtils.mapCdnaToProtein(mapFrom, seq);
 521             if (mapping != null)
 522             {
 523               mapping = mapping.getInverse();
 524             }
 525           }
 526           if (mapping != null)
 527           {
 528             xref.setMap(new Mapping(seq, mapping));
 529             if (dna)
 530             {
 531               AlignmentUtils.computeProteinFeatures(mapFrom, seq, mapping);
 532             }
 533             if (dna)
 534             {
 535               acf.addMap(mapFrom, seq, mapping);
 536             }
 537             else
 538             {
 539               acf.addMap(seq, mapFrom, mapping.getInverse());
 540             }
 541             continue;
 542           }
 543         }
 544       }
 545     }
 546   }
 547
 548   /**
 549    * find references to lrfs in the cross-reference set of each sequence in
 550    * dataset (that is not equal to sequenceI) Identifies matching DBRefEntry
 551    * based on source and accession string only - Map and Version are nulled.
 552    *
 553    * @param sequenceI
 554    * @param lrfs
 555    * @param dataset
 556    * @param rseqs
 557    * @return true if matches were found.
 558    */
 559   private static boolean searchDatasetXrefs(SequenceI sequenceI,
 560           boolean dna, DBRefEntry[] lrfs, AlignmentI dataset,
 561           List<SequenceI> rseqs, AlignedCodonFrame cf)
 562   {
 563     boolean found = false;
 564     if (lrfs == null)
 565     {
 566       return false;
 567     }
 568     for (int i = 0; i < lrfs.length; i++)
 569     {
 570       DBRefEntry xref = new DBRefEntry(lrfs[i]);
 571       // add in wildcards
 572       xref.setVersion(null);
 573       xref.setMap(null);
 574       found = searchDataset(sequenceI, xref, dataset, rseqs, cf, false, dna);
 575     }
 576     return found;
 577   }
 578
 579   /**
 580    * search a given sequence dataset for references matching cross-references to
 581    * the given sequence
 582    *
 583    * @param sequenceI
 584    * @param xrf
 585    * @param dataset
 586    * @param rseqs
 587    *          set of unique sequences
 588    * @param cf
 589    * @return true if one or more unique sequences were found and added
 590    */
 591   public static boolean searchDataset(SequenceI sequenceI, DBRefEntry xrf,
 592           AlignmentI dataset, List<SequenceI> rseqs, AlignedCodonFrame cf)
 593   {
 594     return searchDataset(sequenceI, xrf, dataset, rseqs, cf, true, false);
 595   }
 596
 597   /**
 598    * TODO: generalise to different protein classifications Search dataset for
 599    * DBRefEntrys matching the given one (xrf) and add the associated sequence to
 600    * rseq.
 601    *
 602    * @param sequenceI
 603    * @param xrf
 604    * @param dataset
 605    * @param rseqs
 606    * @param direct
 607    *          - search all references or only subset
 608    * @param dna
 609    *          search dna or protein xrefs (if direct=false)
 610    * @return true if relationship found and sequence added.
 611    */
 612   public static boolean searchDataset(SequenceI sequenceI, DBRefEntry xrf,
 613           AlignmentI dataset, List<SequenceI> rseqs, AlignedCodonFrame cf,
 614           boolean direct, boolean dna)
 615   {
 616     boolean found = false;
 617     SequenceI[] typer = new SequenceI[1];
 618     if (dataset == null)
 619     {
 620       return false;
 621     }
 622     if (dataset.getSequences() == null)
 623     {
 624       System.err.println("Empty dataset sequence set - NO VECTOR");
 625       return false;
 626     }
 627     List<SequenceI> ds;
 628     synchronized (ds = dataset.getSequences())
 629     {
 630       for (SequenceI nxt : ds)
 631       {
 632         if (nxt != null)
 633         {
 634           if (nxt.getDatasetSequence() != null)
 635           {
 636             System.err
 637                     .println("Implementation warning: getProducts passed a dataset alignment without dataset sequences in it!");
 638           }
 639           if (nxt != sequenceI && nxt != sequenceI.getDatasetSequence())
 640           {
 641             // check if this is the correct sequence type
 642             {
 643               typer[0] = nxt;
 644               boolean isDna = jalview.util.Comparison.isNucleotide(typer);
 645               if ((direct && isDna == dna) || (!direct && isDna != dna))
 646               {
 647                 // skip this sequence because it is same molecule type
 648                 continue;
 649               }
 650             }
 651
 652             // look for direct or indirect references in common
 653             DBRefEntry[] poss = nxt.getDBRefs(), cands = null;
 654             if (direct)
 655             {
 656               cands = jalview.util.DBRefUtils.searchRefs(poss, xrf);
 657             }
 658             else
 659             {
 660               poss = CrossRef.findXDbRefs(dna, poss); //
 661               cands = jalview.util.DBRefUtils.searchRefs(poss, xrf);
 662             }
 663             if (cands != null)
 664             {
 665               if (!rseqs.contains(nxt))
 666               {
 667                 rseqs.add(nxt);
 668                 boolean foundmap = cf != null;
 669                 // don't search if we aren't given a codon map object
 670                 for (int r = 0; foundmap && r < cands.length; r++)
 671                 {
 672                   if (cands[r].hasMap())
 673                   {
 674                     if (cands[r].getMap().getTo() != null
 675                             && cands[r].getMap().getMap().getFromRatio() != cands[r]
 676                                     .getMap().getMap().getToRatio())
 677                     {
 678                       foundmap = true;
 679                       // get sense of map correct for adding to product
 680                       // alignment.
 681                       if (dna)
 682                       {
 683                         // map is from dna seq to a protein product
 684                         cf.addMap(sequenceI, nxt, cands[r].getMap()
 685                                 .getMap());
 686                       }
 687                       else
 688                       {
 689                         // map should be from protein seq to its coding dna
 690                         cf.addMap(nxt, sequenceI, cands[r].getMap()
 691                                 .getMap().getInverse());
 692                       }
 693                     }
 694                   }
 695                 }
 696                 // TODO: add mapping between sequences if necessary
 697                 found = true;
 698               }
 699             }
 700
 701           }
 702         }
 703       }
 704     }
 705     return found;
 706   }
 707
 708   /**
 709    * precalculate different products that can be found for seqs in dataset and
 710    * return them.
 711    *
 712    * @param dna
 713    * @param seqs
 714    * @param dataset
 715    * @param fake
 716    *          - don't actually build lists - just get types
 717    * @return public static Object[] buildXProductsList(boolean dna, SequenceI[]
 718    *         seqs, AlignmentI dataset, boolean fake) { String types[] =
 719    *         jalview.analysis.CrossRef.findSequenceXrefTypes( dna, seqs,
 720    *         dataset); if (types != null) { System.out.println("Xref Types for:
 721    *         "+(dna ? "dna" : "prot")); for (int t = 0; t < types.length; t++) {
 722    *         System.out.println("Type: " + types[t]); SequenceI[] prod =
 723    *         jalview.analysis.CrossRef.findXrefSequences(seqs, dna, types[t]);
 724    *         System.out.println("Found " + ((prod == null) ? "no" : "" +
 725    *         prod.length) + " products"); if (prod!=null) { for (int p=0;
 726    *         p<prod.length; p++) { System.out.println("Prod "+p+":
 727    *         "+prod[p].getDisplayId(true)); } } } } else {
 728    *         System.out.println("Trying getProducts for
 729    *         "+al.getSequenceAt(0).getDisplayId(true));
 730    *         System.out.println("Search DS Xref for: "+(dna ? "dna" : "prot"));
 731    *         // have a bash at finding the products amongst all the retrieved
 732    *         sequences. SequenceI[] prod =
 733    *         jalview.analysis.CrossRef.findXrefSequences(al
 734    *         .getSequencesArray(), dna, null, ds); System.out.println("Found " +
 735    *         ((prod == null) ? "no" : "" + prod.length) + " products"); if
 736    *         (prod!=null) { // select non-equivalent sequences from dataset list
 737    *         for (int p=0; p<prod.length; p++) { System.out.println("Prod "+p+":
 738    *         "+prod[p].getDisplayId(true)); } } } }
 739    */
 740 }