src/jalview/datamodel/SeqCigar.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
   3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
   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 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 package jalview.datamodel;
  19
  20 import java.util.Enumeration;
  21 import java.util.Hashtable;
  22
  23 import jalview.analysis.*;
  24 import jalview.util.*;
  25
  26 public class SeqCigar extends CigarSimple
  27 {
  28   /**
  29    * start(inclusive) and end(exclusive) of subsequence on refseq
  30    */
  31   private int start, end;
  32
  33   private SequenceI refseq = null;
  34
  35   private Hashtable seqProps;
  36
  37   /**
  38    * Reference dataset sequence for the cigar string
  39    *
  40    * @return SequenceI
  41    */
  42   public SequenceI getRefSeq()
  43   {
  44     return refseq;
  45   }
  46
  47   /**
  48    *
  49    * @return int start index of cigar ops on refSeq
  50    */
  51   public int getStart()
  52   {
  53     return start;
  54   }
  55
  56   /**
  57    *
  58    * @return int end index (exclusive) of cigar ops on refSeq
  59    */
  60   public int getEnd()
  61   {
  62     return end;
  63   }
  64
  65   /**
  66    * Returns sequence as a string with cigar operations applied to it
  67    *
  68    * @return String
  69    */
  70   public String getSequenceString(char GapChar)
  71   {
  72     return (length == 0) ? "" : (String) getSequenceAndDeletions(
  73             refseq.getSequenceAsString(start, end), GapChar)[0];
  74   }
  75
  76   /**
  77    * recreates a gapped and edited version of RefSeq or null for an empty cigar
  78    * string
  79    *
  80    * @return SequenceI
  81    */
  82   public SequenceI getSeq(char GapChar)
  83   {
  84     Sequence seq;
  85     if (refseq == null || length == 0)
  86     {
  87       return null;
  88     }
  89     Object[] edit_result = getSequenceAndDeletions(
  90             refseq.getSequenceAsString(start, end), GapChar);
  91     if (edit_result == null)
  92     {
  93       throw new Error(
  94               "Implementation Error - unexpected null from getSequenceAndDeletions");
  95     }
  96     int bounds[] = (int[]) edit_result[1];
  97     seq = new Sequence(refseq.getName(), (String) edit_result[0],
  98             refseq.getStart() + start + bounds[0], refseq.getStart()
  99                     + start + ((bounds[2] == 0) ? -1 : bounds[2]));
 100     seq.setDescription(refseq.getDescription());
 101     int sstart = seq.getStart(), send = seq.getEnd();
 102     // seq.checkValidRange(); probably not needed
 103     // recover local properties if present
 104     if (seqProps != null)
 105     {
 106       // this recovers dataset sequence reference as well as local features,
 107       // names, start/end settings.
 108       SeqsetUtils.SeqCharacterUnhash(seq, seqProps);
 109     }
 110     // ensure dataset sequence is up to date from local reference
 111     seq.setDatasetSequence(refseq);
 112     seq.setStart(sstart);
 113     seq.setEnd(send);
 114     return seq;
 115   }
 116
 117   /*
 118    * We don't allow this - refseq is given at construction time only public void
 119    * setSeq(SequenceI seq) { this.seq = seq; }
 120    */
 121   /**
 122    * internal constructor - sets seq to a gapless sequence derived from seq and
 123    * prepends any 'D' operations needed to get to the first residue of seq.
 124    *
 125    * @param seq
 126    *          SequenceI
 127    * @param initialDeletion
 128    *          true to mark initial dataset sequence residues as deleted in
 129    *          subsequence
 130    * @param _s
 131    *          index of first position in seq
 132    * @param _e
 133    *          index after last position in (possibly gapped) seq
 134    * @return true if gaps are present in seq
 135    */
 136   private boolean _setSeq(SequenceI seq, boolean initialDeletion, int _s,
 137           int _e)
 138   {
 139     boolean hasgaps = false;
 140     if (seq == null)
 141     {
 142       throw new Error("Implementation Error - _setSeq(null,...)");
 143     }
 144     if (_s < 0)
 145     {
 146       throw new Error("Implementation Error: _s=" + _s);
 147     }
 148     String seq_string = seq.getSequenceAsString();
 149     if (_e == 0 || _e < _s || _e > seq_string.length())
 150     {
 151       _e = seq_string.length();
 152     }
 153     // resolve start and end positions relative to ungapped reference sequence
 154     start = seq.findPosition(_s) - seq.getStart();
 155     end = seq.findPosition(_e) - seq.getStart();
 156     int l_ungapped = end - start;
 157     // Find correct sequence to reference and correct start and end - if
 158     // necessary
 159     SequenceI ds = seq.getDatasetSequence();
 160     if (ds == null)
 161     {
 162       // make a new dataset sequence
 163       String ungapped = AlignSeq.extractGaps(
 164               jalview.util.Comparison.GapChars, new String(seq_string));
 165       l_ungapped = ungapped.length();
 166       // check that we haven't just duplicated an ungapped sequence.
 167       if (l_ungapped == seq.getLength())
 168       {
 169         ds = seq;
 170       }
 171       else
 172       {
 173         ds = new Sequence(seq.getName(), ungapped, seq.getStart(),
 174                 seq.getStart() + ungapped.length() - 1);
 175         // JBPNote: this would be consistent but may not be useful
 176         // seq.setDatasetSequence(ds);
 177       }
 178     }
 179     // add in offset between seq and the dataset sequence
 180     if (ds.getStart() < seq.getStart())
 181     {
 182       int offset = seq.getStart() - ds.getStart();
 183       if (initialDeletion)
 184       {
 185         // absolute cigar string
 186         addDeleted(_s + offset);
 187         start = 0;
 188         end += offset;
 189       }
 190       else
 191       {
 192         // normal behaviour - just mark start and end subsequence
 193         start += offset;
 194         end += offset;
 195
 196       }
 197
 198     }
 199
 200     // any gaps to process ?
 201     if (l_ungapped != (_e - _s))
 202     {
 203       hasgaps = true;
 204     }
 205
 206     refseq = ds;
 207     // copy over local properties for the sequence instance of the refseq
 208     seqProps = SeqsetUtils.SeqCharacterHash(seq);
 209     // Check offsets
 210     if (end > ds.getLength())
 211     {
 212       throw new Error(
 213               "SeqCigar: Possible implementation error: sequence is longer than dataset sequence");
 214       // end = ds.getLength();
 215     }
 216
 217     return hasgaps;
 218   }
 219
 220   /**
 221    * directly initialise a cigar object with a sequence of range, operation
 222    * pairs and a sequence to apply it to. operation and range should be relative
 223    * to the seq.getStart()'th residue of the dataset seq resolved from seq.
 224    *
 225    * @param seq
 226    *          SequenceI
 227    * @param operation
 228    *          char[]
 229    * @param range
 230    *          int[]
 231    */
 232   public SeqCigar(SequenceI seq, char operation[], int range[])
 233   {
 234     super();
 235     if (seq == null)
 236     {
 237       throw new Error("Implementation Bug. Null seq !");
 238     }
 239     if (operation.length != range.length)
 240     {
 241       throw new Error(
 242               "Implementation Bug. Cigar Operation list!= range list");
 243     }
 244
 245     if (operation != null)
 246     {
 247       this.operation = new char[operation.length + _inc_length];
 248       this.range = new int[operation.length + _inc_length];
 249
 250       if (_setSeq(seq, false, 0, 0))
 251       {
 252         throw new Error(
 253                 "NOT YET Implemented: Constructing a Cigar object from a cigar string and a gapped sequence.");
 254       }
 255       for (int i = this.length, j = 0; j < operation.length; i++, j++)
 256       {
 257         char op = operation[j];
 258         if (op != M && op != I && op != D)
 259         {
 260           throw new Error("Implementation Bug. Cigar Operation '" + j
 261                   + "' '" + op + "' not one of '" + M + "', '" + I
 262                   + "', or '" + D + "'.");
 263         }
 264         this.operation[i] = op;
 265         this.range[i] = range[j];
 266       }
 267       this.length += operation.length;
 268     }
 269     else
 270     {
 271       this.operation = null;
 272       this.range = null;
 273       this.length = 0;
 274       if (_setSeq(seq, false, 0, 0))
 275       {
 276         throw new Error(
 277                 "NOT YET Implemented: Constructing a Cigar object from a cigar string and a gapped sequence.");
 278       }
 279     }
 280   }
 281
 282   /**
 283    * add range matched residues to cigar string
 284    *
 285    * @param range
 286    *          int
 287    */
 288   public void addMatch(int range)
 289   {
 290     this.addOperation(M, range);
 291   }
 292
 293   /**
 294    * Adds insertion and match operations based on seq to the cigar up to the
 295    * endpos column of seq.
 296    *
 297    * @param cigar
 298    *          CigarBase
 299    * @param seq
 300    *          SequenceI
 301    * @param startpos
 302    *          int
 303    * @param endpos
 304    *          int
 305    * @param initialDeletions
 306    *          if true then initial deletions will be added from start of seq to
 307    *          startpos
 308    */
 309   protected static void addSequenceOps(CigarBase cigar, SequenceI seq,
 310           int startpos, int endpos, boolean initialDeletions)
 311   {
 312     char op = '\0';
 313     int range = 0;
 314     int p = 0, res = seq.getLength();
 315
 316     if (!initialDeletions)
 317     {
 318       p = startpos;
 319     }
 320
 321     while (p <= endpos)
 322     {
 323       boolean isGap = (p < res) ? jalview.util.Comparison.isGap(seq
 324               .getCharAt(p)) : true;
 325       if ((startpos <= p) && (p <= endpos))
 326       {
 327         if (isGap)
 328         {
 329           if (range > 0 && op != I)
 330           {
 331             cigar.addOperation(op, range);
 332             range = 0;
 333           }
 334           op = I;
 335           range++;
 336         }
 337         else
 338         {
 339           if (range > 0 && op != M)
 340           {
 341             cigar.addOperation(op, range);
 342             range = 0;
 343           }
 344           op = M;
 345           range++;
 346         }
 347       }
 348       else
 349       {
 350         if (!isGap)
 351         {
 352           if (range > 0 && op != D)
 353           {
 354             cigar.addOperation(op, range);
 355             range = 0;
 356           }
 357           op = D;
 358           range++;
 359         }
 360         else
 361         {
 362           // do nothing - insertions are not made in flanking regions
 363         }
 364       }
 365       p++;
 366     }
 367     if (range > 0)
 368     {
 369       cigar.addOperation(op, range);
 370     }
 371   }
 372
 373   /**
 374    * create a cigar string for given sequence
 375    *
 376    * @param seq
 377    *          SequenceI
 378    */
 379   public SeqCigar(SequenceI seq)
 380   {
 381     super();
 382     if (seq == null)
 383     {
 384       throw new Error("Implementation error for new Cigar(SequenceI)");
 385     }
 386     _setSeq(seq, false, 0, 0);
 387     // there is still work to do
 388     addSequenceOps(this, seq, 0, seq.getLength() - 1, false);
 389   }
 390
 391   /**
 392    * Create Cigar from a range of gaps and residues on a sequence object
 393    *
 394    * @param seq
 395    *          SequenceI
 396    * @param start
 397    *          int - first column in range
 398    * @param end
 399    *          int - last column in range
 400    */
 401   public SeqCigar(SequenceI seq, int start, int end)
 402   {
 403     super();
 404     if (seq == null)
 405     {
 406       throw new Error("Implementation error for new Cigar(SequenceI)");
 407     }
 408     _setSeq(seq, false, start, end + 1);
 409     // there is still work to do
 410     addSequenceOps(this, seq, start, end, false);
 411   }
 412
 413   /**
 414    * Create a cigar object from a cigar string like '[<I|D|M><range>]+' Will
 415    * fail if the given seq already contains gaps (JBPNote: future implementation
 416    * will fix)
 417    *
 418    * @param seq
 419    *          SequenceI object resolvable to a dataset sequence
 420    * @param cigarString
 421    *          String
 422    * @return Cigar
 423    */
 424   public static SeqCigar parseCigar(SequenceI seq, String cigarString)
 425           throws Exception
 426   {
 427     Object[] opsandrange = parseCigarString(cigarString);
 428     return new SeqCigar(seq, (char[]) opsandrange[0],
 429             (int[]) opsandrange[1]);
 430   }
 431
 432   /**
 433    * create an alignment from the given array of cigar sequences and gap
 434    * character, and marking the given segments as visible in the given
 435    * columselection.
 436    *
 437    * @param alseqs
 438    * @param gapCharacter
 439    * @param colsel
 440    *          - columnSelection where hidden regions are marked
 441    * @param segments
 442    *          - visible regions of alignment
 443    * @return SequenceI[]
 444    */
 445   public static SequenceI[] createAlignmentSequences(SeqCigar[] alseqs,
 446           char gapCharacter, ColumnSelection colsel, int[] segments)
 447   {
 448     SequenceI[] seqs = new SequenceI[alseqs.length];
 449     StringBuffer[] g_seqs = new StringBuffer[alseqs.length];
 450     String[] alseqs_string = new String[alseqs.length];
 451     Object[] gs_regions = new Object[alseqs.length];
 452     for (int i = 0; i < alseqs.length; i++)
 453     {
 454       alseqs_string[i] = alseqs[i].getRefSeq().getSequenceAsString(
 455               alseqs[i].start, alseqs[i].end);
 456       gs_regions[i] = alseqs[i].getSequenceAndDeletions(alseqs_string[i],
 457               gapCharacter); // gapped sequence, {start, start col, end.
 458       // endcol}, hidden regions {{start, end, col}})
 459       if (gs_regions[i] == null)
 460       {
 461         throw new Error("Implementation error: " + i
 462                 + "'th sequence Cigar has no operations.");
 463       }
 464       g_seqs[i] = new StringBuffer((String) ((Object[]) gs_regions[i])[0]); // the
 465       // visible
 466       // gapped
 467       // sequence
 468     }
 469     // Now account for insertions. (well - deletions)
 470     // this is complicated because we must keep track of shifted positions in
 471     // each sequence
 472     ShiftList shifts = new ShiftList();
 473     for (int i = 0; i < alseqs.length; i++)
 474     {
 475       Object[] gs_region = ((Object[]) ((Object[]) gs_regions[i])[2]);
 476       if (gs_region != null)
 477
 478       {
 479         for (int hr = 0; hr < gs_region.length; hr++)
 480         {
 481           int[] region = (int[]) gs_region[hr];
 482           char[] insert = new char[region[1] - region[0] + 1];
 483           for (int s = 0; s < insert.length; s++)
 484           {
 485             insert[s] = gapCharacter;
 486           }
 487           int inspos = shifts.shift(region[2]); // resolve insertion position in
 488           // current alignment frame of
 489           // reference
 490           for (int s = 0; s < alseqs.length; s++)
 491           {
 492             if (s != i)
 493             {
 494               if (g_seqs[s].length() <= inspos)
 495               {
 496                 // prefix insertion with more gaps.
 497                 for (int l = inspos - g_seqs[s].length(); l > 0; l--)
 498                 {
 499                   g_seqs[s].append(gapCharacter); // to debug - use a diffferent
 500                   // gap character here
 501                 }
 502               }
 503               g_seqs[s].insert(inspos, insert);
 504             }
 505             else
 506             {
 507               g_seqs[s].insert(inspos,
 508                       alseqs_string[i].substring(region[0], region[1] + 1));
 509             }
 510           }
 511           shifts.addShift(region[2], insert.length); // update shift in
 512           // alignment frame of
 513           // reference
 514           if (segments == null)
 515           {
 516             // add a hidden column for this deletion
 517             colsel.hideColumns(inspos, inspos + insert.length - 1);
 518           }
 519         }
 520       }
 521     }
 522     for (int i = 0; i < alseqs.length; i++)
 523     {
 524       int[] bounds = ((int[]) ((Object[]) gs_regions[i])[1]);
 525       SequenceI ref = alseqs[i].getRefSeq();
 526       seqs[i] = new Sequence(ref.getName(), g_seqs[i].toString(),
 527               ref.getStart() + alseqs[i].start + bounds[0], ref.getStart()
 528                       + alseqs[i].start + (bounds[2] == 0 ? -1 : bounds[2]));
 529       seqs[i].setDatasetSequence(ref);
 530       seqs[i].setDescription(ref.getDescription());
 531     }
 532     if (segments != null)
 533     {
 534       for (int i = 0; i < segments.length; i += 3)
 535       {
 536         // int start=shifts.shift(segments[i]-1)+1;
 537         // int end=shifts.shift(segments[i]+segments[i+1]-1)-1;
 538         colsel.hideColumns(segments[i + 1], segments[i + 1]
 539                 + segments[i + 2] - 1);
 540       }
 541     }
 542     return seqs;
 543   }
 544
 545   /**
 546    * non rigorous testing
 547    */
 548   /**
 549    *
 550    * @param seq
 551    *          Sequence
 552    * @param ex_cs_gapped
 553    *          String
 554    * @return String
 555    */
 556   public static String testCigar_string(Sequence seq, String ex_cs_gapped)
 557   {
 558     SeqCigar c_sgapped = new SeqCigar(seq);
 559     String cs_gapped = c_sgapped.getCigarstring();
 560     if (!cs_gapped.equals(ex_cs_gapped))
 561     {
 562       System.err.println("Failed getCigarstring: incorect string '"
 563               + cs_gapped + "' != " + ex_cs_gapped);
 564     }
 565     return cs_gapped;
 566   }
 567
 568   public static boolean testSeqRecovery(SeqCigar gen_sgapped,
 569           SequenceI s_gapped)
 570   {
 571     // this is non-rigorous - start and end recovery is not tested.
 572     SequenceI gen_sgapped_s = gen_sgapped.getSeq('-');
 573     if (!gen_sgapped_s.getSequence().equals(s_gapped.getSequence()))
 574     {
 575       System.err.println("Couldn't reconstruct sequence.\n"
 576               + gen_sgapped_s.getSequenceAsString() + "\n"
 577               + s_gapped.getSequenceAsString());
 578       return false;
 579     }
 580     return true;
 581   }
 582
 583   public static void main(String argv[]) throws Exception
 584   {
 585     String o_seq;
 586     Sequence s = new Sequence("MySeq",
 587             o_seq = "asdfktryasdtqwrtsaslldddptyipqqwaslchvhttt", 39, 80);
 588     String orig_gapped;
 589     Sequence s_gapped = new Sequence(
 590             "MySeq",
 591             orig_gapped = "----asdf------ktryas---dtqwrtsasll----dddptyipqqwa----slchvhttt",
 592             39, 80);
 593     String ex_cs_gapped = "4I4M6I6M3I11M4I12M4I9M";
 594     s_gapped.setDatasetSequence(s);
 595     String sub_gapped_s;
 596     Sequence s_subsequence_gapped = new Sequence(
 597             "MySeq",
 598             sub_gapped_s = "------ktryas---dtqwrtsasll----dddptyipqqwa----slchvh",
 599             43, 77);
 600
 601     s_subsequence_gapped.setDatasetSequence(s);
 602     SeqCigar c_null = new SeqCigar(s);
 603     String cs_null = c_null.getCigarstring();
 604     if (!cs_null.equals("42M"))
 605     {
 606       System.err
 607               .println("Failed to recover ungapped sequence cigar operations:"
 608                       + ((cs_null == "") ? "empty string" : cs_null));
 609     }
 610     testCigar_string(s_gapped, ex_cs_gapped);
 611     SeqCigar gen_sgapped = SeqCigar.parseCigar(s, ex_cs_gapped);
 612     if (!gen_sgapped.getCigarstring().equals(ex_cs_gapped))
 613     {
 614       System.err.println("Failed parseCigar(" + ex_cs_gapped
 615               + ")->getCigarString()->'" + gen_sgapped.getCigarstring()
 616               + "'");
 617     }
 618     testSeqRecovery(gen_sgapped, s_gapped);
 619     // Test dataset resolution
 620     SeqCigar sub_gapped = new SeqCigar(s_subsequence_gapped);
 621     if (!testSeqRecovery(sub_gapped, s_subsequence_gapped))
 622     {
 623       System.err
 624               .println("Failed recovery for subsequence of dataset sequence");
 625     }
 626     // width functions
 627     if (sub_gapped.getWidth() != sub_gapped_s.length())
 628     {
 629       System.err.println("Failed getWidth()");
 630     }
 631
 632     sub_gapped.getFullWidth();
 633     if (sub_gapped.hasDeletedRegions())
 634     {
 635       System.err.println("hasDeletedRegions is incorrect.");
 636     }
 637     // Test start-end region SeqCigar
 638     SeqCigar sub_se_gp = new SeqCigar(s_subsequence_gapped, 8, 48);
 639     if (sub_se_gp.getWidth() != 41)
 640     {
 641       System.err
 642               .println("SeqCigar(seq, start, end) not properly clipped alignsequence.");
 643     }
 644     System.out.println("Original sequence align:\n" + sub_gapped_s
 645             + "\nReconstructed window from 8 to 48\n" + "XXXXXXXX"
 646             + sub_se_gp.getSequenceString('-') + "..." + "\nCigar String:"
 647             + sub_se_gp.getCigarstring() + "\n");
 648     SequenceI ssgp = sub_se_gp.getSeq('-');
 649     System.out.println("\t " + ssgp.getSequenceAsString());
 650     for (int r = 0; r < 10; r++)
 651     {
 652       sub_se_gp = new SeqCigar(s_subsequence_gapped, 8, 48);
 653       int sl = sub_se_gp.getWidth();
 654       int st = sl - 1 - r;
 655       for (int rs = 0; rs < 10; rs++)
 656       {
 657         int e = st + rs;
 658         sub_se_gp.deleteRange(st, e);
 659         String ssgapedseq = sub_se_gp.getSeq('-').getSequenceAsString();
 660         System.out.println(st + "," + e + "\t:" + ssgapedseq);
 661         st -= 3;
 662       }
 663     }
 664     {
 665       SeqCigar[] set = new SeqCigar[]
 666       { new SeqCigar(s), new SeqCigar(s_subsequence_gapped, 8, 48),
 667           new SeqCigar(s_gapped) };
 668       Alignment al = new Alignment(set);
 669       for (int i = 0; i < al.getHeight(); i++)
 670       {
 671         System.out.println("" + al.getSequenceAt(i).getName() + "\t"
 672                 + al.getSequenceAt(i).getStart() + "\t"
 673                 + al.getSequenceAt(i).getEnd() + "\t"
 674                 + al.getSequenceAt(i).getSequenceAsString());
 675       }
 676     }
 677     {
 678       System.out.println("Gapped.");
 679       SeqCigar[] set = new SeqCigar[]
 680       { new SeqCigar(s), new SeqCigar(s_subsequence_gapped, 8, 48),
 681           new SeqCigar(s_gapped) };
 682       set[0].deleteRange(20, 25);
 683       Alignment al = new Alignment(set);
 684       for (int i = 0; i < al.getHeight(); i++)
 685       {
 686         System.out.println("" + al.getSequenceAt(i).getName() + "\t"
 687                 + al.getSequenceAt(i).getStart() + "\t"
 688                 + al.getSequenceAt(i).getEnd() + "\t"
 689                 + al.getSequenceAt(i).getSequenceAsString());
 690       }
 691     }
 692     // if (!ssgapedseq.equals("ryas---dtqqwa----slchvh"))
 693     // System.err.println("Subseqgaped\n------ktryas---dtqwrtsasll----dddptyipqqwa----slchvhryas---dtqwrtsasll--qwa----slchvh\n"+ssgapedseq+"\n"+sub_se_gp.getCigarstring());
 694   }
 695
 696   /**
 697    * references to entities that this sequence cigar is associated with.
 698    */
 699   private Hashtable selGroups = null;
 700
 701   public void setGroupMembership(Object group)
 702   {
 703     if (selGroups == null)
 704     {
 705       selGroups = new Hashtable();
 706     }
 707     selGroups.put(group, new int[0]);
 708   }
 709
 710   /**
 711    * Test for and if present remove association to group.
 712    *
 713    * @param group
 714    * @return true if group was associated and it was removed
 715    */
 716   public boolean removeGroupMembership(Object group)
 717   {
 718     if (selGroups != null && selGroups.containsKey(group))
 719     {
 720       selGroups.remove(group);
 721       return true;
 722     }
 723     return false;
 724   }
 725
 726   /**
 727    * forget all associations for this sequence.
 728    */
 729   public void clearMemberships()
 730   {
 731     if (selGroups != null)
 732     {
 733       selGroups.clear();
 734     }
 735     selGroups = null;
 736   }
 737
 738   /**
 739    *
 740    * @return null or array of all associated entities
 741    */
 742   public Object[] getAllMemberships()
 743   {
 744     if (selGroups == null)
 745     {
 746       return null;
 747     }
 748     Object[] mmbs = new Object[selGroups.size()];
 749     Enumeration en = selGroups.keys();
 750     for (int i = 0; en.hasMoreElements(); i++)
 751     {
 752       mmbs[i] = en.nextElement();
 753     }
 754     return mmbs;
 755   }
 756
 757   /**
 758    * Test for group membership
 759    *
 760    * @param sgr
 761    *          - a selection group or some other object that may be associated
 762    *          with seqCigar
 763    * @return true if sgr is associated with this seqCigar
 764    */
 765   public boolean isMemberOf(Object sgr)
 766   {
 767     return (selGroups != null) && selGroups.get(sgr) != null;
 768   }
 769 }