home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / Main.bin / FileSystem.java < prev    next >
Encoding:
Java Source  |  1998-10-30  |  11.8 KB  |  500 lines
  1. package com.symantec.itools.io;
  2.  
  3.  
  4. import java.io.BufferedInputStream;
  5. import java.io.BufferedOutputStream;
  6. import java.io.File;
  7. import java.io.FileInputStream;
  8. import java.io.FileOutputStream;
  9. import java.io.IOException;
  10. import java.util.StringTokenizer;
  11. import java.util.Vector;
  12. import com.symantec.itools.lang.IllegalInstantiationError;
  13. import com.symantec.itools.lang.AccessiblePlatform;
  14. import com.symantec.itools.lang.Platform;
  15. import com.symantec.itools.lang.StringUtils;
  16. import com.symantec.itools.util.Properties;
  17.  
  18.  
  19. /**
  20.  * @author Symantec Internet Tools Division
  21.  * @version 1.0
  22.  * @since VCafe 3.0
  23.  */
  24.  
  25. public class FileSystem
  26. {
  27.  
  28.     /**
  29.      * @since VCafe 3.0
  30.      */
  31.     protected static boolean isCaseSensitive;
  32.  
  33.     // load the properties file
  34.     static
  35.     {
  36.         try
  37.         {
  38.             Properties properties;
  39.  
  40.             properties      = new Properties("/com/symantec/itools/io/FileSystem.properties");
  41.             isCaseSensitive = lookupCaseSensitive(properties.getStringList("casesensitive.true"));
  42.         }
  43.         catch(Throwable ex)
  44.         {
  45.             ex.printStackTrace();
  46.         }
  47.     }
  48.  
  49.     protected FileSystem()
  50.     {
  51.         throw new IllegalInstantiationError(FileSystem.class);
  52.     }
  53.  
  54.     /**
  55.      * @since VCafe 3.0
  56.      */
  57.  
  58.     public static boolean isCaseSensitive()
  59.     {
  60.         return (isCaseSensitive);
  61.     }
  62.  
  63.     /**
  64.      * @param fileName TODO
  65.      * @param keepCase TODO
  66.      * @since VCafe 3.0
  67.      */
  68.  
  69.     public static String getCanonicalPath(String fileName, boolean keepCase)
  70.     {
  71.         return (getCanonicalPath(new File(fileName), keepCase));
  72.     }
  73.  
  74.     /**
  75.      * @param fileName TODO
  76.      * @param keepCase TODO
  77.      * @param isDir TODO
  78.      * @since VCafe 3.0
  79.      */
  80.  
  81.     public static String getCanonicalPath(String fileName, boolean keepCase, boolean isDir)
  82.     {
  83.         return (getCanonicalPath(new File(fileName), keepCase, isDir));
  84.     }
  85.  
  86.     /**
  87.      * @param file TODO
  88.      * @param keepCase TODO
  89.      * @since VCafe 3.0
  90.      */
  91.  
  92.     public static String getCanonicalPath(File file, boolean keepCase)
  93.     {
  94.         return (getCanonicalPath(file, keepCase, true));
  95.     }
  96.  
  97.     /**
  98.      * @param file TODO
  99.      * @param keepCase TODO
  100.      * @param isDir TODO
  101.      * @since VCafe 3.0
  102.      */
  103.  
  104.     public static String getCanonicalPath(File file, boolean keepCase, boolean isDir)
  105.     {
  106.         String  fileName;
  107.         boolean ensureSeparator;
  108.  
  109.         try
  110.         {
  111.             String path;
  112.             
  113.             path = file.getPath();
  114.             
  115.             if(path.startsWith("\""))
  116.             {
  117.                 path = path.substring(1);
  118.             }
  119.             
  120.             if(path.endsWith("\""))
  121.             {
  122.                 path = path.substring(0, path.length() - 1);
  123.             }
  124.             
  125.             fileName = new File(path).getCanonicalPath();
  126.         }
  127.         catch(IOException ex)
  128.         {
  129.             fileName = file.getAbsolutePath();
  130.         }
  131.  
  132.         if(!(isCaseSensitive))
  133.         {
  134.             if(Platform.isOSType(Platform.OS_TYPE_WINDOWS) && keepCase)
  135.             {
  136.                 String dir;
  137.  
  138.                 dir      = fileName.substring(0, 1).toLowerCase();
  139.                 fileName = dir + fileName.substring(1, fileName.length());
  140.             }
  141.             else
  142.             {
  143.                 fileName = fileName.toLowerCase();
  144.             }
  145.         }
  146.  
  147.         ensureSeparator = false;
  148.  
  149.         if(!(file.exists()))
  150.         {
  151.             if(isDir)
  152.             {
  153.                 ensureSeparator= true;
  154.             }
  155.         }
  156.         else if(file.isDirectory() && !(fileName.endsWith(File.separator)))
  157.         {
  158.             ensureSeparator = true;
  159.         }
  160.  
  161.         if(ensureSeparator)
  162.         {
  163.             fileName += File.separator;
  164.         }
  165.  
  166.         return (fileName);
  167.     }
  168.  
  169.     /**
  170.      * @since VCafe 3.0
  171.      */
  172.  
  173.     public static String getCurrentDirectory()
  174.     {
  175.         return (getCanonicalPath(new File("."), true));
  176.     }
  177.  
  178.     /**
  179.      * @param list TODO
  180.      * @since VCafe 3.0
  181.      */
  182.  
  183.     protected static boolean lookupCaseSensitive(String[] list)
  184.     {
  185.         String osType;
  186.  
  187.         osType = AccessiblePlatform.getOSType();
  188.  
  189.         if(osType == null)
  190.         {
  191.             // assume case sensitive
  192.             return (true);
  193.         }
  194.  
  195.         for(int i = 0; i < list.length; i++)
  196.         {
  197.             if(osType.equals(list[i]))
  198.             {
  199.                 return (true);
  200.             }
  201.         }
  202.  
  203.         return (false);
  204.     }
  205.  
  206.     /**
  207.      * @param path TODO
  208.      * @since VCafe 3.0
  209.      */
  210.  
  211.     public static String[] getPath(String path)
  212.     {
  213.         return (getPath(path, false));
  214.     }
  215.  
  216.     /**
  217.      * @param path TODO
  218.      * @param allowFiles TODO
  219.      * @since VCafe 3.0
  220.      */
  221.  
  222.     public static String[] getPath(String path, boolean allowFiles)
  223.     {
  224.         StringTokenizer tokenizer;
  225.         String[]        actualPath;
  226.         Vector          list;
  227.  
  228.         tokenizer = new StringTokenizer(path, File.pathSeparator);
  229.         list      = new Vector();
  230.  
  231.         while(tokenizer.hasMoreTokens())
  232.         {
  233.             String entry;
  234.  
  235.             entry = FileSystem.getCanonicalPath(tokenizer.nextToken(), true);
  236.  
  237.             if(!(list.contains(entry)))
  238.             {
  239.                 File file;
  240.  
  241.                 file = new File(entry);
  242.  
  243.                 // is it on the disk?
  244.                 if(file.exists())
  245.                 {
  246.                     // is it a directory or are we allowing files?
  247.                     if(allowFiles || !(allowFiles) && file.isDirectory())
  248.                     {
  249.                         list.addElement(entry);
  250.                     }
  251.                 }
  252.                 // doesn't exist so doesn't matter if it is file.
  253.                 else
  254.                 {
  255.                     list.addElement(entry);
  256.                 }
  257.             }
  258.         }
  259.  
  260.         actualPath = new String[list.size()];
  261.         list.copyInto(actualPath);
  262.  
  263.         return (actualPath);
  264.     }
  265.  
  266.     /**
  267.      * @param path TODO
  268.      * @since VCafe 3.0
  269.      */
  270.  
  271.     public static String[] getValidPath(String path)
  272.     {
  273.         return (getValidPath(path, false));
  274.     }
  275.  
  276.     /**
  277.      * @param path TODO
  278.      * @param allowFiles TODO
  279.      * @since VCafe 3.0
  280.      */
  281.  
  282.     public static String[] getValidPath(String path, boolean allowFiles)
  283.     {
  284.         StringTokenizer tokenizer;
  285.         String[]        validPath;
  286.         Vector          list;
  287.  
  288.         tokenizer = new StringTokenizer(path, File.pathSeparator);
  289.         list      = new Vector();
  290.  
  291.         while(tokenizer.hasMoreTokens())
  292.         {
  293.                 String entry;
  294.  
  295.                 entry = FileSystem.getCanonicalPath(tokenizer.nextToken(), true);
  296.  
  297.                 if(!(list.contains(entry)))
  298.                 {
  299.                     File file;
  300.  
  301.                     file = new File(entry);
  302.  
  303.                     // is it on the disk?
  304.                     if(file.exists())
  305.                     {
  306.                         // is it a directory or are we allowing files?
  307.                         if(allowFiles || !(allowFiles) && file.isDirectory())
  308.                         {
  309.                             list.addElement(entry);
  310.                         }
  311.                     }
  312.                 }
  313.             }
  314.  
  315.             validPath = new String[list.size()];
  316.             list.copyInto(validPath);
  317.  
  318.             return (validPath);
  319.         }
  320.  
  321.     /**
  322.      * @param name1 TODO
  323.      * @param name2 TODO
  324.      * @since VCafe 3.0
  325.      */
  326.  
  327.     public static boolean compareFilenames(String name1, String name2)
  328.     {
  329.         if(isCaseSensitive)
  330.         {
  331.             return (name1.equals(name2));
  332.         }
  333.  
  334.         return (name1.equalsIgnoreCase(name2));
  335.     }
  336.     
  337.     public static boolean compareFilenames(File file1, File file2)
  338.     {
  339.         return (compareFilenames(getCanonicalPath(file1, true),
  340.                                  getCanonicalPath(file2, true)));
  341.     }
  342.  
  343.     /**
  344.      * @param fileName TODO
  345.      * @param directory TODO
  346.      * @since VCafe 3.0
  347.      */
  348.  
  349.     public static boolean isInPath(String fileName, String directory)
  350.     {
  351.         String dir;
  352.  
  353.         fileName = FileSystem.getCanonicalPath(fileName, true);
  354.  
  355.         dir = fileName.substring(0, fileName.lastIndexOf(File.separatorChar)+1);
  356.  
  357.         if(isCaseSensitive)
  358.         {
  359.             return (dir.startsWith(directory));
  360.         }
  361.  
  362.         return (StringUtils.startsWithIgnoreCase(dir, directory));
  363.     }
  364.  
  365.     /**
  366.      * @param fileName TODO
  367.      * @since VCafe 3.0
  368.      */
  369.  
  370.     public static String quoteIfNeeded(String fileName)
  371.     {
  372.         // NOTE: is this OS specific?  If so we need to do this different!
  373.  
  374.         // does it have a space
  375.         if(fileName.indexOf(' ') != -1)
  376.         {
  377.             // make sure that we wrap the filename in spaces
  378.             if(!(fileName.startsWith("\"")))
  379.             {
  380.                 fileName = "\"" + fileName;
  381.             }
  382.  
  383.             if(!(fileName.endsWith("\"")))
  384.             {
  385.                 fileName += "\"";
  386.             }
  387.         }
  388.         else
  389.         {
  390.             // make sure the file name has no spaces
  391.             if(fileName.startsWith("\""))
  392.             {
  393.                 fileName = fileName.substring(1);
  394.             }
  395.  
  396.             if(fileName.endsWith("\""))
  397.             {
  398.                 fileName = fileName.substring(0, fileName.length() - 1);
  399.             }
  400.         }
  401.  
  402.         return (fileName);
  403.     }
  404.  
  405.     /**
  406.      * @param fileName TODO
  407.      * @since VCafe 3.0
  408.      */
  409.  
  410.     public static String quote(String fileName)
  411.     {
  412.         // NOTE: is this OS specific?  If so we need to do this different!
  413.  
  414.         // make sure that we wrap the filename in spaces
  415.         if(!(fileName.startsWith("\"")))
  416.         {
  417.             fileName = "\"" + fileName;
  418.         }
  419.  
  420.         if(!(fileName.endsWith("\"")))
  421.         {
  422.             fileName += "\"";
  423.         }
  424.  
  425.         return (fileName);
  426.     }
  427.  
  428.     public static boolean copyFile(File source, File target)
  429.         throws IOException
  430.     {
  431.         BufferedInputStream  streamIn;
  432.         BufferedOutputStream streamOut;
  433.         File                 targetDir;
  434.  
  435.         if(!(source.exists()))
  436.         {
  437.             throw new IOException(getCanonicalPath(source, true) + " does not exist");
  438.         }
  439.  
  440.         targetDir = new File(target.getParent());
  441.         
  442.         // don't bother copying over the same file!
  443.         if(compareFilenames(source, target))
  444.         {
  445.             return (true);
  446.         }
  447.     
  448.         if(!(targetDir.exists()))
  449.         {
  450.             if(!(targetDir.mkdirs()))
  451.             {
  452.                 throw new IOException("Can't create " + target.getParent());
  453.             }
  454.         }
  455.  
  456.         streamIn  = null;
  457.         streamOut = null;
  458.         
  459.         try
  460.         {
  461.             byte[] buf;
  462.             int    count;
  463.  
  464.             streamIn  = new BufferedInputStream(new FileInputStream(source));
  465.             streamOut = new BufferedOutputStream(new FileOutputStream(target));
  466.             buf       = new byte[1024];
  467.  
  468.             while((count = streamIn.read(buf)) > 0)
  469.             {
  470.                 streamOut.write(buf, 0, count);
  471.             }
  472.         }
  473.         finally
  474.         {
  475.             if(streamIn != null)
  476.             {
  477.                 try
  478.                 {
  479.                     streamIn.close();
  480.                 }
  481.                 catch(IOException ex)
  482.                 {
  483.                 }
  484.             }
  485.  
  486.             if(streamOut != null)
  487.             {
  488.                 try
  489.                 {
  490.                     streamOut.close();
  491.                 }
  492.                 catch(IOException ex)
  493.                 {
  494.                 }
  495.             }
  496.         }
  497.  
  498.         return (true);
  499.     }
  500. }