/*\r
- * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)\r
- * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)\r
+ * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle\r
* \r
- * This program is free software; you can redistribute it and/or\r
- * modify it under the terms of the GNU General Public License\r
- * as published by the Free Software Foundation; either version 2\r
- * of the License, or (at your option) any later version.\r
+ * This file is part of Jalview.\r
* \r
- * This program is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
- * GNU General Public License for more details.\r
+ * Jalview is free software: you can redistribute it and/or\r
+ * modify it under the terms of the GNU General Public License \r
+ * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\r
+ * \r
+ * Jalview is distributed in the hope that it will be useful, but \r
+ * WITHOUT ANY WARRANTY; without even the implied warranty \r
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR \r
+ * PURPOSE. See the GNU General Public License for more details.\r
* \r
- * You should have received a copy of the GNU General Public License\r
- * along with this program; if not, write to the Free Software\r
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA\r
+ * You should have received a copy of the GNU General Public License along with Jalview. If not, see <http://www.gnu.org/licenses/>.\r
*/\r
/*\r
* This extension was written by Benjamin Schuster-Boeckler at sanger.ac.uk\r
*/\r
package jalview.io;\r
\r
-import java.io.*;\r
-import java.util.*;\r
+import jalview.datamodel.AlignmentAnnotation;\r
+import jalview.datamodel.AlignmentI;\r
+import jalview.datamodel.Annotation;\r
+import jalview.datamodel.DBRefEntry;\r
+import jalview.datamodel.Sequence;\r
+import jalview.datamodel.SequenceFeature;\r
+import jalview.datamodel.SequenceI;\r
+import jalview.util.Format;\r
\r
-import com.stevesoft.pat.*;\r
-import jalview.datamodel.*;\r
+import java.io.BufferedReader;\r
+import java.io.FileReader;\r
+import java.io.IOException;\r
+import java.util.ArrayList;\r
+import java.util.Enumeration;\r
+import java.util.Hashtable;\r
+import java.util.List;\r
+import java.util.StringTokenizer;\r
+import java.util.Vector;\r
+\r
+import com.stevesoft.pat.Regex;\r
+\r
+import fr.orsay.lri.varna.exceptions.ExceptionUnmatchedClosingParentheses;\r
+import fr.orsay.lri.varna.factories.RNAFactory;\r
+import fr.orsay.lri.varna.models.rna.RNA;\r
\r
// import org.apache.log4j.*;\r
\r
* into Jalview's local representation.\r
* \r
* @author bsb at sanger.ac.uk\r
+ * @author Natasha Shersnev (Dundee, UK) (Stockholm file writer)\r
+ * @author Lauren Lui (UCSC, USA) (RNA secondary structure annotation import as stockholm)\r
+ * @author Anne Menard (Paris, FR) (VARNA parsing of Stockholm file data)\r
* @version 0.3 + jalview mods\r
* \r
*/\r
public class StockholmFile extends AlignFile\r
{\r
// static Logger logger = Logger.getLogger("jalview.io.StockholmFile");\r
+ protected ArrayList<RNA> result;\r
+ StringBuffer out; // output buffer
+
+ AlignmentI al;
+\r
+ public String id;\r
\r
public StockholmFile()\r
{\r
}\r
\r
+ /**
+ * Creates a new StockholmFile object for output.
+ */
+ public StockholmFile(AlignmentI al)
+ {
+ this.al = al;
+ }
+
public StockholmFile(String inFile, String type) throws IOException\r
{\r
super(inFile, type);\r
}\r
\r
/**\r
+ * Parse a file in Stockholm format using VARNA\r
+ */\r
+ public void _parse_withVARNA(java.io.File inFile) throws IOException\r
+ {\r
+ FileReader fr = null;\r
+ fr = new FileReader(inFile);\r
+\r
+ BufferedReader r = new BufferedReader(fr);\r
+ result = null;\r
+ try\r
+ {\r
+ result = RNAFactory.loadSecStrStockholm(r);\r
+ } catch (ExceptionUnmatchedClosingParentheses umcp)\r
+ {\r
+ errormessage = "Unmatched parentheses in annotation. Aborting ("\r
+ + umcp.getMessage() + ")";\r
+ throw new IOException(umcp);\r
+ }\r
+ // DEBUG System.out.println("this is the secondary scructure:"\r
+ // +result.size());\r
+ SequenceI[] seqs = new SequenceI[result.size()];\r
+ for (int i = 0; i < result.size(); i++)\r
+ {\r
+ // DEBUG System.err.println("Processing i'th sequence in Stockholm file")\r
+ RNA current = result.get(i);\r
+\r
+ String seq = current.getSeq();\r
+ String rna = current.getStructDBN(true);\r
+ // DEBUG System.out.println(seq);\r
+ // DEBUG System.err.println(rna);\r
+ int begin = 0;\r
+ int end = seq.length() - 1;\r
+ id = safeName(getDataName());\r
+ seqs[i] = new Sequence(id, seq, begin, end);\r
+ String[] annot = new String[rna.length()];\r
+ Annotation[] ann = new Annotation[rna.length()];\r
+ for (int j = 0; j < rna.length(); j++)\r
+ {\r
+ annot[j] = rna.substring(j, j + 1);\r
+\r
+ }\r
+\r
+ for (int k = 0; k < rna.length(); k++)\r
+ {\r
+ ann[k] = new Annotation(annot[k], "",\r
+ jalview.schemes.ResidueProperties.getRNASecStrucState(\r
+ annot[k]).charAt(0), 0f);\r
+\r
+ }\r
+ AlignmentAnnotation align = new AlignmentAnnotation("Sec. str.",\r
+ current.getID(), ann);\r
+\r
+ seqs[i].addAlignmentAnnotation(align);\r
+ seqs[i].setRNA(result.get(i));\r
+ this.annotations.addElement(align);\r
+ }\r
+ this.setSeqs(seqs);\r
+\r
+ }\r
+\r
+ \r
+ /**\r
* Parse a file in Stockholm format into Jalview's data model. The file has to\r
* be passed at construction time\r
* \r
* @throws IOException\r
- * If there is an error with the input file\r
+ * If there is an error with the input file\r
*/\r
public void parse() throws IOException\r
{\r
Hashtable seqs = new Hashtable();\r
Regex p, r, rend, s, x;\r
\r
+ // Temporary line for processing RNA annotation\r
+ // String RNAannot = "";\r
+\r
// ------------------ Parsing File ----------------------\r
// First, we have to check that this file has STOCKHOLM format, i.e. the\r
// first line must match\r
}\r
\r
// We define some Regexes here that will be used regularily later\r
- rend = new Regex("\\/\\/"); // Find the end of an alignment\r
+ rend = new Regex("^\\s*\\/\\/"); // Find the end of an alignment\r
p = new Regex("(\\S+)\\/(\\d+)\\-(\\d+)"); // split sequence id in\r
// id/from/to\r
s = new Regex("(\\S+)\\s+(\\S*)\\s+(.*)"); // Parses annotation subtype\r
r = new Regex("#=(G[FSRC]?)\\s+(.*)"); // Finds any annotation line\r
x = new Regex("(\\S+)\\s+(\\S+)"); // split id from sequence\r
\r
+ // Convert all bracket types to parentheses (necessary for passing to VARNA)\r
+ Regex openparen = new Regex("(<|\\[)", "(");\r
+ Regex closeparen = new Regex("(>|\\])", ")");\r
+\r
+ // Detect if file is RNA by looking for bracket types\r
+ Regex detectbrackets = new Regex("(<|>|\\[|\\]|\\(|\\))");\r
+\r
rend.optimize();\r
p.optimize();\r
s.optimize();\r
r.optimize();\r
x.optimize();\r
+ openparen.optimize();\r
+ closeparen.optimize();\r
\r
while ((line = nextLine()) != null)\r
{\r
if (rend.search(line))\r
{\r
// End of the alignment, pass stuff back\r
-\r
this.noSeqs = seqs.size();\r
+\r
+ String seqdb,dbsource = null;\r
+ Regex pf = new Regex("PF[0-9]{5}(.*)"); // Finds AC for Pfam\r
+ Regex rf = new Regex("RF[0-9]{5}(.*)"); // Finds AC for Rfam\r
+ if (getAlignmentProperty("AC") != null)\r
+ {\r
+ String dbType = getAlignmentProperty("AC").toString();\r
+ if (pf.search(dbType))\r
+ {\r
+ // PFAM Alignment - so references are typically from Uniprot\r
+ dbsource = "PFAM";\r
+ }\r
+ else if (rf.search(dbType))\r
+ {\r
+ dbsource = "RFAM";\r
+ }\r
+ }\r
// logger.debug("Number of sequences: " + this.noSeqs);\r
Enumeration accs = seqs.keys();\r
while (accs.hasMoreElements())\r
int start = 1;\r
int end = -1;\r
String sid = acc;\r
- // Retrieve hash of annotations for this accession\r
+ /*\r
+ * Retrieve hash of annotations for this accession Associate\r
+ * Annotation with accession\r
+ */\r
Hashtable accAnnotations = null;\r
\r
if (seqAnn != null && seqAnn.containsKey(acc))\r
{\r
accAnnotations = (Hashtable) seqAnn.remove(acc);\r
+ // TODO: add structures to sequence\r
}\r
\r
// Split accession in id and from/to\r
String desc = (String) accAnnotations.get("DE");\r
seqO.setDescription((desc == null) ? "" : desc);\r
}\r
+\r
// Add DB References (if any)\r
if (accAnnotations != null && accAnnotations.containsKey("DR"))\r
{\r
String src = dbr.substring(0, dbr.indexOf(";"));\r
String acn = dbr.substring(dbr.indexOf(";") + 1);\r
jalview.util.DBRefUtils.parseToDbRef(seqO, src, "0", acn);\r
- // seqO.addDBRef(dbref);\r
}\r
}\r
+\r
+ if (accAnnotations != null && accAnnotations.containsKey("AC"))\r
+ {\r
+ if (dbsource != null)\r
+ {\r
+ String dbr = (String) accAnnotations.get("AC");\r
+ if (dbr != null)\r
+ {\r
+ // we could get very clever here - but for now - just try to guess accession type from source of alignment plus structure of accession\r
+ guessDatabaseFor(seqO, dbr, dbsource);\r
+ \r
+ }\r
+ } \r
+ // else - do what ? add the data anyway and prompt the user to specify what references these are ?\r
+ }\r
+\r
Hashtable features = null;\r
// We need to adjust the positions of all features to account for gaps\r
try\r
// TODO: map coding region to core jalview feature types\r
String type = i.nextElement().toString();\r
Hashtable content = (Hashtable) features.remove(type);\r
+\r
+ // add alignment annotation for this feature\r
+ String key = type2id(type);\r
+ if (key != null)\r
+ {\r
+ if (accAnnotations != null\r
+ && accAnnotations.containsKey(key))\r
+ {\r
+ Vector vv = (Vector) accAnnotations.get(key);\r
+ for (int ii = 0; ii < vv.size(); ii++)\r
+ {\r
+ AlignmentAnnotation an = (AlignmentAnnotation) vv\r
+ .elementAt(ii);\r
+ seqO.addAlignmentAnnotation(an);\r
+ }\r
+ }\r
+ }\r
+\r
Enumeration j = content.keys();\r
while (j.hasMoreElements())\r
{\r
{\r
char c = byChar[k];\r
if (!(c == ' ' || c == '_' || c == '-' || c == '.')) // PFAM\r
- // uses\r
- // '.'\r
- // for\r
- // feature\r
- // background\r
+ // uses\r
+ // '.'\r
+ // for\r
+ // feature\r
+ // background\r
{\r
int new_pos = posmap[k]; // look up nearest seqeunce\r
- // position to this column\r
+ // position to this column\r
SequenceFeature feat = new SequenceFeature(type, desc,\r
new_pos, new_pos, 0f, null);\r
\r
if (x.search(annContent))\r
{\r
// parse out and create alignment annotation directly.\r
- parseAnnotationRow(annotations, x.stringMatched(1), x\r
- .stringMatched(2));\r
+ parseAnnotationRow(annotations, x.stringMatched(1),\r
+ x.stringMatched(2));\r
}\r
}\r
else if (annType.equals("GR"))\r
ann = new Hashtable();\r
seqAnn.put(acc, ann);\r
}\r
-\r
+ // TODO test structure, call parseAnnotationRow with vector from\r
+ // hashtable for specific sequence\r
Hashtable features;\r
// Get an object with all the content for an annotation\r
if (ann.containsKey("features"))\r
ns = "";\r
}\r
ns += seq;\r
- content.put(description, seq);\r
+ content.put(description, ns);\r
+ Hashtable strucAnn;\r
+ if (seqAnn.containsKey(acc))\r
+ {\r
+ strucAnn = (Hashtable) seqAnn.get(acc);\r
+ }\r
+ else\r
+ {\r
+ strucAnn = new Hashtable();\r
+ }\r
+\r
+ Vector newStruc = new Vector();\r
+ parseAnnotationRow(newStruc, type, ns);\r
+ strucAnn.put(type, newStruc);\r
+ seqAnn.put(acc, strucAnn);\r
}\r
else\r
{\r
}\r
}\r
\r
- private AlignmentAnnotation parseAnnotationRow(Vector annotation,\r
- String label, String annots)\r
+ /**\r
+ * Demangle an accession string and guess the originating sequence database for a given sequence\r
+ * @param seqO sequence to be annotated\r
+ * @param dbr Accession string for sequence\r
+ * @param dbsource source database for alignment (PFAM or RFAM)\r
+ */\r
+ private void guessDatabaseFor(Sequence seqO, String dbr, String dbsource)\r
+ {\r
+ DBRefEntry dbrf=null;\r
+ List<DBRefEntry> dbrs=new ArrayList<DBRefEntry>();\r
+ String seqdb="Unknown",sdbac=""+dbr;\r
+ int st=-1,en=-1,p;\r
+ if ((st=sdbac.indexOf("/"))>-1)\r
+ {\r
+ String num,range=sdbac.substring(st+1);\r
+ sdbac = sdbac.substring(0,st);\r
+ if ((p=range.indexOf("-"))>-1)\r
+ {\r
+ p++;\r
+ if (p<range.length())\r
+ {\r
+ num = range.substring(p).trim();\r
+ try {\r
+ en = Integer.parseInt(num);\r
+ } catch (NumberFormatException x)\r
+ {\r
+ // could warn here that index is invalid\r
+ en = -1;\r
+ }\r
+ }\r
+ } else {\r
+ p=range.length();\r
+ }\r
+ num=range.substring(0,p).trim();\r
+ try {\r
+ st = Integer.parseInt(num);\r
+ } catch (NumberFormatException x)\r
+ {\r
+ // could warn here that index is invalid\r
+ st = -1;\r
+ }\r
+ }\r
+ if (dbsource.equals("PFAM")) {\r
+ seqdb = "UNIPROT";\r
+ if (sdbac.indexOf(".")>-1)\r
+ {\r
+ // strip of last subdomain\r
+ sdbac = sdbac.substring(0,sdbac.indexOf("."));\r
+ dbrf = jalview.util.DBRefUtils.parseToDbRef(seqO, seqdb, dbsource, sdbac);\r
+ if (dbrf!=null)\r
+ {\r
+ dbrs.add(dbrf);\r
+ }\r
+ }\r
+ dbrf = jalview.util.DBRefUtils.parseToDbRef(seqO, dbsource, dbsource, dbr);\r
+ if (dbr!=null)\r
+ {\r
+ dbrs.add(dbrf);\r
+ }\r
+ } else {\r
+ seqdb = "EMBL"; // total guess - could be ENA, or something else these days\r
+ if (sdbac.indexOf(".")>-1)\r
+ {\r
+ // strip off last subdomain\r
+ sdbac = sdbac.substring(0,sdbac.indexOf("."));\r
+ dbrf = jalview.util.DBRefUtils.parseToDbRef(seqO, seqdb, dbsource, sdbac);\r
+ if (dbrf!=null)\r
+ {\r
+ dbrs.add(dbrf);\r
+ }\r
+ }\r
+ \r
+ dbrf = jalview.util.DBRefUtils.parseToDbRef(seqO, dbsource, dbsource, dbr);\r
+ if (dbrf!=null)\r
+ {\r
+ dbrs.add(dbrf);\r
+ }\r
+ }\r
+ if (st!=-1 && en!=-1)\r
+ {\r
+ for (DBRefEntry d:dbrs)\r
+ {\r
+ jalview.util.MapList mp = new jalview.util.MapList(new int[] { seqO.getStart(),seqO.getEnd()},new int[] { st,en},1,1);\r
+ jalview.datamodel.Mapping mping = new jalview.datamodel.Mapping(mp);\r
+ d.setMap(mping);\r
+ }\r
+ }\r
+ }\r
+ \r
+ protected static AlignmentAnnotation parseAnnotationRow(\r
+ Vector annotation, String label, String annots)\r
{\r
- String type = (label.indexOf("_cons") == label.length() - 5) ? label\r
+ String convert1, convert2 = null;\r
+\r
+ // Convert all bracket types to parentheses\r
+ Regex openparen = new Regex("(<|\\[)", "(");\r
+ Regex closeparen = new Regex("(>|\\])", ")");\r
+\r
+ // Detect if file is RNA by looking for bracket types\r
+ Regex detectbrackets = new Regex("(<|>|\\[|\\]|\\(|\\))");\r
+\r
+ convert1 = openparen.replaceAll(annots);\r
+ convert2 = closeparen.replaceAll(convert1);\r
+ annots = convert2;\r
+\r
+ String type = label;
+ if (label.contains("_cons"))
+ {
+ type = (label.indexOf("_cons") == label.length() - 5) ? label
.substring(0, label.length() - 5) : label;\r
+ }
boolean ss = false;\r
type = id2type(type);\r
if (type.equals("secondary structure"))\r
String pos = annots.substring(i, i + 1);\r
Annotation ann;\r
ann = new Annotation(pos, "", ' ', 0f); // 0f is 'valid' null - will not\r
- // be written out\r
+ // be written out\r
if (ss)\r
{\r
- ann.secondaryStructure = jalview.schemes.ResidueProperties\r
- .getDssp3state(pos).charAt(0);\r
+ if (detectbrackets.search(pos))\r
+ {\r
+ ann.secondaryStructure = jalview.schemes.ResidueProperties\r
+ .getRNASecStrucState(pos).charAt(0);\r
+ }\r
+ else\r
+ {\r
+ ann.secondaryStructure = jalview.schemes.ResidueProperties\r
+ .getDssp3state(pos).charAt(0);\r
+ }\r
+\r
if (ann.secondaryStructure == pos.charAt(0) || pos.charAt(0) == 'C')\r
{\r
ann.displayCharacter = ""; // null; // " ";\r
annot.annotations.length);\r
System.arraycopy(els, 0, anns, annot.annotations.length, els.length);\r
annot.annotations = anns;\r
+ // System.out.println("else: ");\r
}\r
return annot;\r
}\r
\r
- public static String print(SequenceI[] s)\r
+ public String print(SequenceI[] s)
+ {
+ // find max length of id
+ int max = 0;
+ int maxid = 0;
+ int in = 0;
+ Hashtable dataRef = null;
+ while ((in < s.length) && (s[in] != null))
+ {
+ String tmp = printId(s[in]);
+ if (s[in].getSequence().length > max)
+ {
+ max = s[in].getSequence().length;
+ }
+
+ if (tmp.length() > maxid)
+ {
+ maxid = tmp.length();
+ }
+ if (s[in].getDBRef() != null)
+ {
+ for (int idb = 0; idb < s[in].getDBRef().length; idb++)
+ {
+ if (dataRef == null)
+ dataRef = new Hashtable();
+
+ String datAs1 = s[in].getDBRef()[idb].getSource().toString()
+ + " ; "
+ + s[in].getDBRef()[idb].getAccessionId().toString();
+ dataRef.put(tmp, datAs1);
+ }
+ }
+ in++;
+ }
+ maxid += 9;
+ int i = 0;
+
+ // output database type
+ if (al.getProperties() != null)
+ {
+ if (!al.getProperties().isEmpty())
+ {
+ Enumeration key = al.getProperties().keys();
+ Enumeration val = al.getProperties().elements();
+ while (key.hasMoreElements())
+ {
+ out.append("#=GF " + key.nextElement() + " " + val.nextElement());
+ out.append(newline);
+ }
+ }
+ }
+
+ // output database accessions
+ if (dataRef != null)
+ {
+ Enumeration en = dataRef.keys();
+ while (en.hasMoreElements())
+ {
+ Object idd = en.nextElement();
+ String type = (String) dataRef.remove(idd);
+ out.append(new Format("%-" + (maxid - 2) + "s").form("#=GS "
+ + idd.toString() + " "));
+ if (type.contains("PFAM") || type.contains("RFAM"))
+ {
+
+ out.append(" AC " + type.substring(type.indexOf(";") + 1));
+ }
+ else
+ {
+ out.append(" DR " + type + " ");
+ }
+ out.append(newline);
+ }
+ }
+
+ // output annotations
+ while (i < s.length && s[i] != null)
+ {
+ if (s[i].getDatasetSequence() != null)
+ {
+ SequenceI ds = s[i].getDatasetSequence();
+ AlignmentAnnotation[] alAnot;
+ Annotation[] ann;
+ Annotation annot;
+ alAnot = s[i].getAnnotation();
+ String feature = "";
+ if (alAnot != null)
+ {
+ for (int j = 0; j < alAnot.length; j++)
+ {
+ if (ds.getSequenceFeatures() != null)
+ {
+ feature = ds.getSequenceFeatures()[0].type;
+ }
+ String key = type2id(feature);
+
+ if (key == null)
+ continue;
+
+ // out.append("#=GR ");
+ out.append(new Format("%-" + maxid + "s").form("#=GR "
+ + printId(s[i]) + " " + key + " "));
+ ann = alAnot[j].annotations;
+ String seq = "";
+ for (int k = 0; k < ann.length; k++)
+ {
+ annot = ann[k];
+ String ch = (annot == null) ? Character.toString(s[i]
+ .getCharAt(k)) : annot.displayCharacter;
+ if (ch.length() == 0)
+ {
+ if (key.equals("SS"))
+ {
+ char ll = annot.secondaryStructure;
+ seq = (Character.toString(ll).equals(" ")) ? seq + "C"
+ : seq + ll;
+ }
+ else
+ {
+ seq += ".";
+ }
+ }
+ else if (ch.length() == 1)
+ {
+ seq += ch;
+ }
+ else if (ch.length() > 1)
+ {
+ seq += ch.charAt(1);
+ }
+ }
+ out.append(seq);
+ out.append(newline);
+ }
+ }
+ }
+
+ out.append(new Format("%-" + maxid + "s").form(printId(s[i]) + " "));
+ out.append(s[i].getSequenceAsString());
+ out.append(newline);
+ i++;
+ }
+
+ // alignment annotation
+ AlignmentAnnotation aa;
+ if (al.getAlignmentAnnotation() != null)
+ {
+ for (int ia = 0; ia < al.getAlignmentAnnotation().length; ia++)
+ {
+ aa = al.getAlignmentAnnotation()[ia];
+ if (aa.autoCalculated || !aa.visible)
+ {
+ continue;
+ }
+ String seq = "";
+ String label;
+
+ if (aa.label.equals("seq"))
+ label = "seq_cons";
+ else
+ label = type2id(aa.label.toLowerCase()) + "_cons";
+
+ if (label == null)
+ label = aa.label;
+
+ out.append(new Format("%-" + maxid + "s").form("#=GC " + label
+ + " "));
+ for (int j = 0; j < aa.annotations.length; j++)
+ {
+ String ch = (aa.annotations[j] == null) ? "-"
+ : aa.annotations[j].displayCharacter;
+ if (ch.length() == 0)
+ {
+ char ll = aa.annotations[j].secondaryStructure;
+ if (Character.toString(ll).equals(" "))
+ seq += "C";
+ else
+ seq += ll;
+ }
+ else if (ch.length() == 1)
+ {
+ seq += ch;
+ }
+ else if (ch.length() > 1)
{\r
- return "not yet implemented";\r
+ seq += ch.charAt(1);
+ }
+ }
+ out.append(seq);
+ out.append(newline);
+ }
+ }
+ return out.toString();
}\r
\r
public String print()\r
{\r
- return print(getSeqsAsArray());\r
+ out = new StringBuffer();
+ out.append("# STOCKHOLM 1.0");
+ out.append(newline);
+ print(getSeqsAsArray());
+
+ out.append("//");
+ out.append(newline);
+ return out.toString();
}\r
\r
private static Hashtable typeIds = null;\r
}\r
}\r
\r
- private String id2type(String id)\r
+ protected static String id2type(String id)\r
{\r
if (typeIds.containsKey(id))\r
{\r
+ id);\r
return id;\r
}\r
-}\r
+ \r
+ protected static String type2id(String type)\r
+ {\r
+ String key = null;\r
+ Enumeration e = typeIds.keys();\r
+ while (e.hasMoreElements())\r
+ {\r
+ Object ll = e.nextElement();\r
+ if (typeIds.get(ll).toString().equals(type))\r
+ {\r
+ key = (String) ll;\r
+ break;\r
+ }\r
+ }\r
+ if (key != null)\r
+ {\r
+ return (String) key;\r
+ }\r
+ System.err.println("Warning : Unknown Stockholm annotation type: "\r
+ + type);\r
+ return key;\r
+ }\r
+ /**\r
+ * make a friendly ID string.\r
+ * \r
+ * @param dataName\r
+ * @return truncated dataName to after last '/'\r
+ */\r
+ private String safeName(String dataName)\r
+ {\r
+ int b = 0;\r
+ while ((b = dataName.indexOf("/")) > -1 && b < dataName.length())\r
+ {\r
+ dataName = dataName.substring(b + 1).trim();\r
+\r
+ }\r
+ int e = (dataName.length() - dataName.indexOf(".")) + 1;\r
+ dataName = dataName.substring(1, e).trim();\r
+ return dataName;\r
+ }\r
+}
\ No newline at end of file
git://source.jalview.org / jalview.git / blobdiff