X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequenceFeature.java;h=8eacb68d1c7eb1822b171d6f6b3acb6f191a386b;hb=3917b8cc08f85090d44dfa599c715a2ec7ef5b41;hp=252f46c4f905821948c3c3a9694d3ca8eae9318b;hpb=0b8abe58b934e03c34575b06d532a99f0ba70196;p=jalview.git diff --git a/src/jalview/datamodel/SequenceFeature.java b/src/jalview/datamodel/SequenceFeature.java index 252f46c..8eacb68 100755 --- a/src/jalview/datamodel/SequenceFeature.java +++ b/src/jalview/datamodel/SequenceFeature.java @@ -20,6 +20,8 @@ */ package jalview.datamodel; +import jalview.datamodel.features.FeatureLocationI; + import java.util.HashMap; import java.util.Map; import java.util.Vector; @@ -30,7 +32,7 @@ import java.util.Vector; * @author $author$ * @version $Revision$ */ -public class SequenceFeature +public class SequenceFeature implements FeatureLocationI { private static final String STATUS = "status"; @@ -39,6 +41,13 @@ public class SequenceFeature // private key for Phase designed not to conflict with real GFF data private static final String PHASE = "!Phase"; + // private key for ENA location designed not to conflict with real GFF data + private static final String LOCATION = "!Location"; + + /* + * ATTRIBUTES is reserved for the GFF 'column 9' data, formatted as + * name1=value1;name2=value2,value3;...etc + */ private static final String ATTRIBUTES = "ATTRIBUTES"; public int begin; @@ -51,6 +60,10 @@ public class SequenceFeature public String description; + /* + * a map of key-value pairs; may be populated from GFF 'column 9' data, + * other data sources (e.g. GenBank file), or programmatically + */ public Map otherDetails; public Vector links; @@ -111,49 +124,153 @@ public class SequenceFeature } } + /** + * Constructor including a Status value + * + * @param type + * @param desc + * @param status + * @param begin + * @param end + * @param featureGroup + */ public SequenceFeature(String type, String desc, String status, int begin, int end, String featureGroup) { + this(type, desc, begin, end, featureGroup); + setStatus(status); + } + + /** + * Constructor + * + * @param type + * @param desc + * @param begin + * @param end + * @param featureGroup + */ + SequenceFeature(String type, String desc, int begin, int end, + String featureGroup) + { this.type = type; this.description = desc; - setValue(STATUS, status); this.begin = begin; this.end = end; this.featureGroup = featureGroup; } + /** + * Constructor including a score value + * + * @param type + * @param desc + * @param begin + * @param end + * @param score + * @param featureGroup + */ public SequenceFeature(String type, String desc, int begin, int end, float score, String featureGroup) { - this.type = type; - this.description = desc; - this.begin = begin; - this.end = end; + this(type, desc, begin, end, featureGroup); this.score = score; - this.featureGroup = featureGroup; } - public boolean equals(SequenceFeature sf) + /** + * Two features are considered equal if they have the same type, group, + * description, start, end, phase, strand, and (if present) 'Name', ID' and + * 'Parent' attributes. + * + * Note we need to check Parent to distinguish the same exon occurring in + * different transcripts (in Ensembl GFF). This allows assembly of transcript + * sequences from their component exon regions. + */ + @Override + public boolean equals(Object o) + { + return equals(o, false); + } + + /** + * Overloaded method allows the equality test to optionally ignore the + * 'Parent' attribute of a feature. This supports avoiding adding many + * superficially duplicate 'exon' or CDS features to genomic or protein + * sequence. + * + * @param o + * @param ignoreParent + * @return + */ + public boolean equals(Object o, boolean ignoreParent) { - if (begin != sf.begin || end != sf.end || score != sf.score) + if (o == null || !(o instanceof SequenceFeature)) + { + return false; + } + + SequenceFeature sf = (SequenceFeature) o; + boolean sameScore = Float.isNaN(score) ? Float.isNaN(sf.score) + : score == sf.score; + if (begin != sf.begin || end != sf.end || !sameScore) { return false; } - if (!(type + description + featureGroup).equals(sf.type - + sf.description + sf.featureGroup)) + if (getStrand() != sf.getStrand()) { return false; } + if (!(type + description + featureGroup + getPhase()).equals(sf.type + + sf.description + sf.featureGroup + sf.getPhase())) + { + return false; + } + if (!equalAttribute(getValue("ID"), sf.getValue("ID"))) + { + return false; + } + if (!equalAttribute(getValue("Name"), sf.getValue("Name"))) + { + return false; + } + if (!ignoreParent) + { + if (!equalAttribute(getValue("Parent"), sf.getValue("Parent"))) + { + return false; + } + } return true; } /** + * Returns true if both values are null, are both non-null and equal + * + * @param att1 + * @param att2 + * @return + */ + protected static boolean equalAttribute(Object att1, Object att2) + { + if (att1 == null && att2 == null) + { + return true; + } + if (att1 != null) + { + return att1.equals(att2); + } + return att2.equals(att1); + } + + /** * DOCUMENT ME! * * @return DOCUMENT ME! */ + @Override public int getBegin() { return begin; @@ -169,6 +286,7 @@ public class SequenceFeature * * @return DOCUMENT ME! */ + @Override public int getEnd() { return end; @@ -226,7 +344,10 @@ public class SequenceFeature links = new Vector(); } - links.insertElementAt(labelLink, 0); + if (!links.contains(labelLink)) + { + links.insertElementAt(labelLink, 0); + } } public float getScore() @@ -353,6 +474,12 @@ public class SequenceFeature return strand; } + /** + * Set the value of strand + * + * @param strand + * should be "+" for forward, or "-" for reverse + */ public void setStrand(String strand) { setValue(STRAND, strand); @@ -369,6 +496,26 @@ public class SequenceFeature } /** + * Sets the 'raw' ENA format location specifier e.g. join(12..45,89..121) + * + * @param loc + */ + public void setEnaLocation(String loc) + { + setValue(LOCATION, loc); + } + + /** + * Gets the 'raw' ENA format location specifier e.g. join(12..45,89..121) + * + * @param loc + */ + public String getEnaLocation() + { + return (String) getValue(LOCATION); + } + + /** * Readable representation, for debug only, not guaranteed not to change * between versions */ @@ -378,4 +525,45 @@ public class SequenceFeature return String.format("%d %d %s %s", getBegin(), getEnd(), getType(), getDescription()); } + + /** + * Overridden to ensure that whenever two objects are equal, they have the + * same hashCode + */ + @Override + public int hashCode() + { + String s = getType() + getDescription() + getFeatureGroup() + + getValue("ID") + getValue("Name") + getValue("Parent") + + getPhase(); + return s.hashCode() + getBegin() + getEnd() + (int) getScore() + + getStrand(); + } + + /** + * Answers true if the feature's start/end values represent two related + * positions, rather than ends of a range. Such features may be visualised or + * reported differently to features on a range. + */ + @Override + public boolean isContactFeature() + { + // TODO abstract one day to a FeatureType class + if ("disulfide bond".equalsIgnoreCase(type) + || "disulphide bond".equalsIgnoreCase(type)) + { + return true; + } + return false; + } + + /** + * Answers true if the sequence has zero start and end position + * + * @return + */ + public boolean isNonPositional() + { + return begin == 0 && end == 0; + } }