Logo
Distributed Genetic Programming Framework
print print

File org.sfc.io.Files.java

Here you can find all the information about the file org.sfc.io.Files.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2005 Thomas Weise
 *
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2005-06-17 20:01:54
 * Original Filename: org.sfc.io.Files.java
 * Version          : 1.0.3
 * Last modification: 2006-05-28
 *                by: Thomas Weise
 *
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *
 * Warranty         : This software is provided "as is" without any
 *                    warranty; without even the implied warranty of
 *                    merchantability or fitness for a particular purpose.
 *                    See the Gnu Lesser General Public License for more
 *                    details.
 */


package org.sfc.io;

import java.io.File;
import java.io.IOException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.List;

import org.sfc.collections.Collections;
import org.sfc.utils.Typesafe;

/**
 * This class provides operations and constants used for file
 * handling as well as some default folders.
 *
 * @author Thomas Weise
 */

public final  class Files
  {
/**
 * The file protocol.
 */

  public  static  final String  FILE_PROTOCOL   = "file";

/**
 * The temporary directory.
 */

  public static  final File    TEMP_DIR  ;
/**
 * The current user's directory.
 */

  public static  final File    USER_DIR  ;
/**
 * The home directory.
 */

  public static  final File    HOME_DIR  ;
/**
 * The java virtual machine executable.
 */

  public static  final File    JVM       ;

/**
 * The directory with the libraries to be loaded.
 */

  public static  final File    LIBS_DIR  ;

/**
 * The possible names of the java executables.
 */

  private static  final String[]  JVM_NAMES =
    {
    "wjview.exe",
    "jview.exe",
    "jrew.exe",
    "jre.exe",
    "java.exe",
    "jre",
    "java"
    };

/**
 * Possible locations for the jvm relative to the search paths.
 */

  private static  final String[]  JVM_LOCATIONS =
    {
    File.separator,
    ".." + File.separatorChar + "System32" + File.separatorChar,
    ".." + File.separatorChar,
    "bin" + File.separatorChar
    };


  static
    {

    int       l_i, l_j, l_k;
    String    l_s;
    File      l_f;
    File[]    l_search;

    l_s      = Typesafe.get_system_property("java.home");
    l_search = new File[3];

    if((l_s != null) && (l_s.length() > 0))
      {
      l_f = new File(l_s);
      }
    else
      {
      l_f = new File(".");
      }

    HOME_DIR = l_search[2] = canonicalize(l_f);

    l_s = Typesafe.get_system_property("user.dir");
    if((l_s == null) || (l_s.length() <= 0))
      {
      USER_DIR = HOME_DIR;
      }
    else
      {
      USER_DIR = l_search[1] = canonicalize(new File(l_s));
      }

    l_s = Typesafe.get_system_property("java.io.tmpdir");
    if((l_s == null) || (l_s.length() <= 0))
      {
      TEMP_DIR = USER_DIR;
      }
    else
      {
      TEMP_DIR = l_search[0] = canonicalize(new File(l_s));
      }

looper:
    for(l_i = (l_search.length-1); l_i >= 0; l_i--)
      {
      for(l_j = 0; l_j < JVM_LOCATIONS.length; l_j++)
        {
        for(l_k = 0; l_k < JVM_NAMES.length; l_k++)
          {
          l_f = new File(l_search[l_i],
                         JVM_LOCATIONS[l_j] + JVM_NAMES[l_k]);
          if(l_f.exists() && l_f.isFile())
            {
            break looper;
            }
          }
        }
      }

    JVM = canonicalize((l_f != null) ? l_f : new File("java"));

    LIBS_DIR = canonicalize(new File(USER_DIR, "libs"));
    }

/**
 * The jar suffix.
 */

  private static  final String  JAR_SUFFIX = ".jar";

/**
 * The hidden constructor prevents anyone from instantiating this class.
 */

  private Files()
    {
    Typesafe.do_not_call();
    }
  
/**
 * Canonicalize a file so it is unique in this system.
 *
 * @param p_file  The file to canonicalize.
 *
 * @return  The canonicalized file.
 */

  public  static  final File  canonicalize (File p_file)
    {
    if(p_file instanceof CanonicalFile) return p_file;
    return new CanonicalFile(p_file);
    }

/**
 * Append a filename to a string builder.
 * @param p_file    The file to append the filename of.
 * @param p_builder The string builder to append the file's name to.
 */

  public  static  final void  append_file (final String         p_file,
                                           final StringBuilder  p_builder)
    {
    if(File.separatorChar == '\\')
      {
      p_builder.append('
"');
      }
    
    p_builder.append(p_file);
    
    if(File.separatorChar == '\\')
      {
      p_builder.append('"
');
      }
    }
  
/**
 * Append a filename to a string builder.
 * @param p_file    The file to append the filename of.
 * @param p_builder The string builder to append the file's name to.
 */

  public  static  final void  append_file (final File           p_file,
                                           final StringBuilder  p_builder)
    {
    append_file(p_file.toString(), p_builder);
    }
  
/**
 * Deletes a file, regardless if it is a directory or not.
 *
 * @param p_file  The file to be deleted.
 */

  public  static  final void  delete       (final  File p_file)
    {
    File[]  l_f;
    int     l_i;

    if(p_file != null)
      {
      try
        {
        if(p_file.isDirectory())
          {
          l_f = p_file.listFiles();

          if(l_f != null)
            {
            for(l_i = (l_f.length-1); l_i >= 0; l_i--)
              {
              delete(l_f[l_i]);
              }
            }
          }

        p_file.delete();
        }
      catch(Throwable l_t)
        {
        //
        }
      }
    }


/**
 * Create a new instance of the java virtual machine.
 * @param p_class The name of the class-file to be run.
 * @param p_jars        A list with other jar-files used by the main class.
 * @param p_additional  A set of additional jvm parameters.
 * @return  The new process.
 * @throws  IOException If something goes maaadly wrong  
 */

  public static final Process exec_jvm 
                              (final  File                    p_class,
                               final  List<? extends File>    p_jars,
                               final  List<? extends String>  p_additional)
  throws IOException
    {
    String        l_c;
    int           l_i;
    StringBuilder l_sb;
    
    l_sb = new StringBuilder();
    append_file(JVM, l_sb);
    l_sb.append(' ');
    
    if(p_additional != null) 
      {
      for(l_i = (p_additional.size()-1); l_i >= 0; l_i--)
        {
        l_sb.append(p_additional.get(l_i));
        l_sb.append(' ');
        }
      }
    
    if( (p_jars != null) && ((l_i = p_jars.size()) > 0) )
      {      
      l_sb.append("-classpath ");
      for(--l_i; l_i > 0; l_i--)
        {
        append_file(p_jars.get(l_i), l_sb);
        l_sb.append(';');
        }
      append_file(p_jars.get(l_i).toString(), l_sb);
      l_sb.append(' ');
      }
    
    l_c   = p_class.toString();
    l_i   = l_c.lastIndexOf('.');
    
    if(l_i >= 0)
      {
      if(l_c.substring(l_i).equalsIgnoreCase(JAR_SUFFIX))
        {
        l_sb.append("-jar ");
        append_file(l_c, l_sb);
        }
      else
        {
        append_file(l_c.substring(0, l_i), l_sb);
        }
      }
    else append_file(l_c, l_sb);
  
    return Runtime.getRuntime().exec(l_sb.toString());
    }
  
/**
 * Returns all the .jar-archives in a directory as easy to use
 * <code>List</code>.
 *
 * @param p_start     The starting file or directory, all .jar-archives
 *                    contained in it will be listed.
 * @param p_recursive <code>true</code> if and only if sub-directories of
 *                    <code>p_start</code> should also be parsed.
 * @return  A <code>List</code>-instance containing all the .jar-archives
 *          residing in <code>p_start</code>.
 */

  public  static  final List<File> get_jars  (File     p_start,
                                      boolean  p_recursive)
    {
    List<File>  l_l;

    l_l = Collections.create_list(0);
    if(p_start != null)
      {
      p_start = canonicalize(p_start);
      if(p_start.exists())
        {
        find_jars(canonicalize(p_start), l_l, p_recursive);
        }
      }
    return l_l;
    }

    
/**
 * Adds all the .jar-archives in a directory to an easy to use
 * <code>List</code>.
 *
 * @param p_start     The starting file or directory, all .jar-archives
 *                    contained in it will be listed.
 * @param p_recursive <code>true</code> if and only if sub-directories of
 *                    <code>p_start</code> should also be parsed.
 * @param p_list      A <code>List</code>-instance containing all the
 *                   .jar-archives residing in <code>p_start</code>.
 */

  private static  final void  find_jars (File           p_start,
                                 List<File>     p_list,
                                 boolean        p_recursive)
    {
    File[]  l_f;
    int     l_i;

    if(p_start.isFile())
      {
      if(p_start.getPath().toLowerCase().endsWith(JAR_SUFFIX))
        {
        p_list.add(canonicalize(p_start));
        }
      }
    else
      {
      if(p_recursive && (p_start.isDirectory()))
        {
        l_f = p_start.listFiles();

        if(l_f != null)
          {
          for(l_i = (l_f.length-1); l_i >= 0; l_i--)
            {
            find_jars(l_f[l_i], p_list, p_recursive);
            }
          }
        }
      }
    }

  
/**
 * This class is a tag to find out if a file is canonical or not.
 *
 * @author Thomas Weise
 */

  private static  final class CanonicalFile extends     File
    {
/**
 * The serial version uid.
 */

    private static final long serialVersionUID = 1;
/**
 * Create a canonical file by canonicalizing a normal file.
 *
 * @param p_file  The file to canonicalize.
 */

    CanonicalFile (final  File p_file)
      {
      this((AccessController.doPrivileged(new Canonicalizer(p_file))));
      }

/**
 * Create a canonical file by specifying a canonical path.
 *
 * @param p_filename  The canonical path.
 */

    CanonicalFile (final  String p_filename)
      {
      super(p_filename);
      }

/**
 * Returns the abstract pathname of this abstract pathname's parent,
 * or <code>null</code> if this pathname does not name a parent
 * directory.
 *
 * <p> The <em>parent</em> of an abstract pathname consists of the
 * pathname's prefix, if any, and each name in the pathname's name
 * sequence except for the last.  If the name sequence is empty then
 * the pathname does not name a parent directory.
 *
 * @return  The abstract pathname of the parent directory named by this
 *          abstract pathname, or <code>null</code> if this pathname
 *          does not name a parent
 */

    @Override
    public  final File  getParentFile ()
      {
      String  l_s;

      l_s = getParent();
      return (l_s != null) ? new CanonicalFile(l_s) : null;
      }

/**
 * Returns the absolute form of this abstract pathname.  Equivalent to
 * <code>new&nbsp;File(this.{@link #getAbsolutePath}())</code>.
 *
 * @return  The absolute abstract pathname denoting the same file or
 *          directory as this abstract pathname
 */

    @Override
    public  final File  getAbsoluteFile()
      {
      return this;
      }

/**
 * Returns the canonical form of this abstract pathname.  Equivalent to
 * <code>new&nbsp;File(this.{@link #getCanonicalPath}())</code>.
 *
 * @return  The canonical pathname string denoting the same file or
 *          directory as this abstract pathname
 */

    @Override
    public  final File  getCanonicalFile()
      {
      return this;
      }

/**
 * Returns the absolute pathname string of this abstract pathname.
 *
 * <p> If this abstract pathname is already absolute, then the pathname
 * string is simply returned as if by the
 * <code>{@link java.io.File#getPath}</code> method.
 * If this abstract pathname is the empty abstract pathname then
 * the pathname string of the current user directory, which is named by the
 * system property <code>user.dir</code>, is returned.  Otherwise this
 * pathname is resolved in a system-dependent way.  On UNIX systems, a
 * relative pathname is made absolute by resolving it against the current
 * user directory.  On Microsoft Windows systems, a relative pathname is
 * made absolute by resolving it against the current directory of the drive
 * named by the pathname, if any; if not, it is resolved against the current
 * user directory.
 *
 * @return  The absolute pathname string denoting the same file or
 *          directory as this abstract pathname
 *
 * @see     java.io.File#isAbsolute()
 */

    @Override
    public  final String  getAbsolutePath()
      {
      return getPath();
      }

/**
 * Returns the canonical pathname string of this abstract pathname.
 *
 * <p> A canonical pathname is both absolute and unique.  The precise
 * definition of canonical form is system-dependent.  This method first
 * converts this pathname to absolute form if necessary, as if by invoking the
 * {@link #getAbsolutePath} method, and then maps it to its unique form in a
 * system-dependent way.  This typically involves removing redundant names
 * such as <tt>"."</tt> and <tt>".."</tt> from the pathname, resolving
 * symbolic links (on UNIX platforms), and converting drive letters to a
 * standard case (on Microsoft Windows platforms).
 *
 * <p> Every pathname that denotes an existing file or directory has a
 * unique canonical form.  Every pathname that denotes a nonexistent file
 * or directory also has a unique canonical form.  The canonical form of
 * the pathname of a nonexistent file or directory may be different from
 * the canonical form of the same pathname after the file or directory is
 * created.  Similarly, the canonical form of the pathname of an existing
 * file or directory may be different from the canonical form of the same
 * pathname after the file or directory is deleted.
 *
 * @return  The canonical pathname string denoting the same file or
 *          directory as this abstract pathname
 */

    @Override
    public  final String  getCanonicalPath()
      {
      return getPath();
      }

/**
 * Tests whether this abstract pathname is absolute.  The definition of
 * absolute pathname is system dependent.  On UNIX systems, a pathname is
 * absolute if its prefix is <code>"/"</code>.  On Microsoft Windows
 * systems, a pathname is absolute if its prefix is a drive specifier
 * followed by <code>"\\"</code>, or if its prefix is <code>"\\\\"</code>.
 *
 * @return  <code>true</code> if this abstract pathname is absolute,
 *          <code>false</code> otherwise
 */

    @Override
    public  final boolean isAbsolute  ()
      {
      return true;
      }

/**
 * This small private class helps to canonicalize a file by tunnelling this
 * operation through a <code>PrivilegedAction</code>.
 *
 * @author Thomas Weise
 */

    private static  final class       Canonicalizer
                          implements  PrivilegedAction<String>
      {
/**
 * The file to canonicalize.
 */

      private final File  m_file  ;

/**
 * The constructor of the canonicalizer.
 *
 * @param p_file  The to be canonicalized.
 */

      private Canonicalizer (final  File p_file)
        {
        super();
        this.m_file = p_file;
        }

/**
 * Perform the canonicalization.
 *
 * @return The canonicalized file.
 */

      public  final String  run ()
        {
        try
          {
          return this.m_file.getCanonicalPath();
          }
        catch(IOException l_io)
          {
          return null;
          }
        }
      }
    }
  }

File Information:

file name:Files.java
package:org.sfc.io
qualified name:org.sfc.io.Files.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/io/Files.java
size:16.197 KB (16586 B)
uploaded: 2018-01-07 12:03:36 GMT+0000
last update: 2006-07-24 03:39:34 GMT+0000
last access: 2018-04-25 06:41:53 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2018-01-07 12:03:34 GMT+0000 served at 2018-04-25 06:41:53 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo