X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FSequenceFeature.java;h=bbf1b4515595fdc5837e1384a47cb046259237e1;hb=08c7bee16c16563cc7cec7ea4d336b3e0c4c937a;hp=035291832c22ed56e7a65a398f6cc405d36ad47f;hpb=b0662fe4091847830936de1c4f4522b023dfc323;p=jalview.git diff --git a/src/jalview/datamodel/SequenceFeature.java b/src/jalview/datamodel/SequenceFeature.java index 0352918..bbf1b45 100755 --- a/src/jalview/datamodel/SequenceFeature.java +++ b/src/jalview/datamodel/SequenceFeature.java @@ -20,19 +20,25 @@ */ package jalview.datamodel; -import jalview.datamodel.features.FeatureLocationI; - -import java.util.HashMap; +import java.util.Comparator; +import java.util.LinkedHashMap; import java.util.Map; import java.util.Map.Entry; +import java.util.SortedMap; import java.util.TreeMap; import java.util.Vector; +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; + /** - * 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 { @@ -44,29 +50,15 @@ public class SequenceFeature implements FeatureLocationI private static final String STATUS = "status"; - private static final String STRAND = "STRAND"; + public static final String STRAND = "STRAND"; - // private key for Phase designed not to conflict with real GFF data - private static final String PHASE = "!Phase"; + // key for Phase designed not to conflict with real GFF data + public static final String PHASE = "!Phase"; // private key for ENA location designed not to conflict with real GFF data private static final String LOCATION = "!Location"; - /* - * map of otherDetails special keys, and their value fields' delimiter - */ - private static final Map INFO_KEYS = new HashMap<>(); - - static - { - INFO_KEYS.put("CSQ", ","); - } - - /* - * ATTRIBUTES is reserved for the GFF 'column 9' data, formatted as - * name1=value1;name2=value2,value3;...etc - */ - private static final String ATTRIBUTES = "ATTRIBUTES"; + private static final String ROW_DATA = "%s%s%s"; /* * type, begin, end, featureGroup, score and contactFeature are final @@ -95,6 +87,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 @@ -166,21 +164,17 @@ public class SequenceFeature implements FeatureLocationI 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()); - } + otherDetails = new LinkedHashMap<>(); + otherDetails.putAll(sf.otherDetails); } 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)); - } + links = new Vector<>(); + links.addAll(sf.links); } } @@ -339,11 +333,16 @@ public class SequenceFeature implements FeatureLocationI return featureGroup; } + /** + * Adds a hyperlink for the feature. This should have the format label|url. + * + * @param labelLink + */ public void addLink(String labelLink) { if (links == null) { - links = new Vector(); + links = new Vector<>(); } if (!links.contains(labelLink)) @@ -377,6 +376,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 +428,36 @@ public class SequenceFeature implements FeatureLocationI { if (otherDetails == null) { - otherDetails = new HashMap(); + /* + * LinkedHashMap preserves insertion order of attributes + */ + otherDetails = new LinkedHashMap<>(); } 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); } /* @@ -426,16 +474,6 @@ public class SequenceFeature implements FeatureLocationI return (String) getValue(STATUS); } - public void setAttributes(String attr) - { - setValue(ATTRIBUTES, attr); - } - - public String getAttributes() - { - return (String) getValue(ATTRIBUTES); - } - /** * Return 1 for forward strand ('+' in GFF), -1 for reverse strand ('-' in * GFF), and 0 for unknown or not (validly) specified @@ -548,26 +586,60 @@ public class SequenceFeature implements FeatureLocationI } /** - * Answers a formatted text report of feature details + * Answers an html-formatted report of feature details. If parameter + * {@code mf} is not null, the feature is a virtual linked feature, and + * details included both the original location and the mapped location + * (CDS/peptide). + * + * @param seqName + * @param mf * * @return */ - public String getDetailsReport() + public String getDetailsReport(String seqName, MappedFeatures mf) { + FeatureSourceI metadata = FeatureSources.getInstance() + .getSource(source); + StringBuilder sb = new StringBuilder(128); - if (begin == end) + sb.append("
"); + sb.append(""); + String name = mf == null ? seqName : mf.getLinkedSequenceName(); + sb.append(String.format(ROW_DATA, "Location", name, + begin == end ? begin + : begin + (isContactFeature() ? ":" : "-") + end)); + + String consequence = ""; + if (mf != null) { - sb.append(String.format("%s %d %s", type, begin, description)); + int[] localRange = mf.getMappedPositions(begin, end); + int from = localRange[0]; + int to = localRange[localRange.length - 1]; + String s = mf.isFromCds() ? "Peptide Location" : "Coding location"; + sb.append(String.format(ROW_DATA, s, seqName, from == to ? from + : from + (isContactFeature() ? ":" : "-") + to)); + if (mf.isFromCds()) + { + consequence = mf.findProteinVariants(this); + } } - else + sb.append(String.format(ROW_DATA, "Type", type, "")); + String desc = StringUtils.stripHtmlTags(description); + sb.append(String.format(ROW_DATA, "Description", desc, "")); + if (!Float.isNaN(score) && score != 0f) { - sb.append(String.format("%s %d-%d %s", type, begin, end, description)); + sb.append(String.format(ROW_DATA, "Score", score, "")); } if (featureGroup != null) { - sb.append(" (").append(featureGroup).append(")"); + sb.append(String.format(ROW_DATA, "Group", featureGroup, "")); + } + + if (!consequence.isEmpty()) + { + sb.append(String.format(ROW_DATA, "Consequence", + "Translated by Jalview", consequence)); } - sb.append("\n\n"); if (otherDetails != null) { @@ -578,27 +650,119 @@ public class SequenceFeature implements FeatureLocationI for (Entry entry : ordered.entrySet()) { String key = entry.getKey(); - if (ATTRIBUTES.equals(key)) - { - continue; // to avoid double reporting - } - if (INFO_KEYS.containsKey(key)) + + Object value = entry.getValue(); + if (value instanceof Map) { /* - * split selected INFO data by delimiter over multiple lines + * expand values in a Map attribute across separate lines + * copy to a TreeMap for alphabetical ordering */ - sb.append(key).append("=\n "); - String delimiter = INFO_KEYS.get(key); - String value = entry.getValue().toString(); - sb.append(value.replace(delimiter, "\n ")); + 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 { - sb.append(key + "=" + entry.getValue().toString() + "\n"); + // 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(); + } }