seqData, String seqId)
+ throws IOException
+ {
+ /*
+ * New sequence found in second or later data block - error.
+ */
+ if (this.firstDataBlockRead && !seqData.containsKey(seqId))
+ {
+ throw new IOException(
+ "Parse error: misplaced new sequence starting at " + dataLine);
+ }
+
+ StringBuilder sb = getSequenceDataBuffer(seqData, seqId);
+ String data = dataLine.substring(seqId.length() + 1).trim();
+
+ /*
+ * Do nothing if this line is _only_ a sequence id with no data following.
+ *
+ * Remove any internal spaces (present in the 'fancy' file format)
+ */
+ if (data != null && data.length() > 0)
+ {
+ if (data.indexOf(SPACE) != -1)
+ {
+ data = data.replace(SPACE, "");
+ }
+ sb.append(data);
+ assertInterleaved(true, dataLine);
+ }
+ }
+
+ /**
+ * If the line begins with (e.g.) "#abcde " then returns "abcde" as the
+ * identifier. Else returns null.
+ *
+ * @param dataLine
+ * @return
+ */
+ public static String getSequenceId(String dataLine)
+ {
+ // TODO refactor to a StringUtils type class
+ if (dataLine != null)
+ {
+ if (dataLine.startsWith(HASHSIGN))
+ {
+ int spacePos = dataLine.indexOf(" ");
+ return (spacePos == -1 ? dataLine.substring(1) : dataLine
+ .substring(1, spacePos));
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Read the #MEGA and Title/Format/Description/Gene header lines (if present).
+ *
+ * Save as annotation properties in case useful.
+ *
+ * @return the next non-blank line following the header lines.
+ * @throws IOException
+ */
+ protected String parseHeaderLines() throws IOException
+ {
+ String inputLine = null;
+ while ((inputLine = nextLine()) != null)
+ {
+ inputLine = inputLine.trim();
+
+ /*
+ * skip blank lines
+ */
+ if (inputLine.length() == 0)
+ {
+ continue;
+ }
+
+ if (inputLine.startsWith(BANG))
+ {
+ setFileFormat(FileFormat.FANCY);
+ }
+
+ if (inputLine.startsWith(BANG + PROP_DESCRIPTION))
+ {
+ parseDescriptionLines();
+ }
+
+ else if (isPropertyLine(inputLine))
+ {
+ /*
+ * If a property is matched, parse and save it.
+ */
+ String[] property_value = parsePropertyValue(inputLine);
+ setAlignmentProperty(property_value[0], property_value[1]);
+ }
+ else if (!inputLine.toUpperCase().startsWith(MEGA_ID))
+ {
+
+ /*
+ * Return the first 'data line' i.e. one that is not blank, #MEGA or
+ * TITLE:
+ */
+ break;
+ }
+ }
+ return inputLine;
+ }
+
+ /**
+ * Read following lines until blank, appending each to the Description
+ * property value.
+ *
+ * Assumes the !Description line itself does not include description text.
+ *
+ * Assumes the description is followed by a blank line (else we will consume
+ * one too many).
+ *
+ * @throws IOException
+ */
+ protected void parseDescriptionLines() throws IOException
+ {
+ StringBuilder desc = new StringBuilder(256);
+ String line = null;
+ while ((line = nextLine()) != null) {
+ if ("".equals(line.trim()))
+ {
+ break;
+ }
+ desc.append(line).append(newline);
+ }
+ setAlignmentProperty(PROP_DESCRIPTION, desc.toString());
+ }
+
+ /**
+ * Test whether the line holds an expected property declaration.
+ *
+ * @param inputLine
+ * @return
+ */
+ protected boolean isPropertyLine(String inputLine)
+ {
+ if (lineMatchesFlag(inputLine, PROP_TITLE, BANG, COLON)
+ || lineMatchesFlag(inputLine, PROP_FORMAT, BANG, COLON)
+ || lineMatchesFlag(inputLine, PROP_DESCRIPTION, BANG, COLON)
+ || lineMatchesFlag(inputLine, PROP_GENE, BANG, COLON))
+ {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Helper method that extract the name and value of a property, assuming the
+ * first space or equals sign is the separator.
+ *
+ * Thus "Description: Melanogaster" or "!Description=Melanogaster" both return
+ * {"Description", "Melanogaster"}.
+ *
+ * Returns an empty value string if no space or equals sign is present.
+ *
+ * @param s
+ * @return
+ */
+ public static String[] parsePropertyValue(String s)
+ {
+ // TODO refactor to a string utils helper class (or find equivalent)
+ // TODO handle other cases e.g. "Description = Melanogaster"
+ String propertyName = s;
+ String value = "";
+
+ int separatorPos = -1;
+
+ if (s != null)
+ {
+ int spacePos = s.indexOf(SPACE);
+ int eqPos = s.indexOf(EQUALS);
+ if (spacePos == -1 && eqPos > -1)
+ {
+ separatorPos = eqPos;
+ }
+ else if (spacePos > -1 && eqPos == -1)
+ {
+ separatorPos = spacePos;
+ }
+ else if (spacePos > -1 && eqPos > -1)
+ {
+ separatorPos = Math.min(spacePos, eqPos);
+ }
+ }
+ if (separatorPos > -1)
+ {
+ value = s.substring(separatorPos + 1);
+ propertyName = s.substring(0, separatorPos);
+ }
+
+ /*
+ * finally strip any leading / trailing chars from property name
+ */
+ if (propertyName.startsWith(BANG))
+ {
+ propertyName = propertyName.substring(1);
+ }
+ if (propertyName.endsWith(COLON))
+ {
+ propertyName = propertyName.substring(0, propertyName.length() - 1);
+ }
+
+ return new String[]
+ { propertyName, value };
+ }
+
+ /**
+ * Test whether a line starts with the specified flag field followed by a
+ * space (or nothing).
+ *
+ * Here we accept an optional prefix and suffix on the flag, and the check is
+ * not case-sensitive. So these would match for "Title"
+ *
+ *
+ * Title Melanogaster
+ * Title=Melanogaster
+ * TITLE Melanogaster
+ * TITLE=Melanogaster
+ * !Title Melanogaster
+ * !Title=Melanogaster
+ * !TITLE Melanogaster
+ * !TITLE=Melanogaster
+ * Title: Melanogaster
+ * Title:=Melanogaster
+ * TITLE: Melanogaster
+ * TITLE:=Melanogaster
+ * !Title: Melanogaster
+ * !Title:=Melanogaster
+ * !TITLE: Melanogaster
+ * !TITLE:=Melanogaster
+ * Title
+ * TITLE
+ * !Title
+ * !TITLE
+ *
+ *
+ * @param line
+ * @param flag
+ * @param prefix
+ * @param suffix
+ * @return
+ */
+ public static boolean lineMatchesFlag(String line, String flag, String prefix, String suffix)
+ {
+ // TODO refactor to a string utils helper class
+ boolean result = false;
+ if (line != null && flag != null) {
+ String lineUpper = line.toUpperCase().trim();
+ String flagUpper = flag.toUpperCase();
+
+ // skip prefix character e.g. ! before attempting match
+ if (lineUpper.startsWith(prefix)) {
+ lineUpper = lineUpper.substring(1);
+ }
+
+ // test for flag + SPACE or flag + EQUALS, with or without suffix
+ if (lineUpper.startsWith(flagUpper + SPACE)
+ || lineUpper.startsWith(flagUpper + EQUALS)
+ || lineUpper.startsWith(flagUpper + suffix + SPACE)
+ || lineUpper.startsWith(flagUpper + suffix + EQUALS))
+ {
+ result = true;
+ }
+ else
+ {
+ // test for exact match i.e. flag only on this line
+ if (lineUpper.equals(flagUpper)
+ || lineUpper.startsWith(flagUpper + suffix))
+ {
+ result = true;
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Write out the alignment sequences in Mega format.
+ */
+ @Override
+ public String print()
+ {
+ return print(getSeqsAsArray());
+ }
+
+ /**
+ * Write out the alignment sequences in Mega format - interleaved unless
+ * explicitly noninterleaved.
+ */
+ public String print(SequenceI[] s)
+ {
+ // TODO: is there a way to preserve the 'interleaved' property so it can
+ // affect output?
+
+ String result = null;
+ if (this.fileFormat == FileFormat.FANCY)
+ {
+ result = printInterleavedCodons(s);
+ }
+ else if (this.interleaved != null && !this.interleaved)
+ {
+ result = printNonInterleaved(s);
+ }
+ else
+ {
+ result = printInterleaved(s);
+ }
+ return result;
+ }
+
+ /**
+ * Print the sequences in interleaved format, each row 15 space-separated
+ * triplets.
+ *
+ * @param s
+ * @return
+ */
+ protected String printInterleavedCodons(SequenceI[] s)
+ {
+ // TODO not coded yet - defaulting to the 'simple' format output
+ return printInterleaved(s);
+ }
+
+ /**
+ * Print to string in Interleaved format - blocks of next 50 characters of
+ * each sequence in turn.
+ *
+ * @param s
+ */
+ protected String printInterleaved(SequenceI[] s)
+ {
+ int maxIdLength = getMaxIdLength(s);
+ int maxSequenceLength = getMaxSequenceLength(s);
+ int numLines = maxSequenceLength / POSITIONS_PER_LINE + 3; // approx
+
+ /*
+ * Size a buffer to hold the whole output
+ */
+ StringBuilder sb = new StringBuilder(numLines
+ * (maxIdLength + 2 + POSITIONS_PER_LINE));
+ printHeaders(sb, FileFormat.SIMPLE);
+
+ int numDataBlocks = (maxSequenceLength - 1) / POSITIONS_PER_LINE + 1;
+ for (int i = 0; i < numDataBlocks; i++)
+ {
+ sb.append(newline);
+ for (SequenceI seq : s)
+ {
+
+ String seqId = String.format("#%-" + maxIdLength + "s ",
+ seq.getName());
+ char[] subSequence = seq.getSequence(i * POSITIONS_PER_LINE,
+ (i + 1) * POSITIONS_PER_LINE);
+ sb.append(seqId);
+ sb.append(subSequence);
+ sb.append(newline);
+ }
+ }
+
+ return new String(sb);
+ }
+
+ /**
+ * Append the MEGA header and any other known properties
+ *
+ * @param sb
+ */
+ private void printHeaders(StringBuilder sb, FileFormat format)
+ {
+ sb.append(MEGA_ID);
+ sb.append(newline);
+ /*
+ *
+ */
+ Set> props = getAlignmentProperties();
+ if (props != null)
+ {
+ for (Entry prop : props)
+ {
+ Object key = prop.getKey();
+ Object value = prop.getValue();
+ if (key instanceof String && value instanceof String)
+ {
+ if (format == FileFormat.FANCY)
+ {
+ sb.append(BANG).append(key).append(SPACE).append(value);
+ }
+ else
+ {
+ sb.append(key).append(COLON).append(SPACE).append(value);
+ }
+ sb.append(newline);
+ }
+ }
+ }
+ }
+
+ /**
+ * Get the longest sequence id (to allow aligned printout).
+ *
+ * @param s
+ * @return
+ */
+ protected static int getMaxIdLength(SequenceI[] s)
+ {
+ // TODO pull up for reuse
+ int maxLength = 0;
+ for (SequenceI seq : s)
+ {
+ int len = seq.getName().length();
+ if (len > maxLength)
+ {
+ maxLength = len;
+ }
+ }
+ return maxLength;
+ }
+
+ /**
+ * Get the longest sequence length
+ *
+ * @param s
+ * @return
+ */
+ protected static int getMaxSequenceLength(SequenceI[] s)
+ {
+ // TODO pull up for reuse
+ int maxLength = 0;
+ for (SequenceI seq : s)
+ {
+ int len = seq.getLength();
+ if (len > maxLength)
+ {
+ maxLength = len;
+ }
+ }
+ return maxLength;
+ }
+
+ /**
+ * Print to string in noninterleaved format - all of each sequence in turn, in
+ * blocks of 50 characters.
+ *
+ * @param s
+ * @return
+ */
+ protected String printNonInterleaved(SequenceI[] s)
+ {
+ int maxSequenceLength = getMaxSequenceLength(s);
+ // approx
+ int numLines = maxSequenceLength / POSITIONS_PER_LINE + 2 + s.length;
+
+ /*
+ * Roughly size a buffer to hold the whole output
+ */
+ StringBuilder sb = new StringBuilder(numLines * POSITIONS_PER_LINE);
+ printHeaders(sb, FileFormat.SIMPLE);
+
+ for (SequenceI seq : s)
+ {
+ sb.append(newline);
+ sb.append(HASHSIGN + seq.getName()).append(newline);
+ int startPos = 0;
+ while (startPos <= seq.getLength())
+ {
+ char[] subSequence = seq.getSequence(startPos, startPos
+ + POSITIONS_PER_LINE);
+ sb.append(subSequence);
+ sb.append(newline);
+ startPos += POSITIONS_PER_LINE;
+ }
+ }
+
+ return new String(sb);
+ }
+
+ /**
+ * Flag this file as interleaved or not, based on data format. Throws an
+ * exception if has previously been determined to be otherwise.
+ *
+ * @param isIt
+ * @param dataLine
+ * @throws IOException
+ */
+ protected void assertInterleaved(boolean isIt, String dataLine)
+ throws IOException
+ {
+ if (this.interleaved != null && isIt != this.interleaved.booleanValue())
+ {
+ throw new IOException(
+ "Parse error: mix of interleaved and noninterleaved detected, at line: "
+ + dataLine);
+ }
+ this.interleaved = new Boolean(isIt);
+ }
+
+ public boolean isInterleaved()
+ {
+ return this.interleaved == null ? false : this.interleaved
+ .booleanValue();
+ }
+
+ public FileFormat getFileFormat()
+ {
+ return this.fileFormat;
+ }
+
+ public void setFileFormat(FileFormat fileFormat)
+ {
+ this.fileFormat = fileFormat;
+ }
+}