newseqs, boolean relaxedIdMatching)
{
if (seqId == null)
{
return null;
}
SequenceI match = null;
if (relaxedIdMatching)
{
if (lastmatchedAl != align)
{
lastmatchedAl = align;
matcher = new SequenceIdMatcher(align.getSequencesArray());
if (newseqs != null)
{
matcher.addAll(newseqs);
}
}
match = matcher.findIdMatch(seqId);
}
else
{
match = align.findName(seqId, true);
if (match == null && newseqs != null)
{
for (SequenceI m : newseqs)
{
if (seqId.equals(m.getName()))
{
return m;
}
}
}
}
if (match == null && newseqs != null)
{
match = new SequenceDummy(seqId);
if (relaxedIdMatching)
{
matcher.addAll(Arrays.asList(new SequenceI[] { match }));
}
// add dummy sequence to the newseqs list
newseqs.add(match);
}
return match;
}
/**
* Parses the input line to a map of name / value(s) pairs. For example the
* line
*
*
* Notes=Fe-S;Method=manual curation, prediction; source = Pfam; Notes = Metal
*
*
* if parsed with delimiter=";" and separators {' ', '='}
* would return a map with { Notes={Fe=S, Metal}, Method={manual curation,
* prediction}, source={Pfam}}
*
* This method supports parsing of either GFF2 format (which uses space ' ' as
* the name/value delimiter, and allows multiple occurrences of the same
* name), or GFF3 format (which uses '=' as the name/value delimiter, and
* strictly does not allow repeat occurrences of the same name - but does
* allow a comma-separated list of values).
*
* Returns a (possibly empty) map of lists of values by attribute name.
*
* @param text
* @param namesDelimiter
* the major delimiter between name-value pairs
* @param nameValueSeparator
* separator used between name and value
* @param valuesDelimiter
* delimits a list of more than one value
* @return
*/
public static Map> parseNameValuePairs(String text,
String namesDelimiter, char nameValueSeparator,
String valuesDelimiter)
{
Map> map = new HashMap<>();
if (text == null || text.trim().length() == 0)
{
return map;
}
/*
* split by major delimiter (; for GFF3)
*/
for (String nameValuePair : text.trim().split(namesDelimiter))
{
nameValuePair = nameValuePair.trim();
if (nameValuePair.length() == 0)
{
continue;
}
/*
* find name/value separator (= for GFF3)
*/
int sepPos = nameValuePair.indexOf(nameValueSeparator);
if (sepPos == -1)
{
// no name=value found
continue;
}
String name = nameValuePair.substring(0, sepPos).trim();
String values = nameValuePair.substring(sepPos + 1).trim();
if (values.isEmpty())
{
continue;
}
List vals = map.get(name);
if (vals == null)
{
vals = new ArrayList<>();
map.put(name, vals);
}
/*
* if 'values' contains more name/value separators, parse as a map
* (nested sub-attribute values)
*/
if (values.indexOf(nameValueSeparator) != -1)
{
vals.add(values);
}
else
{
for (String val : values.split(valuesDelimiter))
{
vals.add(val);
}
}
}
return map;
}
/**
* Constructs a SequenceFeature from the GFF column data. Subclasses may wish
* to call this method then adjust the SequenceFeature depending on the
* particular usage of different tools that generate GFF.
*
* @param gff
* @param attributes
* @return
*/
protected SequenceFeature buildSequenceFeature(String[] gff,
Map> attributes)
{
return buildSequenceFeature(gff, TYPE_COL, gff[SOURCE_COL], attributes);
}
/**
* @param gff
* @param typeColumn
* @param group
* @param attributes
* @return
*/
protected SequenceFeature buildSequenceFeature(String[] gff,
int typeColumn, String group, Map> attributes)
{
try
{
int start = Integer.parseInt(gff[START_COL]);
int end = Integer.parseInt(gff[END_COL]);
/*
* default 'score' is 0 rather than Float.NaN - see JAL-2554
*/
float score = 0f;
try
{
score = Float.parseFloat(gff[SCORE_COL]);
} catch (NumberFormatException nfe)
{
// e.g. '.' - leave as zero
}
SequenceFeature sf = new SequenceFeature(gff[typeColumn],
gff[SOURCE_COL], start, end, score, group);
sf.setStrand(gff[STRAND_COL]);
sf.setPhase(gff[PHASE_COL]);
if (attributes != null)
{
/*
* Add attributes in column 9 to the sequence feature's
* 'otherData' table; use Note as a best proxy for description;
* decode any encoded comma, equals, semi-colon as per GFF3 spec
*/
for (Entry> attr : attributes.entrySet())
{
String key = attr.getKey();
List values = attr.getValue();
if (values.size() == 1 && values.get(0).contains(EQUALS))
{
/*
* 'value' is actually nested subattributes as x=a,y=b,z=c
*/
Map valueMap = parseAttributeMap(values.get(0));
sf.setValue(key, valueMap);
}
else
{
String csvValues = StringUtils.listToDelimitedString(values,
COMMA);
csvValues = StringUtils.urlDecode(csvValues, GFF_ENCODABLE);
sf.setValue(key, csvValues);
if (NOTE.equals(key))
{
sf.setDescription(csvValues);
}
}
}
}
return sf;
} catch (NumberFormatException nfe)
{
System.err.println("Invalid number in gff: " + nfe.getMessage());
return null;
}
}
/**
* Parses a (GFF3 format) list of comma-separated key=value pairs into a Map
* of {@code key,
* value}
* An input string like {@code a=b,c,d=e,f=g,h} is parsed to
*
*
* a = "b,c"
* d = "e"
* f = "g,h"
*
*
* @param s
*
* @return
*/
protected static Map parseAttributeMap(String s)
{
Map map = new HashMap<>();
String[] fields = s.split(EQUALS);
/*
* format validation
*/
boolean valid = true;
if (fields.length < 2)
{
/*
* need at least A=B here
*/
valid = false;
}
else if (fields[0].isEmpty() || fields[0].contains(COMMA))
{
/*
* A,B=C is not a valid start, nor is =C
*/
valid = false;
}
else
{
for (int i = 1; i < fields.length - 1; i++)
{
if (fields[i].isEmpty() || !fields[i].contains(COMMA))
{
/*
* intermediate tokens must include value,name
*/
valid = false;
}
}
}
if (!valid)
{
System.err.println(INVALID_GFF_ATTRIBUTE_FORMAT + s);
return map;
}
int i = 0;
while (i < fields.length - 1)
{
boolean lastPair = i == fields.length - 2;
String before = fields[i];
String after = fields[i + 1];
/*
* if 'key' looks like a,b,c then the last token is the
* key
*/
String theKey = before.contains(COMMA)
? before.substring(before.lastIndexOf(COMMA) + 1)
: before;
theKey = theKey.trim();
if (theKey.isEmpty())
{
System.err.println(INVALID_GFF_ATTRIBUTE_FORMAT + s);
map.clear();
return map;
}
/*
* if 'value' looks like a,b,c then all but the last token is the value,
* unless this is the last field (no more = to follow), in which case
* all of it makes up the value
*/
String theValue = after.contains(COMMA) && !lastPair
? after.substring(0, after.lastIndexOf(COMMA))
: after;
map.put(StringUtils.urlDecode(theKey, GFF_ENCODABLE),
StringUtils.urlDecode(theValue, GFF_ENCODABLE));
i += 1;
}
return map;
}
/**
* Returns any existing mapping held on the alignment between the given
* dataset sequences, or a new one if none found. This is a convenience method
* to facilitate processing multiple GFF lines that make up a single 'spliced'
* mapping, by extending the first mapping as the others are read.
*
* @param align
* @param fromSeq
* @param toSeq
* @return
*/
protected AlignedCodonFrame getMapping(AlignmentI align,
SequenceI fromSeq, SequenceI toSeq)
{
AlignedCodonFrame acf = align.getMapping(fromSeq, toSeq);
if (acf == null)
{
acf = new AlignedCodonFrame();
}
return acf;
}
}