JAL-4298 comment markers
[jalview.git] / src / jalview / io / packed / ParsePackedSet.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.packed;
22
23 import java.util.Locale;
24
25 import jalview.api.FeatureColourI;
26 import jalview.datamodel.AlignmentI;
27 import jalview.io.AppletFormatAdapter;
28 import jalview.io.FileFormatI;
29 import jalview.io.FileParse;
30 import jalview.io.FormatAdapter;
31 import jalview.io.IdentifyFile;
32 import jalview.io.packed.DataProvider.JvDataType;
33
34 import java.io.BufferedReader;
35 import java.io.IOException;
36 import java.util.ArrayList;
37 import java.util.HashMap;
38 import java.util.List;
39
40 public class ParsePackedSet
41 {
42
43   /**
44    * return results as a series of jalview.datamodel objects suitable for
45    * display
46    * 
47    * @param context
48    *          - context which is updated with new data
49    * @param files
50    *          - source data
51    * @return list of data objects added to context
52    * @throws Exception
53    */
54   public Object[] getAlignment(JalviewDataset context,
55           Iterable<DataProvider> files) throws Exception
56   {
57     List<Object> rslt = new ArrayList<>();
58     if (context == null)
59     {
60       context = new JalviewDataset();
61     }
62     boolean deuniquify = false;
63     for (DataProvider dta : files)
64     {
65       Exception exerror = null;
66       String errmsg = null;
67       FileParse src = dta.getDataSource();
68       if (dta.getType().equals(DataProvider.JvDataType.ALIGNMENT))
69       {
70         FileFormatI fmt = null;
71         try
72         {
73           fmt = new IdentifyFile().identify(src, false);
74         } catch (Exception ex)
75         {
76           exerror = ex;
77           errmsg = "Couldn't identify alignment format.";
78         }
79
80         if (fmt != null)
81         {
82           // parse the alignment
83           AlignmentI al = null;
84           try
85           {
86             al = new FormatAdapter().readFromFile(src, fmt);
87           } catch (Exception e)
88           {
89             errmsg = "Failed to parse alignment from result set";
90             exerror = e;
91           }
92           if (al != null)
93           {
94             // deuniquify and construct/merge additional dataset entries if
95             // necessary.
96             context.addAlignment(al);
97             context.updateSetModified(true);
98             rslt.add(al);
99             deuniquify = true;
100           }
101         }
102       }
103       if (dta.getType().equals(JvDataType.ANNOTATION))
104       {
105         if (!context.hasAlignments())
106         {
107           errmsg = "No alignment or sequence dataset to associate annotation with.";
108           // could duplicate the dataset reference here as default behaviour for
109           // sequence associated annotation ?
110         }
111         try
112         {
113           BufferedReader br;
114           if (src.getReader() instanceof BufferedReader)
115           {
116             br = (BufferedReader) src.getReader();
117           }
118           else
119           {
120             br = new BufferedReader(src.getReader());
121           }
122           // TODO: add columnSelection to context
123           if (new jalview.io.AnnotationFile().parseAnnotationFrom(
124                   context.getLastAlignment(), null, br))
125           {
126             context.updateSetModified(true);
127           }
128           else
129           {
130             errmsg = "Annotation file contained no data.";
131           }
132
133         } catch (Exception e)
134         {
135           errmsg = ((errmsg == null) ? "" : errmsg)
136                   + "Failed to parse the annotation file associated with the alignment.";
137           exerror = e;
138         }
139       }
140       if (dta.getType().equals(JvDataType.SEQASSOCATED))
141       {
142         if (!context.hasSequenceAssoc())
143         {
144           errmsg = "No sequence to associate data with.";
145
146         }
147         errmsg = "parsing of sequence associated data is not implemented";
148         exerror = new Exception(errmsg);
149       }
150       if (dta.getType().equals(JvDataType.FEATURES))
151       {
152         // check the context has a place to store feature rendering definitions,
153         // if not, create one.
154         if (context.featureColours == null)
155         {
156           context.featureColours = new HashMap<>();
157         }
158         try
159         {
160           jalview.io.FeaturesFile ff = new jalview.io.FeaturesFile(src);
161           context.updateSetModified(ff.parse(context.getLastAlignment(),
162                   context.featureColours, false,
163                   context.relaxedIdMatching));
164         } catch (Exception e)
165         {
166           errmsg = ("Failed to parse the Features file associated with the alignment.");
167           exerror = e;
168         }
169       }
170       if (dta.getType().equals(JvDataType.TREE))
171       {
172         try
173         {
174           jalview.io.NewickFile nf = new jalview.io.NewickFile(src);
175           if (!nf.isValid())
176           {
177             nf.close();
178             nf = null;
179           }
180           else
181           {
182             // do association to current alignment.
183
184             context.addTreeFromFile(nf);
185             rslt.add(nf);
186             context.updateSetModified(true);
187           }
188         } catch (Exception e)
189         {
190           errmsg = ("Failed to parse the treeFile associated with the result.");
191           exerror = e;
192         }
193
194       }
195       if (exerror != null)
196       {
197         if (errmsg != null && errmsg.length() > 0)
198         {
199           throw new IOException(errmsg, exerror);
200         }
201         else
202         {
203           throw new IOException(errmsg, exerror);
204         }
205       }
206       else
207       {
208         if (errmsg != null && errmsg.length() > 0)
209         {
210           throw new IOException(errmsg);
211         }
212       }
213     }
214     if (deuniquify)
215     {
216       context.getLastAlignmentSet().deuniquifyAlignment();
217     }
218     return rslt.toArray();
219   }
220
221   /**
222    * simple command line test. Arguments should be one or more pairs of
223    * <DataProvider.JvDataType> <Filename> arguments. The routine will attempt to
224    * read each source in turn, and report what kind of Jalview datamodel objects
225    * would be created.
226    * 
227    * @param args
228    * @j2sIgnore
229    */
230   public static void main(String args[])
231   {
232     // make data providers from the set of keys/files
233     int i = 0;
234     List<DataProvider> dp = new ArrayList<>();
235     while ((i + 1) < args.length)
236     {
237       String type = args[i++];
238       final String file = args[i++];
239       final JvDataType jtype = DataProvider.JvDataType
240               .valueOf(type.toUpperCase(Locale.ROOT));
241       if (jtype != null)
242       {
243         final FileParse fp;
244         try
245         {
246           fp = new FileParse(file, AppletFormatAdapter.checkProtocol(file));
247         } catch (Exception e)
248         {
249           jalview.bin.Console.errPrintln("Couldn't handle datasource of type " + jtype
250                   + " using URI " + file);
251           e.printStackTrace();
252           return;
253         }
254         dp.add(new SimpleDataProvider(jtype, fp, null));
255       }
256       else
257       {
258         jalview.bin.Console.outPrintln("Couldn't parse source type token '"
259                 + type.toUpperCase(Locale.ROOT) + "'");
260       }
261     }
262     if (i < args.length)
263     {
264       System.out.print("** WARNING\nIgnoring unused arguments:\n");
265       while (i < args.length)
266       {
267         System.out.print(" " + args[i]);
268       }
269       System.out.print("\n");
270
271     }
272     jalview.bin.Console.outPrintln("Now trying to parse set:");
273     JalviewDataset context;
274     Object[] newdm;
275     ParsePackedSet pps;
276     try
277     {
278       newdm = (pps = new ParsePackedSet())
279               .getAlignment(context = new JalviewDataset(), dp);
280     } catch (Exception e)
281     {
282       jalview.bin.Console.outPrintln("Test failed for these arguments.\n");
283       e.printStackTrace(System.out);
284       return;
285     }
286     if (newdm != null)
287     {
288       for (Object o : newdm)
289       {
290         jalview.bin.Console.outPrintln("Will need to create an " + o.getClass());
291       }
292
293       // now test uniquify/deuniquify stuff
294       // uniquify alignment and write alignment, annotation, features, and trees
295       // to buffers.
296       // import with deuniquify info, and compare results to input.
297
298     }
299     else
300     {
301       if (context.getLastAlignmentSet().isModified())
302       {
303         jalview.bin.Console.errPrintln(
304                 "Initial alignment set was modified and any associated views should be updated.");
305       }
306     }
307   }
308 }