JAL-1759 corrected syntax for 'atom picked' callback (toggles label
[jalview.git] / src / jalview / io / AlignFile.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.AlignmentAnnotation;
24 import jalview.datamodel.AlignmentI;
25 import jalview.datamodel.Sequence;
26 import jalview.datamodel.SequenceGroup;
27 import jalview.datamodel.SequenceI;
28 import jalview.util.MessageManager;
29
30 import java.io.IOException;
31 import java.util.ArrayList;
32 import java.util.Enumeration;
33 import java.util.Hashtable;
34 import java.util.List;
35 import java.util.Vector;
36
37 /**
38  * DOCUMENT ME!
39  * 
40  * @author $author$
41  * @version $Revision$
42  */
43 public abstract class AlignFile extends FileParse
44 {
45   int noSeqs = 0;
46
47   int maxLength = 0;
48
49   /**
50    * Sequences to be added to form a new alignment.
51    */
52   protected Vector<SequenceI> seqs;
53
54   /**
55    * annotation to be added to generated alignment object
56    */
57   protected Vector<AlignmentAnnotation> annotations;
58
59   /**
60    * SequenceGroups to be added to the alignment object
61    */
62   protected List<SequenceGroup> seqGroups;
63
64   /**
65    * Properties to be added to generated alignment object
66    */
67   protected Hashtable properties;
68
69   long start;
70
71   long end;
72
73   boolean jvSuffix = true;
74
75   private boolean parseCalled;
76
77   /**
78    * Creates a new AlignFile object.
79    */
80   public AlignFile()
81   {
82     // Shouldn't we init data structures (JBPNote: not sure - initData is for
83     // initialising the structures used for reading from a datasource, and the
84     // bare constructor hasn't got any datasource)
85     initData();
86   }
87
88   /**
89    * Constructor which parses the data from a file of some specified type.
90    * 
91    * @param inFile
92    *          Filename to read from.
93    * @param type
94    *          What type of file to read from (File, URL)
95    */
96   public AlignFile(String inFile, String type) throws IOException
97   {
98     this(true, inFile, type);
99   }
100   
101   /**
102    * Constructor which (optionally delays) parsing of data from a file of some specified type.
103    * 
104    * @param parseImmediately
105    *          if false, need to call 'doParse()' to begin parsing data
106    * @param inFile
107    *          Filename to read from.
108    * @param type
109    *          What type of file to read from (File, URL)
110    * @throws IOException
111    */
112   public AlignFile(boolean parseImmediately, String inFile, String type) throws IOException
113   {
114     super(inFile, type);
115     initData();
116     if (parseImmediately) {
117       doParse();
118     }
119   }
120   /**
121    * Attempt to read from the position where some other parsing process left
122    * off.
123    * 
124    * @param source
125    * @throws IOException
126    */
127   public AlignFile(FileParse source) throws IOException
128   {
129     this(true,source);
130   }
131   /**
132    * Construct a new parser to read from the position where some other parsing process left
133    * 
134    * @param parseImmediately
135    *          if false, need to call 'doParse()' to begin parsing data
136    * @param source
137    */
138   public AlignFile(boolean parseImmediately, FileParse source) throws IOException
139   {
140     super(source);
141     initData();
142     if (parseImmediately) {
143       doParse();
144     }
145   }
146   /**
147    * called if parsing was delayed till after parser was constructed
148    * @throws IOException
149    */
150   public void doParse() throws IOException
151   {
152     if (parseCalled)
153     {
154       throw new IOException(
155               "Implementation error: Parser called twice for same data.\n"
156                       + "Need to call initData() again before parsing can be reattempted.");
157     }
158     parseCalled=true;
159     parse();
160     // sets the index of each sequence in the alignment
161     for (int i = 0, c = seqs.size(); i < c; i++)
162     {
163       seqs.get(i).setIndex(i);
164     }
165   }
166
167
168   /**
169    * Return the seqs Vector
170    */
171   public Vector<SequenceI> getSeqs()
172   {
173     return seqs;
174   }
175
176   public List<SequenceGroup> getSeqGroups()
177   {
178     return seqGroups;
179   }
180
181   /**
182    * Return the Sequences in the seqs Vector as an array of Sequences
183    */
184   public SequenceI[] getSeqsAsArray()
185   {
186     SequenceI[] s = new SequenceI[seqs.size()];
187
188     for (int i = 0; i < seqs.size(); i++)
189     {
190       s[i] = seqs.elementAt(i);
191     }
192
193     return s;
194   }
195
196   /**
197    * called by AppletFormatAdapter to generate an annotated alignment, rather
198    * than bare sequences.
199    * 
200    * @param al
201    */
202   public void addAnnotations(AlignmentI al)
203   {
204     addProperties(al);
205     for (int i = 0; i < annotations.size(); i++)
206     {
207       // detect if annotations.elementAt(i) rna secondary structure
208       // if so then do:
209       /*
210        * SequenceFeature[] pairArray =
211        * Rna.GetBasePairsFromAlignmentAnnotation(annotations.elementAt(i));
212        * Rna.HelixMap(pairArray);
213        */
214       AlignmentAnnotation an = annotations
215               .elementAt(i);
216       an.validateRangeAndDisplay();
217       al.addAnnotation(an);
218     }
219
220   }
221
222   /**
223    * register sequence groups on the alignment for **output**
224    * 
225    * @param al
226    */
227   public void addSeqGroups(AlignmentI al)
228   {
229     this.seqGroups = al.getGroups();
230
231   }
232
233   /**
234    * Add any additional information extracted from the file to the alignment
235    * properties.
236    * 
237    * @note implicitly called by addAnnotations()
238    * @param al
239    */
240   public void addProperties(AlignmentI al)
241   {
242     if (properties != null && properties.size() > 0)
243     {
244       Enumeration keys = properties.keys();
245       Enumeration vals = properties.elements();
246       while (keys.hasMoreElements())
247       {
248         al.setProperty(keys.nextElement(), vals.nextElement());
249       }
250     }
251   }
252
253   /**
254    * Store a non-null key-value pair in a hashtable used to set alignment
255    * properties note: null keys will raise an error, null values will result in
256    * the key/value pair being silently ignored.
257    * 
258    * @param key
259    *          - non-null key object
260    * @param value
261    *          - non-null value
262    */
263   protected void setAlignmentProperty(Object key, Object value)
264   {
265     if (key == null)
266     {
267       throw new Error(MessageManager.getString("error.implementation_error_cannot_have_null_alignment"));
268     }
269     if (value == null)
270     {
271       return; // null properties are ignored.
272     }
273     if (properties == null)
274     {
275       properties = new Hashtable();
276     }
277     properties.put(key, value);
278   }
279
280   protected Object getAlignmentProperty(Object key)
281   {
282     if (properties != null && key != null)
283     {
284       return properties.get(key);
285     }
286     return null;
287   }
288
289   /**
290    * Initialise objects to store sequence data in.
291    */
292   protected void initData()
293   {
294     seqs = new Vector<SequenceI>();
295     annotations = new Vector<AlignmentAnnotation>();
296     seqGroups = new ArrayList<SequenceGroup>();
297     parseCalled=false;
298   }
299
300   /**
301    * DOCUMENT ME!
302    * 
303    * @param s
304    *          DOCUMENT ME!
305    */
306   protected void setSeqs(SequenceI[] s)
307   {
308     seqs = new Vector<SequenceI>();
309
310     for (int i = 0; i < s.length; i++)
311     {
312       seqs.addElement(s[i]);
313     }
314   }
315
316   /**
317    * This method must be implemented to parse the contents of the file.
318    */
319   public abstract void parse() throws IOException;
320
321   /**
322    * Print out in alignment file format the Sequences in the seqs Vector.
323    */
324   public abstract String print();
325
326   public void addJVSuffix(boolean b)
327   {
328     jvSuffix = b;
329   }
330
331   /**
332    * A general parser for ids.
333    * 
334    * @String id Id to be parsed
335    */
336   Sequence parseId(String id)
337   {
338     Sequence seq = null;
339     id = id.trim();
340     int space = id.indexOf(" ");
341     if (space > -1)
342     {
343       seq = new Sequence(id.substring(0, space), "");
344       seq.setDescription(id.substring(space + 1));
345     }
346     else
347     {
348       seq = new Sequence(id, "");
349     }
350
351     return seq;
352   }
353
354   /**
355    * Creates the output id. Adds prefix Uniprot format source|id And suffix
356    * Jalview /start-end
357    * 
358    * @String id Id to be parsed
359    */
360   String printId(SequenceI seq)
361   {
362     return seq.getDisplayId(jvSuffix);
363   }
364
365   /**
366    * vector of String[] treeName, newickString pairs
367    */
368   Vector<String[]> newickStrings = null;
369
370   protected void addNewickTree(String treeName, String newickString)
371   {
372     if (newickStrings == null)
373     {
374       newickStrings = new Vector<String[]>();
375     }
376     newickStrings.addElement(new String[]
377     { treeName, newickString });
378   }
379
380   protected int getTreeCount()
381   {
382     return newickStrings == null ? 0 : newickStrings.size();
383   }
384
385   public void addGroups(AlignmentI al)
386   {
387
388     for (SequenceGroup sg : getSeqGroups())
389     {
390       al.addGroup(sg);
391     }
392   }
393
394 }