src/net/ametros/dive/writer/AbstractWriter.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.writer;
  19
  20 import net.ametros.dive.ComputedDive;
  21 import net.ametros.dive.ComputedStop;
  22 import net.ametros.dive.data.Gas;
  23
  24 import java.io.File;
  25 import java.io.FileOutputStream;
  26 import java.io.OutputStream;
  27 import java.util.Comparator;
  28 import java.util.EnumSet;
  29 import java.util.Map;
  30 import java.util.Set;
  31 import java.util.SortedSet;
  32 import java.util.TreeMap;
  33 import java.util.TreeSet;
  34 import java.util.regex.Matcher;
  35 import java.util.regex.Pattern;
  36
  37
  38 /** Writes dive tables. */
  39 public abstract class AbstractWriter implements Writer
  40 {
  41   /** Groups dives by depth, and then by duration. */
  42   protected final Map<Integer, SortedSet<ComputedDive>> dives =
  43     new TreeMap<Integer, SortedSet<ComputedDive>>();
  44
  45
  46   @Override
  47   public void clear()
  48   {
  49     dives.clear();
  50   }
  51
  52
  53   @Override
  54   public void add (Iterable<ComputedDive> dives)
  55   {
  56     for (ComputedDive d: dives)
  57       add (d);
  58   }
  59
  60
  61   @Override
  62   public void add (ComputedDive[] dives)
  63   {
  64     for (ComputedDive d: dives)
  65       add (d);
  66   }
  67
  68
  69   @Override
  70   public void add (ComputedDive dive)
  71   {
  72     final int depth = dive.getDepth();
  73
  74     if (!dives.containsKey (depth))
  75     {
  76       dives.put (depth,
  77                  new TreeSet<ComputedDive> (new Comparator<ComputedDive>() {
  78                    @Override
  79                    public int compare (ComputedDive d1, ComputedDive d2)
  80                    {
  81                      return d1.getDuration() - d2.getDuration();
  82                    }
  83                  }));
  84     }
  85
  86     dives.get (depth).add (dive);
  87   }
  88
  89
  90   @Override
  91   public void write (File file) throws Exception
  92   {
  93     OutputStream os = null;
  94     boolean deleteFile = false;
  95
  96     try
  97     {
  98       os = new FileOutputStream (file);
  99       deleteFile = true;
 100       write (os);
 101       os.close();
 102       os = null;
 103       deleteFile = false;
 104     }
 105     finally
 106     {
 107       try { if (null != os) os.close(); }
 108       finally { if (deleteFile) file.delete(); }
 109     }
 110   }
 111
 112
 113   private static final Pattern formatNx = Pattern.compile ("NX_(\\d+)");
 114   private static final Pattern formatTx = Pattern.compile ("TX_(\\d+)_(\\d+)");
 115
 116   public String format (Gas gas)
 117   {
 118     final String str = "" + gas;
 119
 120     Matcher m = formatNx.matcher (str);
 121     if (m.matches())
 122       return "Nx " + m.group (1);
 123
 124     m = formatTx.matcher (str);
 125     if (m.matches())
 126       return "Tx " + m.group (1) + '/' + m.group (2);
 127
 128     return str;
 129   }
 130
 131
 132   /** Gets a set of stops representing all (Gas, Depth) pairs for all stops
 133    *  for all dives to a given bottom depth, ordered by decreasing depth and
 134    *  then by gas.
 135    */
 136   protected SortedSet<ComputedStop> getStopKeys (int bottomDepth)
 137   {
 138     final SortedSet<ComputedStop> stops =
 139       new TreeSet<ComputedStop> (new Comparator<ComputedStop>() {
 140         @Override
 141         public int compare (ComputedStop s1, ComputedStop s2)
 142         {
 143           final int d1 = s1.getDepth();
 144           final int d2 = s2.getDepth();
 145
 146           if (d1 != d2)
 147             return d2 - d1;
 148
 149           final Gas g1 = s1.getGas();
 150           final Gas g2 = s2.getGas();
 151
 152           return g1.toString().compareTo (g2.toString());
 153         }
 154       });
 155
 156     for (ComputedDive d: dives.get (bottomDepth))
 157       for (ComputedStop s: d.getStops())
 158         stops.add (s);
 159
 160     return stops;
 161   }
 162
 163
 164   /** Gets a set of the gases used for dives to a given bottom depth. */
 165   protected Set<Gas> getGases (int bottomDepth)
 166   {
 167     final Set<Gas> gases = EnumSet.noneOf (Gas.class);
 168
 169     for (ComputedDive d: dives.get (bottomDepth))
 170     {
 171       gases.add (d.getGas());
 172
 173       for (ComputedStop s: d.getStops())
 174         gases.add (s.getGas());
 175     }
 176
 177     return gases;
 178   }
 179
 180
 181   public long ceil (double in)
 182   {
 183     return (long)Math.ceil (in);
 184   }
 185 }
 186