import jalview.datamodel.AlignmentI;
import jalview.datamodel.Annotation;
import jalview.datamodel.DBRefEntry;
+import jalview.datamodel.DBRefSource;
import jalview.datamodel.Mapping;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.schemes.ResidueProperties;
import jalview.util.Comparison;
+import jalview.util.DBRefUtils;
import jalview.util.Format;
import jalview.util.MessageManager;
import jalview.util.Platform;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Locale;
import java.util.Map;
import java.util.Vector;
{
private static final String ANNOTATION = "annotation";
- // WUSS extended symbols. Avoid ambiguity with protein SS annotations by using
- // NOT_RNASS first.
+ private static final char UNDERSCORE = '_';
+
+ // WUSS extended symbols. Avoid ambiguity with protein SS annotations by using NOT_RNASS first.
public static final String RNASS_BRACKETS = "<>[](){}AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz";
public static final int REGEX_STOCKHOLM = 0;
public static final int REGEX_BRACKETS = 1;
-
// use the following regex to decide an annotations (whole) line is NOT an RNA
// SS (it contains only E,H,e,h and other non-brace/non-alpha chars)
public static final int REGEX_NOT_RNASS = 2;
/**
* Centralize all actual Regex instantialization in Platform.
- *
+ * // JBPNote: Why is this 'centralisation' better ?
* @param id
* @return
*/
StringBuffer out; // output buffer
- AlignmentI al;
+ private AlignmentI al;
public StockholmFile()
{
}
/**
- * Creates a new StockholmFile object for output.
+ * Creates a new StockholmFile object for output
*/
public StockholmFile(AlignmentI al)
{
if (accAnnotations != null && accAnnotations.containsKey("AC"))
{
- if (dbsource != null)
- {
String dbr = (String) accAnnotations.get("AC");
if (dbr != null)
{
// we could get very clever here - but for now - just try to
- // guess accession type from source of alignment plus structure
+ // guess accession type from type of sequence, source of alignment plus
+ // structure
// of accession
guessDatabaseFor(seqO, dbr, dbsource);
-
- }
}
// else - do what ? add the data anyway and prompt the user to
// specify what references these are ?
treeName = an.stringMatched(2);
treeString = new StringBuffer();
}
+ // TODO: JAL-3532 - this is where GF comments and database references are lost
+ // suggest overriding this method for Stockholm files to catch and properly
+ // process CC, DR etc into multivalued properties
setAlignmentProperty(an.stringMatched(1), an.stringMatched(2));
}
}
if (features.containsKey(this.id2type(type)))
{
// logger.debug("Found content for " + this.id2type(type));
- content = (Hashtable) features.get(this.id2type(type));
+ content = (Hashtable) features
+ .get(this.id2type(type));
}
else
{
// logger.debug("Creating new content holder for " +
// this.id2type(type));
content = new Hashtable();
- features.put(this.id2type(type), content);
+ features.put(id2type(type), content);
}
String ns = (String) content.get(ANNOTATION);
st = -1;
}
}
+ if (dbsource == null)
+ {
+ // make up an origin based on whether the sequence looks like it is nucleotide
+ // or protein
+ dbsource = (seqO.isProtein()) ? "PFAM" : "RFAM";
+ }
if (dbsource.equals("PFAM"))
{
seqdb = "UNIPROT";
Vector<AlignmentAnnotation> annotation, String label,
String annots)
{
- String convert1, convert2 = null;
-
- // convert1 = OPEN_PAREN.replaceAll(annots);
- // convert2 = CLOSE_PAREN.replaceAll(convert1);
+ String convert1, convert2 = null;
+ // String convert1 = OPEN_PAREN.replaceAll(annots);
+ // String convert2 = CLOSE_PAREN.replaceAll(convert1);
// annots = convert2;
String type = label;
for (int i = 0; i < annots.length(); i++)
{
String pos = annots.substring(i, i + 1);
+ // TODO 2.12 release: verify this Stockholm IO behaviour change in release notes
+ if (UNDERSCORE == pos.charAt(0))
+ {
+ pos = " ";
+ }
Annotation ann;
ann = new Annotation(pos, "", ' ', 0f); // 0f is 'valid' null - will not
// be written out
return annot;
}
+ private String dbref_to_ac_record(DBRefEntry ref)
+ {
+ return ref.getSource().toString() + " ; "
+ + ref.getAccessionId().toString();
+ }
@Override
public String print(SequenceI[] s, boolean jvSuffix)
{
int slen = s.length;
SequenceI seq;
Hashtable<String, String> dataRef = null;
+ boolean isAA = s[in].isProtein();
while ((in < slen) && ((seq = s[in]) != null))
{
String tmp = printId(seq, jvSuffix);
{
dataRef = new Hashtable<>();
}
- for (int idb = 0; idb < ndb; idb++)
+ List<DBRefEntry> primrefs = seq.getPrimaryDBRefs();
+ if (primrefs.size() >= 1)
{
-
- DBRefEntry ref = seqrefs.get(idb);
- String datAs1 = ref.getSource().toString()
- + " ; "
- + ref.getAccessionId().toString();
- dataRef.put(tmp, datAs1);
+ dataRef.put(tmp, dbref_to_ac_record(primrefs.get(0)));
+ }
+ else
+ {
+ for (int idb = 0; idb < ndb; idb++)
+ {
+ DBRefEntry dbref = seqrefs.get(idb);
+ dataRef.put(tmp, dbref_to_ac_record(dbref));
+ // if we put in a uniprot or EMBL record then we're done:
+ if ((isAA ? DBRefSource.UNIPROT : DBRefSource.EMBL)
+ .equals(DBRefUtils.getCanonicalName(dbref.getSource())))
+ {
+ break;
+ }
+ }
}
}
in++;
String type = dataRef.remove(idd);
out.append(new Format("%-" + (maxid - 2) + "s")
.form("#=GS " + idd.toString() + " "));
- if (type.contains("PFAM") || type.contains("RFAM"))
+ if (isAA && type.contains("UNIPROT")
+ || (!isAA && type.contains("EMBL")))
{
out.append(" AC " + type.substring(type.indexOf(";") + 1));
if (alAnot != null)
{
Annotation[] ann;
- for (int j = 0, nj = alAnot.length; j < nj; j++)
+ for (int j = 0; j < alAnot.length; j++)
{
- String key = type2id(alAnot[j].label);
- boolean isrna = alAnot[j].isValidStruc();
-
- if (isrna)
- {
- // hardwire to secondary structure if there is RNA secondary
- // structure on the annotation
- key = "SS";
- }
- if (key == null)
+ if (alAnot[j].annotations != null)
{
+ String key = type2id(alAnot[j].label);
+ boolean isrna = alAnot[j].isValidStruc();
- continue;
- }
+ if (isrna)
+ {
+ // hardwire to secondary structure if there is RNA secondary
+ // structure on the annotation
+ key = "SS";
+ }
+ if (key == null)
+ {
+ continue;
+ }
- // out.append("#=GR ");
- out.append(new Format("%-" + maxid + "s").form(
- "#=GR " + printId(seq, jvSuffix) + " " + key + " "));
- ann = alAnot[j].annotations;
- String sseq = "";
- for (int k = 0, nk = ann.length; k < nk; k++)
- {
- sseq += outputCharacter(key, k, isrna, ann, seq);
- }
- out.append(sseq);
- out.append(newline);
+ // out.append("#=GR ");
+ out.append(new Format("%-" + maxid + "s").form(
+ "#=GR " + printId(s[i], jvSuffix) + " " + key + " "));
+ ann = alAnot[j].annotations;
+ String sseq = "";
+ for (int k = 0; k < ann.length; k++)
+ {
+ sseq += outputCharacter(key, k, isrna, ann, s[i]);
+ }
+ out.append(sseq);
+ out.append(newline);
+ }
}
}
: seq;
}
+ /**
+ * make a friendly ID string.
+ *
+ * @param dataName
+ * @return truncated dataName to after last '/'
+ */
+ private String safeName(String dataName)
+ {
+ int b = 0;
+ while ((b = dataName.indexOf("/")) > -1 && b < dataName.length())
+ {
+ dataName = dataName.substring(b + 1).trim();
+
+ }
+ int e = (dataName.length() - dataName.indexOf(".")) + 1;
+ dataName = dataName.substring(1, e).trim();
+ return dataName;
+ }
+
+
public String print()
{
out = new StringBuffer();
}
}
+
protected static String id2type(String id)
{
if (typeIds.containsKey(id))
"Warning : Unknown Stockholm annotation type: " + type);
return key;
}
-
- /**
- * make a friendly ID string.
- *
- * @param dataName
- * @return truncated dataName to after last '/'
- */
- private String safeName(String dataName)
- {
- int b = 0;
- while ((b = dataName.indexOf("/")) > -1 && b < dataName.length())
- {
- dataName = dataName.substring(b + 1).trim();
-
- }
- int e = (dataName.length() - dataName.indexOf(".")) + 1;
- dataName = dataName.substring(1, e).trim();
- return dataName;
- }
}