gov/nasa/worldwind/formats/rpf/RpfTocCrawler.java

   1 /*
   2  Copyright (C) 2001, 2006 United States Government as represented by
   3 the Administrator of the National Aeronautics and Space Administration.
   4 All Rights Reserved.
   5 */
   6 package gov.nasa.worldwind.formats.rpf;
   7
   8 import gov.nasa.worldwind.*;
   9
  10 import java.io.*;
  11 import java.util.*;
  12 import java.util.concurrent.locks.*;
  13 import static java.util.logging.Level.*;
  14
  15 /**
  16  * @author dcollins
  17  * @version $Id: RpfTocCrawler.java 1762 2007-05-07 19:43:55Z dcollins $
  18  */
  19 public class RpfTocCrawler
  20 {
  21     public static final String RPF_DIRECTORY = "RPF";
  22     public static final String RPF_OVERVIEW_EXTENSION = ".OVR";
  23     public static final String RPF_TOC_EXTENSION = ".TOC";
  24
  25     public static interface RpfTocCrawlerListener
  26     {
  27         void fileFound(File tocFile);
  28
  29         void finished();
  30     }
  31
  32     public abstract static class RpfTocGrouper implements RpfTocCrawlerListener
  33     {
  34         private final RpfFramePropertyType groupType;
  35
  36         public RpfTocGrouper(RpfFramePropertyType groupType)
  37         {
  38             if (groupType == null)
  39             {
  40                 String message = WorldWind.retrieveErrMsg("nullValue.RpfFramePropertyTypeIsNull");
  41                 WorldWind.logger().log(FINE, message);
  42                 throw new IllegalArgumentException(message);
  43             }
  44             this.groupType = groupType;
  45         }
  46
  47         public void fileFound(File tocFile)
  48         {
  49             RpfTocFile rpfTocFile = null;
  50             try
  51             {
  52                 rpfTocFile = RpfTocFile.load(tocFile);
  53             }
  54             catch (IOException e)
  55             {
  56                 WorldWind.logger().log(FINE, e.getMessage());
  57             }
  58
  59             if (rpfTocFile == null)
  60                 return;
  61
  62             String firstFrameFilename = findFirstRpfFrameFilename(rpfTocFile);
  63             if (firstFrameFilename == null)
  64                 return;
  65
  66             RpfFrameProperties firstFrameProperties = null;
  67             try
  68             {
  69                 firstFrameProperties = RpfFrameFilenameUtil.parseFilename(firstFrameFilename);
  70             }
  71             catch (Exception e)
  72             {
  73                 String message = WorldWind.retrieveErrMsg("RpfTocCrawler.ExceptionParsingFilename");
  74                 WorldWind.logger().log(FINE, message, e);
  75             }
  76
  77             if (firstFrameProperties != null)
  78                 this.addToGroup(this.groupType.getInstance(firstFrameProperties), rpfTocFile);
  79         }
  80
  81         public void finished()
  82         {
  83         }
  84
  85         public abstract void addToGroup(Object groupKey, RpfTocFile rpfTocFile);
  86     }
  87
  88     private static class RpfTocRunner implements Runnable
  89     {
  90         private final RpfTocCrawler context;
  91         private final File directory;
  92         private final RpfTocCrawlerListener listener;
  93
  94         public RpfTocRunner(RpfTocCrawler context, File directory, RpfTocCrawlerListener listener)
  95         {
  96             this.context = context;
  97             this.directory = directory;
  98             this.listener = listener;
  99         }
 100
 101         public void run()
 102         {
 103             this.context.process(this.directory, listener, true);
 104             this.context.threadLock.lock();
 105             try
 106             {
 107                 if (this.context.thread != this.context.deadThread)
 108                 {
 109                     listener.finished();
 110                     this.context.thread = this.context.deadThread;
 111                 }
 112             }
 113             finally
 114             {
 115                 this.context.threadLock.unlock();
 116             }
 117         }
 118     }
 119
 120     private final Thread deadThread = new Thread();
 121     private final Lock threadLock = new ReentrantLock();
 122     private volatile Thread thread = null;
 123
 124     public RpfTocCrawler()
 125     {
 126     }
 127
 128     public static String findFirstRpfFrameFilename(RpfTocFile tocFile)
 129     {
 130         if (tocFile != null
 131             && tocFile.getFrameFileIndexSection() != null
 132             && tocFile.getFrameFileIndexSection().getFrameFileIndexTable() != null
 133             && tocFile.getFrameFileIndexSection().getFrameFileIndexTable().size() > 0)
 134         {
 135             for (RpfFrameFileIndexSection.RpfFrameFileIndexRecord frameFileIndexRecord
 136                 : tocFile.getFrameFileIndexSection().getFrameFileIndexTable())
 137             {
 138                 if (frameFileIndexRecord != null
 139                     && frameFileIndexRecord.getFrameFileName() != null
 140                     && !frameFileIndexRecord.getFrameFileName().toUpperCase().endsWith(RPF_OVERVIEW_EXTENSION))
 141                 {
 142                     return frameFileIndexRecord.getFrameFileName();
 143                 }
 144             }
 145         }
 146         return null;
 147     }
 148
 149     private void process(File file, RpfTocCrawlerListener listener, boolean inOwnThread)
 150     {
 151         this.threadLock.lock();
 152         try
 153         {
 154             if (inOwnThread && this.thread == deadThread)
 155                 return;
 156         }
 157         finally
 158         {
 159             this.threadLock.unlock();
 160         }
 161
 162         File[] children = file.listFiles();
 163         if (children == null)
 164             return;
 165         if (RPF_DIRECTORY.compareToIgnoreCase(file.getName()) == 0)
 166             this.processRpfDirectory(children, listener, inOwnThread);
 167         else
 168             this.processUnknownDirectory(children, listener, inOwnThread);
 169     }
 170
 171     private void processRpfDirectory(File[] contents, RpfTocCrawlerListener listener, boolean inOwnThread)
 172     {
 173         for (File file : contents)
 174         {
 175             this.threadLock.lock();
 176             try
 177             {
 178                 if (inOwnThread && this.thread == deadThread)
 179                     return;
 180             }
 181             finally
 182             {
 183                 this.threadLock.unlock();
 184             }
 185
 186             if (file.getName().toUpperCase().endsWith(RPF_TOC_EXTENSION))
 187                 listener.fileFound(file);
 188         }
 189     }
 190
 191     private void processUnknownDirectory(File[] contents, RpfTocCrawlerListener listener, boolean inOwnThread)
 192     {
 193         for (File file : contents)
 194         {
 195             this.threadLock.lock();
 196             try
 197             {
 198                 if (inOwnThread && this.thread == deadThread)
 199                     return;
 200             }
 201             finally
 202             {
 203                 this.threadLock.unlock();
 204             }
 205
 206             if (file.isDirectory())
 207                 this.process(file, listener, inOwnThread);
 208         }
 209     }
 210
 211     public File[] invoke(File directory)
 212     {
 213         File validDir = this.validateDirectory(directory);
 214         final Collection<File> results = new ArrayList<File>();
 215         this.process(validDir, new RpfTocCrawlerListener()
 216         {
 217             public void fileFound(File file)
 218             {
 219                 if (file.exists())
 220                     results.add(file);
 221             }
 222
 223             public void finished()
 224             {
 225             }
 226         }, false);
 227         File[] tocFileArray = new File[results.size()];
 228         results.toArray(tocFileArray);
 229         return tocFileArray;
 230     }
 231
 232     public void invoke(File directory, RpfTocCrawlerListener listener)
 233     {
 234         File validDir = this.validateDirectory(directory);
 235         this.process(validDir, listener, false);
 236     }
 237
 238     public void start(File directory, RpfTocCrawlerListener listener)
 239     {
 240         this.threadLock.lock();
 241         try
 242         {
 243             if (this.thread != null || this.thread == deadThread)
 244             {
 245                 String message = WorldWind.retrieveErrMsg("RpfTocCrawler.BadStart");
 246                 WorldWind.logger().log(FINE, message);
 247                 throw new IllegalStateException(message);
 248             }
 249             File validDir = this.validateDirectory(directory);
 250             this.thread = new Thread(new RpfTocRunner(this, validDir, listener));
 251             this.thread.start();
 252         }
 253         finally
 254         {
 255             this.threadLock.unlock();
 256         }
 257     }
 258
 259     public void stop()
 260     {
 261         this.threadLock.lock();
 262         try
 263         {
 264             this.thread = deadThread;
 265         }
 266         finally
 267         {
 268             this.threadLock.unlock();
 269         }
 270     }
 271
 272     private File validateDirectory(File directory)
 273     {
 274         if (directory == null)
 275         {
 276             String message = WorldWind.retrieveErrMsg("nullValue.FileIsNull");
 277             WorldWind.logger().log(FINE, message);
 278             throw new IllegalArgumentException(message);
 279         }
 280         String path = directory.getAbsolutePath();
 281         if (!path.endsWith("/") && !path.endsWith("\\"))
 282         {
 283             path = path + File.separatorChar;
 284             directory = new File(path);
 285         }
 286         if (!directory.exists())
 287         {
 288             String message = WorldWind.retrieveErrMsg("generic.fileNotFound");
 289             WorldWind.logger().log(FINE, message);
 290             throw new IllegalArgumentException(message);
 291         }
 292         return directory;
 293     }
 294 }