gov/nasa/worldwind/WWIO.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7
   8 /**
   9  * @author Tom Gaskins
  10  * @version $Id: WWIO.java 1869 2007-05-23 22:18:47Z tgaskins $
  11  */
  12 package gov.nasa.worldwind;
  13
  14 import java.net.*;
  15 import java.nio.*;
  16 import java.nio.channels.*;
  17 import java.io.*;
  18 import java.util.zip.*;
  19
  20 public class WWIO
  21 {
  22     public static boolean saveBuffer(ByteBuffer buffer, File file) throws IOException
  23     {
  24         if (buffer == null)
  25         {
  26             String message = WorldWind.retrieveErrMsg("nullValue.BufferNull");
  27             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  28             throw new IllegalArgumentException(message);
  29         }
  30
  31         if (file == null)
  32         {
  33             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
  34             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  35             throw new IllegalArgumentException(message);
  36         }
  37
  38         FileOutputStream fos = null;
  39         FileChannel channel = null;
  40         FileLock lock;
  41         int numBytesWritten = 0;
  42         try
  43         {
  44             fos = new FileOutputStream(file);
  45             channel = fos.getChannel();
  46             lock = channel.tryLock();
  47             if (lock == null)
  48             {
  49                 // The file is being written to, or some other process is keeping it to itself.
  50                 // This is an okay condition, but worth noting.
  51                 String message = WorldWind.retrieveErrMsg("WWIO.UnableToAcquireLockFor") + file.getPath();
  52                 WorldWind.logger().log(java.util.logging.Level.FINER, message);
  53                 return false;
  54             }
  55
  56             for (buffer.rewind(); buffer.hasRemaining();)
  57             {
  58                 numBytesWritten += channel.write(buffer);
  59             }
  60
  61             return true;
  62         }
  63         catch (IOException e)
  64         {
  65             String message = WorldWind.retrieveErrMsg("WWIO.ErrorSavingBufferTo") + file.getPath();
  66             WorldWind.logger().log(java.util.logging.Level.FINE, message, e);
  67
  68             if (numBytesWritten > 0) // don't leave behind incomplete files
  69                 file.delete();
  70
  71             throw e;
  72         }
  73         finally
  74         {
  75             try
  76             {
  77                 if (channel != null)
  78                     channel.close(); // also releases the lock
  79                 else if (fos != null)
  80                     fos.close();
  81             }
  82             catch (java.io.IOException e)
  83             {
  84                 String message = WorldWind.retrieveErrMsg("WWIO.ErrorTryingToClose") + file.getPath();
  85                 WorldWind.logger().log(java.util.logging.Level.FINE, message);
  86             }
  87         }
  88     }
  89
  90     public static MappedByteBuffer mapFile(File file) throws IOException
  91     {
  92         if (file == null)
  93         {
  94             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
  95             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  96             throw new IllegalArgumentException(message);
  97         }
  98
  99         FileInputStream is = new FileInputStream(file);
 100         try
 101         {
 102             return is.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, file.length());
 103         }
 104         finally
 105         {
 106             is.close();
 107         }
 108     }
 109
 110     public static ByteBuffer readURLContentToBuffer(URL url) throws IOException
 111     {
 112         if (url == null)
 113         {
 114             String message = WorldWind.retrieveErrMsg("nullValue.URLIsNull");
 115             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 116             throw new IllegalArgumentException(message);
 117         }
 118
 119         InputStream is = url.openStream();
 120         return readStreamToBuffer(is);
 121 //        ByteBuffer buffer;
 122 //        try
 123 //        {
 124 //            URLConnection connection = url.openConnection();
 125 //            int size = connection.getContentLength();
 126 //            buffer = ByteBuffer.allocateDirect(size);
 127 //            byte inputBuffer[] = new byte[size];
 128 //            int n;
 129 //            do
 130 //            {
 131 //                n = is.read(inputBuffer);
 132 //                if (n > 0)
 133 //                    buffer.put(inputBuffer, 0, n);
 134 //            } while (buffer.hasRemaining() && n >= 0);
 135 //            buffer.flip();
 136 //            buffer.rewind();
 137 //        }
 138 //        finally
 139 //        {
 140 //            if (is != null)
 141 //            {
 142 //                is.close();
 143 //            }
 144 //        }
 145 //
 146 //        return buffer;
 147     }
 148
 149     public static ByteBuffer readFileToBuffer(File file) throws IOException
 150     {
 151         if (file == null)
 152         {
 153             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 154             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 155             throw new IllegalArgumentException(message);
 156         }
 157
 158         FileInputStream is = new FileInputStream(file);
 159         try
 160         {
 161             FileChannel fc = is.getChannel();
 162             ByteBuffer buffer = ByteBuffer.allocate((int) fc.size());
 163             for (int count = 0; count >= 0 && buffer.hasRemaining();)
 164             {
 165                 count = fc.read(buffer);
 166             }
 167             buffer.flip();
 168             return buffer;
 169         }
 170         finally
 171         {
 172             is.close();
 173         }
 174     }
 175
 176     public static ByteBuffer readZipEntryToBuffer(File zipFile, String entryName) throws IOException
 177     {
 178         if (zipFile == null)
 179         {
 180             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 181             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 182             throw new IllegalArgumentException(message);
 183         }
 184
 185         InputStream is = null;
 186         ZipEntry ze;
 187         try
 188         {
 189             ZipFile zf = new ZipFile(zipFile);
 190             if (zf.size() < 1)
 191             {
 192                 String message = WorldWind.retrieveErrMsg("WWIO.ZipFileIsEmpty") + zipFile.getPath();
 193                 WorldWind.logger().log(java.util.logging.Level.FINE, message);
 194                 throw new java.io.IOException(message);
 195             }
 196
 197             if (entryName != null)
 198             {   // Read the specified entry
 199                 ze = zf.getEntry(entryName);
 200                 if (ze == null)
 201                 {
 202                     String message = WorldWind.retrieveErrMsg("WWIO.ZipFileEntryNIF") + entryName
 203                         + WorldWind.retrieveErrMsg("punctuation.space") + zipFile.getPath();
 204                     WorldWind.logger().log(java.util.logging.Level.FINE, message);
 205                     throw new IOException(message);
 206                 }
 207             }
 208             else
 209             {   // Read the first entry
 210                 ze = zf.entries().nextElement(); // get the first entry
 211             }
 212
 213             is = zf.getInputStream(ze);
 214             ByteBuffer buffer = null;
 215             if (ze.getSize() > 0)
 216             {
 217                 buffer = transferStreamToByteBuffer(is, (int) ze.getSize());
 218                 buffer.flip();
 219             }
 220             return buffer;
 221         }
 222         finally
 223         {
 224             if (is != null)
 225                 is.close();
 226         }
 227     }
 228
 229     private static ByteBuffer transferStreamToByteBuffer(InputStream stream, int numBytes) throws IOException
 230     {
 231         if (stream == null)
 232         {
 233             String message = WorldWind.retrieveErrMsg("nullValue.InputStreamIsNull");
 234             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 235             throw new IllegalArgumentException(message);
 236         }
 237
 238         if (numBytes < 1)
 239         {
 240             String message = WorldWind.retrieveErrMsg("WWIO.NumberBytesTransferLessThanOne");
 241             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 242             throw new IllegalArgumentException(message);
 243         }
 244
 245         int bytesRead = 0;
 246         int count = 0;
 247         byte[] bytes = new byte[numBytes];
 248         while (count >= 0 && (numBytes - bytesRead) > 0)
 249         {
 250             count = stream.read(bytes, bytesRead, numBytes - bytesRead);
 251             if (count > 0)
 252             {
 253                 bytesRead += count;
 254             }
 255         }
 256         return ByteBuffer.wrap(bytes);
 257     }
 258
 259     public static ByteBuffer readStreamToBuffer(InputStream inputStream) throws IOException
 260     {
 261         final int PAGE_SIZE = 8192;
 262
 263         ReadableByteChannel channel = Channels.newChannel(inputStream);
 264         ByteBuffer buffer = ByteBuffer.allocate(PAGE_SIZE);
 265
 266         int count = 0;
 267         while (count >= 0)
 268         {
 269             count = channel.read(buffer);
 270             if (count > 0 && !buffer.hasRemaining())
 271             {
 272                 ByteBuffer biggerBuffer = ByteBuffer.allocate(buffer.limit() + PAGE_SIZE);
 273                 biggerBuffer.put((ByteBuffer) buffer.rewind());
 274                 buffer = biggerBuffer;
 275             }
 276         }
 277
 278         if (buffer != null)
 279             buffer.flip();
 280
 281         return buffer;
 282     }
 283
 284     public static String replaceSuffix(String in, String newSuffix)
 285     {
 286         if (in == null)
 287         {
 288             String message = WorldWind.retrieveErrMsg("nullValue.InputFileNameIsNull");
 289             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 290             throw new IllegalArgumentException(message);
 291         }
 292
 293         return in.substring(0, in.lastIndexOf(".")) + (newSuffix != null ? newSuffix : "");
 294     }
 295
 296     public static File saveBufferToTempFile(ByteBuffer buffer, String suffix) throws IOException
 297     {
 298         if (buffer == null)
 299         {
 300             String message = WorldWind.retrieveErrMsg("nullValue.ByteBufferIsNull");
 301             gov.nasa.worldwind.WorldWind.logger().log(java.util.logging.Level.FINE, message);
 302             throw new IllegalArgumentException(message);
 303         }
 304
 305         File outputFile = java.io.File.createTempFile("WorldWind", suffix != null ? suffix : "");
 306         outputFile.deleteOnExit();
 307         buffer.rewind();
 308         WWIO.saveBuffer(buffer, outputFile);
 309
 310         return outputFile;
 311     }
 312
 313     public static String getSuffixForMimeType(String mimeType)
 314     {
 315         if (mimeType == null)
 316         {
 317             String msg = WorldWind.retrieveErrMsg("nullValue.MimeTypeIsNull");
 318             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 319             throw new IllegalArgumentException(msg);
 320         }
 321
 322         if (mimeType.equalsIgnoreCase("image/jpeg") || mimeType.equalsIgnoreCase("image/jpg"))
 323             return ".jpg";
 324         if (mimeType.equalsIgnoreCase("image/png"))
 325             return ".png";
 326
 327         return null;
 328     }
 329
 330     public static boolean isFileOutOfDate(URL url, long expiryTime)
 331     {
 332         if (url == null)
 333         {
 334             String message = WorldWind.retrieveErrMsg("nullValue.URLIsNull");
 335             gov.nasa.worldwind.WorldWind.logger().log(java.util.logging.Level.FINE, message);
 336             throw new IllegalArgumentException(message);
 337         }
 338
 339         try
 340         {
 341             // Determine whether the file can be treated like a File, e.g., a jar entry.
 342             URI uri = url.toURI();
 343             if (uri.isOpaque())
 344                 return false; // TODO: Determine how to check the date of non-Files
 345
 346             File file = new File(uri);
 347
 348             return file.exists() && file.lastModified() < expiryTime;
 349         }
 350         catch (URISyntaxException e)
 351         {
 352             String message = WorldWind.retrieveErrMsg("WWIO.ExceptionValidatingFileExpiration");
 353             WorldWind.logger().log(java.util.logging.Level.FINE, message + url);
 354             return false;
 355         }
 356     }
 357 }