/*
* 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.
*
* 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 .
* The Jalview Authors are detailed in the 'AUTHORS' file.
*/
package jalview.ws.sifts;
import jalview.analysis.AlignSeq;
import jalview.api.DBRefEntryI;
import jalview.api.SiftsClientI;
import jalview.datamodel.DBRefEntry;
import jalview.datamodel.DBRefSource;
import jalview.datamodel.SequenceI;
import jalview.schemes.ResidueProperties;
import jalview.structure.StructureMapping;
import jalview.util.Format;
import jalview.xml.binding.sifts.Entry;
import jalview.xml.binding.sifts.Entry.Entity;
import jalview.xml.binding.sifts.Entry.Entity.Segment;
import jalview.xml.binding.sifts.Entry.Entity.Segment.ListMapRegion.MapRegion;
import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue;
import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue.CrossRefDb;
import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue.ResidueDetail;
import jalview.xml.binding.sifts.Entry.ListDB.Db;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.TreeMap;
import java.util.zip.GZIPInputStream;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.stream.FactoryConfigurationError;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import MCview.Atom;
import MCview.PDBChain;
import MCview.PDBfile;
public class SiftsClient implements SiftsClientI
{
private Entry siftsEntry;
private PDBfile pdb;
private String pdbId;
private String structId;
private String segStartEnd;
private CoordinateSys seqCoordSys = CoordinateSys.UNIPROT;
private static final int BUFFER_SIZE = 4096;
public static final int UNASSIGNED = -1;
private static final int PDB_RES_POS = 0;
private static final int PDB_ATOM_POS = 1;
private static final String NOT_FOUND = "Not_Found";
private static final String NOT_OBSERVED = "Not_Observed";
private static final String SIFTS_FTP_BASE_URL = "ftp://ftp.ebi.ac.uk/pub/databases/msd/sifts/xml/";
public static final String DEFAULT_SIFTS_DOWNLOAD_DIR = System
.getProperty("user.home")
+ File.separatorChar
+ ".sifts_downloads" + File.separatorChar;
public static final String SIFTS_DOWNLOAD_DIR = jalview.bin.Cache
.getDefault("sifts_download_dir", DEFAULT_SIFTS_DOWNLOAD_DIR);
private final static String NEWLINE = System.lineSeparator();
private String curSourceDBRef;
private HashSet curDBRefAccessionIdsString;
public enum CoordinateSys
{
UNIPROT("UniProt"), PDB("PDBresnum"), PDBe("PDBe");
private String name;
private CoordinateSys(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
};
public enum ResidueDetailType
{
NAME_SEC_STRUCTURE("nameSecondaryStructure"), CODE_SEC_STRUCTURE(
"codeSecondaryStructure"), ANNOTATION("Annotation");
private String code;
private ResidueDetailType(String code)
{
this.code = code;
}
public String getCode()
{
return code;
}
};
/**
* Fetch SIFTs file for the given PDBfile and construct an instance of
* SiftsClient
*
* @param pdbId
* @throws SiftsException
*/
public SiftsClient(PDBfile pdb) throws SiftsException
{
this.pdb = pdb;
this.pdbId = pdb.id;
File siftsFile = getSiftsFile(pdbId);
siftsEntry = parseSIFTs(siftsFile);
}
/**
* Construct an instance of SiftsClient using the supplied SIFTs file. Note:
* The SIFTs file should correspond to the PDB Id in PDBfile instance
*
* @param pdbId
* @param siftsFile
* @throws SiftsException
* @throws Exception
*/
public SiftsClient(PDBfile pdb, File siftsFile) throws SiftsException
{
this.pdb = pdb;
this.pdbId = pdb.id;
siftsEntry = parseSIFTs(siftsFile);
}
/**
* Parse the given SIFTs File and return a JAXB POJO of parsed data
*
* @param siftFile
* - the GZipped SIFTs XML file to parse
* @return
* @throws Exception
* if a problem occurs while parsing the SIFTs XML
*/
private Entry parseSIFTs(File siftFile) throws SiftsException
{
try (InputStream in = new FileInputStream(siftFile);
GZIPInputStream gzis = new GZIPInputStream(in);)
{
System.out.println("File : " + siftFile.getAbsolutePath());
JAXBContext jc = JAXBContext.newInstance("jalview.xml.binding.sifts");
XMLStreamReader streamReader = XMLInputFactory.newInstance()
.createXMLStreamReader(gzis);
Unmarshaller um = jc.createUnmarshaller();
return (Entry) um.unmarshal(streamReader);
} catch (JAXBException e)
{
e.printStackTrace();
throw new SiftsException(e.getMessage());
} catch (FileNotFoundException e)
{
e.printStackTrace();
throw new SiftsException(e.getMessage());
} catch (XMLStreamException e)
{
e.printStackTrace();
throw new SiftsException(e.getMessage());
} catch (FactoryConfigurationError e)
{
e.printStackTrace();
throw new SiftsException(e.getMessage());
} catch (IOException e)
{
e.printStackTrace();
throw new SiftsException(e.getMessage());
}
}
/**
* Get a SIFTs XML file for a given PDB Id from Cache or download from FTP
* repository if not found in cache
*
* @param pdbId
* @return SIFTs XML file
* @throws SiftsException
*/
public static File getSiftsFile(String pdbId) throws SiftsException
{
File siftsFile = new File(SIFTS_DOWNLOAD_DIR + pdbId.toLowerCase()
+ ".xml.gz");
if (siftsFile.exists())
{
// TODO it may be worth performing an age check to determine if a
// new SIFTs file should be re-downloaded as SIFTs entries are usually
// updated weekly
System.out.println(">>> SIFTS File already downloaded for " + pdbId);
return siftsFile;
}
siftsFile = downloadSiftsFile(pdbId.toLowerCase());
return siftsFile;
}
/**
* Download a SIFTs XML file for a given PDB Id from an FTP repository
*
* @param pdbId
* @return downloaded SIFTs XML file
* @throws SiftsException
*/
public static File downloadSiftsFile(String pdbId) throws SiftsException
{
String siftFile = pdbId + ".xml.gz";
String siftsFileFTPURL = SIFTS_FTP_BASE_URL + siftFile;
String downloadedSiftsFile = SIFTS_DOWNLOAD_DIR + siftFile;
File siftsDownloadDir = new File(SIFTS_DOWNLOAD_DIR);
if (!siftsDownloadDir.exists())
{
siftsDownloadDir.mkdirs();
}
try
{
System.out.println(">> Download ftp url : " + siftsFileFTPURL);
URL url = new URL(siftsFileFTPURL);
URLConnection conn = url.openConnection();
InputStream inputStream = conn.getInputStream();
FileOutputStream outputStream = new FileOutputStream(
downloadedSiftsFile);
byte[] buffer = new byte[BUFFER_SIZE];
int bytesRead = -1;
while ((bytesRead = inputStream.read(buffer)) != -1)
{
outputStream.write(buffer, 0, bytesRead);
}
outputStream.close();
inputStream.close();
System.out.println(">>> File downloaded : " + downloadedSiftsFile);
} catch (IOException ex)
{
throw new SiftsException(ex.getMessage());
}
return new File(downloadedSiftsFile);
}
/**
* Delete the SIFTs file for the given PDB Id in the local SIFTs download
* directory
*
* @param pdbId
* @return true if the file was deleted or doesn't exist
*/
public static boolean deleteSiftsFileByPDBId(String pdbId)
{
File siftsFile = new File(SIFTS_DOWNLOAD_DIR + pdbId.toLowerCase()
+ ".xml.gz");
if (siftsFile.exists())
{
return siftsFile.delete();
}
return true;
}
/**
* Get a valid SIFTs DBRef for the given sequence current SIFTs entry
*
* @param seq
* - the target sequence for the operation
* @return a valid DBRefEntry that is SIFTs compatible
* @throws Exception
* if no valid source DBRefEntry was found for the given sequences
*/
public DBRefEntryI getValidSourceDBRef(SequenceI seq)
throws SiftsException
{
DBRefEntryI sourceDBRef = null;
sourceDBRef = seq.getSourceDBRef();
if (sourceDBRef != null && isValidDBRefEntry(sourceDBRef))
{
return sourceDBRef;
}
else
{
DBRefEntry[] dbRefs = seq.getDBRefs();
if (dbRefs == null || dbRefs.length < 1)
{
final SequenceI[] seqs = new SequenceI[] { seq };
new jalview.ws.DBRefFetcher(seqs, null, null, null, false)
.fetchDBRefs(true);
dbRefs = seq.getDBRefs();
}
if (dbRefs == null || dbRefs.length < 1)
{
throw new SiftsException("Could not get source DB Ref");
}
for (DBRefEntryI dbRef : dbRefs)
{
if (dbRef == null || dbRef.getAccessionId() == null
|| dbRef.getSource() == null)
{
continue;
}
if (isFoundInSiftsEntry(dbRef.getAccessionId())
&& (dbRef.getSource().equalsIgnoreCase(DBRefSource.UNIPROT) || dbRef
.getSource().equalsIgnoreCase(DBRefSource.PDB)))
{
return dbRef;
}
}
}
if (sourceDBRef != null && isValidDBRefEntry(sourceDBRef))
{
return sourceDBRef;
}
throw new SiftsException("Could not get source DB Ref");
}
/**
* Check that the DBRef Entry is properly populated and is available in this
* SiftClient instance
*
* @param entry
* - DBRefEntry to validate
* @return true validation is successful otherwise false is returned.
*/
private boolean isValidDBRefEntry(DBRefEntryI entry)
{
return entry != null && entry.getAccessionId() != null
&& isFoundInSiftsEntry(entry.getAccessionId());
}
@Override
public HashSet getAllMappingAccession()
{
HashSet accessions = new HashSet();
List entities = siftsEntry.getEntity();
for (Entity entity : entities)
{
List segments = entity.getSegment();
for (Segment segment : segments)
{
List mapRegions = segment.getListMapRegion()
.getMapRegion();
for (MapRegion mapRegion : mapRegions)
{
accessions.add(mapRegion.getDb().getDbAccessionId());
}
}
}
return accessions;
}
@Override
public StructureMapping getSiftsStructureMapping(SequenceI seq,
String pdbFile, String chain) throws SiftsException
{
structId = (chain == null) ? pdbId : pdbId + "|" + chain;
System.out.println("Getting mapping for: " + pdbId + "|" + chain
+ " : seq- " + seq.getName());
final StringBuilder mappingDetails = new StringBuilder(128);
PrintStream ps = new PrintStream(System.out)
{
@Override
public void print(String x)
{
mappingDetails.append(x);
}
@Override
public void println()
{
mappingDetails.append(NEWLINE);
}
};
HashMap mapping = getGreedyMapping(chain, seq, ps);
String mappingOutput = mappingDetails.toString();
StructureMapping siftsMapping = new StructureMapping(seq, pdbFile,
pdbId, chain, mapping,
mappingOutput);
return siftsMapping;
}
@Override
public HashMap getGreedyMapping(String entityId, SequenceI seq,
java.io.PrintStream os)
throws SiftsException
{
ArrayList omitNonObserved = new ArrayList();
int nonObservedShiftIndex = 0;
System.out.println("Generating mappings for : " + entityId);
Entity entity = null;
entity = getEntityById(entityId);
String originalSeq = AlignSeq.extractGaps(
jalview.util.Comparison.GapChars,
seq.getSequenceAsString());
HashMap mapping = new HashMap();
DBRefEntryI sourceDBRef = seq.getSourceDBRef();
if (sourceDBRef == null)
{
sourceDBRef = getValidSourceDBRef(seq);
// TODO ensure sequence start/end is in the same coordinate system and
// consistent with the choosen sourceDBRef
}
// set sequence coordinate system - default value is UniProt
if (sourceDBRef.getSource().equalsIgnoreCase(DBRefSource.PDB))
{
seqCoordSys = CoordinateSys.PDB;
}
HashSet dbRefAccessionIdsString = new HashSet();
for (DBRefEntry dbref : seq.getDBRefs())
{
dbRefAccessionIdsString.add(dbref.getAccessionId().toLowerCase());
}
dbRefAccessionIdsString.add(sourceDBRef.getAccessionId().toLowerCase());
curDBRefAccessionIdsString = dbRefAccessionIdsString;
curSourceDBRef = sourceDBRef.getAccessionId();
TreeMap resNumMap = new TreeMap();
List segments = entity.getSegment();
for (Segment segment : segments)
{
segStartEnd = segment.getStart() + " - " + segment.getEnd();
System.out.println("Mappging segments : " + segment.getSegId() + "\\"
+ segStartEnd);
List residues = segment.getListResidue().getResidue();
for (Residue residue : residues)
{
int currSeqIndex = UNASSIGNED;
List cRefDbs = residue.getCrossRefDb();
CrossRefDb pdbRefDb = null;
for (CrossRefDb cRefDb : cRefDbs)
{
if (cRefDb.getDbSource().equalsIgnoreCase(DBRefSource.PDB))
{
pdbRefDb = cRefDb;
}
if (cRefDb.getDbCoordSys()
.equalsIgnoreCase(seqCoordSys.getName())
&& isAccessionMatched(cRefDb.getDbAccessionId()))
{
String resNumIndexString = cRefDb.getDbResNum()
.equalsIgnoreCase("None") ? String.valueOf(UNASSIGNED)
: cRefDb.getDbResNum();
currSeqIndex = Integer.valueOf(resNumIndexString);
if (pdbRefDb != null)
{
break;// exit loop if pdb and uniprot are already found
}
}
}
if (currSeqIndex == UNASSIGNED)
{
continue;
}
if (currSeqIndex > seq.getStart() && currSeqIndex <= seq.getEnd())
{
int resNum;
try
{
resNum = (pdbRefDb == null) ? Integer.valueOf(residue
.getDbResNum()) : Integer.valueOf(pdbRefDb.getDbResNum());
} catch (NumberFormatException nfe)
{
resNum = (pdbRefDb == null) ? Integer.valueOf(residue
.getDbResNum()) : Integer.valueOf(pdbRefDb
.getDbResNum().split("[a-zA-Z]")[0]);
}
if (isResidueObserved(residue)
|| seqCoordSys == CoordinateSys.UNIPROT)
{
char resCharCode = ResidueProperties
.getSingleCharacterCode(residue.getDbResName());
resNumMap.put(currSeqIndex, String.valueOf(resCharCode));
}
else
{
omitNonObserved.add(currSeqIndex);
++nonObservedShiftIndex;
}
mapping.put(currSeqIndex - nonObservedShiftIndex, new int[] {
Integer.valueOf(resNum), UNASSIGNED });
}
}
}
try
{
populateAtomPositions(entityId, mapping);
} catch (Exception e)
{
e.printStackTrace();
}
padWithGaps(resNumMap, omitNonObserved);
int seqStart = UNASSIGNED;
int seqEnd = UNASSIGNED;
int pdbStart = UNASSIGNED;
int pdbEnd = UNASSIGNED;
Integer[] keys = mapping.keySet().toArray(new Integer[0]);
Arrays.sort(keys);
seqStart = keys[0];
seqEnd = keys[keys.length - 1];
String matchedSeq = originalSeq;
if (seqStart != UNASSIGNED)
{
pdbStart = mapping.get(seqStart)[PDB_RES_POS];
pdbEnd = mapping.get(seqEnd)[PDB_RES_POS];
int orignalSeqStart = seq.getStart();
if (orignalSeqStart >= 1)
{
int subSeqStart = seqStart - orignalSeqStart;
int subSeqEnd = seqEnd - (orignalSeqStart - 1);
subSeqEnd = originalSeq.length() < subSeqEnd ? originalSeq.length()
: subSeqEnd;
matchedSeq = originalSeq.substring(subSeqStart, subSeqEnd);
}
}
StringBuilder targetStrucSeqs = new StringBuilder();
for (String res : resNumMap.values())
{
targetStrucSeqs.append(res);
}
if (os != null)
{
MappingOutputPojo mop = new MappingOutputPojo();
mop.setSeqStart(seqStart);
mop.setSeqEnd(seqEnd);
mop.setSeqName(seq.getName());
mop.setSeqResidue(matchedSeq);
mop.setStrStart(pdbStart);
mop.setStrEnd(pdbEnd);
mop.setStrName(structId);
mop.setStrResidue(targetStrucSeqs.toString());
mop.setType("pep");
os.print(getMappingOutput(mop).toString());
}
return mapping;
}
/**
* Checks if the residue instance is marked 'Not_observed' or not
*
* @param residue
* @return
*/
private boolean isResidueObserved(Residue residue)
{
String annotation = getResidueAnnotaiton(residue,
ResidueDetailType.ANNOTATION);
if (annotation == null)
{
return true;
}
if (!annotation.equalsIgnoreCase(NOT_FOUND)
&& annotation.equalsIgnoreCase(NOT_OBSERVED))
{
return false;
}
return true;
}
/**
* Get annotation String for a given residue and annotation type
*
* @param residue
* @param type
* @return
*/
private String getResidueAnnotaiton(Residue residue,
ResidueDetailType type)
{
List resDetails = residue.getResidueDetail();
for (ResidueDetail resDetail : resDetails)
{
if (resDetail.getProperty().equalsIgnoreCase(type.getCode()))
{
return resDetail.getContent();
}
}
return NOT_FOUND;
}
@Override
public boolean isAccessionMatched(String accession)
{
boolean isStrictMatch = true;
return isStrictMatch ? curSourceDBRef.equalsIgnoreCase(accession)
: curDBRefAccessionIdsString.contains(accession.toLowerCase());
}
private boolean isFoundInSiftsEntry(String accessionId)
{
return accessionId != null
&& getAllMappingAccession().contains(accessionId);
}
/**
* Pad omitted residue positions in PDB sequence with gaps
*
* @param resNumMap
*/
void padWithGaps(TreeMap resNumMap,
ArrayList omitNonObserved)
{
if (resNumMap == null || resNumMap.isEmpty())
{
return;
}
Integer[] keys = resNumMap.keySet().toArray(new Integer[0]);
Arrays.sort(keys);
int firstIndex = keys[0];
int lastIndex = keys[keys.length - 1];
System.out.println("Min value " + firstIndex);
System.out.println("Max value " + lastIndex);
for (int x = firstIndex; x <= lastIndex; x++)
{
if (!resNumMap.containsKey(x) && !omitNonObserved.contains(x))
{
resNumMap.put(x, "-");
}
}
}
/**
*
* @param chainId
* Target chain to populate mapping of its atom positions.
* @param mapping
* Two dimension array of residue index versus atom position
* @throws IllegalArgumentException
* Thrown if chainId or mapping is null
*/
void populateAtomPositions(String chainId, HashMap mapping)
throws IllegalArgumentException
{
PDBChain chain = pdb.findChain(chainId);
if (chain == null || mapping == null)
{
throw new IllegalArgumentException(
"Chain id or mapping must not be null.");
}
for (int[] map : mapping.values())
{
if (map[PDB_RES_POS] != UNASSIGNED)
{
map[PDB_ATOM_POS] = getAtomIndex(map[PDB_RES_POS], chain.atoms);
}
}
}
/**
*
* @param residueIndex
* The residue index used for the search
* @param atoms
* A collection of Atom to search
* @return atom position for the given residue index
*/
int getAtomIndex(int residueIndex, Collection atoms)
{
if (atoms == null)
{
throw new IllegalArgumentException(
"atoms collection must not be null!");
}
for (Atom atom : atoms)
{
if (atom.resNumber == residueIndex)
{
return atom.atomIndex;
}
}
return UNASSIGNED;
}
@Override
public Entity getEntityById(String id) throws SiftsException
{
List entities = siftsEntry.getEntity();
for (Entity entity : entities)
{
if (!entity.getEntityId().equalsIgnoreCase(id))
{
continue;
}
return entity;
}
throw new SiftsException("Entity " + id + " not found");
}
@Override
public String[] getEntryDBs()
{
System.out.println("\nListing DB entries...");
List availDbs = new ArrayList();
List dbs = siftsEntry.getListDB().getDb();
for (Db db : dbs)
{
availDbs.add(db.getDbSource());
System.out.println(db.getDbSource() + " | " + db.getDbCoordSys());
}
return availDbs.toArray(new String[0]);
}
@Override
public StringBuffer getMappingOutput(MappingOutputPojo mp)
throws SiftsException
{
String seqRes = mp.getSeqResidue();
String seqName = mp.getSeqName();
int sStart = mp.getSeqStart();
int sEnd = mp.getSeqEnd();
String strRes = mp.getStrResidue();
String strName = mp.getStrName();
int pdbStart = mp.getStrStart();
int pdbEnd = mp.getStrEnd();
String type = mp.getType();
int maxid = (seqName.length() >= strName.length()) ? seqName.length()
: strName.length();
int len = 72 - maxid - 1;
int nochunks = ((seqRes.length()) / len)
+ ((seqRes.length()) % len > 0 ? 1 : 0);
// output mappings
StringBuffer output = new StringBuffer();
output.append(NEWLINE);
output.append("Sequence ⟷ Structure mapping details").append(NEWLINE);
output.append("Method: SIFTS");
output.append(NEWLINE).append(NEWLINE);
output.append(new Format("%" + maxid + "s").form(seqName));
output.append(" : ");
output.append(String.valueOf(sStart));
output.append(" - ");
output.append(String.valueOf(sEnd));
output.append(" Maps to ");
output.append(NEWLINE);
output.append(new Format("%" + maxid + "s").form(structId));
output.append(" : ");
output.append(String.valueOf(pdbStart));
output.append(" - ");
output.append(String.valueOf(pdbEnd));
output.append(NEWLINE).append(NEWLINE);
int matchedSeqCount = 0;
for (int j = 0; j < nochunks; j++)
{
// Print the first aligned sequence
output.append(new Format("%" + (maxid) + "s").form(seqName)).append(
" ");
for (int i = 0; i < len; i++)
{
if ((i + (j * len)) < seqRes.length())
{
output.append(seqRes.charAt(i + (j * len)));
}
}
output.append(NEWLINE);
output.append(new Format("%" + (maxid) + "s").form(" ")).append(" ");
// Print out the matching chars
for (int i = 0; i < len; i++)
{
try
{
if ((i + (j * len)) < seqRes.length())
{
if (seqRes.charAt(i + (j * len)) == strRes.charAt(i + (j * len))
&& !jalview.util.Comparison.isGap(seqRes.charAt(i
+ (j * len))))
{
matchedSeqCount++;
output.append("|");
}
else if (type.equals("pep"))
{
if (ResidueProperties.getPAM250(seqRes.charAt(i + (j * len)),
strRes.charAt(i + (j * len))) > 0)
{
output.append(".");
}
else
{
output.append(" ");
}
}
else
{
output.append(" ");
}
}
} catch (IndexOutOfBoundsException e)
{
continue;
}
}
// Now print the second aligned sequence
output = output.append(NEWLINE);
output = output.append(new Format("%" + (maxid) + "s").form(strName))
.append(" ");
for (int i = 0; i < len; i++)
{
if ((i + (j * len)) < strRes.length())
{
output.append(strRes.charAt(i + (j * len)));
}
}
output.append(NEWLINE).append(NEWLINE);
}
float pid = (float) matchedSeqCount / seqRes.length() * 100;
if (pid < 2)
{
throw new SiftsException("Low PID detected for SIFTs mapping...");
}
output.append("Length of alignment = " + seqRes.length())
.append(NEWLINE);
output.append(new Format("Percentage ID = %2.2f").form(pid));
output.append(NEWLINE);
return output;
}
@Override
public int getEntityCount()
{
return siftsEntry.getEntity().size();
}
@Override
public String getDbAccessionId()
{
return siftsEntry.getDbAccessionId();
}
@Override
public String getDbCoordSys()
{
return siftsEntry.getDbCoordSys();
}
@Override
public String getDbEvidence()
{
return siftsEntry.getDbEvidence();
}
@Override
public String getDbSource()
{
return siftsEntry.getDbSource();
}
@Override
public String getDbVersion()
{
return siftsEntry.getDbVersion();
}
}