X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2Ffeatures%2FFeatureAttributes.java;h=26e6f8b9844a34420812d30a1afe1eff5b09efb5;hb=b53d89acfa678df63d6870176b4c7ec9285f52ee;hp=3dc4f191950acf6428282e5b5d6437f4b90a424b;hpb=14307f5cfcbc90c419c892434613a500ca550ecc;p=jalview.git diff --git a/src/jalview/datamodel/features/FeatureAttributes.java b/src/jalview/datamodel/features/FeatureAttributes.java index 3dc4f19..26e6f8b 100644 --- a/src/jalview/datamodel/features/FeatureAttributes.java +++ b/src/jalview/datamodel/features/FeatureAttributes.java @@ -2,9 +2,11 @@ package jalview.datamodel.features; import java.util.ArrayList; import java.util.Collections; +import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.TreeMap; /** @@ -12,9 +14,52 @@ import java.util.TreeMap; */ public class FeatureAttributes { + public enum Datatype + { + Character, Number, Mixed + } + private static FeatureAttributes instance = new FeatureAttributes(); - private Map> attributes; + /* + * map, by feature type, of a map, by attribute name, of + * attribute description and min-max range (if known) + */ + private Map> attributes; + + /* + * a case-insensitive comparator so that attributes are ordered e.g. + * AC + * af + * CSQ:AFR_MAF + * CSQ:Allele + */ + private Comparator comparator = new Comparator() + { + @Override + public int compare(String[] o1, String[] o2) + { + int i = 0; + while (i < o1.length || i < o2.length) + { + if (o2.length <= i) + { + return o1.length <= i ? 0 : 1; + } + if (o1.length <= i) + { + return -1; + } + int comp = String.CASE_INSENSITIVE_ORDER.compare(o1[i], o2[i]); + if (comp != 0) + { + return comp; + } + i++; + } + return 0; // same length and all matched + } + }; private class AttributeData { @@ -39,9 +84,11 @@ public class FeatureAttributes */ boolean hasValue = false; + Datatype type; + /** - * Note one instance of this attribute, recording unique, non-null names, - * and the min/max of any numerical values + * Note one instance of this attribute, recording unique, non-null + * descriptions, and the min/max of any numerical values * * @param desc * @param value @@ -52,15 +99,35 @@ public class FeatureAttributes if (value != null) { - try - { - float f = Float.valueOf(value); - min = Float.min(min, f); - max = Float.max(max, f); - hasValue = true; - } catch (NumberFormatException e) + value = value.trim(); + + /* + * Parse numeric value unless we have previously + * seen text data for this attribute type + */ + if (type == null || type == Datatype.Number) { - // ok, wasn't a number, ignore for min-max purposes + try + { + float f = Float.valueOf(value); + min = hasValue ? Float.min(min, f) : f; + max = hasValue ? Float.max(max, f) : f; + hasValue = true; + type = (type == null || type == Datatype.Number) + ? Datatype.Number + : Datatype.Mixed; + } catch (NumberFormatException e) + { + /* + * non-numeric data: treat attribute as Character (or Mixed) + */ + type = (type == null || type == Datatype.Character) + ? Datatype.Character + : Datatype.Mixed; + min = 0f; + max = 0f; + hasValue = false; + } } } } @@ -78,6 +145,11 @@ public class FeatureAttributes return null; } + public Datatype getType() + { + return type; + } + /** * Adds the given description to the list of known descriptions (without * duplication) @@ -116,17 +188,19 @@ public class FeatureAttributes } /** - * Answers the attributes known for the given feature type, in alphabetical - * order (not case sensitive), or an empty set if no attributes are known + * Answers the attribute names known for the given feature type, in + * alphabetical order (not case sensitive), or an empty set if no attributes + * are known. An attribute name is typically 'simple' e.g. "AC", but may be + * 'compound' e.g. {"CSQ", "Allele"} where a feature has map-valued attributes * * @param featureType * @return */ - public List getAttributes(String featureType) + public List getAttributes(String featureType) { if (!attributes.containsKey(featureType)) { - return Collections. emptyList(); + return Collections. emptyList(); } return new ArrayList<>(attributes.get(featureType).keySet()); @@ -156,23 +230,39 @@ public class FeatureAttributes * type, and updates the min-max for any numeric value * * @param featureType - * @param attName * @param description * @param value + * @param attName */ - public void addAttribute(String featureType, String attName, - String description, String value) + public void addAttribute(String featureType, String description, + Object value, String... attName) { if (featureType == null || attName == null) { return; } - Map atts = attributes.get(featureType); + /* + * if attribute value is a map, drill down one more level to + * record its sub-fields + */ + if (value instanceof Map) + { + for (Entry entry : ((Map) value).entrySet()) + { + String[] attNames = new String[attName.length + 1]; + System.arraycopy(attName, 0, attNames, 0, attName.length); + attNames[attName.length] = entry.getKey().toString(); + addAttribute(featureType, description, entry.getValue(), attNames); + } + return; + } + + String valueAsString = value.toString(); + Map atts = attributes.get(featureType); if (atts == null) { - atts = new TreeMap( - String.CASE_INSENSITIVE_ORDER); + atts = new TreeMap<>(comparator); attributes.put(featureType, atts); } AttributeData attData = atts.get(attName); @@ -181,7 +271,7 @@ public class FeatureAttributes attData = new AttributeData(); atts.put(attName, attData); } - attData.addInstance(description, value); + attData.addInstance(description, valueAsString); } /** @@ -192,10 +282,10 @@ public class FeatureAttributes * @param attName * @return */ - public String getDescription(String featureType, String attName) + public String getDescription(String featureType, String... attName) { String desc = null; - Map atts = attributes.get(featureType); + Map atts = attributes.get(featureType); if (atts != null) { AttributeData attData = atts.get(attName); @@ -209,17 +299,16 @@ public class FeatureAttributes /** * Answers the [min, max] value range of the given attribute for the given - * feature type, if known, else null. Attributes which only have text values - * would normally return null, however text values which happen to be numeric - * could result in a 'min-max' range. + * feature type, if known, else null. Attributes with a mixture of text and + * numeric values are considered text (do not return a min-max range). * * @param featureType * @param attName * @return */ - public float[] getMinMax(String featureType, String attName) + public float[] getMinMax(String featureType, String... attName) { - Map atts = attributes.get(featureType); + Map atts = attributes.get(featureType); if (atts != null) { AttributeData attData = atts.get(attName); @@ -238,19 +327,18 @@ public class FeatureAttributes * @param attName * @param description */ - public void addDescription(String featureType, String attName, - String description) + public void addDescription(String featureType, String description, + String... attName) { if (featureType == null || attName == null) { return; } - Map atts = attributes.get(featureType); + Map atts = attributes.get(featureType); if (atts == null) { - atts = new TreeMap( - String.CASE_INSENSITIVE_ORDER); + atts = new TreeMap<>(comparator); attributes.put(featureType, atts); } AttributeData attData = atts.get(attName); @@ -261,4 +349,49 @@ public class FeatureAttributes } attData.addDescription(description); } + + /** + * Answers the datatype of the feature, which is one of Character, Number or + * Mixed (or null if not known), as discovered from values recorded. + * + * @param featureType + * @param attName + * @return + */ + public Datatype getDatatype(String featureType, String... attName) + { + Map atts = attributes.get(featureType); + if (atts != null) + { + AttributeData attData = atts.get(attName); + if (attData != null) + { + return attData.getType(); + } + } + return null; + } + + /** + * Resets all attribute metadata + */ + public void clear() + { + attributes.clear(); + } + + /** + * Resets attribute metadata for one feature type + * + * @param featureType + */ + public void clear(String featureType) + { + Map map = attributes.get(featureType); + if (map != null) + { + map.clear(); + } + + } }