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.FeatureLocationI;
  24
  25 import java.util.HashMap;
  26 import java.util.Map;
  27 import java.util.Map.Entry;
  28 import java.util.Vector;
  29
  30 /**
  31  * DOCUMENT ME!
  32  *
  33  * @author $author$
  34  * @version $Revision$
  35  */
  36 public class SequenceFeature implements FeatureLocationI
  37 {
  38   /*
  39    * score value if none is set; preferably Float.Nan, but see
  40    * JAL-2060 and JAL-2554 for a couple of blockers to that
  41    */
  42   private static final float NO_SCORE = 0f;
  43
  44   private static final String STATUS = "status";
  45
  46   private static final String STRAND = "STRAND";
  47
  48   // private key for Phase designed not to conflict with real GFF data
  49   private static final String PHASE = "!Phase";
  50
  51   // private key for ENA location designed not to conflict with real GFF data
  52   private static final String LOCATION = "!Location";
  53
  54   /*
  55    * ATTRIBUTES is reserved for the GFF 'column 9' data, formatted as
  56    * name1=value1;name2=value2,value3;...etc
  57    */
  58   private static final String ATTRIBUTES = "ATTRIBUTES";
  59
  60   /*
  61    * type, begin, end, featureGroup, score and contactFeature are final
  62    * to ensure that the integrity of SequenceFeatures data store
  63    * can't be broken by direct update of these fields
  64    */
  65   public final String type;
  66
  67   public final int begin;
  68
  69   public final int end;
  70
  71   public final String featureGroup;
  72
  73   public final float score;
  74
  75   private final boolean contactFeature;
  76
  77   public String description;
  78
  79   /*
  80    * a map of key-value pairs; may be populated from GFF 'column 9' data,
  81    * other data sources (e.g. GenBank file), or programmatically
  82    */
  83   public Map<String, Object> otherDetails;
  84
  85   public Vector<String> links;
  86
  87   /**
  88    * Constructs a duplicate feature. Note: Uses makes a shallow copy of the
  89    * otherDetails map, so the new and original SequenceFeature may reference the
  90    * same objects in the map.
  91    *
  92    * @param cpy
  93    */
  94   public SequenceFeature(SequenceFeature cpy)
  95   {
  96     this(cpy, cpy.getBegin(), cpy.getEnd(), cpy.getFeatureGroup(), cpy
  97             .getScore());
  98   }
  99
 100   /**
 101    * Constructor
 102    *
 103    * @param theType
 104    * @param theDesc
 105    * @param theBegin
 106    * @param theEnd
 107    * @param group
 108    */
 109   public SequenceFeature(String theType, String theDesc, int theBegin,
 110           int theEnd, String group)
 111   {
 112     this(theType, theDesc, theBegin, theEnd, NO_SCORE, group);
 113   }
 114
 115   /**
 116    * Constructor including a score value
 117    *
 118    * @param theType
 119    * @param theDesc
 120    * @param theBegin
 121    * @param theEnd
 122    * @param theScore
 123    * @param group
 124    */
 125   public SequenceFeature(String theType, String theDesc, int theBegin,
 126           int theEnd, float theScore, String group)
 127   {
 128     this.type = theType;
 129     this.description = theDesc;
 130     this.begin = theBegin;
 131     this.end = theEnd;
 132     this.featureGroup = group;
 133     this.score = theScore;
 134
 135     /*
 136      * for now, only "Disulfide/disulphide bond" is treated as a contact feature
 137      */
 138     this.contactFeature = "disulfide bond".equalsIgnoreCase(type)
 139             || "disulphide bond".equalsIgnoreCase(type);
 140   }
 141
 142   /**
 143    * A copy constructor that allows the value of final fields to be 'modified'
 144    *
 145    * @param sf
 146    * @param newBegin
 147    * @param newEnd
 148    * @param newGroup
 149    * @param newScore
 150    */
 151   public SequenceFeature(SequenceFeature sf, int newBegin, int newEnd,
 152           String newGroup, float newScore)
 153   {
 154     this(sf.getType(), sf.getDescription(), newBegin, newEnd, newScore,
 155             newGroup);
 156
 157     if (sf.otherDetails != null)
 158     {
 159       otherDetails = new HashMap<String, Object>();
 160       for (Entry<String, Object> entry : sf.otherDetails.entrySet())
 161       {
 162         otherDetails.put(entry.getKey(), entry.getValue());
 163       }
 164     }
 165     if (sf.links != null && sf.links.size() > 0)
 166     {
 167       links = new Vector<String>();
 168       for (int i = 0, iSize = sf.links.size(); i < iSize; i++)
 169       {
 170         links.addElement(sf.links.elementAt(i));
 171       }
 172     }
 173   }
 174
 175   /**
 176    * Two features are considered equal if they have the same type, group,
 177    * description, start, end, phase, strand, and (if present) 'Name', ID' and
 178    * 'Parent' attributes.
 179    *
 180    * Note we need to check Parent to distinguish the same exon occurring in
 181    * different transcripts (in Ensembl GFF). This allows assembly of transcript
 182    * sequences from their component exon regions.
 183    */
 184   @Override
 185   public boolean equals(Object o)
 186   {
 187     return equals(o, false);
 188   }
 189
 190   /**
 191    * Overloaded method allows the equality test to optionally ignore the
 192    * 'Parent' attribute of a feature. This supports avoiding adding many
 193    * superficially duplicate 'exon' or CDS features to genomic or protein
 194    * sequence.
 195    *
 196    * @param o
 197    * @param ignoreParent
 198    * @return
 199    */
 200   public boolean equals(Object o, boolean ignoreParent)
 201   {
 202     if (o == null || !(o instanceof SequenceFeature))
 203     {
 204       return false;
 205     }
 206
 207     SequenceFeature sf = (SequenceFeature) o;
 208     boolean sameScore = Float.isNaN(score) ? Float.isNaN(sf.score)
 209             : score == sf.score;
 210     if (begin != sf.begin || end != sf.end || !sameScore)
 211     {
 212       return false;
 213     }
 214
 215     if (getStrand() != sf.getStrand())
 216     {
 217       return false;
 218     }
 219
 220     if (!(type + description + featureGroup + getPhase()).equals(sf.type
 221             + sf.description + sf.featureGroup + sf.getPhase()))
 222     {
 223       return false;
 224     }
 225     if (!equalAttribute(getValue("ID"), sf.getValue("ID")))
 226     {
 227       return false;
 228     }
 229     if (!equalAttribute(getValue("Name"), sf.getValue("Name")))
 230     {
 231       return false;
 232     }
 233     if (!ignoreParent)
 234     {
 235       if (!equalAttribute(getValue("Parent"), sf.getValue("Parent")))
 236       {
 237         return false;
 238       }
 239     }
 240     return true;
 241   }
 242
 243   /**
 244    * Returns true if both values are null, are both non-null and equal
 245    *
 246    * @param att1
 247    * @param att2
 248    * @return
 249    */
 250   protected static boolean equalAttribute(Object att1, Object att2)
 251   {
 252     if (att1 == null && att2 == null)
 253     {
 254       return true;
 255     }
 256     if (att1 != null)
 257     {
 258       return att1.equals(att2);
 259     }
 260     return att2.equals(att1);
 261   }
 262
 263   /**
 264    * DOCUMENT ME!
 265    *
 266    * @return DOCUMENT ME!
 267    */
 268   @Override
 269   public int getBegin()
 270   {
 271     return begin;
 272   }
 273
 274   /**
 275    * DOCUMENT ME!
 276    *
 277    * @return DOCUMENT ME!
 278    */
 279   @Override
 280   public int getEnd()
 281   {
 282     return end;
 283   }
 284
 285   /**
 286    * DOCUMENT ME!
 287    *
 288    * @return DOCUMENT ME!
 289    */
 290   public String getType()
 291   {
 292     return type;
 293   }
 294
 295   /**
 296    * DOCUMENT ME!
 297    *
 298    * @return DOCUMENT ME!
 299    */
 300   public String getDescription()
 301   {
 302     return description;
 303   }
 304
 305   public void setDescription(String desc)
 306   {
 307     description = desc;
 308   }
 309
 310   public String getFeatureGroup()
 311   {
 312     return featureGroup;
 313   }
 314
 315   public void addLink(String labelLink)
 316   {
 317     if (links == null)
 318     {
 319       links = new Vector<String>();
 320     }
 321
 322     if (!links.contains(labelLink))
 323     {
 324       links.insertElementAt(labelLink, 0);
 325     }
 326   }
 327
 328   public float getScore()
 329   {
 330     return score;
 331   }
 332
 333   /**
 334    * Used for getting values which are not in the basic set. eg STRAND, PHASE
 335    * for GFF file
 336    *
 337    * @param key
 338    *          String
 339    */
 340   public Object getValue(String key)
 341   {
 342     if (otherDetails == null)
 343     {
 344       return null;
 345     }
 346     else
 347     {
 348       return otherDetails.get(key);
 349     }
 350   }
 351
 352   /**
 353    * Returns a property value for the given key if known, else the specified
 354    * default value
 355    *
 356    * @param key
 357    * @param defaultValue
 358    * @return
 359    */
 360   public Object getValue(String key, Object defaultValue)
 361   {
 362     Object value = getValue(key);
 363     return value == null ? defaultValue : value;
 364   }
 365
 366   /**
 367    * Used for setting values which are not in the basic set. eg STRAND, FRAME
 368    * for GFF file
 369    *
 370    * @param key
 371    *          eg STRAND
 372    * @param value
 373    *          eg +
 374    */
 375   public void setValue(String key, Object value)
 376   {
 377     if (value != null)
 378     {
 379       if (otherDetails == null)
 380       {
 381         otherDetails = new HashMap<String, Object>();
 382       }
 383
 384       otherDetails.put(key, value);
 385     }
 386   }
 387
 388   /*
 389    * The following methods are added to maintain the castor Uniprot mapping file
 390    * for the moment.
 391    */
 392   public void setStatus(String status)
 393   {
 394     setValue(STATUS, status);
 395   }
 396
 397   public String getStatus()
 398   {
 399     return (String) getValue(STATUS);
 400   }
 401
 402   public void setAttributes(String attr)
 403   {
 404     setValue(ATTRIBUTES, attr);
 405   }
 406
 407   public String getAttributes()
 408   {
 409     return (String) getValue(ATTRIBUTES);
 410   }
 411
 412   /**
 413    * Return 1 for forward strand ('+' in GFF), -1 for reverse strand ('-' in
 414    * GFF), and 0 for unknown or not (validly) specified
 415    *
 416    * @return
 417    */
 418   public int getStrand()
 419   {
 420     int strand = 0;
 421     if (otherDetails != null)
 422     {
 423       Object str = otherDetails.get(STRAND);
 424       if ("-".equals(str))
 425       {
 426         strand = -1;
 427       }
 428       else if ("+".equals(str))
 429       {
 430         strand = 1;
 431       }
 432     }
 433     return strand;
 434   }
 435
 436   /**
 437    * Set the value of strand
 438    *
 439    * @param strand
 440    *          should be "+" for forward, or "-" for reverse
 441    */
 442   public void setStrand(String strand)
 443   {
 444     setValue(STRAND, strand);
 445   }
 446
 447   public void setPhase(String phase)
 448   {
 449     setValue(PHASE, phase);
 450   }
 451
 452   public String getPhase()
 453   {
 454     return (String) getValue(PHASE);
 455   }
 456
 457   /**
 458    * Sets the 'raw' ENA format location specifier e.g. join(12..45,89..121)
 459    *
 460    * @param loc
 461    */
 462   public void setEnaLocation(String loc)
 463   {
 464     setValue(LOCATION, loc);
 465   }
 466
 467   /**
 468    * Gets the 'raw' ENA format location specifier e.g. join(12..45,89..121)
 469    *
 470    * @param loc
 471    */
 472   public String getEnaLocation()
 473   {
 474     return (String) getValue(LOCATION);
 475   }
 476
 477   /**
 478    * Readable representation, for debug only, not guaranteed not to change
 479    * between versions
 480    */
 481   @Override
 482   public String toString()
 483   {
 484     return String.format("%d %d %s %s", getBegin(), getEnd(), getType(),
 485             getDescription());
 486   }
 487
 488   /**
 489    * Overridden to ensure that whenever two objects are equal, they have the
 490    * same hashCode
 491    */
 492   @Override
 493   public int hashCode()
 494   {
 495     String s = getType() + getDescription() + getFeatureGroup()
 496             + getValue("ID") + getValue("Name") + getValue("Parent")
 497             + getPhase();
 498     return s.hashCode() + getBegin() + getEnd() + (int) getScore()
 499             + getStrand();
 500   }
 501
 502   /**
 503    * Answers true if the feature's start/end values represent two related
 504    * positions, rather than ends of a range. Such features may be visualised or
 505    * reported differently to features on a range.
 506    */
 507   @Override
 508   public boolean isContactFeature()
 509   {
 510     return contactFeature;
 511   }
 512
 513   /**
 514    * Answers true if the sequence has zero start and end position
 515    *
 516    * @return
 517    */
 518   public boolean isNonPositional()
 519   {
 520     return begin == 0 && end == 0;
 521   }
 522 }