JAL-1481 relevant todo re warning user for broken regex
[jalview.git] / src / jalview / io / packed / ParsePackedSet.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.0b1)
3  * Copyright (C) 2014 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 of the License, or (at your option) any later version.
10  *  
11  * Jalview is distributed in the hope that it will be useful, but 
12  * WITHOUT ANY WARRANTY; without even the implied warranty 
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
14  * PURPOSE.  See the GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
17  * The Jalview Authors are detailed in the 'AUTHORS' file.
18  */
19 package jalview.io.packed;
20
21 import jalview.datamodel.AlignmentI;
22 import jalview.io.AppletFormatAdapter;
23 import jalview.io.FileParse;
24 import jalview.io.FormatAdapter;
25 import jalview.io.IdentifyFile;
26 import jalview.io.packed.DataProvider.JvDataType;
27
28 import java.io.BufferedReader;
29 import java.io.IOException;
30 import java.util.ArrayList;
31 import java.util.Hashtable;
32 import java.util.List;
33
34 public class ParsePackedSet
35 {
36
37   /**
38    * return results as a series of jalview.datamodel objects suitable for
39    * display
40    * 
41    * @param context
42    *          - context which is updated with new data
43    * @param files
44    *          - source data
45    * @return list of data objects added to context
46    * @throws Exception
47    */
48   public Object[] getAlignment(JalviewDataset context,
49           Iterable<DataProvider> files) throws Exception
50   {
51     List<Object> rslt = new ArrayList<Object>();
52     if (context == null)
53     {
54       context = new JalviewDataset();
55     }
56     boolean deuniquify = false;
57     for (DataProvider dta : files)
58     {
59       Exception exerror = null;
60       String errmsg = null;
61       FileParse src = dta.getDataSource();
62       if (dta.getType().equals(DataProvider.JvDataType.ALIGNMENT))
63       {
64         String fmt = null;
65         try
66         {
67           fmt = new IdentifyFile().Identify(src, false);
68         } catch (Exception ex)
69         {
70           exerror = ex;
71           errmsg = "Couldn't identify alignment format.";
72         }
73
74         if (fmt != null)
75         {
76           if (!FormatAdapter.isValidIOFormat(fmt, false))
77           {
78             errmsg = fmt;
79             exerror = null;
80           }
81           else
82           {
83             // parse the alignment
84             AlignmentI al = null;
85             try
86             {
87               al = new FormatAdapter().readFromFile(src, fmt);
88             } catch (Exception e)
89             {
90               errmsg = "Failed to parse alignment from result set";
91               exerror = e;
92             }
93             if (al != null)
94             {
95               // deuniquify and construct/merge additional dataset entries if
96               // necessary.
97               context.addAlignment(al);
98               context.updateSetModified(true);
99               rslt.add(al);
100               deuniquify = true;
101             }
102           }
103         }
104       }
105       if (dta.getType().equals(JvDataType.ANNOTATION))
106       {
107         if (!context.hasAlignments())
108         {
109           errmsg = "No alignment or sequence dataset to associate annotation with.";
110           // could duplicate the dataset reference here as default behaviour for
111           // sequence associated annotation ?
112         }
113         try
114         {
115           BufferedReader br;
116           if (src.getReader() instanceof BufferedReader)
117           {
118             br = (BufferedReader) src.getReader();
119           }
120           else
121           {
122             br = new BufferedReader(src.getReader());
123           }
124           if (new jalview.io.AnnotationFile().parseAnnotationFrom(
125                   context.getLastAlignment(), br))
126           {
127             context.updateSetModified(true);
128           }
129           else
130           {
131             errmsg = "Annotation file contained no data.";
132           }
133
134         } catch (Exception e)
135         {
136           errmsg = ((errmsg == null) ? "" : errmsg)
137                   + "Failed to parse the annotation file associated with the alignment.";
138           exerror = e;
139         }
140       }
141       if (dta.getType().equals(JvDataType.SEQASSOCATED))
142       {
143         if (!context.hasSequenceAssoc())
144         {
145           errmsg = "No sequence to associate data with.";
146
147         }
148         errmsg = "parsing of sequence associated data is not implemented";
149         exerror = new Exception(errmsg);
150       }
151       if (dta.getType().equals(JvDataType.FEATURES))
152       {
153         // check the context has a place to store feature rendering definitions,
154         // if not, create one.
155         if (context.featureColours == null)
156         {
157           context.featureColours = new Hashtable();
158         }
159         try
160         {
161           jalview.io.FeaturesFile ff = new jalview.io.FeaturesFile(src);
162           context.updateSetModified(ff.parse(context.getLastAlignment(),
163                   context.featureColours, false, 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    */
229   public static void main(String args[])
230   {
231     // make data providers from the set of keys/files
232     int i = 0;
233     List<DataProvider> dp = new ArrayList<DataProvider>();
234     while ((i + 1) < args.length)
235     {
236       String type = args[i++];
237       final String file = args[i++];
238       final JvDataType jtype = DataProvider.JvDataType.valueOf(type
239               .toUpperCase());
240       if (jtype != null)
241       {
242         final FileParse fp;
243         try
244         {
245           fp = new FileParse(file, AppletFormatAdapter.checkProtocol(file));
246         } catch (Exception e)
247         {
248           System.err.println("Couldn't handle datasource of type " + jtype
249                   + " using URI " + file);
250           e.printStackTrace();
251           return;
252         }
253         dp.add(new SimpleDataProvider(jtype, fp, null));
254       }
255       else
256       {
257         System.out.println("Couldn't parse source type token '"
258                 + type.toUpperCase() + "'");
259       }
260     }
261     if (i < args.length)
262     {
263       System.out.print("** WARNING\nIgnoring unused arguments:\n");
264       while (i < args.length)
265       {
266         System.out.print(" " + args[i]);
267       }
268       System.out.print("\n");
269
270     }
271     System.out.println("Now trying to parse set:");
272     JalviewDataset context;
273     Object[] newdm;
274     ParsePackedSet pps;
275     try
276     {
277       newdm = (pps = new ParsePackedSet()).getAlignment(
278               context = new JalviewDataset(), dp);
279     } catch (Exception e)
280     {
281       System.out.println("Test failed for these arguments.\n");
282       e.printStackTrace(System.out);
283       return;
284     }
285     if (newdm != null)
286     {
287       for (Object o : newdm)
288       {
289         System.out.println("Will need to create an " + o.getClass());
290       }
291
292       // now test uniquify/deuniquify stuff
293       // uniquify alignment and write alignment, annotation, features, and trees
294       // to buffers.
295       // import with deuniquify info, and compare results to input.
296
297     }
298     else
299     {
300       if (context.getLastAlignmentSet().isModified())
301       {
302         System.err
303                 .println("Initial alignment set was modified and any associated views should be updated.");
304       }
305     }
306   }
307 }