X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequenceFeature.java;h=30e0929e7f4d7573fd481e54da13608fa8666018;hb=b74cdec4b07000bee431a7cca86a948f44d3ffbe;hp=627e1ae35b3f533860f056e828bf1514eb364ff5;hpb=398491c5f9629ead21e1d1bf975c8372a84c6ebf;p=jalview.git diff --git a/src/jalview/datamodel/SequenceFeature.java b/src/jalview/datamodel/SequenceFeature.java index 627e1ae..30e0929 100755 --- a/src/jalview/datamodel/SequenceFeature.java +++ b/src/jalview/datamodel/SequenceFeature.java @@ -20,20 +20,36 @@ */ package jalview.datamodel; +import jalview.datamodel.features.FeatureAttributeType; +import jalview.datamodel.features.FeatureAttributes; import jalview.datamodel.features.FeatureLocationI; +import jalview.datamodel.features.FeatureSourceI; +import jalview.datamodel.features.FeatureSources; +import jalview.util.StringUtils; +import java.util.Comparator; import java.util.HashMap; import java.util.Map; +import java.util.Map.Entry; +import java.util.SortedMap; +import java.util.TreeMap; import java.util.Vector; +import intervalstore.api.IntervalI; + /** - * DOCUMENT ME! - * - * @author $author$ - * @version $Revision$ + * A class that models a single contiguous feature on a sequence. If flag + * 'contactFeature' is true, the start and end positions are interpreted instead + * as two contact points. */ public class SequenceFeature implements FeatureLocationI { + /* + * score value if none is set; preferably Float.Nan, but see + * JAL-2060 and JAL-2554 for a couple of blockers to that + */ + private static final float NO_SCORE = 0f; + private static final String STATUS = "status"; private static final String STRAND = "STRAND"; @@ -44,6 +60,8 @@ public class SequenceFeature implements FeatureLocationI // private key for ENA location designed not to conflict with real GFF data private static final String LOCATION = "!Location"; + private static final String ROW_DATA = "%s%s%s"; + /* * ATTRIBUTES is reserved for the GFF 'column 9' data, formatted as * name1=value1;name2=value2,value3;...etc @@ -51,9 +69,9 @@ public class SequenceFeature implements FeatureLocationI private static final String ATTRIBUTES = "ATTRIBUTES"; /* - * type, begin, end, featureGroup are final to ensure that - * the integrity of SequenceFeatures data store can't be - * broken by direct update of these fields + * type, begin, end, featureGroup, score and contactFeature are final + * to ensure that the integrity of SequenceFeatures data store + * can't be broken by direct update of these fields */ public final String type; @@ -63,7 +81,9 @@ public class SequenceFeature implements FeatureLocationI public final String featureGroup; - public float score; + public final float score; + + private final boolean contactFeature; public String description; @@ -75,6 +95,12 @@ public class SequenceFeature implements FeatureLocationI public Vector links; + /* + * the identifier (if known) for the FeatureSource held in FeatureSources, + * as a provider of metadata about feature attributes + */ + private String source; + /** * Constructs a duplicate feature. Note: Uses makes a shallow copy of the * otherDetails map, so the new and original SequenceFeature may reference the @@ -84,114 +110,101 @@ public class SequenceFeature implements FeatureLocationI */ public SequenceFeature(SequenceFeature cpy) { - this(cpy, cpy.getBegin(), cpy.getEnd(), cpy.getFeatureGroup()); - - score = cpy.score; - description = cpy.description; - if (cpy.otherDetails != null) - { - try - { - otherDetails = (Map) ((HashMap) cpy.otherDetails) - .clone(); - } catch (Exception e) - { - // ignore - } - } - if (cpy.links != null && cpy.links.size() > 0) - { - links = new Vector(); - for (int i = 0, iSize = cpy.links.size(); i < iSize; i++) - { - links.addElement(cpy.links.elementAt(i)); - } - } - } - - /** - * 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); + this(cpy, cpy.getBegin(), cpy.getEnd(), cpy.getFeatureGroup(), cpy + .getScore()); } /** * Constructor * - * @param type - * @param desc - * @param begin - * @param end - * @param featureGroup + * @param theType + * @param theDesc + * @param theBegin + * @param theEnd + * @param group */ - SequenceFeature(String type, String desc, int begin, int end, - String featureGroup) + public SequenceFeature(String theType, String theDesc, int theBegin, + int theEnd, String group) { - this.type = type; - this.description = desc; - this.begin = begin; - this.end = end; - this.featureGroup = featureGroup; + this(theType, theDesc, theBegin, theEnd, NO_SCORE, group); } /** * Constructor including a score value * - * @param type - * @param desc - * @param begin - * @param end - * @param score - * @param featureGroup + * @param theType + * @param theDesc + * @param theBegin + * @param theEnd + * @param theScore + * @param group */ - public SequenceFeature(String type, String desc, int begin, int end, - float score, String featureGroup) + public SequenceFeature(String theType, String theDesc, int theBegin, + int theEnd, float theScore, String group) { - this(type, desc, begin, end, featureGroup); - this.score = score; + this.type = theType; + this.description = theDesc; + this.begin = theBegin; + this.end = theEnd; + this.featureGroup = group; + this.score = theScore; + + /* + * for now, only "Disulfide/disulphide bond" is treated as a contact feature + */ + this.contactFeature = "disulfide bond".equalsIgnoreCase(type) + || "disulphide bond".equalsIgnoreCase(type); } /** - * A copy constructor that allows the begin and end positions and group to be - * modified + * A copy constructor that allows the value of final fields to be 'modified' * * @param sf + * @param newType * @param newBegin * @param newEnd * @param newGroup + * @param newScore */ - public SequenceFeature(SequenceFeature sf, int newBegin, int newEnd, - String newGroup) + public SequenceFeature(SequenceFeature sf, String newType, int newBegin, + int newEnd, String newGroup, float newScore) { - this(sf.getType(), newBegin, newEnd, newGroup); + this(newType, sf.getDescription(), newBegin, newEnd, newScore, + newGroup); + + this.source = sf.source; + + if (sf.otherDetails != null) + { + otherDetails = new HashMap<>(); + for (Entry entry : sf.otherDetails.entrySet()) + { + otherDetails.put(entry.getKey(), entry.getValue()); + } + } + if (sf.links != null && sf.links.size() > 0) + { + links = new Vector<>(); + for (int i = 0, iSize = sf.links.size(); i < iSize; i++) + { + links.addElement(sf.links.elementAt(i)); + } + } } /** - * Constructor that sets the final fields type, begin, end, group + * A copy constructor that allows the value of final fields to be 'modified' * - * @param theType - * @param theBegin - * @param theEnd - * @param theGroup + * @param sf + * @param newBegin + * @param newEnd + * @param newGroup + * @param newScore */ - private SequenceFeature(String theType, int theBegin, int theEnd, - String theGroup) + public SequenceFeature(SequenceFeature sf, int newBegin, int newEnd, + String newGroup, float newScore) { - type = theType; - begin = theBegin; - end = theEnd; - featureGroup = theGroup; + this(sf, sf.getType(), newBegin, newEnd, newGroup, newScore); } /** @@ -206,10 +219,20 @@ public class SequenceFeature implements FeatureLocationI @Override public boolean equals(Object o) { - return equals(o, false); + return (o != null && (o instanceof SequenceFeature) + && equalsInterval((SequenceFeature) o)); } /** + * Having determined that this is in fact a SequenceFeature, now check it for + * equivalence. Overridden in CrossRef; used by IntervalStore (possibly). + */ + @Override + public boolean equalsInterval(IntervalI sf) + { + return sf != null && equals((SequenceFeature) sf, 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 @@ -219,47 +242,19 @@ public class SequenceFeature implements FeatureLocationI * @param ignoreParent * @return */ - public boolean equals(Object o, boolean ignoreParent) + public boolean equals(SequenceFeature sf, boolean ignoreParent) { - 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 (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; + return (begin == sf.begin && end == sf.end + && getStrand() == sf.getStrand() + && (Float.isNaN(score) ? Float.isNaN(sf.score) + : score == sf.score) + && (type + description + featureGroup + getPhase()) + .equals(sf.type + sf.description + sf.featureGroup + + sf.getPhase()) + && equalAttribute(getValue("ID"), sf.getValue("ID")) + && equalAttribute(getValue("Name"), sf.getValue("Name")) + && (ignoreParent || equalAttribute(getValue("Parent"), + sf.getValue("Parent")))); } /** @@ -338,7 +333,7 @@ public class SequenceFeature implements FeatureLocationI { if (links == null) { - links = new Vector(); + links = new Vector<>(); } if (!links.contains(labelLink)) @@ -352,11 +347,6 @@ public class SequenceFeature implements FeatureLocationI return score; } - public void setScore(float value) - { - score = value; - } - /** * Used for getting values which are not in the basic set. eg STRAND, PHASE * for GFF file @@ -377,6 +367,30 @@ public class SequenceFeature implements FeatureLocationI } /** + * Answers the value of the specified attribute as string, or null if no such + * value. If more than one attribute name is provided, tries to resolve as keys + * to nested maps. For example, if attribute "CSQ" holds a map of key-value + * pairs, then getValueAsString("CSQ", "Allele") returns the value of "Allele" + * in that map. + * + * @param key + * @return + */ + public String getValueAsString(String... key) + { + if (otherDetails == null) + { + return null; + } + Object value = otherDetails.get(key[0]); + if (key.length > 1 && value instanceof Map) + { + value = ((Map) value).get(key[1]); + } + return value == null ? null : value.toString(); + } + + /** * Returns a property value for the given key if known, else the specified * default value * @@ -405,11 +419,33 @@ public class SequenceFeature implements FeatureLocationI { if (otherDetails == null) { - otherDetails = new HashMap(); + otherDetails = new HashMap<>(); } otherDetails.put(key, value); + recordAttribute(key, value); + } + } + + /** + * Notifies the addition of a feature attribute. This lets us keep track of + * which attributes are present on each feature type, and also the range of + * numerical-valued attributes. + * + * @param key + * @param value + */ + protected void recordAttribute(String key, Object value) + { + String attDesc = null; + if (source != null) + { + attDesc = FeatureSources.getInstance().getSource(source) + .getAttributeName(key); } + + FeatureAttributes.getInstance().addAttribute(this.type, attDesc, value, + key); } /* @@ -534,13 +570,7 @@ public class SequenceFeature implements FeatureLocationI @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; + return contactFeature; } /** @@ -552,4 +582,162 @@ public class SequenceFeature implements FeatureLocationI { return begin == 0 && end == 0; } + + /** + * Answers an html-formatted report of feature details + * + * @return + */ + public String getDetailsReport() + { + FeatureSourceI metadata = FeatureSources.getInstance() + .getSource(source); + + StringBuilder sb = new StringBuilder(128); + sb.append("
"); + sb.append(""); + sb.append(String.format(ROW_DATA, "Type", type, "")); + sb.append(String.format(ROW_DATA, "Start/end", begin == end ? begin + : begin + (isContactFeature() ? ":" : "-") + end, "")); + String desc = StringUtils.stripHtmlTags(description); + sb.append(String.format(ROW_DATA, "Description", desc, "")); + if (!Float.isNaN(score) && score != 0f) + { + sb.append(String.format(ROW_DATA, "Score", score, "")); + } + if (featureGroup != null) + { + sb.append(String.format(ROW_DATA, "Group", featureGroup, "")); + } + + if (otherDetails != null) + { + TreeMap ordered = new TreeMap<>( + String.CASE_INSENSITIVE_ORDER); + ordered.putAll(otherDetails); + + for (Entry entry : ordered.entrySet()) + { + String key = entry.getKey(); + if (ATTRIBUTES.equals(key)) + { + continue; // to avoid double reporting + } + + Object value = entry.getValue(); + if (value instanceof Map) + { + /* + * expand values in a Map attribute across separate lines + * copy to a TreeMap for alphabetical ordering + */ + Map values = (Map) value; + SortedMap sm = new TreeMap<>( + String.CASE_INSENSITIVE_ORDER); + sm.putAll(values); + for (Entry e : sm.entrySet()) + { + sb.append(String.format(ROW_DATA, key, e.getKey().toString(), e + .getValue().toString())); + } + } + else + { + // tried
but it failed to provide a tooltip :-( + String attDesc = null; + if (metadata != null) + { + attDesc = metadata.getAttributeName(key); + } + String s = entry.getValue().toString(); + if (isValueInteresting(key, s, metadata)) + { + sb.append(String.format(ROW_DATA, key, attDesc == null ? "" + : attDesc, s)); + } + } + } + } + sb.append("
"); + + String text = sb.toString(); + return text; + } + + /** + * Answers true if we judge the value is worth displaying, by some heuristic + * rules, else false + * + * @param key + * @param value + * @param metadata + * @return + */ + boolean isValueInteresting(String key, String value, + FeatureSourceI metadata) + { + /* + * currently suppressing zero values as well as null or empty + */ + if (value == null || "".equals(value) || ".".equals(value) + || "0".equals(value)) + { + return false; + } + + if (metadata == null) + { + return true; + } + + FeatureAttributeType attType = metadata.getAttributeType(key); + if (attType != null + && (attType == FeatureAttributeType.Float || attType + .equals(FeatureAttributeType.Integer))) + { + try + { + float fval = Float.valueOf(value); + if (fval == 0f) + { + return false; + } + } catch (NumberFormatException e) + { + // ignore + } + } + + return true; // default to interesting + } + + /** + * Sets the feature source identifier + * + * @param theSource + */ + public void setSource(String theSource) + { + source = theSource; + } + + +} + +class SFSortByEnd implements Comparator +{ + @Override + public int compare(SequenceFeature a, SequenceFeature b) + { + return a.getEnd() - b.getEnd(); + } +} + +class SFSortByBegin implements Comparator +{ + @Override + public int compare(SequenceFeature a, SequenceFeature b) + { + return a.getBegin() - b.getBegin(); + } }