X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FDBRefEntry.java;h=aedfd3b793adb47e468834fa9755a5f0bb5127ba;hb=HEAD;hp=738c4dc831caf71090ddf09bd57ff458f468be44;hpb=ea36a0b44f1661422284e55ad5e137a0c81821f1;p=jalview.git diff --git a/src/jalview/datamodel/DBRefEntry.java b/src/jalview/datamodel/DBRefEntry.java index 738c4dc..aedfd3b 100755 --- a/src/jalview/datamodel/DBRefEntry.java +++ b/src/jalview/datamodel/DBRefEntry.java @@ -20,14 +20,31 @@ */ package jalview.datamodel; +import java.util.Locale; + 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 int startRes, endRes; - /** + private String version = ""; + + private String ucversion; + + private String accessionId = ""; + + int sourceKey = Integer.MIN_VALUE; + + String canonicalSourceName; + + boolean isCanonicalAccession = false; + + /* * maps from associated sequence to the database sequence's coordinate system */ Mapping map = null; @@ -37,41 +54,71 @@ public class DBRefEntry implements DBRefEntryI } - + /** + * + * @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 + * may not be null + * @param version + * may be null + * @param accessionId + * may be null + */ + public DBRefEntry(String source, String version, String accessionId, + Mapping map) + { + this(source, version, accessionId, map, false); } /** * * @param source - * canonical source (uppercase only) + * canonical source (turned to uppercase; cannot be null) * @param version - * (source dependent version string) + * (source dependent version string or null) * @param accessionId - * (source dependent accession number string) + * (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; + + this.source = source.toUpperCase(Locale.ROOT); + setVersion(version); this.accessionId = accessionId; this.map = map; + this.isCanonicalAccession = isCanonical; } + /** + * Clone an entry, this time not allowing any null fields except map. + * + */ public DBRefEntry(DBRefEntryI entry) { 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.getVersion() == null ? "" + : new String(entry.getVersion())), + (entry.getAccessionId() == null ? "" + : new String(entry.getAccessionId())), + (entry.getMap() == null ? null : new Mapping(entry.getMap())), + entry.isCanonical()); } @Override @@ -79,22 +126,26 @@ public class DBRefEntry implements DBRefEntryI { // 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; - } - if (equalRef(entry) - && ((map == null && entry.map == null) || (map != null - && entry.map != null && map.equals(entry.map)))) - { - return true; - } - return false; + + // 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; } /** @@ -103,7 +154,8 @@ public class DBRefEntry implements DBRefEntryI * @@ -112,7 +164,7 @@ public class DBRefEntry implements DBRefEntryI * @return */ @Override - public boolean updateFrom(DBRefEntry other) + public boolean updateFrom(DBRefEntryI other) { if (other == null) { @@ -123,6 +175,7 @@ public class DBRefEntry implements DBRefEntryI return true; } + boolean improved = false; /* * source must either match or be both null */ @@ -140,16 +193,31 @@ public class DBRefEntry implements DBRefEntryI String otherAccession = other.getAccessionId(); if ((accessionId == null && otherAccession != null) || (accessionId != null && otherAccession == null) - || (accessionId != null && !accessionId.equalsIgnoreCase(otherAccession))) + || (accessionId != null + && !accessionId.equalsIgnoreCase(otherAccession))) { return false; } + if (!isCanonicalAccession && other.isCanonical()) + { + isCanonicalAccession = true; + improved = true; + } + else + { + if (isCanonicalAccession && !other.isCanonical()) + { + // other is not an authoritative source of canonical accessions + 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) { @@ -157,14 +225,18 @@ public class DBRefEntry implements DBRefEntryI } else { - if (!version.equalsIgnoreCase(otherVersion)) + if (version != null && (otherVersion == null + || !version.equalsIgnoreCase(otherVersion))) { - return false; + // FIXME: there may be a problem with old version strings not allowing + // updating of dbrefentries + return improved; } } /* - * if I have no mapping, take that of the other dbref + * if I have no mapping, take that of the other dbref + * - providing it had a version and so do I */ if (map == null) { @@ -191,17 +263,17 @@ public class DBRefEntry implements DBRefEntryI { return true; } - if (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()))) - { - 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 @@ -210,40 +282,61 @@ public class DBRefEntry implements DBRefEntryI 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; } - @Override public void setAccessionId(String accessionId) { this.accessionId = accessionId; + // this.accessionId = (accessionId == null ? "" : + // accessionId).toUpperCase(Locale.ROOT); } - + /** + * CAUTION! allows setting source null or not uppercase! + */ @Override public void setSource(String source) { this.source = source; - } + // this.source = (source == null ? "" : source).toUpperCase(Locale.ROOT); + // this.canonicalSourceName = DBRefUtils.getCanonicalName(this.source); + // this.sourceKey = DBRefSource.getSourceKey(this.canonicalSourceName); + } @Override public void setVersion(String version) { this.version = version; + this.ucversion = (version == null ? null + : version.toUpperCase(Locale.ROOT)); } - @Override public Mapping getMap() { @@ -281,26 +374,78 @@ public class DBRefEntry implements DBRefEntryI } @Override - public int getStartRes() + public boolean isPrimaryCandidate() { - return startRes; + /* + * 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); } - @Override - public void setStartRes(int startRes) + /** + * stores the upper-case canonical name of the source for use in + * Sequence.getPrimaryDBRefs(). + * + * @author Bob Hanson + * + * @return + */ + public String getCanonicalSourceName() { - this.startRes = startRes; + return (canonicalSourceName == null + ? (canonicalSourceName = DBRefUtils + .getCanonicalName(this.source)) + : canonicalSourceName); } - @Override - public int getEndRes() + /** + * + * @param canonical + */ + public void setCanonical(boolean canonical) { - return endRes; + isCanonicalAccession = canonical; } - @Override - public void setEndRes(int endRes) + /** + * + * @return true if this is the primary canonical accession for the database + * source + */ + public boolean isCanonical() { - this.endRes = endRes; + // TODO Auto-generated method stub + return isCanonicalAccession; } }