src/net/ametros/dive/parser/AbstractParser.java

   1 /* Ametros Dive Computer
   2  * Copyright (C) 2010 Geoff Johnstone
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 package net.ametros.dive.parser;
  19
  20 import net.ametros.dive.data.Ascent;
  21 import net.ametros.dive.data.Dive;
  22 import net.ametros.dive.data.Dives;
  23 import net.ametros.dive.data.Gas;
  24 import net.ametros.dive.data.ObjectFactory;
  25 import net.ametros.dive.data.Physiology;
  26 import net.ametros.dive.data.Stop;
  27 import net.ametros.dive.data.Water;
  28
  29 import java.io.File;
  30 import java.io.FileInputStream;
  31 import java.io.InputStream;
  32 import java.io.IOException;
  33 import java.util.HashMap;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.regex.Matcher;
  37 import java.util.regex.Pattern;
  38
  39
  40 /** Parses dive plans. */
  41 public abstract class AbstractParser implements Parser
  42 {
  43   private static final Map<String, Gas> gasMap = new HashMap<String, Gas>();
  44   static
  45   {
  46     for (Gas gas: Gas.values())
  47     {
  48       String str = gas.toString().toLowerCase();
  49       gasMap.put (str, gas);
  50       gasMap.put (str.replace ('_', '/'), gas);
  51       gasMap.put (str.replace ('_', ' '), gas);
  52       gasMap.put (str.replace ('_', '-'), gas);
  53       gasMap.put (str.replace ("_", "--"), gas);
  54
  55       if (str.startsWith ("tx_"))
  56       {
  57         str = str.substring (3);
  58         gasMap.put (str.replace ('_', '/'), gas);
  59         gasMap.put (str.replace ('_', ' '), gas);
  60         gasMap.put (str.replace ('_', '-'), gas);
  61         gasMap.put (str.replace ("_", "--"), gas);
  62       }
  63       else if (str.startsWith ("nx_"))
  64       {
  65         gasMap.put ("nx" + str.substring (3), gas);
  66         gasMap.put (str.substring (3) + "% nitrox", gas);
  67       }
  68     }
  69   }
  70
  71   protected final ObjectFactory of = new ObjectFactory();
  72
  73   private Dives dives;
  74
  75
  76   protected abstract void doParse (File file) throws Exception;
  77
  78
  79   @Override
  80   public Dives parse (File file) throws Exception
  81   {
  82     try
  83     {
  84       dives = of.createDives();
  85       doParse (file);
  86       return dives;
  87     }
  88     finally
  89     {
  90       dives = null;
  91     }
  92   }
  93
  94
  95   protected Gas parseGas (String in)
  96   {
  97     final String lower = in.toLowerCase();
  98     if (gasMap.containsKey (lower))
  99       return gasMap.get (lower);
 100
 101     return Gas.valueOf (in);
 102   }
 103
 104
 105   protected Dive createDive (int depth, int duration, Gas gas)
 106   {
 107     final Dive dive = of.createDive();
 108     dive.setAscent (of.createAscent());
 109     dive.setDepth (depth);
 110     dive.setDuration (duration);
 111     dive.setGas (gas);
 112     dive.setPhysiology (createPhysiology());
 113     dive.setWater (createWater());
 114     return dive;
 115   }
 116
 117
 118   private int getDefault (String property, int value)
 119   {
 120     final String str = System.getProperty (property);
 121     return (null == str) ? value : Integer.parseInt (str);
 122   }
 123
 124
 125   protected Gas getDefaultGas()
 126   {
 127     final String str = System.getProperty ("ametros.dive.defaultGas");
 128     return (null == str) ? Gas.TX_18_45 : parseGas (str);
 129   }
 130
 131
 132   protected Water getDefaultWater()
 133   {
 134     final Water water = of.createWater();
 135     water.setDensity (getDefault ("ametros.dive.defaultDensity", 1025));
 136     return water;
 137   }
 138
 139
 140   protected Water createWater()
 141   {
 142     return getDefaultWater();
 143   }
 144
 145
 146   protected Physiology getDefaultPhysiology()
 147   {
 148     final Physiology phys = of.createPhysiology();
 149     phys.setSacr (getDefault ("ametros.dive.defaultSacr", 20));
 150     phys.setSaca (getDefault ("ametros.dive.defaultSaca", 30));
 151     return phys;
 152   }
 153
 154
 155   protected Physiology createPhysiology()
 156   {
 157     return getDefaultPhysiology();
 158   }
 159
 160
 161   protected void addDives (Dive[] dives)
 162   {
 163     if (null != dives)
 164       for (Dive dive: dives)
 165         addDive (dive);
 166   }
 167
 168
 169   protected void addDives (Iterable<Dive> dives)
 170   {
 171     if (null != dives)
 172       for (Dive dive: dives)
 173         addDive (dive);
 174   }
 175
 176
 177   protected void addDive (Dive dive)
 178   {
 179     dives.getDives().add (dive);
 180   }
 181
 182
 183   /** Replaces non-breaking spaces with ' '; trims leading/trailing
 184    *  whitespace.
 185    */
 186   protected String normaliseWhitespace (char[] in)
 187   {
 188     final char[] out = new char[in.length];
 189
 190     for (int i = 0; i < in.length; ++i)
 191       out[i] = ('\u00a0' == in[i]) ? ' ' :  in[i];
 192
 193     return new String (out).trim();
 194   }
 195 }
 196