X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FDBRefEntry.java;h=b6cae62e2ab74b482458ab2f91b260cab5b0d549;hb=c49fa6aa001663914b33fc53a1d002bfc6a291ba;hp=6dc6641a9043fc9dfc0a22f6bcd29cec0eeb56f9;hpb=865a855a4ca87eadb3e5ff284ed32ed307d9c34b;p=jalview.git diff --git a/src/jalview/datamodel/DBRefEntry.java b/src/jalview/datamodel/DBRefEntry.java index 6dc6641..b6cae62 100755 --- a/src/jalview/datamodel/DBRefEntry.java +++ b/src/jalview/datamodel/DBRefEntry.java @@ -1,28 +1,48 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.0b1) - * Copyright (C) 2014 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * * Jalview is free software: you can redistribute it and/or * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. * * Jalview is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty * of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License along with Jalview. If not, see . + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . * The Jalview Authors are detailed in the 'AUTHORS' file. */ package jalview.datamodel; -public class DBRefEntry +import jalview.api.DBRefEntryI; +import jalview.util.DBRefUtils; +import jalview.util.MapList; + +import java.util.List; + +public class DBRefEntry implements DBRefEntryI { - String source = "", version = "", accessionId = ""; + String source = ""; - /** + private String version = ""; + + private String ucversion; + + private String accessionId = ""; + + int sourceKey = Integer.MIN_VALUE; + + String canonicalSourceName; + + boolean isCanonicalAccession; + + /* * maps from associated sequence to the database sequence's coordinate system */ Mapping map = null; @@ -32,54 +52,177 @@ public class DBRefEntry } + /** + * + * @param source + * may not be null + * @param version + * may be null + * @param accessionId + * may be null + */ public DBRefEntry(String source, String version, String accessionId) { - this(source, version, accessionId, null); + this(source, version, accessionId, null,false); } /** * * @param source - * canonical source (uppercase only) + * may not be null * @param version - * (source dependent version string) + * may be null * @param accessionId - * (source dependent accession number string) + * may be null + */ + public DBRefEntry(String source, String version, String accessionId, Mapping map) + { + this(source, version, accessionId, map,false); + } + /** + * + * @param source + * canonical source (turned to uppercase; cannot be null) + * @param version + * (source dependent version string or null) + * @param accessionId + * (source dependent accession number string or null) * @param map * (mapping from local sequence numbering to source accession - * numbering) + * numbering or null) */ public DBRefEntry(String source, String version, String accessionId, - Mapping map) + Mapping map,boolean isCanonical) { + this.source = source.toUpperCase(); - this.version = version; + setVersion(version); this.accessionId = accessionId; this.map = map; + this.isCanonicalAccession=isCanonical; } - public DBRefEntry(DBRefEntry entry) + /** + * Clone an entry, this time not allowing any null fields except map. + * + */ + public DBRefEntry(DBRefEntryI entry) { - this( - (entry.source == null ? "" : new String(entry.source)), - (entry.version == null ? "" : new String(entry.version)), - (entry.accessionId == null ? "" : new String(entry.accessionId)), - (entry.map == null ? null : new Mapping(entry.map))); + this((entry.getSource() == null ? "" : new String(entry.getSource())), + (entry.getVersion() == null ? "" + : new String(entry.getVersion())), + (entry.getAccessionId() == null ? "" + : new String(entry.getAccessionId())), + (entry.getMap() == null ? null : new Mapping(entry.getMap())),entry.isCanonical()); } - public boolean equals(DBRefEntry entry) + @Override + public boolean equals(Object o) { - if (entry == this) - return true; - if (entry == null) + // TODO should also override hashCode to ensure equal objects have equal + // hashcodes + + +// if (o == null || !(o instanceof DBRefEntry)) +// { +// return false; +// } +// DBRefEntry entry = (DBRefEntry) o; +// if (entry == this) +// { +// return true; +// } + Mapping em; + return (o != null && o instanceof DBRefEntry + && (o == this + || equalRef((DBRefEntry) o) + && (map == null) == ((em = ((DBRefEntry) o).map) == null) + && (map == null || map.equals(em)))); +// +// { +// return true; +// } +// return false; + } + + /** + * Answers true if this object is either equivalent to, or can be 'improved' + * by, the given entry. Specifically, answers true if + * + * + * @param other + * @return + */ + @Override + public boolean updateFrom(DBRefEntryI other) + { + if (other == null) + { return false; - if (equalRef(entry) - && ((map == null && entry.map == null) || (map != null - && entry.map != null && map.equals(entry.map)))) + } + if (other == this) { return true; } - return false; + + /* + * source must either match or be both null + */ + String otherSource = other.getSource(); + if ((source == null && otherSource != null) + || (source != null && otherSource == null) + || (source != null && !source.equalsIgnoreCase(otherSource))) + { + return false; + } + + /* + * accession id must either match or be both null + */ + String otherAccession = other.getAccessionId(); + if ((accessionId == null && otherAccession != null) + || (accessionId != null && otherAccession == null) + || (accessionId != null + && !accessionId.equalsIgnoreCase(otherAccession))) + { + return false; + } + + /* + * if my version is null, "0" or "source:0" then replace with other version, + * otherwise the versions have to match + */ + String otherVersion = other.getVersion(); + + if ((version == null || version.equals("0") || version.endsWith(":0")) + && otherVersion != null) + { + setVersion(otherVersion); + } + else + { + if (version != null && (otherVersion == null + || !version.equalsIgnoreCase(otherVersion))) + { + return false; + } + } + + /* + * if I have no mapping, take that of the other dbref + */ + if (map == null) + { + setMap(other.getMap()); + } + return true; } /** @@ -88,71 +231,88 @@ public class DBRefEntry * @param entry * @return true if source, accession and version are equal with those of entry */ - public boolean equalRef(DBRefEntry entry) + @Override + public boolean equalRef(DBRefEntryI entry) { + // TODO is this method and equals() not needed? if (entry == null) { return false; } if (entry == this) - return true; - if ((source != null && entry.source != null && source - .equalsIgnoreCase(entry.source)) - && (accessionId != null && entry.accessionId != null && accessionId - .equalsIgnoreCase(entry.accessionId)) - && (version != null && entry.version != null && version - .equalsIgnoreCase(entry.version))) { return true; } - return false; + + // BH 2019.01.25/2019.02.04 source cannot/should not be null. + // for example, StructureChooser has dbRef.getSource().equalsIgnoreCase... + + return (entry != null + && (source != null && entry.getSource() != null + && source.equalsIgnoreCase(entry.getSource())) + && (accessionId != null && entry.getAccessionId() != null + && accessionId.equalsIgnoreCase(entry.getAccessionId())) + && (version != null && entry.getVersion() != null + && version.equalsIgnoreCase(entry.getVersion()))); } + @Override public String getSource() { return source; } + public int getSourceKey() + { + return (sourceKey == Integer.MIN_VALUE ? (sourceKey = DBRefSource.getSourceKey(getCanonicalSourceName())) : sourceKey); + } + + /** + * can be null + */ + @Override public String getVersion() { return version; } + /** + * can be null + */ + @Override public String getAccessionId() { return accessionId; } - /** - * @param accessionId - * the accessionId to set - */ + @Override public void setAccessionId(String accessionId) { - this.accessionId = accessionId; + this.accessionId = accessionId; +// this.accessionId = (accessionId == null ? "" : accessionId).toUpperCase(); } /** - * @param source - * the source to set + * CAUTION! allows setting source null or not uppercase! */ + @Override public void setSource(String source) { - this.source = source; + this.source = source; + +// this.source = (source == null ? "" : source).toUpperCase(); +// this.canonicalSourceName = DBRefUtils.getCanonicalName(this.source); +// this.sourceKey = DBRefSource.getSourceKey(this.canonicalSourceName); } - /** - * @param version - * the version to set - */ + @Override public void setVersion(String version) { this.version = version; + this.ucversion = (version == null ? null : version.toUpperCase()); } - /** - * @return the map - */ + @Override public Mapping getMap() { return map; @@ -181,4 +341,80 @@ public class DBRefEntry return ((source != null) ? source : "") + ":" + ((accessionId != null) ? accessionId : ""); } + + @Override + public String toString() + { + return getSrcAccString(); + } + + @Override + public boolean isPrimaryCandidate() + { + /* + * if a map is present, unless it is 1:1 and has no SequenceI mate, it cannot be a primary reference. + */ + if (map != null) + { + SequenceI mto = map.getTo(); + if (mto != null) + { + return false; + } + MapList ml = map.getMap(); + if (ml.getFromRatio() != ml.getToRatio() + || ml.getFromRatio() != 1) + { + return false; + } + // check map is between identical single contiguous ranges + List fromRanges, toRanges; + if ((fromRanges = ml.getFromRanges()).size() != 1 || (toRanges = ml.getToRanges()).size() != 1) + { + return false; + } + if (fromRanges.get(0)[0] != toRanges.get(0)[0] + || fromRanges.get(0)[1] != toRanges.get(0)[1]) + { + return false; + } + } + if (version == null) + { + // no version string implies the reference has not been verified at all. + return false; + } + + return DBRefSource.isPrimaryCandidate(ucversion); + } + + /** + * stores the upper-case canonical name of the source for use in + * Sequence.getPrimaryDBRefs(). + * + * @author Bob Hanson + * + * @return + */ + public String getCanonicalSourceName() { + return (canonicalSourceName == null ? (canonicalSourceName = DBRefUtils.getCanonicalName(this.source)) : canonicalSourceName); + } + + /** + * + * @param canonical + */ + public void setCanonical(boolean canonical) + { + isCanonicalAccession = canonical; + } + /** + * + * @return true if this is the primary canonical accession for the database source + */ + public boolean isCanonical() + { + // TODO Auto-generated method stub + return isCanonicalAccession; + } }