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