alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (FileLocator.java)

This example Java source code file (FileLocator.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

bufferedinputstream, datainputstream, fileinputstream, filelocator, filenotfoundexception, ioexception, nameddatainputstream, nosuchelementexception, nullpointerexception, object, string, stringtokenizer, util, zip, zipexception, zipfile

The FileLocator.java Java example source code

/*
 * Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
/*
 * Licensed Materials - Property of IBM
 * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997,1998
 * RMI-IIOP v1.0
 *
 */

package com.sun.tools.corba.se.idl.som.cff;

import java.lang.Exception;
import java.lang.String;
import java.lang.System;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.IOException;
import java.util.Locale;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.zip.*;

/**
 * FileLocator is an abstract class (one that cannot be instantiated) that
 * provides class methods for finding files in the directories or zip
 * archives that make up the CLASSPATH.
 *
 * @author      Larry K. Raper
 */
public abstract class FileLocator extends Object {

    /* Class variables */


    static final Properties pp = System.getProperties ();
    static final String classPath = pp.getProperty ("java.class.path", ".");
    static final String pathSeparator = pp.getProperty ("path.separator", ";");

    /* Instance variables */

    /* [None, no instances of this class are ever instantiated.] */

    /**
     * locateClassFile returns a DataInputStream with mark/reset
     * capability that can be used to read the requested class file.  The
     * CLASSPATH is used to locate the class.
     *
     * @param classFileName The name of the class to locate.  The class name
     * should be given in fully-qualified form, for example:
     * <pre>
     *     java.lang.Object
     *     java.io.DataInputStream
     * </pre>
     *
     * @exception java.io.FileNotFoundException The requested class file
     * could not be found.
     * @exception java.io.IOException The requested class file
     * could not be opened.
     */
    public static DataInputStream locateClassFile (String classFileName)
        throws FileNotFoundException, IOException {

        boolean notFound = true;
        StringTokenizer st;
        String path = "";
        String pathNameForm;
        File cf = null;
        NamedDataInputStream result;

        st = new StringTokenizer (classPath, pathSeparator, false);
        pathNameForm = classFileName.replace ('.', File.separatorChar) +
            ".class";

        while (st.hasMoreTokens () && notFound) {

            try {path = st.nextToken ();}
                catch (NoSuchElementException nse) {break;}
            int pLen = path.length ();
            String pathLast4 = pLen > 3 ? path.substring (pLen - 4) : "";
            if (pathLast4.equalsIgnoreCase (".zip") ||
                pathLast4.equalsIgnoreCase (".jar")) {

                try {

                    result = locateInZipFile (path, classFileName, true, true);
                    if (result == null)
                        continue;
                    return (DataInputStream) result;

                } catch (ZipException zfe) {
                    continue;
                } catch (IOException ioe) {
                    continue;
                }

            } else {
                try {cf = new File (path + File.separator + pathNameForm);
                } catch (NullPointerException npe) { continue; }
                if ((cf != null) && cf.exists ())
                    notFound = false;
            }
        }

        if (notFound) {

            /* Make one last attempt to find the file in the current
             * directory
             */

            int lastdot = classFileName.lastIndexOf ('.');
            String simpleName =
                (lastdot >= 0) ? classFileName.substring (lastdot+1) :
                classFileName;

            result = new NamedDataInputStream (new BufferedInputStream (
               new FileInputStream (simpleName + ".class")),
                   simpleName + ".class", false);
            return (DataInputStream) result;
        }

        result = new NamedDataInputStream (new BufferedInputStream (
            new FileInputStream (cf)), path + File.separator + pathNameForm,
                false);
        return (DataInputStream) result;

    }

    /**
     * locateLocaleSpecificFileInClassPath returns a DataInputStream that
     * can be used to read the requested file, but the name of the file is
     * determined using information from the current locale and the supplied
     * file name (which is treated as a "base" name, and is supplemented with
     * country and language related suffixes, obtained from the current
     * locale).  The CLASSPATH is used to locate the file.
     *
     * @param fileName The name of the file to locate.  The file name
     * may be qualified with a partial path name, using '/' as the separator
     * character or using separator characters appropriate for the host file
     * system, in which case each directory or zip file in the CLASSPATH will
     * be used as a base for finding the fully-qualified file.
     * Here is an example of how the supplied fileName is used as a base
     * for locating a locale-specific file:
     *
     * <pre>
     *     Supplied fileName: a/b/c/x.y,  current locale: US English
     *
     *                     Look first for: a/b/c/x_en_US.y
     *     (if that fails) Look next for:  a/b/c/x_en.y
     *     (if that fails) Look last for:  a/b/c/x.y
     *
     *     All elements of the class path are searched for each name,
     *     before the next possible name is tried.
     * </pre>
     *
     * @exception java.io.FileNotFoundException The requested class file
     * could not be found.
     * @exception java.io.IOException The requested class file
     * could not be opened.
     */
    public static DataInputStream locateLocaleSpecificFileInClassPath (
        String fileName) throws FileNotFoundException, IOException {

        String localeSuffix = "_" + Locale.getDefault ().toString ();
        int lastSlash = fileName.lastIndexOf ('/');
        int lastDot   = fileName.lastIndexOf ('.');
        String fnFront, fnEnd;
        DataInputStream result = null;
        boolean lastAttempt = false;

        if ((lastDot > 0) && (lastDot > lastSlash)) {
            fnFront = fileName.substring (0, lastDot);
            fnEnd   = fileName.substring (lastDot);
        } else {
            fnFront = fileName;
            fnEnd   = "";
        }

        while (true) {
            if (lastAttempt)
                result = locateFileInClassPath (fileName);
            else try {
                result = locateFileInClassPath (fnFront + localeSuffix + fnEnd);
            } catch (Exception e) { /* ignore */ }
            if ((result != null) || lastAttempt)
                break;
            int lastUnderbar = localeSuffix.lastIndexOf ('_');
            if (lastUnderbar > 0)
                localeSuffix = localeSuffix.substring (0, lastUnderbar);
            else
                lastAttempt = true;
        }
        return result;

    }

    /**
     * locateFileInClassPath returns a DataInputStream that can be used
     * to read the requested file.  The CLASSPATH is used to locate the file.
     *
     * @param fileName The name of the file to locate.  The file name
     * may be qualified with a partial path name, using '/' as the separator
     * character or using separator characters appropriate for the host file
     * system, in which case each directory or zip file in the CLASSPATH will
     * be used as a base for finding the fully-qualified file.
     *
     * @exception java.io.FileNotFoundException The requested class file
     * could not be found.
     * @exception java.io.IOException The requested class file
     * could not be opened.
     */
    public static DataInputStream locateFileInClassPath (String fileName)
        throws FileNotFoundException, IOException {

        boolean notFound = true;
        StringTokenizer st;
        String path = "";
        File cf = null;
        NamedDataInputStream result;

        String zipEntryName = File.separatorChar == '/' ? fileName :
            fileName.replace (File.separatorChar, '/');

        String localFileName = File.separatorChar == '/' ? fileName :
            fileName.replace ('/', File.separatorChar);

        st = new StringTokenizer (classPath, pathSeparator, false);

        while (st.hasMoreTokens () && notFound) {

            try {path = st.nextToken ();}
                catch (NoSuchElementException nse) {break;}
            int pLen = path.length ();
            String pathLast4 = pLen > 3 ? path.substring (pLen - 4) : "";
            if (pathLast4.equalsIgnoreCase (".zip") ||
                pathLast4.equalsIgnoreCase (".jar")) {

                try {

                    result = locateInZipFile (path, zipEntryName, false, false);
                    if (result == null)
                        continue;
                    return (DataInputStream) result;

                } catch (ZipException zfe) {
                    continue;
                } catch (IOException ioe) {
                    continue;
                }

            } else {
                try {cf = new File (path + File.separator + localFileName);
                } catch (NullPointerException npe) { continue; }
                if ((cf != null) && cf.exists ())
                    notFound = false;
            }
        }

        if (notFound) {

            /* Make one last attempt to find the file in the current
             * directory
             */

            int lastpart = localFileName.lastIndexOf (File.separator);
            String simpleName =
                (lastpart >= 0) ? localFileName.substring (lastpart+1) :
                localFileName;

            result = new NamedDataInputStream (new BufferedInputStream (
               new FileInputStream (simpleName)), simpleName, false);
            return (DataInputStream) result;
        }

        result = new NamedDataInputStream (new BufferedInputStream (
            new FileInputStream (cf)), path + File.separator + localFileName,
                false);
        return (DataInputStream) result;

    }

    /**
     * Returns the fully qualified file name associated with the passed
     * DataInputStream <i>if the DataInputStream was created using one
     * of the static locate methods supplied with this class</i>, otherwise
     * returns a zero length string.
     */
    public static String getFileNameFromStream (DataInputStream ds) {

        if (ds instanceof NamedDataInputStream)
            return ((NamedDataInputStream) ds).fullyQualifiedFileName;
        return "";

    }

    /**
     * Returns an indication of whether the passed DataInputStream is
     * associated with a member of a zip file <i>if the DataInputStream was
     * created using one of the static locate methods supplied with this
     * class</i>, otherwise returns false.
     */
    public static boolean isZipFileAssociatedWithStream (DataInputStream ds) {

        if (ds instanceof NamedDataInputStream)
            return ((NamedDataInputStream) ds).inZipFile;
        return false;

    }

    private static NamedDataInputStream locateInZipFile (String zipFileName,
        String fileName, boolean wantClass, boolean buffered)
        throws ZipException, IOException {

        ZipFile zf;
        ZipEntry ze;
        zf = new ZipFile (zipFileName);

        if (zf == null)
            return null;
        String zeName = wantClass ?
            fileName.replace ('.', '/') + ".class" :
            fileName;

        //  This code works with JDK 1.0 level SUN zip classes
        //

        //  ze = zf.get (zeName);
        //  if (ze == null)
        //      return null;
        //  return new NamedDataInputStream (
        //      new BufferedInputStream (new ZipInputStream (ze)),
        //          zipFileName + '(' +zeName + ')', true);

        //  This code works with JDK 1.0.2 and JDK 1.1 level SUN zip classes
        //

            ze = zf.getEntry (zeName);
            if (ze == null) {
                zf.close(); // D55355, D56419
                zf = null;
                return null;
            }
            InputStream istream = zf.getInputStream(ze);
            if (buffered)
                istream = new BufferedInputStream(istream);
            return new NamedDataInputStream (istream,
                    zipFileName + '(' + zeName + ')', true);

    }

}

/**
 * This class is used to associate a filename with a DataInputStream
 * The host platform's file naming conventions are assumed for the filename.
 *
 * @author      Larry K. Raper
 *
 */
/* default access */ class NamedDataInputStream extends DataInputStream {

    /* Instance variables */

    /**
     * The name of the file associated with the DataInputStream.
     */
    public String fullyQualifiedFileName;

    /**
     * Indicates whether or not the file is contained in a .zip file.
     */
    public boolean inZipFile;

    /* Constructors */

    protected NamedDataInputStream (InputStream in, String fullyQualifiedName,
        boolean inZipFile) {

        super (in);
        this.fullyQualifiedFileName = fullyQualifiedName;
        this.inZipFile = inZipFile;

    }

}

Other Java examples (source code examples)

Here is a short list of links related to this Java FileLocator.java source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.