Classes

Class	Line #	Total Statements	Complexity	TOTAL Coverage	Actions
MSFfile	42	137	49	0.896713689.7%	Show methods

Class MSFfile

Class MSFfile	Line # 42	Total Statements 137	Complexity 49	TOTAL Coverage 0.896713689.7%
MSFfile()   MSFfile()	4848	0.00	1.01	-1.0 -1.0 -
MSFfile(String,DataSourceType)   MSFfile(String,DataSourceType)	6363	1.01	1.01	0.0 0.00%
MSFfile(FileParse)   MSFfile(FileParse)	6868	1.01	1.01	1.0 1.0100%
parse() : void   parse() : void	7676	39.039	13.013	0.89830506 0.8983050689.8%
checkSum(String) : int   checkSum(String) : int	187187	10.010	4.04	0.78571427 0.7857142778.6%
print(SequenceI[],boolean) : String   print(SequenceI[],boolean) : String	223223	86.086	29.029	0.9166667 0.916666791.7%

 

Contributing tests

Contributing tests

Select all

	Test contribution	Test	Result	Actions
	0.8967136	jalview.io.FormatAdapterTest.testRoundTripjalview.io.FormatAdapterTest.testRoundTrip	1PASS
	0.32394367	jalview.io.FormatAdapterTest.testRoundTripjalview.io.FormatAdapterTest.testRoundTrip	1PASS

 

Source view

1		/*
2		* Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3		* Copyright (C) $$Year-Rel$$ The Jalview Authors
4		*
5		* This file is part of Jalview.
6		*
7		* Jalview is free software: you can redistribute it and/or
8		* modify it under the terms of the GNU General Public License
9		* as published by the Free Software Foundation, either version 3
10		* of the License, or (at your option) any later version.
11		*
12		* Jalview is distributed in the hope that it will be useful, but
13		* WITHOUT ANY WARRANTY; without even the implied warranty
14		* of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15		* PURPOSE. See the GNU General Public License for more details.
16		*
17		* You should have received a copy of the GNU General Public License
18		* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19		* The Jalview Authors are detailed in the 'AUTHORS' file.
20		*/
21		package jalview.io;
22
23		import java.util.Locale;
24
25		import jalview.datamodel.Sequence;
26		import jalview.datamodel.SequenceI;
27		import jalview.util.Comparison;
28		import jalview.util.Format;
29
30		import java.io.IOException;
31		import java.util.ArrayList;
32		import java.util.Hashtable;
33		import java.util.List;
34		import java.util.StringTokenizer;
35
36		/**
37		* DOCUMENT ME!
38		*
39		* @author $author$
40		* @version $Revision$
41		*/
		89.7% Uncovered Elements: 22 (213) Complexity: 49 Complexity Density: 0.36
42		public class MSFfile extends AlignFile
43		{
44
45		/**
46		* Creates a new MSFfile object.
47		*/
		- Uncovered Elements: 0 (0) Complexity: 1 Complexity Density: -
48	2	public MSFfile()...
49		{
50		}
51
52		/**
53		* Creates a new MSFfile object.
54		*
55		* @param inFile
56		* DOCUMENT ME!
57		* @param type
58		* DOCUMENT ME!
59		*
60		* @throws IOException
61		* DOCUMENT ME!
62		*/
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
63	0	public MSFfile(String inFile, DataSourceType type) throws IOException...
64		{
65	0	super(inFile, type);
66		}
67
		100% Uncovered Elements: 0 (1) Complexity: 1 Complexity Density: 1
68	2	public MSFfile(FileParse source) throws IOException...
69		{
70	2	super(source);
71		}
72
73		/**
74		* Read and parse MSF sequence data
75		*/
		89.8% Uncovered Elements: 6 (59) Complexity: 13 Complexity Density: 0.33
76	2	@Override...
77		public void parse() throws IOException
78		{
79	2	boolean seqFlag = false;
80	2	List<String> headers = new ArrayList<String>();
81	2	Hashtable<String, StringBuilder> seqhash = new Hashtable<String, StringBuilder>();
82
83	2	try
84		{
85	2	String line;
86	?	while ((line = nextLine()) != null)
87		{
88	176	StringTokenizer str = new StringTokenizer(line);
89
90	176	String key = null;
91	540	while (str.hasMoreTokens())
92		{
93	364	String inStr = str.nextToken();
94
95		// If line has header information add to the headers vector
96	364	if (inStr.indexOf("Name:") != -1)
97		{
98	30	key = str.nextToken();
99	30	headers.add(key);
100		}
101
102		// if line has // set SeqFlag so we know sequences are coming
103	364	if (inStr.indexOf("//") != -1)
104		{
105	2	seqFlag = true;
106		}
107
108		// Process lines as sequence lines if seqFlag is set
109	364	if ((inStr.indexOf("//") == -1) && seqFlag)
110		{
111		// sequence id is the first field
112	120	key = inStr;
113
114	120	StringBuilder tempseq;
115
116		// Get sequence from hash if it exists
117	120	if (seqhash.containsKey(key))
118		{
119	90	tempseq = seqhash.get(key);
120		}
121		else
122		{
123	30	tempseq = new StringBuilder(64);
124	30	seqhash.put(key, tempseq);
125		}
126
127		// loop through the rest of the words
128	600	while (str.hasMoreTokens())
129		{
130		// append the word to the sequence
131	480	String sequenceBlock = str.nextToken();
132	480	tempseq.append(sequenceBlock);
133		}
134		}
135		}
136		}
137		} catch (IOException e)
138		{
139	0	jalview.bin.Console.errPrintln("Exception parsing MSFFile " + e);
140	0	e.printStackTrace();
141		}
142
143	2	this.noSeqs = headers.size();
144
145		// Add sequences to the hash
146	32	for (int i = 0; i < headers.size(); i++)
147		{
148	30	if (seqhash.get(headers.get(i)) != null)
149		{
150	30	String head = headers.get(i);
151	30	String seq = seqhash.get(head).toString();
152
153	30	if (maxLength < head.length())
154		{
155	6	maxLength = head.length();
156		}
157
158		/*
159		* replace ~ (leading/trailing positions) with the gap character;
160		* use '.' as this is the internal gap character required by MSF
161		*/
162	30	seq = seq.replace('~', '.');
163
164	30	Sequence newSeq = parseId(head);
165
166	30	newSeq.setSequence(seq);
167
168	30	seqs.addElement(newSeq);
169		}
170		else
171		{
172	0	jalview.bin.Console
173		.errPrintln("MSFFile Parser: Can't find sequence for "
174		+ headers.get(i));
175		}
176		}
177		}
178
179		/**
180		* DOCUMENT ME!
181		*
182		* @param seq
183		* DOCUMENT ME!
184		*
185		* @return DOCUMENT ME!
186		*/
		78.6% Uncovered Elements: 3 (14) Complexity: 4 Complexity Density: 0.4
187	30	public int checkSum(String seq)...
188		{
189	30	int check = 0;
190	30	String sequence = seq.toUpperCase(Locale.ROOT);
191
192	4740	for (int i = 0; i < sequence.length(); i++)
193		{
194	4710	try
195		{
196
197	4710	int value = sequence.charAt(i);
198	4710	if (value != -1)
199		{
200	4710	check += (i % 57 + 1) * value;
201		}
202		} catch (Exception e)
203		{
204	0	jalview.bin.Console
205		.errPrintln("Exception during MSF Checksum calculation");
206	0	e.printStackTrace();
207		}
208		}
209
210	30	return check % 10000;
211		}
212
213		/**
214		* DOCUMENT ME!
215		*
216		* @param s
217		* DOCUMENT ME!
218		* @param is_NA
219		* DOCUMENT ME!
220		*
221		* @return DOCUMENT ME!
222		*/
		91.7% Uncovered Elements: 11 (132) Complexity: 29 Complexity Density: 0.34
223	1	@Override...
224		public String print(SequenceI[] sqs, boolean jvSuffix)
225		{
226
227	1	boolean is_NA = Comparison.isNucleotide(sqs);
228
229	1	SequenceI[] s = new SequenceI[sqs.length];
230
231	1	StringBuilder out = new StringBuilder(256);
232	1	out.append("!!").append(is_NA ? "NA" : "AA")
233		.append("_MULTIPLE_ALIGNMENT 1.0");
234		// TODO: JBPNote : Jalview doesn't remember NA or AA yet.
235	1	out.append(newline);
236	1	out.append(newline);
237	1	int max = 0;
238	1	int maxid = 0;
239	1	int i = 0;
240
241	16	while ((i < sqs.length) && (sqs[i] != null))
242		{
243		/*
244		* modify to MSF format: uses '.' for internal gaps,
245		* and '~' for leading or trailing gaps
246		*/
247	15	String seqString = sqs[i].getSequenceAsString().replace('-', '.');
248
249	15	StringBuilder sb = new StringBuilder(seqString);
250
251	192	for (int ii = 0; ii < sb.length(); ii++)
252		{
253	192	if (sb.charAt(ii) == '.')
254		{
255	177	sb.setCharAt(ii, '~');
256		}
257		else
258		{
259	15	break;
260		}
261		}
262
263	65	for (int ii = sb.length() - 1; ii > 0; ii--)
264		{
265	65	if (sb.charAt(ii) == '.')
266		{
267	50	sb.setCharAt(ii, '~');
268		}
269		else
270		{
271	15	break;
272		}
273		}
274	15	s[i] = new Sequence(sqs[i].getName(), sb.toString(),
275		sqs[i].getStart(), sqs[i].getEnd());
276
277	15	if (sb.length() > max)
278		{
279	1	max = sb.length();
280		}
281
282	15	i++;
283		}
284
285	1	Format maxLenpad = new Format(
286		"%" + (new String("" + max)).length() + "d");
287	1	Format maxChkpad = new Format(
288		"%" + (new String("1" + max)).length() + "d");
289	1	i = 0;
290
291	1	int bigChecksum = 0;
292	1	int[] checksums = new int[s.length];
293	16	while (i < s.length)
294		{
295	15	checksums[i] = checkSum(s[i].getSequenceAsString());
296	15	bigChecksum += checksums[i];
297	15	i++;
298		}
299
300	1	long maxNB = 0;
301	1	out.append(" MSF: " + s[0].getLength() + " Type: "
302	1	+ (is_NA ? "N" : "P") + " Check: " + (bigChecksum % 10000)
303		+ " ..");
304	1	out.append(newline);
305	1	out.append(newline);
306	1	out.append(newline);
307
308	1	String[] nameBlock = new String[s.length];
309	1	String[] idBlock = new String[s.length];
310
311	1	i = 0;
312	16	while ((i < s.length) && (s[i] != null))
313		{
314
315	15	nameBlock[i] = new String(" Name: " + printId(s[i], jvSuffix) + " ");
316
317	15	idBlock[i] = new String("Len: " + maxLenpad.form(s[i].getLength())
318		+ " Check: " + maxChkpad.form(checksums[i])
319		+ " Weight: 1.00" + newline);
320
321	15	if (s[i].getName().length() > maxid)
322		{
323	3	maxid = s[i].getName().length();
324		}
325
326	15	if (nameBlock[i].length() > maxNB)
327		{
328	3	maxNB = nameBlock[i].length();
329		}
330
331	15	i++;
332		}
333
334	1	if (maxid < 10)
335		{
336	0	maxid = 10;
337		}
338
339	1	if (maxNB < 15)
340		{
341	0	maxNB = 15;
342		}
343
344	1	Format nbFormat = new Format("%-" + maxNB + "s");
345
346	16	for (i = 0; (i < s.length) && (s[i] != null); i++)
347		{
348	15	out.append(nbFormat.form(nameBlock[i]) + idBlock[i]);
349		}
350
351	1	maxid++;
352	1	out.append(newline);
353	1	out.append(newline);
354	1	out.append("//");
355	1	out.append(newline);
356	1	out.append(newline);
357	1	int len = 50;
358
359	1	int nochunks = (max / len) + (max % len > 0 ? 1 : 0);
360
361	5	for (i = 0; i < nochunks; i++)
362		{
363	4	int j = 0;
364
365	64	while ((j < s.length) && (s[j] != null))
366		{
367	60	String name = printId(s[j], jvSuffix);
368
369	60	out.append(new Format("%-" + maxid + "s").form(name + " "));
370
371	360	for (int k = 0; k < 5; k++)
372		{
373	300	int start = (i * 50) + (k * 10);
374	300	int end = start + 10;
375
376	300	int length = s[j].getLength();
377	300	if ((end < length) && (start < length))
378		{
379	225	out.append(s[j].getSequence(start, end));
380
381	225	if (k < 4)
382		{
383	180	out.append(" ");
384		}
385		else
386		{
387	45	out.append(newline);
388		}
389		}
390		else
391		{
392	75	if (start < length)
393		{
394	15	out.append(s[j].getSequenceAsString().substring(start));
395	15	out.append(newline);
396		}
397		else
398		{
399	60	if (k == 0)
400		{
401	0	out.append(newline);
402		}
403		}
404		}
405		}
406
407	60	j++;
408		}
409
410	4	out.append(newline);
411		}
412
413	1	return out.toString();
414		}
415		}