X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequence.java;h=cc21f35aa020b3d91a3ec6397f90cc70ab1985b4;hb=HEAD;hp=1905f421569d5d1b046812c31653d4aa57f64001;hpb=14193747f3831242bc7dfac12394eb20eb0ba480;p=jalview.git diff --git a/src/jalview/datamodel/Sequence.java b/src/jalview/datamodel/Sequence.java index 1905f42..cc21f35 100755 --- a/src/jalview/datamodel/Sequence.java +++ b/src/jalview/datamodel/Sequence.java @@ -20,54 +20,81 @@ */ package jalview.datamodel; -import jalview.analysis.AlignSeq; -import jalview.api.DBRefEntryI; -import jalview.datamodel.features.SequenceFeatures; -import jalview.datamodel.features.SequenceFeaturesI; -import jalview.util.Comparison; -import jalview.util.DBRefUtils; -import jalview.util.MapList; -import jalview.util.StringUtils; - import java.util.ArrayList; import java.util.Arrays; import java.util.BitSet; +import java.util.Collection; import java.util.Collections; import java.util.Enumeration; +import java.util.Iterator; import java.util.List; import java.util.ListIterator; import java.util.Vector; import fr.orsay.lri.varna.models.rna.RNA; +import jalview.analysis.AlignSeq; +import jalview.analysis.AlignmentUtils; +import jalview.analysis.SeqsetUtils; +import jalview.datamodel.features.SequenceFeatures; +import jalview.datamodel.features.SequenceFeaturesI; +import jalview.util.Comparison; +import jalview.util.DBRefUtils; +import jalview.util.MapList; +import jalview.util.StringUtils; +import jalview.ws.datamodel.alphafold.MappableContactMatrix; /** * - * Implements the SequenceI interface for a char[] based sequence object. - * - * @author $author$ - * @version $Revision$ + * Implements the SequenceI interface for a char[] based sequence object */ public class Sequence extends ASequence implements SequenceI { + + /** + * A subclass that gives us access to modCount, which tracks whether there + * have been any changes. We use this to update + * + * @author hansonr + * + * @param + */ + @SuppressWarnings("serial") + public class DBModList extends ArrayList + { + + protected int getModCount() + { + return modCount; + } + + } + SequenceI datasetSequence; - String name; + private String name; private char[] sequence; - String description; + private String description; - int start; + private int start; - int end; + private int end; - Vector pdbIds; + private Vector pdbIds; - String vamsasId; + private String vamsasId; - DBRefEntry[] dbrefs; + private DBModList dbrefs; // controlled access - RNA rna; + /** + * a flag to let us know that elements have changed in dbrefs + * + * @author Bob Hanson + */ + private int refModCount = 0; + + private RNA rna; /** * This annotation is displayed below the alignment but the positions are tied @@ -75,12 +102,7 @@ public class Sequence extends ASequence implements SequenceI * * TODO: change to List<> */ - Vector annotation; - - /** - * The index of the sequence in a MSA - */ - int index = -1; + private Vector annotation; private SequenceFeaturesI sequenceFeatureStore; @@ -152,7 +174,7 @@ public class Sequence extends ASequence implements SequenceI { if (name == null) { - System.err.println( + jalview.bin.Console.errPrintln( "POSSIBLE IMPLEMENTATION ERROR: null sequence name passed to constructor."); name = ""; } @@ -285,18 +307,18 @@ public class Sequence extends ASequence implements SequenceI { setDatasetSequence(seq.getDatasetSequence()); } - + /* * only copy DBRefs and seqfeatures if we really are a dataset sequence */ if (datasetSequence == null) { - if (seq.getDBRefs() != null) + List dbr = seq.getDBRefs(); + if (dbr != null) { - DBRefEntry[] dbr = seq.getDBRefs(); - for (int i = 0; i < dbr.length; i++) + for (int i = 0, n = dbr.size(); i < n; i++) { - addDBRef(new DBRefEntry(dbr[i])); + addDBRef(new DBRefEntry(dbr.get(i))); } } @@ -330,6 +352,11 @@ public class Sequence extends ASequence implements SequenceI { // only copy the given annotation AlignmentAnnotation newann = new AlignmentAnnotation(sqann[i]); + ContactMatrixI cm = seq.getContactMatrixFor(sqann[i]); + if (cm != null) + { + addContactListFor(newann, cm); + } addAlignmentAnnotation(newann); } } @@ -360,8 +387,8 @@ public class Sequence extends ASequence implements SequenceI { if (sf.getType() == null) { - System.err.println("SequenceFeature type may not be null: " - + sf.toString()); + jalview.bin.Console.errPrintln( + "SequenceFeature type may not be null: " + sf.toString()); return false; } @@ -413,7 +440,7 @@ public class Sequence extends ASequence implements SequenceI { if (pdbIds == null) { - pdbIds = new Vector(); + pdbIds = new Vector<>(); pdbIds.add(entry); return true; } @@ -449,22 +476,23 @@ public class Sequence extends ASequence implements SequenceI @Override public Vector getAllPDBEntries() { - return pdbIds == null ? new Vector() : pdbIds; + return pdbIds == null ? new Vector<>() : pdbIds; } /** - * DOCUMENT ME! + * Answers the sequence name, with '/start-end' appended if jvsuffix is true * - * @return DOCUMENT ME! + * @return */ @Override public String getDisplayId(boolean jvsuffix) { - StringBuffer result = new StringBuffer(name); - if (jvsuffix) + if (!jvsuffix) { - result.append("/" + start + "-" + end); + return name; } + StringBuilder result = new StringBuilder(name); + result.append("/").append(start).append("-").append(end); return result.toString(); } @@ -503,6 +531,7 @@ public class Sequence extends ASequence implements SequenceI public void setStart(int start) { this.start = start; + sequenceChanged(); } /** @@ -580,8 +609,8 @@ public class Sequence extends ASequence implements SequenceI public char[] getSequence() { // return sequence; - return sequence == null ? null : Arrays.copyOf(sequence, - sequence.length); + return sequence == null ? null + : Arrays.copyOf(sequence, sequence.length); } /* @@ -677,8 +706,8 @@ public class Sequence extends ASequence implements SequenceI public void setGeneLoci(String speciesId, String assemblyId, String chromosomeId, MapList map) { - addDBRef(new DBRefEntry(speciesId, assemblyId, DBRefEntry.CHROMOSOME - + ":" + chromosomeId, new Mapping(map))); + addDBRef(new GeneLocus(speciesId, assemblyId, chromosomeId, + new Mapping(map))); } /** @@ -689,41 +718,14 @@ public class Sequence extends ASequence implements SequenceI @Override public GeneLociI getGeneLoci() { - DBRefEntry[] refs = getDBRefs(); + List refs = getDBRefs(); if (refs != null) { for (final DBRefEntry ref : refs) { - if (ref.isChromosome()) + if (ref instanceof GeneLociI) { - return new GeneLociI() - { - @Override - public String getSpeciesId() - { - return ref.getSource(); - } - - @Override - public String getAssemblyId() - { - return ref.getVersion(); - } - - @Override - public String getChromosomeId() - { - // strip off "chromosome:" prefix to chrId - return ref.getAccessionId().substring( - DBRefEntry.CHROMOSOME.length() + 1); - } - - @Override - public MapList getMap() - { - return ref.getMap().getMap(); - } - }; + return (GeneLociI) ref; } } } @@ -801,6 +803,7 @@ public class Sequence extends ASequence implements SequenceI * preserve end residue column provided cursor was valid */ int endColumn = isValidCursor(cursor) ? cursor.lastColumnPosition : 0; + if (residuePos == this.end) { endColumn = column; @@ -819,7 +822,7 @@ public class Sequence extends ASequence implements SequenceI * @param curs * @return */ - protected int findIndex(int pos, SequenceCursor curs) + protected int findIndex(final int pos, SequenceCursor curs) { if (!isValidCursor(curs)) { @@ -837,16 +840,20 @@ public class Sequence extends ASequence implements SequenceI /* * move left or right to find pos from hint.position */ - int col = curs.columnPosition - 1; // convert from base 1 to 0-based array - // index + int col = curs.columnPosition - 1; // convert from base 1 to base 0 int newPos = curs.residuePosition; int delta = newPos > pos ? -1 : 1; while (newPos != pos) { col += delta; // shift one column left or right - if (col < 0 || col == sequence.length) + if (col < 0) + { + break; + } + if (col == sequence.length) { + col--; // return last column if we failed to reach pos break; } if (!Comparison.isGap(sequence[col])) @@ -856,7 +863,14 @@ public class Sequence extends ASequence implements SequenceI } col++; // convert back to base 1 - updateCursor(pos, col, curs.firstColumnPosition); + + /* + * only update cursor if we found the target position + */ + if (newPos == pos) + { + updateCursor(pos, col, curs.firstColumnPosition); + } return col; } @@ -874,7 +888,7 @@ public class Sequence extends ASequence implements SequenceI { return findPosition(column + 1, cursor); } - + // TODO recode this more naturally i.e. count residues only // as they are found, not 'in anticipation' @@ -1061,7 +1075,7 @@ public class Sequence extends ASequence implements SequenceI * {@inheritDoc} */ @Override - public Range findPositions(int fromColumn, int toColumn) + public ContiguousI findPositions(int fromColumn, int toColumn) { if (toColumn < fromColumn || fromColumn < 1) { @@ -1133,6 +1147,27 @@ public class Sequence extends ASequence implements SequenceI return map; } + /** + * Build a bitset corresponding to sequence gaps + * + * @return a BitSet where set values correspond to gaps in the sequence + */ + @Override + public BitSet gapBitset() + { + BitSet gaps = new BitSet(sequence.length); + int j = 0; + while (j < sequence.length) + { + if (jalview.util.Comparison.isGap(sequence[j])) + { + gaps.set(j); + } + j++; + } + return gaps; + } + @Override public int[] findPositionMap() { @@ -1156,9 +1191,9 @@ public class Sequence extends ASequence implements SequenceI @Override public List getInsertions() { - ArrayList map = new ArrayList(); + ArrayList map = new ArrayList<>(); int lastj = -1, j = 0; - int pos = start; + // int pos = start; int seqlen = sequence.length; while ((j < seqlen)) { @@ -1192,7 +1227,7 @@ public class Sequence extends ASequence implements SequenceI { BitSet map = new BitSet(); int lastj = -1, j = 0; - int pos = start; + // int pos = start; int seqlen = sequence.length; while ((j < seqlen)) { @@ -1222,7 +1257,7 @@ public class Sequence extends ASequence implements SequenceI } @Override - public void deleteChars(int i, int j) + public void deleteChars(final int i, final int j) { int newstart = start, newend = end; if (i >= sequence.length || i < 0) @@ -1234,62 +1269,76 @@ public class Sequence extends ASequence implements SequenceI boolean createNewDs = false; // TODO: take a (second look) at the dataset creation validation method for // the very large sequence case - int eindex = -1, sindex = -1; - boolean ecalc = false, scalc = false; - for (int s = i; s < j; s++) + + int startIndex = findIndex(start) - 1; + int endIndex = findIndex(end) - 1; + int startDeleteColumn = -1; // for dataset sequence deletions + int deleteCount = 0; + + for (int s = i; s < j && s < sequence.length; s++) { - if (jalview.schemes.ResidueProperties.aaIndex[sequence[s]] != 23) + if (Comparison.isGap(sequence[s])) { - if (createNewDs) + continue; + } + deleteCount++; + if (startDeleteColumn == -1) + { + startDeleteColumn = findPosition(s) - start; + } + if (createNewDs) + { + newend--; + } + else + { + if (startIndex == s) { - newend--; + /* + * deleting characters from start of sequence; new start is the + * sequence position of the next column (position to the right + * if the column position is gapped) + */ + newstart = findPosition(j); + break; } else { - if (!scalc) + if (endIndex < j) { - sindex = findIndex(start) - 1; - scalc = true; - } - if (sindex == s) - { - // delete characters including start of sequence - newstart = findPosition(j); - break; // don't need to search for any more residue characters. + /* + * deleting characters at end of sequence; new end is the sequence + * position of the column before the deletion; subtract 1 if this is + * gapped since findPosition returns the next sequence position + */ + newend = findPosition(i - 1); + if (Comparison.isGap(sequence[i - 1])) + { + newend--; + } + break; } else { - // delete characters after start. - if (!ecalc) - { - eindex = findIndex(end) - 1; - ecalc = true; - } - if (eindex < j) - { - // delete characters at end of sequence - newend = findPosition(i - 1); - break; // don't need to search for any more residue characters. - } - else - { - createNewDs = true; - newend--; // decrease end position by one for the deleted residue - // and search further - } + createNewDs = true; + newend--; } } } } - // deletion occured in the middle of the sequence + if (createNewDs && this.datasetSequence != null) { - // construct a new sequence + /* + * if deletion occured in the middle of the sequence, + * construct a new dataset sequence and delete the residues + * that were deleted from the aligned sequence + */ Sequence ds = new Sequence(datasetSequence); + ds.deleteChars(startDeleteColumn, startDeleteColumn + deleteCount); + datasetSequence = ds; // TODO: remove any non-inheritable properties ? // TODO: create a sequence mapping (since there is a relation here ?) - ds.deleteChars(i, j); - datasetSequence = ds; } start = newstart; end = newend; @@ -1346,24 +1395,22 @@ public class Sequence extends ASequence implements SequenceI vamsasId = id; } + @Deprecated @Override - public void setDBRefs(DBRefEntry[] dbref) + public void setDBRefs(DBModList newDBrefs) { if (dbrefs == null && datasetSequence != null && this != datasetSequence) { - datasetSequence.setDBRefs(dbref); + datasetSequence.setDBRefs(newDBrefs); return; } - dbrefs = dbref; - if (dbrefs != null) - { - DBRefUtils.ensurePrimaries(this); - } + dbrefs = newDBrefs; + refModCount = 0; } @Override - public DBRefEntry[] getDBRefs() + public DBModList getDBRefs() { if (dbrefs == null && datasetSequence != null && this != datasetSequence) @@ -1376,6 +1423,7 @@ public class Sequence extends ASequence implements SequenceI @Override public void addDBRef(DBRefEntry entry) { + // TODO JAL-3980 maintain as sorted list if (datasetSequence != null) { datasetSequence.addDBRef(entry); @@ -1384,12 +1432,13 @@ public class Sequence extends ASequence implements SequenceI if (dbrefs == null) { - dbrefs = new DBRefEntry[0]; + dbrefs = new DBModList<>(); } + // TODO JAL-3979 LOOK UP RATHER THAN SWEEP FOR EFFICIENCY - for (DBRefEntryI dbr : dbrefs) + for (int ib = 0, nb = dbrefs.size(); ib < nb; ib++) { - if (dbr.updateFrom(entry)) + if (dbrefs.get(ib).updateFrom(entry)) { /* * found a dbref that either matched, or could be @@ -1399,18 +1448,19 @@ public class Sequence extends ASequence implements SequenceI } } - /* - * extend the array to make room for one more - */ - // TODO use an ArrayList instead - int j = dbrefs.length; - DBRefEntry[] temp = new DBRefEntry[j + 1]; - System.arraycopy(dbrefs, 0, temp, 0, j); - temp[temp.length - 1] = entry; + // /// BH OUCH! + // /* + // * extend the array to make room for one more + // */ + // // TODO use an ArrayList instead + // int j = dbrefs.length; + // List temp = new DBRefEntry[j + 1]; + // System.arraycopy(dbrefs, 0, temp, 0, j); + // temp[temp.length - 1] = entry; + // + // dbrefs = temp; - dbrefs = temp; - - DBRefUtils.ensurePrimaries(this); + dbrefs.add(entry); } @Override @@ -1454,7 +1504,7 @@ public class Sequence extends ASequence implements SequenceI { if (this.annotation == null) { - this.annotation = new Vector(); + this.annotation = new Vector<>(); } if (!this.annotation.contains(annotation)) { @@ -1523,6 +1573,8 @@ public class Sequence extends ASequence implements SequenceI private int _seqhash = 0; + private List primaryRefs; + /** * Answers false if the sequence is more than 85% nucleotide (ACGTU), else * true @@ -1540,7 +1592,7 @@ public class Sequence extends ASequence implements SequenceI _isNa = Comparison.isNucleotide(this); } return !_isNa; - }; + } /* * (non-Javadoc) @@ -1581,8 +1633,20 @@ public class Sequence extends ASequence implements SequenceI _aa.adjustForAlignment(); // uses annotation's own record of // sequence-column mapping datasetSequence.addAlignmentAnnotation(_aa); + + if (_cmholder != null) + { // transfer contact matrices + ContactMatrixI cm = _cmholder.getContactMatrixFor(aa); + if (cm != null) + { + datasetSequence.addContactListFor(_aa, cm); + datasetSequence.addContactListFor(aa, cm); + } + } } } + // all matrices should have been transferred. so we clear the local holder + _cmholder = null; } return datasetSequence; } @@ -1621,7 +1685,7 @@ public class Sequence extends ASequence implements SequenceI return null; } - Vector subset = new Vector(); + Vector subset = new Vector<>(); Enumeration e = annotation.elements(); while (e.hasMoreElements()) { @@ -1654,13 +1718,14 @@ public class Sequence extends ASequence implements SequenceI // TODO: could merge DBRefs return datasetSequence.updatePDBIds(); } - if (dbrefs == null || dbrefs.length == 0) + if (dbrefs == null || dbrefs.size() == 0) { return false; } boolean added = false; - for (DBRefEntry dbr : dbrefs) + for (int ib = 0, nb = dbrefs.size(); ib < nb; ib++) { + DBRefEntry dbr = dbrefs.get(ib); if (DBRefSource.PDB.equals(dbr.getSource())) { /* @@ -1689,6 +1754,14 @@ public class Sequence extends ASequence implements SequenceI transferAnnotation(entry.getDatasetSequence(), mp); return; } + // transfer from entry to sequence + // if entry has a description and sequence doesn't, then transfer + if (entry.getDescription() != null + && (description == null || description.trim().length() == 0)) + { + description = entry.getDescription(); + } + // transfer any new features from entry onto sequence if (entry.getSequenceFeatures() != null) { @@ -1696,8 +1769,9 @@ public class Sequence extends ASequence implements SequenceI List sfs = entry.getSequenceFeatures(); for (SequenceFeature feature : sfs) { - SequenceFeature sf[] = (mp != null) ? mp.locateFeature(feature) - : new SequenceFeature[] { new SequenceFeature(feature) }; + SequenceFeature sf[] = (mp != null) ? mp.locateFeature(feature) + : new SequenceFeature[] + { new SequenceFeature(feature) }; if (sf != null) { for (int sfi = 0; sfi < sf.length; sfi++) @@ -1719,12 +1793,12 @@ public class Sequence extends ASequence implements SequenceI } } // transfer database references - DBRefEntry[] entryRefs = entry.getDBRefs(); + List entryRefs = entry.getDBRefs(); if (entryRefs != null) { - for (int r = 0; r < entryRefs.length; r++) + for (int r = 0, n = entryRefs.size(); r < n; r++) { - DBRefEntry newref = new DBRefEntry(entryRefs[r]); + DBRefEntry newref = new DBRefEntry(entryRefs.get(r)); if (newref.getMap() != null && mp != null) { // remap ref using our local mapping @@ -1739,53 +1813,46 @@ public class Sequence extends ASequence implements SequenceI } } - /** - * @return The index (zero-based) on this sequence in the MSA. It returns - * {@code -1} if this information is not available. - */ @Override - public int getIndex() + public void setRNA(RNA r) { - return index; + rna = r; } - /** - * Defines the position of this sequence in the MSA. Use the value {@code -1} - * if this information is undefined. - * - * @param The - * position for this sequence. This value is zero-based (zero for - * this first sequence) - */ @Override - public void setIndex(int value) + public RNA getRNA() { - index = value; + return rna; } @Override - public void setRNA(RNA r) + public List getAlignmentAnnotations(String calcId, + String label) { - rna = r; + return getAlignmentAnnotations(calcId, label, null, true); } @Override - public RNA getRNA() + public List getAlignmentAnnotations(String calcId, + String label, String description) { - return rna; + return getAlignmentAnnotations(calcId, label, description, false); } - @Override - public List getAlignmentAnnotations(String calcId, - String label) + private List getAlignmentAnnotations(String calcId, + String label, String description, boolean ignoreDescription) { - List result = new ArrayList(); + List result = new ArrayList<>(); if (this.annotation != null) { for (AlignmentAnnotation ann : annotation) { - if (ann.calcId != null && ann.calcId.equals(calcId) - && ann.label != null && ann.label.equals(label)) + if ((ann.calcId != null && ann.calcId.equals(calcId)) + && (ann.label != null && ann.label.equals(label)) + && ((ignoreDescription && description == null) + || (ann.description != null + && ann.description.equals(description)))) + { result.add(ann); } @@ -1822,6 +1889,8 @@ public class Sequence extends ASequence implements SequenceI return null; } + private List tmpList; + @Override public List getPrimaryDBRefs() { @@ -1829,16 +1898,29 @@ public class Sequence extends ASequence implements SequenceI { return datasetSequence.getPrimaryDBRefs(); } - if (dbrefs == null || dbrefs.length == 0) + if (dbrefs == null || dbrefs.size() == 0) { return Collections.emptyList(); } synchronized (dbrefs) { - List primaries = new ArrayList(); - DBRefEntry[] tmp = new DBRefEntry[1]; - for (DBRefEntry ref : dbrefs) + if (refModCount == dbrefs.getModCount() && primaryRefs != null) { + return primaryRefs; // no changes + } + refModCount = dbrefs.getModCount(); + List primaries = (primaryRefs == null + ? (primaryRefs = new ArrayList<>()) + : primaryRefs); + primaries.clear(); + if (tmpList == null) + { + tmpList = new ArrayList<>(); + tmpList.add(null); // for replacement + } + for (int i = 0, n = dbrefs.size(); i < n; i++) + { + DBRefEntry ref = dbrefs.get(i); if (!ref.isPrimaryCandidate()) { continue; @@ -1853,8 +1935,8 @@ public class Sequence extends ASequence implements SequenceI } } // whilst it looks like it is a primary ref, we also sanity check type - if (DBRefUtils.getCanonicalName(DBRefSource.PDB) - .equals(DBRefUtils.getCanonicalName(ref.getSource()))) + if (DBRefSource.PDB_CANONICAL_NAME + .equals(ref.getCanonicalSourceName())) { // PDB dbrefs imply there should be a PDBEntry associated // TODO: tighten PDB dbrefs @@ -1863,21 +1945,28 @@ public class Sequence extends ASequence implements SequenceI // handle on the PDBEntry, and a real mapping between sequence and // extracted sequence from PDB file PDBEntry pdbentry = getPDBEntry(ref.getAccessionId()); - if (pdbentry != null && pdbentry.getFile() != null) + if (pdbentry == null || pdbentry.getFile() == null) { - primaries.add(ref); + continue; } - continue; } - // check standard protein or dna sources - tmp[0] = ref; - DBRefEntry[] res = DBRefUtils.selectDbRefs(!isProtein(), tmp); - if (res != null && res[0] == tmp[0]) + else { - primaries.add(ref); - continue; + // check standard protein or dna sources + tmpList.set(0, ref); + List res = DBRefUtils.selectDbRefs(!isProtein(), + tmpList); + if (res == null || res.get(0) != tmpList.get(0)) + { + continue; + } } + primaries.add(ref); } + + // version must be not null, as otherwise it will not be a candidate, + // above + DBRefUtils.ensurePrimaries(this, primaries); return primaries; } } @@ -1977,4 +2066,154 @@ public class Sequence extends ASequence implements SequenceI return count; } + + @Override + public String getSequenceStringFromIterator(Iterator it) + { + StringBuilder newSequence = new StringBuilder(); + while (it.hasNext()) + { + int[] block = it.next(); + if (it.hasNext()) + { + newSequence.append(getSequence(block[0], block[1] + 1)); + } + else + { + newSequence.append(getSequence(block[0], block[1])); + } + } + + return newSequence.toString(); + } + + @Override + public int firstResidueOutsideIterator(Iterator regions) + { + int start = 0; + + if (!regions.hasNext()) + { + return findIndex(getStart()) - 1; + } + + // Simply walk along the sequence whilst watching for region + // boundaries + int hideStart = getLength(); + int hideEnd = -1; + boolean foundStart = false; + + // step through the non-gapped positions of the sequence + for (int i = getStart(); i <= getEnd() && (!foundStart); i++) + { + // get alignment position of this residue in the sequence + int p = findIndex(i) - 1; + + // update region start/end + while (hideEnd < p && regions.hasNext()) + { + int[] region = regions.next(); + hideStart = region[0]; + hideEnd = region[1]; + } + if (hideEnd < p) + { + hideStart = getLength(); + } + // update boundary for sequence + if (p < hideStart) + { + start = p; + foundStart = true; + } + } + + if (foundStart) + { + return start; + } + // otherwise, sequence was completely hidden + return 0; + } + + //// + //// Contact Matrix Holder Boilerplate + //// + ContactMapHolderI _cmholder = null; + + private ContactMapHolderI getContactMapHolder() + { + if (datasetSequence != null) + { + return ((Sequence) datasetSequence).getContactMapHolder(); + } + if (_cmholder == null) + { + _cmholder = new ContactMapHolder(); + } + return _cmholder; + } + + @Override + public Collection getContactMaps() + { + return getContactMapHolder().getContactMaps(); + } + + @Override + public ContactMatrixI getContactMatrixFor(AlignmentAnnotation ann) + { + return getContactMapHolder().getContactMatrixFor(ann); + } + + @Override + public ContactListI getContactListFor(AlignmentAnnotation _aa, int column) + { + return getContactMapHolder().getContactListFor(_aa, column); + } + + @Override + public AlignmentAnnotation addContactList(ContactMatrixI cm) + { + AlignmentAnnotation aa; + + if (datasetSequence != null) + { + aa = datasetSequence.addContactList(cm); + // clone the annotation for the local sequence + aa = new AlignmentAnnotation(aa); + aa.restrict(start, end); + aa.adjustForAlignment(); + getContactMapHolder().addContactListFor(aa, cm); + addAlignmentAnnotation(aa); + return aa; + } + + // construct new annotation for matrix on dataset sequence + aa = getContactMapHolder().addContactList(cm); + + Annotation _aa[] = new Annotation[getLength()]; + + for (int i = 0; i < _aa.length; _aa[i++] = new Annotation(0.0f)) + { + ; + } + aa.annotations = _aa; + aa.setSequenceRef(this); + if (cm instanceof MappableContactMatrix + && !((MappableContactMatrix) cm).hasReferenceSeq()) + { + ((MappableContactMatrix) cm).setRefSeq(this); + } + aa.createSequenceMapping(this, getStart(), false); + addAlignmentAnnotation(aa); + return aa; + } + + @Override + public void addContactListFor(AlignmentAnnotation annotation, + ContactMatrixI cm) + { + getContactMapHolder().addContactListFor(annotation, cm); + } }