core/java12/com/vladium/util/IPathEnumerator.java - platform/external/emma - Git at Google

 /* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
  *
  * This program and the accompanying materials are made available under
  * the terms of the Common Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/cpl-v10.html
  *
  * $Id: IPathEnumerator.java,v 1.1.1.1.2.1 2004/07/16 23:32:04 vlad_r Exp $
  */
 package com.vladium.util;

 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.StringTokenizer;
 import java.util.jar.Attributes;
 import java.util.jar.JarFile;
 import java.util.jar.JarInputStream;
 import java.util.jar.Manifest;
 import java.util.zip.ZipEntry;

 import com.vladium.logging.Logger;
 import com.vladium.util.asserts.$assert;

 // ----------------------------------------------------------------------------
 /**
  * @author Vlad Roubtsov, (C) 2003
  */
 public
 interface IPathEnumerator
 {
     // public: ................................................................

     // TODO: archives inside archives? (.war ?)

     public static interface IPathHandler
     {
         void handleDirStart (File pathDir, File dir); // not generated for path dirs themselves
         void handleFile (File pathDir, File file);
         void handleDirEnd (File pathDir, File dir);

         /**
          * Called just after the enumerator's zip input stream for this archive
          * is opened and the manifest entry is read.
          */
         void handleArchiveStart (File parentDir, File archive, Manifest manifest);

         void handleArchiveEntry (JarInputStream in, ZipEntry entry);

         /**
          * Called after the enumerator's zip input stream for this archive
          * has been closed.
          */
         void handleArchiveEnd (File parentDir, File archive);

     } // end of nested interface


     void enumerate () throws IOException;


     public static abstract class Factory
     {
         public static IPathEnumerator create (final File [] path, final boolean canonical, final IPathHandler handler)
         {
             return new PathEnumerator (path, canonical, handler);
         }

         private static final class PathEnumerator implements IPathEnumerator
         {
             public void enumerate () throws IOException
             {
                 final IPathHandler handler = m_handler;

                 for (m_pathIndex = 0; m_pathIndex < m_path.size (); ++ m_pathIndex) // important not to cache m_path.size()
                 {
                     final File f = (File) m_path.get (m_pathIndex);

                     if (! f.exists ())
                     {
                         if (IGNORE_INVALID_ENTRIES)
                             continue;
                         else
                             throw new IllegalArgumentException ("path entry does not exist: [" + f + "]");
                     }


                     if (f.isDirectory ())
                     {
                         if (m_verbose) m_log.verbose ("processing dir path entry [" + f.getAbsolutePath () + "] ...");

                         m_currentPathDir = f;
                         enumeratePathDir (null);
                     }
                     else
                     {
                         final String name = f.getName ();
                         final String lcName = name.toLowerCase ();

                         if (lcName.endsWith (".zip") || lcName.endsWith (".jar"))
                         {
                             if (m_verbose) m_log.verbose ("processing archive path entry [" + f.getAbsolutePath () + "] ...");

                             final File parent = f.getParentFile (); // could be null
                             final File archive = new File (name);
                             m_currentPathDir = parent;

                             // move to enumeratePathArchive(): handler.handleArchiveStart (parent, archive);
                             enumeratePathArchive (name);
                             handler.handleArchiveEnd (parent, archive); // note: it is important that this is called after the zip stream has been closed
                         }
                         else if (! IGNORE_INVALID_ENTRIES)
                         {
                             throw new IllegalArgumentException ("path entry is not a directory or an archive: [" + f + "]");
                         }
                     }
                 }
             }

             PathEnumerator (final File [] path, final boolean canonical, final IPathHandler handler)
             {
                 m_path = new ArrayList (path.length);
                 for (int p = 0; p < path.length; ++ p) m_path.add (path [p]);

                 m_canonical = canonical;

                 if (handler == null) throw new IllegalArgumentException ("null input: handler");
                 m_handler = handler;

                 m_processManifest = true; // TODO

                 if (m_processManifest)
                 {
                     m_pathSet = new HashSet (path.length);
                     for (int p = 0; p < path.length; ++ p)
                     {
                         m_pathSet.add (path [p].getPath ()); // set of [possibly canonical] paths
                     }
                 }
                 else
                 {
                     m_pathSet = null;
                 }

                 m_log = Logger.getLogger (); // each path enumerator caches its logger at creation time
                 m_verbose = m_log.atVERBOSE ();
                 m_trace1 = m_log.atTRACE1 ();
             }


             private void enumeratePathDir (final String dir)
                 throws IOException
             {
                 final boolean trace1 = m_trace1;

                 final File currentPathDir = m_currentPathDir;
                 final File fullDir = dir != null ? new File (currentPathDir, dir) : currentPathDir;

                 final String [] children = fullDir.list ();
                 final IPathHandler handler = m_handler;

                 for (int c = 0, cLimit = children.length; c < cLimit; ++ c)
                 {
                     final String childName = children [c];

                     final File child = dir != null ? new File (dir, childName) : new File (childName);
                     final File fullChild = new File (fullDir, childName);

                     if (fullChild.isDirectory ())
                     {
                         handler.handleDirStart (currentPathDir, child);
                         if (trace1) m_log.trace1 ("enumeratePathDir", "recursing into [" + child.getName () + "] ...");
                         enumeratePathDir (child.getPath ());
                         handler.handleDirEnd (currentPathDir, child);
                     }
                     else
                     {
 //                        final String lcName = childName.toLowerCase ();
 //
 //                        if (lcName.endsWith (".zip") || lcName.endsWith (".jar"))
 //                        {
 //                            handler.handleArchiveStart (currentPathDir, child);
 //                            enumeratePathArchive (child.getPath ());
 //                            handler.handleArchiveEnd (currentPathDir, child);
 //                        }
 //                        else
                         {
                             if (trace1) m_log.trace1 ("enumeratePathDir", "processing file [" + child.getName () + "] ...");
                             handler.handleFile (currentPathDir, child);
                         }
                     }
                 }
             }

             private void enumeratePathArchive (final String archive)
                 throws IOException
             {
                 final boolean trace1 = m_trace1;

                 final File fullArchive = new File (m_currentPathDir, archive);

                 JarInputStream in = null;
                 try
                 {
                     // note: Sun's JarFile uses native code and has been known to
                     // crash the JVM in some builds; however, it uses random file
                     // access and can find "bad" manifests that are not the first
                     // entries in their archives (which JarInputStream can't do);
                     // [bugs: 4263225, 4696354, 4338238]
                     //
                     // there is really no good solution here but as a compromise
                     // I try to read the manifest again via a JarFile if the stream
                     // returns null for it:

                     in = new JarInputStream (new BufferedInputStream (new FileInputStream (fullArchive), 32 * 1024));

                     final IPathHandler handler = m_handler;

                     Manifest manifest = in.getManifest (); // can be null
                     if (manifest == null) manifest = readManifestViaJarFile (fullArchive); // can be null

                     handler.handleArchiveStart (m_currentPathDir, new File (archive), manifest);

                     // note: this loop does not skip over the manifest-related
                     // entries [the handler needs to be smart about that]
                     for (ZipEntry entry; (entry = in.getNextEntry ()) != null; )
                     {
                         // TODO: handle nested archives

                         if (trace1) m_log.trace1 ("enumeratePathArchive", "processing archive entry [" + entry.getName () + "] ...");
                         handler.handleArchiveEntry (in, entry);
                         in.closeEntry ();
                     }


                     // TODO: this needs major testing
                     if (m_processManifest)
                     {
                         // note: JarInputStream only reads the manifest if it the
                         // first jar entry
                         if (manifest == null) manifest = in.getManifest ();
                         if (manifest != null)
                         {
                             final Attributes attributes = manifest.getMainAttributes ();
                             if (attributes != null)
                             {
                                 // note: Sun's documentation says that multiple Class-Path:
                                 // entries are merged sequentially (http://java.sun.com/products/jdk/1.2/docs/guide/extensions/spec.html)
                                 // however, their own code does not implement this
                                 final String jarClassPath = attributes.getValue (Attributes.Name.CLASS_PATH);
                                 if (jarClassPath != null)
                                 {
                                     final StringTokenizer tokenizer = new StringTokenizer (jarClassPath);
                                     for (int p = 1; tokenizer.hasMoreTokens (); )
                                     {
                                         final String relPath = tokenizer.nextToken ();

                                         final File archiveParent = fullArchive.getParentFile ();
                                         final File path = archiveParent != null ? new File (archiveParent, relPath) : new File (relPath);

                                         final String fullPath = m_canonical ? Files.canonicalizePathname (path.getPath ()) : path.getPath ();

                                         if (m_pathSet.add (fullPath))
                                         {
                                             if (m_verbose) m_log.verbose ("  added manifest Class-Path entry [" + path + "]");
                                             m_path.add (m_pathIndex + (p ++), path); // insert after the current m_path entry
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
                 catch (FileNotFoundException fnfe) // ignore: this should not happen
                 {
                     if ($assert.ENABLED) throw fnfe;
                 }
                 finally
                 {
                     if (in != null) try { in.close (); } catch (Exception ignore) {}
                 }
             }


             // see comments at the start of enumeratePathArchive()

             private static Manifest readManifestViaJarFile (final File archive)
             {
                 Manifest result = null;

                 JarFile jarfile = null;
                 try
                 {
                     jarfile = new JarFile (archive, false); // 3-arg constructor is not in J2SE 1.2
                     result = jarfile.getManifest ();
                 }
                 catch (IOException ignore)
                 {
                 }
                 finally
                 {
                     if (jarfile != null) try { jarfile.close (); } catch (IOException ignore) {}
                 }

                 return result;
             }


             private final ArrayList /* File */ m_path;
             private final boolean m_canonical;
             private final Set /* String */ m_pathSet;
             private final IPathHandler m_handler;
             private final boolean m_processManifest;

             private final Logger m_log;
             private boolean m_verbose, m_trace1;

             private int m_pathIndex;
             private File m_currentPathDir;

             // if 'true', non-existent or non-archive or non-directory path entries
             // will be silently ignored:
             private static final boolean IGNORE_INVALID_ENTRIES = true; // this is consistent with the normal JVM behavior

         } // end of nested class

     } // end of nested class

 } // end of interface
 // ----------------------------------------------------------------------------
	/* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved.
	*
	* This program and the accompanying materials are made available under
	* the terms of the Common Public License v1.0 which accompanies this distribution,
	* and is available at http://www.eclipse.org/legal/cpl-v10.html
	*
	* $Id: IPathEnumerator.java,v 1.1.1.1.2.1 2004/07/16 23:32:04 vlad_r Exp $
	*/
	package com.vladium.util;

	import java.io.BufferedInputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Set;
	import java.util.StringTokenizer;
	import java.util.jar.Attributes;
	import java.util.jar.JarFile;
	import java.util.jar.JarInputStream;
	import java.util.jar.Manifest;
	import java.util.zip.ZipEntry;

	import com.vladium.logging.Logger;
	import com.vladium.util.asserts.$assert;

	// ----------------------------------------------------------------------------
	/**
	* @author Vlad Roubtsov, (C) 2003
	*/
	public
	interface IPathEnumerator
	{
	// public: ................................................................

	// TODO: archives inside archives? (.war ?)

	public static interface IPathHandler
	{
	void handleDirStart (File pathDir, File dir); // not generated for path dirs themselves
	void handleFile (File pathDir, File file);
	void handleDirEnd (File pathDir, File dir);

	/**
	* Called just after the enumerator's zip input stream for this archive
	* is opened and the manifest entry is read.
	*/
	void handleArchiveStart (File parentDir, File archive, Manifest manifest);

	void handleArchiveEntry (JarInputStream in, ZipEntry entry);

	/**
	* Called after the enumerator's zip input stream for this archive
	* has been closed.
	*/
	void handleArchiveEnd (File parentDir, File archive);

	} // end of nested interface


	void enumerate () throws IOException;


	public static abstract class Factory
	{
	public static IPathEnumerator create (final File [] path, final boolean canonical, final IPathHandler handler)
	{
	return new PathEnumerator (path, canonical, handler);
	}

	private static final class PathEnumerator implements IPathEnumerator
	{
	public void enumerate () throws IOException
	{
	final IPathHandler handler = m_handler;

	for (m_pathIndex = 0; m_pathIndex < m_path.size (); ++ m_pathIndex) // important not to cache m_path.size()
	{
	final File f = (File) m_path.get (m_pathIndex);

	if (! f.exists ())
	{
	if (IGNORE_INVALID_ENTRIES)
	continue;
	else
	throw new IllegalArgumentException ("path entry does not exist: [" + f + "]");
	}


	if (f.isDirectory ())
	{
	if (m_verbose) m_log.verbose ("processing dir path entry [" + f.getAbsolutePath () + "] ...");

	m_currentPathDir = f;
	enumeratePathDir (null);
	}
	else
	{
	final String name = f.getName ();
	final String lcName = name.toLowerCase ();

	if (lcName.endsWith (".zip") \|\| lcName.endsWith (".jar"))
	{
	if (m_verbose) m_log.verbose ("processing archive path entry [" + f.getAbsolutePath () + "] ...");

	final File parent = f.getParentFile (); // could be null
	final File archive = new File (name);
	m_currentPathDir = parent;

	// move to enumeratePathArchive(): handler.handleArchiveStart (parent, archive);
	enumeratePathArchive (name);
	handler.handleArchiveEnd (parent, archive); // note: it is important that this is called after the zip stream has been closed
	}
	else if (! IGNORE_INVALID_ENTRIES)
	{
	throw new IllegalArgumentException ("path entry is not a directory or an archive: [" + f + "]");
	}
	}
	}
	}

	PathEnumerator (final File [] path, final boolean canonical, final IPathHandler handler)
	{
	m_path = new ArrayList (path.length);
	for (int p = 0; p < path.length; ++ p) m_path.add (path [p]);

	m_canonical = canonical;

	if (handler == null) throw new IllegalArgumentException ("null input: handler");
	m_handler = handler;

	m_processManifest = true; // TODO

	if (m_processManifest)
	{
	m_pathSet = new HashSet (path.length);
	for (int p = 0; p < path.length; ++ p)
	{
	m_pathSet.add (path [p].getPath ()); // set of [possibly canonical] paths
	}
	}
	else
	{
	m_pathSet = null;
	}

	m_log = Logger.getLogger (); // each path enumerator caches its logger at creation time
	m_verbose = m_log.atVERBOSE ();
	m_trace1 = m_log.atTRACE1 ();
	}


	private void enumeratePathDir (final String dir)
	throws IOException
	{
	final boolean trace1 = m_trace1;

	final File currentPathDir = m_currentPathDir;
	final File fullDir = dir != null ? new File (currentPathDir, dir) : currentPathDir;

	final String [] children = fullDir.list ();
	final IPathHandler handler = m_handler;

	for (int c = 0, cLimit = children.length; c < cLimit; ++ c)
	{
	final String childName = children [c];

	final File child = dir != null ? new File (dir, childName) : new File (childName);
	final File fullChild = new File (fullDir, childName);

	if (fullChild.isDirectory ())
	{
	handler.handleDirStart (currentPathDir, child);
	if (trace1) m_log.trace1 ("enumeratePathDir", "recursing into [" + child.getName () + "] ...");
	enumeratePathDir (child.getPath ());
	handler.handleDirEnd (currentPathDir, child);
	}
	else
	{
	// final String lcName = childName.toLowerCase ();
	//
	// if (lcName.endsWith (".zip") \|\| lcName.endsWith (".jar"))
	// {
	// handler.handleArchiveStart (currentPathDir, child);
	// enumeratePathArchive (child.getPath ());
	// handler.handleArchiveEnd (currentPathDir, child);
	// }
	// else
	{
	if (trace1) m_log.trace1 ("enumeratePathDir", "processing file [" + child.getName () + "] ...");
	handler.handleFile (currentPathDir, child);
	}
	}
	}
	}

	private void enumeratePathArchive (final String archive)
	throws IOException
	{
	final boolean trace1 = m_trace1;

	final File fullArchive = new File (m_currentPathDir, archive);

	JarInputStream in = null;
	try
	{
	// note: Sun's JarFile uses native code and has been known to
	// crash the JVM in some builds; however, it uses random file
	// access and can find "bad" manifests that are not the first
	// entries in their archives (which JarInputStream can't do);
	// [bugs: 4263225, 4696354, 4338238]
	//
	// there is really no good solution here but as a compromise
	// I try to read the manifest again via a JarFile if the stream
	// returns null for it:

	in = new JarInputStream (new BufferedInputStream (new FileInputStream (fullArchive), 32 * 1024));

	final IPathHandler handler = m_handler;

	Manifest manifest = in.getManifest (); // can be null
	if (manifest == null) manifest = readManifestViaJarFile (fullArchive); // can be null

	handler.handleArchiveStart (m_currentPathDir, new File (archive), manifest);

	// note: this loop does not skip over the manifest-related
	// entries [the handler needs to be smart about that]
	for (ZipEntry entry; (entry = in.getNextEntry ()) != null; )
	{
	// TODO: handle nested archives

	if (trace1) m_log.trace1 ("enumeratePathArchive", "processing archive entry [" + entry.getName () + "] ...");
	handler.handleArchiveEntry (in, entry);
	in.closeEntry ();
	}


	// TODO: this needs major testing
	if (m_processManifest)
	{
	// note: JarInputStream only reads the manifest if it the
	// first jar entry
	if (manifest == null) manifest = in.getManifest ();
	if (manifest != null)
	{
	final Attributes attributes = manifest.getMainAttributes ();
	if (attributes != null)
	{
	// note: Sun's documentation says that multiple Class-Path:
	// entries are merged sequentially (http://java.sun.com/products/jdk/1.2/docs/guide/extensions/spec.html)
	// however, their own code does not implement this
	final String jarClassPath = attributes.getValue (Attributes.Name.CLASS_PATH);
	if (jarClassPath != null)
	{
	final StringTokenizer tokenizer = new StringTokenizer (jarClassPath);
	for (int p = 1; tokenizer.hasMoreTokens (); )
	{
	final String relPath = tokenizer.nextToken ();

	final File archiveParent = fullArchive.getParentFile ();
	final File path = archiveParent != null ? new File (archiveParent, relPath) : new File (relPath);

	final String fullPath = m_canonical ? Files.canonicalizePathname (path.getPath ()) : path.getPath ();

	if (m_pathSet.add (fullPath))
	{
	if (m_verbose) m_log.verbose (" added manifest Class-Path entry [" + path + "]");
	m_path.add (m_pathIndex + (p ++), path); // insert after the current m_path entry
	}
	}
	}
	}
	}
	}
	}
	catch (FileNotFoundException fnfe) // ignore: this should not happen
	{
	if ($assert.ENABLED) throw fnfe;
	}
	finally
	{
	if (in != null) try { in.close (); } catch (Exception ignore) {}
	}
	}


	// see comments at the start of enumeratePathArchive()

	private static Manifest readManifestViaJarFile (final File archive)
	{
	Manifest result = null;

	JarFile jarfile = null;
	try
	{
	jarfile = new JarFile (archive, false); // 3-arg constructor is not in J2SE 1.2
	result = jarfile.getManifest ();
	}
	catch (IOException ignore)
	{
	}
	finally
	{
	if (jarfile != null) try { jarfile.close (); } catch (IOException ignore) {}
	}

	return result;
	}


	private final ArrayList /* File */ m_path;
	private final boolean m_canonical;
	private final Set /* String */ m_pathSet;
	private final IPathHandler m_handler;
	private final boolean m_processManifest;

	private final Logger m_log;
	private boolean m_verbose, m_trace1;

	private int m_pathIndex;
	private File m_currentPathDir;

	// if 'true', non-existent or non-archive or non-directory path entries
	// will be silently ignored:
	private static final boolean IGNORE_INVALID_ENTRIES = true; // this is consistent with the normal JVM behavior

	} // end of nested class

	} // end of nested class

	} // end of interface
	// ----------------------------------------------------------------------------