X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequenceFeature.java;h=8146400f27e362ff963250d618a97156fcf04b4f;hb=ddcce112558a130196ca384c4683b4f9b7d7d133;hp=28ab82cda7d0d5c34fb9b88e6a60ee326556a559;hpb=be32c14cd8e48fe0a207cd7030cb9cd46f894678;p=jalview.git diff --git a/src/jalview/datamodel/SequenceFeature.java b/src/jalview/datamodel/SequenceFeature.java index 28ab82c..8146400 100755 --- a/src/jalview/datamodel/SequenceFeature.java +++ b/src/jalview/datamodel/SequenceFeature.java @@ -20,7 +20,8 @@ */ package jalview.datamodel; -import java.util.Hashtable; +import java.util.HashMap; +import java.util.Map; import java.util.Vector; /** @@ -31,6 +32,15 @@ import java.util.Vector; */ public class SequenceFeature { + private static final String STATUS = "status"; + + private static final String STRAND = "STRAND"; + + // private key for Phase designed not to conflict with real GFF data + private static final String PHASE = "!Phase"; + + private static final String ATTRIBUTES = "ATTRIBUTES"; + public int begin; public int end; @@ -41,7 +51,7 @@ public class SequenceFeature public String description; - public Hashtable otherDetails; + public Map otherDetails; public Vector links; @@ -54,9 +64,9 @@ public class SequenceFeature } /** - * Constructs a duplicate feature. Note: Uses clone on the otherDetails so - * only shallow copies are made of additional properties and method will - * silently fail if unclonable objects are found in the hash. + * Constructs a duplicate feature. Note: Uses makes a shallow copy of the + * otherDetails map, so the new and original SequenceFeature may reference the + * same objects in the map. * * @param cpy */ @@ -83,10 +93,11 @@ public class SequenceFeature { try { - otherDetails = (Hashtable) cpy.otherDetails.clone(); + otherDetails = (Map) ((HashMap) cpy.otherDetails) + .clone(); } catch (Exception e) { - // Uncloneable objects in the otherDetails - don't complain + // ignore } } if (cpy.links != null && cpy.links.size() > 0) @@ -105,7 +116,7 @@ public class SequenceFeature { this.type = type; this.description = desc; - setValue("status", status); + setValue(STATUS, status); this.begin = begin; this.end = end; this.featureGroup = featureGroup; @@ -122,23 +133,93 @@ public class SequenceFeature 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 (o == null || !(o instanceof SequenceFeature)) + { + return false; + } + + SequenceFeature sf = (SequenceFeature) o; if (begin != sf.begin || end != sf.end || score != sf.score) { 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! @@ -229,7 +310,7 @@ public class SequenceFeature } /** - * Used for getting values which are not in the basic set. eg STRAND, FRAME + * Used for getting values which are not in the basic set. eg STRAND, PHASE * for GFF file * * @param key @@ -248,6 +329,20 @@ public class SequenceFeature } /** + * Returns a property value for the given key if known, else the specified + * default value + * + * @param key + * @param defaultValue + * @return + */ + public Object getValue(String key, Object defaultValue) + { + Object value = getValue(key); + return value == null ? defaultValue : value; + } + + /** * Used for setting values which are not in the basic set. eg STRAND, FRAME * for GFF file * @@ -262,7 +357,7 @@ public class SequenceFeature { if (otherDetails == null) { - otherDetails = new Hashtable(); + otherDetails = new HashMap(); } otherDetails.put(key, value); @@ -275,20 +370,22 @@ public class SequenceFeature */ public void setStatus(String status) { - setValue("status", status); + setValue(STATUS, status); } public String getStatus() { - if (otherDetails != null) - { - String stat = (String) otherDetails.get("status"); - if (stat != null) - { - return new String(stat); - } - } - return null; + return (String) getValue(STATUS); + } + + public void setAttributes(String attr) + { + setValue(ATTRIBUTES, attr); + } + + public String getAttributes() + { + return (String) getValue(ATTRIBUTES); } public void setPosition(int pos) @@ -302,4 +399,67 @@ public class SequenceFeature return begin; } + /** + * Return 1 for forward strand ('+' in GFF), -1 for reverse strand ('-' in + * GFF), and 0 for unknown or not (validly) specified + * + * @return + */ + public int getStrand() + { + int strand = 0; + if (otherDetails != null) + { + Object str = otherDetails.get(STRAND); + if ("-".equals(str)) + { + strand = -1; + } + else if ("+".equals(str)) + { + strand = 1; + } + } + return strand; + } + + public void setStrand(String strand) + { + setValue(STRAND, strand); + } + + public void setPhase(String phase) + { + setValue(PHASE, phase); + } + + public String getPhase() + { + return (String) getValue(PHASE); + } + + /** + * Readable representation, for debug only, not guaranteed not to change + * between versions + */ + @Override + public String toString() + { + 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(); + } }