src/jalview/datamodel/SequenceFeature.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.datamodel;
  22
  23 import jalview.datamodel.features.FeatureAttributeType;
  24 import jalview.datamodel.features.FeatureAttributes;
  25 import jalview.datamodel.features.FeatureLocationI;
  26 import jalview.datamodel.features.FeatureSourceI;
  27 import jalview.datamodel.features.FeatureSources;
  28 import jalview.util.StringUtils;
  29
  30 import java.util.HashMap;
  31 import java.util.Map;
  32 import java.util.Map.Entry;
  33 import java.util.TreeMap;
  34 import java.util.Vector;
  35
  36 /**
  37  * A class that models a single contiguous feature on a sequence. If flag
  38  * 'contactFeature' is true, the start and end positions are interpreted instead
  39  * as two contact points.
  40  */
  41 public class SequenceFeature implements FeatureLocationI
  42 {
  43   /*
  44    * score value if none is set; preferably Float.Nan, but see
  45    * JAL-2060 and JAL-2554 for a couple of blockers to that
  46    */
  47   private static final float NO_SCORE = 0f;
  48
  49   private static final String STATUS = "status";
  50
  51   private static final String STRAND = "STRAND";
  52
  53   // private key for Phase designed not to conflict with real GFF data
  54   private static final String PHASE = "!Phase";
  55
  56   // private key for ENA location designed not to conflict with real GFF data
  57   private static final String LOCATION = "!Location";
  58
  59   private static final String ROW_DATA = "<tr><td>%s</td><td>%s</td><td>%s</td></tr>";
  60
  61   /*
  62    * map of otherDetails special keys, and their value fields' delimiter
  63    */
  64   private static final Map<String, String> INFO_KEYS = new HashMap<>();
  65
  66   static
  67   {
  68     INFO_KEYS.put("CSQ", ",");
  69     // todo capture second level metadata (CSQ FORMAT)
  70     // and delimiter "|" so as to report in a table within a table?
  71   }
  72
  73   /*
  74    * ATTRIBUTES is reserved for the GFF 'column 9' data, formatted as
  75    * name1=value1;name2=value2,value3;...etc
  76    */
  77   private static final String ATTRIBUTES = "ATTRIBUTES";
  78
  79   /*
  80    * type, begin, end, featureGroup, score and contactFeature are final
  81    * to ensure that the integrity of SequenceFeatures data store
  82    * can't be broken by direct update of these fields
  83    */
  84   public final String type;
  85
  86   public final int begin;
  87
  88   public final int end;
  89
  90   public final String featureGroup;
  91
  92   public final float score;
  93
  94   private final boolean contactFeature;
  95
  96   public String description;
  97
  98   /*
  99    * a map of key-value pairs; may be populated from GFF 'column 9' data,
 100    * other data sources (e.g. GenBank file), or programmatically
 101    */
 102   public Map<String, Object> otherDetails;
 103
 104   public Vector<String> links;
 105
 106   /*
 107    * the identifier (if known) for the FeatureSource held in FeatureSources,
 108    * as a provider of metadata about feature attributes
 109    */
 110   private String source;
 111
 112   /**
 113    * Constructs a duplicate feature. Note: Uses makes a shallow copy of the
 114    * otherDetails map, so the new and original SequenceFeature may reference the
 115    * same objects in the map.
 116    *
 117    * @param cpy
 118    */
 119   public SequenceFeature(SequenceFeature cpy)
 120   {
 121     this(cpy, cpy.getBegin(), cpy.getEnd(), cpy.getFeatureGroup(), cpy
 122             .getScore());
 123   }
 124
 125   /**
 126    * Constructor
 127    *
 128    * @param theType
 129    * @param theDesc
 130    * @param theBegin
 131    * @param theEnd
 132    * @param group
 133    */
 134   public SequenceFeature(String theType, String theDesc, int theBegin,
 135           int theEnd, String group)
 136   {
 137     this(theType, theDesc, theBegin, theEnd, NO_SCORE, group);
 138   }
 139
 140   /**
 141    * Constructor including a score value
 142    *
 143    * @param theType
 144    * @param theDesc
 145    * @param theBegin
 146    * @param theEnd
 147    * @param theScore
 148    * @param group
 149    */
 150   public SequenceFeature(String theType, String theDesc, int theBegin,
 151           int theEnd, float theScore, String group)
 152   {
 153     this.type = theType;
 154     this.description = theDesc;
 155     this.begin = theBegin;
 156     this.end = theEnd;
 157     this.featureGroup = group;
 158     this.score = theScore;
 159
 160     /*
 161      * for now, only "Disulfide/disulphide bond" is treated as a contact feature
 162      */
 163     this.contactFeature = "disulfide bond".equalsIgnoreCase(type)
 164             || "disulphide bond".equalsIgnoreCase(type);
 165   }
 166
 167   /**
 168    * A copy constructor that allows the value of final fields to be 'modified'
 169    *
 170    * @param sf
 171    * @param newType
 172    * @param newBegin
 173    * @param newEnd
 174    * @param newGroup
 175    * @param newScore
 176    */
 177   public SequenceFeature(SequenceFeature sf, String newType, int newBegin,
 178           int newEnd, String newGroup, float newScore)
 179   {
 180     this(newType, sf.getDescription(), newBegin, newEnd, newScore,
 181             newGroup);
 182
 183     this.source = sf.source;
 184
 185     if (sf.otherDetails != null)
 186     {
 187       otherDetails = new HashMap<String, Object>();
 188       for (Entry<String, Object> entry : sf.otherDetails.entrySet())
 189       {
 190         otherDetails.put(entry.getKey(), entry.getValue());
 191       }
 192     }
 193     if (sf.links != null && sf.links.size() > 0)
 194     {
 195       links = new Vector<String>();
 196       for (int i = 0, iSize = sf.links.size(); i < iSize; i++)
 197       {
 198         links.addElement(sf.links.elementAt(i));
 199       }
 200     }
 201   }
 202
 203   /**
 204    * A copy constructor that allows the value of final fields to be 'modified'
 205    *
 206    * @param sf
 207    * @param newBegin
 208    * @param newEnd
 209    * @param newGroup
 210    * @param newScore
 211    */
 212   public SequenceFeature(SequenceFeature sf, int newBegin, int newEnd,
 213           String newGroup, float newScore)
 214   {
 215     this(sf, sf.getType(), newBegin, newEnd, newGroup, newScore);
 216   }
 217
 218   /**
 219    * Two features are considered equal if they have the same type, group,
 220    * description, start, end, phase, strand, and (if present) 'Name', ID' and
 221    * 'Parent' attributes.
 222    *
 223    * Note we need to check Parent to distinguish the same exon occurring in
 224    * different transcripts (in Ensembl GFF). This allows assembly of transcript
 225    * sequences from their component exon regions.
 226    */
 227   @Override
 228   public boolean equals(Object o)
 229   {
 230     return equals(o, false);
 231   }
 232
 233   /**
 234    * Overloaded method allows the equality test to optionally ignore the
 235    * 'Parent' attribute of a feature. This supports avoiding adding many
 236    * superficially duplicate 'exon' or CDS features to genomic or protein
 237    * sequence.
 238    *
 239    * @param o
 240    * @param ignoreParent
 241    * @return
 242    */
 243   public boolean equals(Object o, boolean ignoreParent)
 244   {
 245     if (o == null || !(o instanceof SequenceFeature))
 246     {
 247       return false;
 248     }
 249
 250     SequenceFeature sf = (SequenceFeature) o;
 251     boolean sameScore = Float.isNaN(score) ? Float.isNaN(sf.score)
 252             : score == sf.score;
 253     if (begin != sf.begin || end != sf.end || !sameScore)
 254     {
 255       return false;
 256     }
 257
 258     if (getStrand() != sf.getStrand())
 259     {
 260       return false;
 261     }
 262
 263     if (!(type + description + featureGroup + getPhase()).equals(
 264             sf.type + sf.description + sf.featureGroup + sf.getPhase()))
 265     {
 266       return false;
 267     }
 268     if (!equalAttribute(getValue("ID"), sf.getValue("ID")))
 269     {
 270       return false;
 271     }
 272     if (!equalAttribute(getValue("Name"), sf.getValue("Name")))
 273     {
 274       return false;
 275     }
 276     if (!ignoreParent)
 277     {
 278       if (!equalAttribute(getValue("Parent"), sf.getValue("Parent")))
 279       {
 280         return false;
 281       }
 282     }
 283     return true;
 284   }
 285
 286   /**
 287    * Returns true if both values are null, are both non-null and equal
 288    *
 289    * @param att1
 290    * @param att2
 291    * @return
 292    */
 293   protected static boolean equalAttribute(Object att1, Object att2)
 294   {
 295     if (att1 == null && att2 == null)
 296     {
 297       return true;
 298     }
 299     if (att1 != null)
 300     {
 301       return att1.equals(att2);
 302     }
 303     return att2.equals(att1);
 304   }
 305
 306   /**
 307    * DOCUMENT ME!
 308    *
 309    * @return DOCUMENT ME!
 310    */
 311   @Override
 312   public int getBegin()
 313   {
 314     return begin;
 315   }
 316
 317   /**
 318    * DOCUMENT ME!
 319    *
 320    * @return DOCUMENT ME!
 321    */
 322   @Override
 323   public int getEnd()
 324   {
 325     return end;
 326   }
 327
 328   /**
 329    * DOCUMENT ME!
 330    *
 331    * @return DOCUMENT ME!
 332    */
 333   public String getType()
 334   {
 335     return type;
 336   }
 337
 338   /**
 339    * DOCUMENT ME!
 340    *
 341    * @return DOCUMENT ME!
 342    */
 343   public String getDescription()
 344   {
 345     return description;
 346   }
 347
 348   public void setDescription(String desc)
 349   {
 350     description = desc;
 351   }
 352
 353   public String getFeatureGroup()
 354   {
 355     return featureGroup;
 356   }
 357
 358   public void addLink(String labelLink)
 359   {
 360     if (links == null)
 361     {
 362       links = new Vector<String>();
 363     }
 364
 365     if (!links.contains(labelLink))
 366     {
 367       links.insertElementAt(labelLink, 0);
 368     }
 369   }
 370
 371   public float getScore()
 372   {
 373     return score;
 374   }
 375
 376   /**
 377    * Used for getting values which are not in the basic set. eg STRAND, PHASE
 378    * for GFF file
 379    *
 380    * @param key
 381    *          String
 382    */
 383   public Object getValue(String key)
 384   {
 385     if (otherDetails == null)
 386     {
 387       return null;
 388     }
 389     else
 390     {
 391       return otherDetails.get(key);
 392     }
 393   }
 394
 395   /**
 396    * Answers the value of the specified attribute as string, or null if no such
 397    * value
 398    *
 399    * @param key
 400    * @return
 401    */
 402   public String getValueAsString(String key)
 403   {
 404     if (otherDetails == null)
 405     {
 406       return null;
 407     }
 408     Object value = otherDetails.get(key);
 409     return value == null ? null : value.toString();
 410   }
 411
 412   /**
 413    * Returns a property value for the given key if known, else the specified
 414    * default value
 415    *
 416    * @param key
 417    * @param defaultValue
 418    * @return
 419    */
 420   public Object getValue(String key, Object defaultValue)
 421   {
 422     Object value = getValue(key);
 423     return value == null ? defaultValue : value;
 424   }
 425
 426   /**
 427    * Used for setting values which are not in the basic set. eg STRAND, FRAME
 428    * for GFF file
 429    *
 430    * @param key
 431    *          eg STRAND
 432    * @param value
 433    *          eg +
 434    */
 435   public void setValue(String key, Object value)
 436   {
 437     if (value != null)
 438     {
 439       if (otherDetails == null)
 440       {
 441         otherDetails = new HashMap<String, Object>();
 442       }
 443
 444       otherDetails.put(key, value);
 445       recordAttribute(key, value);
 446     }
 447   }
 448
 449   /**
 450    * Notifies the addition of a feature attribute. This lets us keep track of
 451    * which attributes are present on each feature type, and also the range of
 452    * numerical-valued attributes.
 453    *
 454    * @param key
 455    * @param value
 456    */
 457   protected void recordAttribute(String key, Object value)
 458   {
 459     String attDesc = null;
 460     if (source != null)
 461     {
 462       attDesc = FeatureSources.getInstance().getSource(source)
 463               .getAttributeName(key);
 464     }
 465
 466     FeatureAttributes.getInstance().addAttribute(this.type, key, attDesc,
 467             value.toString());
 468   }
 469
 470   /*
 471    * The following methods are added to maintain the castor Uniprot mapping file
 472    * for the moment.
 473    */
 474   public void setStatus(String status)
 475   {
 476     setValue(STATUS, status);
 477   }
 478
 479   public String getStatus()
 480   {
 481     return (String) getValue(STATUS);
 482   }
 483
 484   public void setAttributes(String attr)
 485   {
 486     setValue(ATTRIBUTES, attr);
 487   }
 488
 489   public String getAttributes()
 490   {
 491     return (String) getValue(ATTRIBUTES);
 492   }
 493
 494   /**
 495    * Return 1 for forward strand ('+' in GFF), -1 for reverse strand ('-' in
 496    * GFF), and 0 for unknown or not (validly) specified
 497    *
 498    * @return
 499    */
 500   public int getStrand()
 501   {
 502     int strand = 0;
 503     if (otherDetails != null)
 504     {
 505       Object str = otherDetails.get(STRAND);
 506       if ("-".equals(str))
 507       {
 508         strand = -1;
 509       }
 510       else if ("+".equals(str))
 511       {
 512         strand = 1;
 513       }
 514     }
 515     return strand;
 516   }
 517
 518   /**
 519    * Set the value of strand
 520    *
 521    * @param strand
 522    *          should be "+" for forward, or "-" for reverse
 523    */
 524   public void setStrand(String strand)
 525   {
 526     setValue(STRAND, strand);
 527   }
 528
 529   public void setPhase(String phase)
 530   {
 531     setValue(PHASE, phase);
 532   }
 533
 534   public String getPhase()
 535   {
 536     return (String) getValue(PHASE);
 537   }
 538
 539   /**
 540    * Sets the 'raw' ENA format location specifier e.g. join(12..45,89..121)
 541    *
 542    * @param loc
 543    */
 544   public void setEnaLocation(String loc)
 545   {
 546     setValue(LOCATION, loc);
 547   }
 548
 549   /**
 550    * Gets the 'raw' ENA format location specifier e.g. join(12..45,89..121)
 551    *
 552    * @param loc
 553    */
 554   public String getEnaLocation()
 555   {
 556     return (String) getValue(LOCATION);
 557   }
 558
 559   /**
 560    * Readable representation, for debug only, not guaranteed not to change
 561    * between versions
 562    */
 563   @Override
 564   public String toString()
 565   {
 566     return String.format("%d %d %s %s", getBegin(), getEnd(), getType(),
 567             getDescription());
 568   }
 569
 570   /**
 571    * Overridden to ensure that whenever two objects are equal, they have the
 572    * same hashCode
 573    */
 574   @Override
 575   public int hashCode()
 576   {
 577     String s = getType() + getDescription() + getFeatureGroup()
 578             + getValue("ID") + getValue("Name") + getValue("Parent")
 579             + getPhase();
 580     return s.hashCode() + getBegin() + getEnd() + (int) getScore()
 581             + getStrand();
 582   }
 583
 584   /**
 585    * Answers true if the feature's start/end values represent two related
 586    * positions, rather than ends of a range. Such features may be visualised or
 587    * reported differently to features on a range.
 588    */
 589   @Override
 590   public boolean isContactFeature()
 591   {
 592     return contactFeature;
 593   }
 594
 595   /**
 596    * Answers true if the sequence has zero start and end position
 597    *
 598    * @return
 599    */
 600   public boolean isNonPositional()
 601   {
 602     return begin == 0 && end == 0;
 603   }
 604
 605   /**
 606    * Answers an html-formatted report of feature details
 607    *
 608    * @return
 609    */
 610   public String getDetailsReport()
 611   {
 612     FeatureSourceI metadata = FeatureSources.getInstance()
 613             .getSource(source);
 614
 615     StringBuilder sb = new StringBuilder(128);
 616     sb.append("<br>");
 617     sb.append("<table>");
 618     sb.append(String.format(ROW_DATA, "Type", type, ""));
 619     sb.append(String.format(ROW_DATA, "Start/end", begin == end ? begin
 620             : begin + (isContactFeature() ? ":" : "-") + end, ""));
 621     String desc = StringUtils.stripHtmlTags(description);
 622     sb.append(String.format(ROW_DATA, "Description", desc, ""));
 623     if (!Float.isNaN(score) && score != 0f)
 624     {
 625       sb.append(String.format(ROW_DATA, "Score", score, ""));
 626     }
 627     if (featureGroup != null)
 628     {
 629       sb.append(String.format(ROW_DATA, "Group", featureGroup, ""));
 630     }
 631
 632     if (otherDetails != null)
 633     {
 634       TreeMap<String, Object> ordered = new TreeMap<>(
 635               String.CASE_INSENSITIVE_ORDER);
 636       ordered.putAll(otherDetails);
 637
 638       for (Entry<String, Object> entry : ordered.entrySet())
 639       {
 640         String key = entry.getKey();
 641         if (ATTRIBUTES.equals(key))
 642         {
 643           continue; // to avoid double reporting
 644         }
 645         if (INFO_KEYS.containsKey(key))
 646         {
 647           /*
 648            * split selected INFO data by delimiter over multiple lines
 649            */
 650           String delimiter = INFO_KEYS.get(key);
 651           String[] values = entry.getValue().toString().split(delimiter);
 652           for (String value : values)
 653           {
 654             sb.append(String.format(ROW_DATA, key, "", value));
 655           }
 656         }
 657         else
 658         { // tried <td title="key"> but it failed to provide a tooltip :-(
 659           String attDesc = null;
 660           if (metadata != null)
 661           {
 662             attDesc = metadata.getAttributeName(key);
 663           }
 664           String value = entry.getValue().toString();
 665           if (isValueInteresting(key, value, metadata))
 666           {
 667             sb.append(String.format(ROW_DATA, key, attDesc == null ? ""
 668                     : attDesc, value));
 669           }
 670         }
 671       }
 672     }
 673     sb.append("</table>");
 674
 675     String text = sb.toString();
 676     return text;
 677   }
 678
 679   /**
 680    * Answers true if we judge the value is worth displaying, by some heuristic
 681    * rules, else false
 682    *
 683    * @param key
 684    * @param value
 685    * @param metadata
 686    * @return
 687    */
 688   boolean isValueInteresting(String key, String value,
 689           FeatureSourceI metadata)
 690   {
 691     /*
 692      * currently suppressing zero values as well as null or empty
 693      */
 694     if (value == null || "".equals(value) || ".".equals(value)
 695             || "0".equals(value))
 696     {
 697       return false;
 698     }
 699
 700     if (metadata == null)
 701     {
 702       return true;
 703     }
 704
 705     FeatureAttributeType attType = metadata.getAttributeType(key);
 706     if (attType != null
 707             && (attType == FeatureAttributeType.Float || attType
 708                     .equals(FeatureAttributeType.Integer)))
 709     {
 710       try
 711       {
 712         float fval = Float.valueOf(value);
 713         if (fval == 0f)
 714         {
 715           return false;
 716         }
 717       } catch (NumberFormatException e)
 718       {
 719         // ignore
 720       }
 721     }
 722
 723     return true; // default to interesting
 724   }
 725
 726   /**
 727    * Sets the feature source identifier
 728    *
 729    * @param theSource
 730    */
 731   public void setSource(String theSource)
 732   {
 733     source = theSource;
 734   }
 735 }