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