| gvSIG desktop 1

package org.gvsig.remoteClient.utils;

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

*

* Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program 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 for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

*

* For more information, contact:

*

*  Generalitat Valenciana

*   Conselleria d'Infraestructures i Transport

*   Av. Blasco Ib??ez, 50

*   46010 VALENCIA

*   SPAIN

*

*      +34 963862235

*   gvsig@gva.es

*      www.gvsig.gva.es

*

*    or

*

*   IVER T.I. S.A

*   Salamanca 50

*   46005 Valencia

*   Spain

*

*   +34 963163400

*   dac@iver.es

*/

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URL;

import java.rmi.NoSuchObjectException;

import java.util.Hashtable;

import java.util.StringTokenizer;

import java.util.Vector;

/**

* Clase con m?todos de utilidad en el protocolo WMS

*

* @authors Laura D?az, jaume dominguez faus

*/

public class Utilities {

    private static String characters;

    /**

     * <b>key</b>: URL, <b>value</b>: path to the downloaded file.

     */

    private static Hashtable downloadedFiles;

    static {

        characters = "";

        for (int j = 32; j<=127; j++){

            characters += (char) j;

        }

        characters += "?????????????????????????????????????????????????\n\r\f\t";

    }

    /**

     * Checks a File and tries to figure if the file is a text or a binary file.<br>

     * Keep in mind that binary files are those that contains at least one

     * non-printable character.

     * 

     * @param file

     * @return <b>true</b> when the file is <b>pretty problably</b> text, 

     * <b>false</b> if the file <b>is</b> binary.

     */

    public static boolean isTextFile(File file){

        return isTextFile(file, 1024);

    }

     /**

     * Checks a File and tries to figure if the file is a text or a binary file.<br>

     * Keep in mind that binary files are those that contains at least one

     * non-printable character. 

     * 

     * @param file

     * @param byteAmount, number of bytes to check.

     * @return <b>true</b> when the file is <b>pretty problably</b> text, 

     * <b>false</b> if the file <b>is</b> binary.

     */

    public static boolean isTextFile(File file, int byteAmount){

        int umbral = byteAmount; 

        try {

            FileReader fr = new FileReader(file);

            for (int i = 0; i < umbral; i++) {

                int c = fr.read();

                if (c==-1){

                    // End of file. If we reach this

                    // everything before is printable data.

                    return true;

                }

                char ch = (char) c;

                if (characters.indexOf(ch)==-1){

                    // We've found a non-printable character.

                    // Then we'll assume that this file is binary.

                    return false;

                }

            }

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        }

        return true;

    }

    /**

     * Checks a byte array and tells if it contains only text or contains

     * any binary data.

     * 

     * @param file

     * @return <b>true</b> when the data is <b>only</b> text, <b>false</b> otherwise.

     */

    public static boolean isTextData(byte[] data){

        char[] charData = new char[data.length];

        for (int i = 0; i<data.length; i++){

            charData[i] = (char) data[i];

        }

        for (int i = 0; i < data.length; i++) {

            int c = charData[i];

            if (c==-1){

                // End of file. If we reach this

                // everything before is printable data.

                return true;

            }

            char ch = (char) c;

            if (characters.indexOf(ch)==-1){

                // We've found a non-printable character.

                // Then we'll assume that this file is binary.

                return false;

            }

        }

        return true;

    }

    /**

     * Returns the content of this URL as a file from the file system.<br>

     * <p>

     * If the URL has been already downloaded in this session and notified 

     * to the system using the static <b>Utilities.addDownloadedURL(URL)</b>

     * method, it can be restored faster from the file system avoiding to

     * download it again.

     * </p>

     * @param url

     * @return File containing this URL's content or null if no file was found.

     */

    public static File getPreviousDownloadedURL(URL url){

        File f = null;

        if (downloadedFiles!=null && downloadedFiles.containsKey(url)){

            String filePath = (String) downloadedFiles.get(url);

            f = new File(filePath);

        }

        return f;

    }

    /**

     * Adds an URL to the table of downloaded files for further uses. If the URL

     * already exists in the table its filePath value is updated to the new one and

     * the old file itself is removed from the file system.

     * 

     * @param url

     * @param filePath

     */

    public static void addDownloadedURL(URL url, String filePath){

        if (downloadedFiles==null)

            downloadedFiles = new Hashtable();

        String fileName = (String) downloadedFiles.put(url, filePath);

        if (fileName!=null){

            File f = new File(fileName);

            if (f.exists())

                f.delete();

        }

    }

    /**

     * Remove an URL to the table of downloaded files. Once removed, the system

     * will not be able to restore the URL from the file system.

     * @param url

     * @return the value of this entry in the table of downloaded files just

     * before it is removed.

     */

    public static String removeDownloadedURL(URL url){

        if (downloadedFiles!=null){

            return (String) downloadedFiles.remove(url);

        }

        return null;

    }

    /**

    * Copia el contenido de un InputStream en un OutputStream

    *

    * @param in InputStream

    * @param out OutputStream

    */

   public static void serializar(InputStream in, OutputStream out) {

       byte[] buffer = new byte[102400];

       int n;

       try {

           while ((n = in.read(buffer)) != -1) {

               out.write(buffer, 0, n);

           }

       } catch (IOException e) {

           e.printStackTrace();

       }

   }

   /**

    * Elimina del xml la declaraci?n del DTD

    *

    * @param bytes bytes del fichero XML de respuesta a getCapabilities

    * @param startTag Tag raiz del xml respuesta a getCapabilities

    *

    * @return bytes del fichero XML sin la declaraci?n del DTD

    */

   public static byte[] eliminarDTD(byte[] bytes, String startTag) {

       String text = new String(bytes);

       int index1 = text.indexOf("?>") + 2;

       int index2;

       try {

           index2 = findBeginIndex(bytes, startTag);

       } catch (NoSuchObjectException e) {

           return bytes;

       }

       byte[] buffer = new byte[bytes.length - (index2 - index1)];

       System.arraycopy(bytes, 0, buffer, 0, index1);

       System.arraycopy(bytes, index2, buffer, index1, bytes.length - index2);

       return buffer;

   }

   /**

    * Obtiene el ?ndice del comienzo del xml

    *

    * @param bytes bytes del fichero XML en el que se busca

    * @param tagRaiz Tag raiz del xml respuesta a getCapabilities

    *

    * @return ?ndice donde empieza el tag raiz

    *

    * @throws NoSuchObjectException Si no se encuentra el tag

    */

   private static int findBeginIndex(byte[] bytes, String tagRaiz)

       throws NoSuchObjectException {

       try {

           int nodo = 0;

           int ret = -1;

           int i = 0;

           while (true) {

               switch (nodo) {

                   case 0:

                       if (bytes[i] == '<') {

                           ret = i;

                           nodo = 1;

                       }

                       break;

                   case 1:

                       if (bytes[i] == ' ') {

                       } else if (bytes[i] == tagRaiz.charAt(0)) {

                           nodo = 2;

                       } else {

                           nodo = 0;

                       }

                       break;

                   case 2:

                       String aux = new String(bytes, i, 18);

                       if (aux.equalsIgnoreCase(tagRaiz.substring(1))) {

                           return ret;

                       }

                       nodo = 0;

                       break;

               }

               i++;

           }

       } catch (Exception e) {

           throw new NoSuchObjectException("No se pudo parsear el xml");

       }

   }

   /**

    * Converts the contents of a Vector to a comma separated list

    * 

    * */

   public static String Vector2CS(Vector v)

   {

           String str = new String();

           int i;

           for (i=0; i<v.size() ;i++)

           {

                   str = str + v.elementAt(i);

                   if (i<v.size()-1)

                           str = str + ",";

           }

           return str;

   }

        public static boolean isValidVersion(String version)

        {

         if(version.trim().length() == 5)

          {

                if ( (version.charAt(1)=='.') && (version.charAt(3)=='.'))

                {

                  char x = version.charAt(0);

                  char y = version.charAt(2);

                  char z = version.charAt(4);

                  if ((Character.isDigit(x)) && (Character.isDigit(y)) && (Character.isDigit(z)))

                  {

                        return true;

                  }

                  else

                  {

                        return false;

                  }

                }

                else

                {

                  return false;

                }

          }

          else

          {

                return false;

          }

        }

   /**

    * Checks if a String is a number or not

    * 

    * @param String, s

    * @return boolean, true if s is a number

    */

   public static boolean isNumber(String s) 

    {

           try

           {

                   double d = Double.parseDouble(s);

                   return true;

           }

           catch(NumberFormatException e)

           {

                   return false;

           }

//      int pointCount = 0;

//      int commaCount = 0;

//      

//      char[] c = s.toCharArray();

//      for (int i = c.length; --i >= 0; ) 

//      {

//        char cc = c[i];

//

//        if (Character.isDigit(cc))

//        {

//          continue;

//        }

//        else

//        {

//          /* 'cc' is not a digit. */

//

//          if (cc == '.')

//          {

//            pointCount++;

//            if (pointCount > 1)

//            {

//              return false;

//            }

//          }

//          else if (cc == ',')

//          {

//            commaCount++;

//            if (commaCount > 1)

//            {

//              return false;

//            }

//          }

//          else if (cc != '-')

//          {

//            return false;

//          }

//        }

//      }

//      return true;

    }   

        /**

         * Parses the String containing different items [character] separated and

         * creates a vector with them.

         * @param str String contains item1[c]item2[c]item3...

         * @param c is the string value for separating the items

         * @return Vector containing all the items

         */

        public static Vector createVector(String str, String c)

        {

                StringTokenizer tokens = new StringTokenizer(str, c);

                Vector v = new Vector();

                try

                {

                        while (tokens.hasMoreTokens())

                        {

                                v.addElement(tokens.nextToken());

                        }

                        return v;

                }

                catch (Exception e)

                {

                        return new Vector();

                }

        }

}