src/jalview/io/packed/ParsePackedSet.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
   3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, G Barton, M Clamp, S Searle
   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  */
  18 package jalview.io.packed;
  19
  20 import jalview.datamodel.AlignmentI;
  21 import jalview.io.AppletFormatAdapter;
  22 import jalview.io.FileParse;
  23 import jalview.io.FormatAdapter;
  24 import jalview.io.IdentifyFile;
  25 import jalview.io.packed.DataProvider.JvDataType;
  26
  27 import java.io.BufferedReader;
  28 import java.io.IOException;
  29 import java.util.ArrayList;
  30 import java.util.Hashtable;
  31 import java.util.List;
  32
  33 public class ParsePackedSet
  34 {
  35
  36   /**
  37    * return results as a series of jalview.datamodel objects suitable for
  38    * display
  39    *
  40    * @param context
  41    *          - context which is updated with new data
  42    * @param files
  43    *          - source data
  44    * @return list of data objects added to context
  45    * @throws Exception
  46    */
  47   public Object[] getAlignment(JalviewDataset context,
  48           Iterable<DataProvider> files) throws Exception
  49   {
  50     List<Object> rslt = new ArrayList<Object>();
  51     if (context == null)
  52     {
  53       context = new JalviewDataset();
  54     }
  55     boolean deuniquify = false;
  56     for (DataProvider dta : files)
  57     {
  58       Exception exerror = null;
  59       String errmsg = null;
  60       FileParse src = dta.getDataSource();
  61       if (dta.getType().equals(DataProvider.JvDataType.ALIGNMENT))
  62       {
  63         String fmt = null;
  64         try
  65         {
  66           fmt = new IdentifyFile().Identify(src, false);
  67         } catch (Exception ex)
  68         {
  69           exerror = ex;
  70           errmsg = "Couldn't identify alignment format.";
  71         }
  72
  73         if (fmt != null)
  74         {
  75           if (!FormatAdapter.isValidIOFormat(fmt, false))
  76           {
  77             errmsg = fmt;
  78             exerror = null;
  79           }
  80           else
  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       }
 104       if (dta.getType().equals(JvDataType.ANNOTATION))
 105       {
 106         if (!context.hasAlignments())
 107         {
 108           errmsg = "No alignment or sequence dataset to associate annotation with.";
 109           // could duplicate the dataset reference here as default behaviour for
 110           // sequence associated annotation ?
 111         }
 112         try
 113         {
 114           BufferedReader br;
 115           if (src.getReader() instanceof BufferedReader)
 116           {
 117             br = (BufferedReader) src.getReader();
 118           }
 119           else
 120           {
 121             br = new BufferedReader(src.getReader());
 122           }
 123           if (new jalview.io.AnnotationFile().parseAnnotationFrom(
 124                   context.getLastAlignment(), 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 Hashtable();
 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, context.relaxedIdMatching));
 163         } catch (Exception e)
 164         {
 165           errmsg = ("Failed to parse the Features file associated with the alignment.");
 166           exerror = e;
 167         }
 168       }
 169       if (dta.getType().equals(JvDataType.TREE))
 170       {
 171         try
 172         {
 173           jalview.io.NewickFile nf = new jalview.io.NewickFile(src);
 174           if (!nf.isValid())
 175           {
 176             nf.close();
 177             nf = null;
 178           }
 179           else
 180           {
 181             // do association to current alignment.
 182
 183             context.addTreeFromFile(nf);
 184             rslt.add(nf);
 185             context.updateSetModified(true);
 186           }
 187         } catch (Exception e)
 188         {
 189           errmsg = ("Failed to parse the treeFile associated with the result.");
 190           exerror = e;
 191         }
 192
 193       }
 194       if (exerror != null)
 195       {
 196         if (errmsg != null && errmsg.length() > 0)
 197         {
 198           throw new IOException(errmsg, exerror);
 199         }
 200         else
 201         {
 202           throw new IOException(errmsg, exerror);
 203         }
 204       }
 205       else
 206       {
 207         if (errmsg != null && errmsg.length() > 0)
 208         {
 209           throw new IOException(errmsg);
 210         }
 211       }
 212     }
 213     if (deuniquify)
 214     {
 215       context.getLastAlignmentSet().deuniquifyAlignment();
 216     }
 217     return rslt.toArray();
 218   }
 219
 220   /**
 221    * simple command line test. Arguments should be one or more pairs of
 222    * <DataProvider.JvDataType> <Filename> arguments. The routine will attempt to
 223    * read each source in turn, and report what kind of Jalview datamodel objects
 224    * would be created.
 225    *
 226    * @param args
 227    */
 228   public static void main(String args[])
 229   {
 230     // make data providers from the set of keys/files
 231     int i = 0;
 232     List<DataProvider> dp = new ArrayList<DataProvider>();
 233     while ((i + 1) < args.length)
 234     {
 235       String type = args[i++];
 236       final String file = args[i++];
 237       final JvDataType jtype = DataProvider.JvDataType.valueOf(type
 238               .toUpperCase());
 239       if (jtype != null)
 240       {
 241         final FileParse fp;
 242         try
 243         {
 244           fp = new FileParse(file, AppletFormatAdapter.checkProtocol(file));
 245         } catch (Exception e)
 246         {
 247           System.err.println("Couldn't handle datasource of type " + jtype
 248                   + " using URI " + file);
 249           e.printStackTrace();
 250           return;
 251         }
 252         dp.add(new SimpleDataProvider(jtype, fp, null));
 253       }
 254       else
 255       {
 256         System.out.println("Couldn't parse source type token '"
 257                 + type.toUpperCase() + "'");
 258       }
 259     }
 260     if (i < args.length)
 261     {
 262       System.out.print("** WARNING\nIgnoring unused arguments:\n");
 263       while (i < args.length)
 264       {
 265         System.out.print(" " + args[i]);
 266       }
 267       System.out.print("\n");
 268
 269     }
 270     System.out.println("Now trying to parse set:");
 271     JalviewDataset context;
 272     Object[] newdm;
 273     ParsePackedSet pps;
 274     try
 275     {
 276       newdm = (pps = new ParsePackedSet()).getAlignment(
 277               context = new JalviewDataset(), dp);
 278     } catch (Exception e)
 279     {
 280       System.out.println("Test failed for these arguments.\n");
 281       e.printStackTrace(System.out);
 282       return;
 283     }
 284     if (newdm != null)
 285     {
 286       for (Object o : newdm)
 287       {
 288         System.out.println("Will need to create an " + o.getClass());
 289       }
 290
 291       // now test uniquify/deuniquify stuff
 292       // uniquify alignment and write alignment, annotation, features, and trees
 293       // to buffers.
 294       // import with deuniquify info, and compare results to input.
 295
 296     }
 297     else
 298     {
 299       if (context.getLastAlignmentSet().isModified())
 300       {
 301         System.err
 302                 .println("Initial alignment set was modified and any associated views should be updated.");
 303       }
 304     }
 305   }
 306 }