    001    package org.maltparser.core.helper;
    002
    003
    004    import java.io.BufferedInputStream;
    005    import java.io.BufferedOutputStream;
    006    import java.io.Closeable;
    007    import java.io.FileInputStream;
    008    import java.io.FileNotFoundException;
    009    import java.io.FileOutputStream;
    010    import java.io.IOException;
    011
    012    import org.apache.log4j.Logger;
    013    import org.maltparser.core.exception.MaltChainedException;
    014
    015    /**
    016    *
    017    *
    018    * @author Johan Hall
    019    */
    020    public class Util {
    021              private static final int BUFFER = 4096;
    022              private static final char AMP_CHAR = '&';
    023              private static final char LT_CHAR = '<';
    024              private static final char GT_CHAR = '>';
    025              private static final char QUOT_CHAR = '"';
    026              private static final char APOS_CHAR = '\'';
    027
    028              public static String xmlEscape(String str) {
    029                      boolean needEscape = false;
    030                      char c;
    031                      for (int i = 0; i < str.length(); i++) {
    032                              c = str.charAt(i);
    033                              if (c == AMP_CHAR || c == LT_CHAR || c == GT_CHAR || c == QUOT_CHAR || c == APOS_CHAR) {
    034                                      needEscape = true;
    035                                      break;
    036                              }
    037                      }
    038                      if (!needEscape) {
    039                              return str;
    040                      }
    041                      final StringBuilder sb = new StringBuilder();
    042                      for (int i = 0; i < str.length(); i++) {
    043                              c = str.charAt(i);
    044                              if (str.charAt(i) == AMP_CHAR) {
    045                                      sb.append("&amp;");
    046                              } else if ( str.charAt(i) == LT_CHAR) {
    047                                      sb.append("&lt;");
    048                              } else if (str.charAt(i) == GT_CHAR) {
    049                                      sb.append("&gt;");
    050                              } else if (str.charAt(i) == QUOT_CHAR) {
    051                                      sb.append("&quot;");
    052                              } else if (str.charAt(i) == APOS_CHAR) {
    053                                      sb.append("&apos;");
    054                              } else {
    055                                      sb.append(c);
    056                              }
    057                      }
    058                      return sb.toString();
    059              }
    060
    061            public static int simpleTicer(Logger logger, long startTime, int nTicxRow, int inTic, int subject) {
    062                    logger.info(".");
    063                    int tic = inTic + 1;
    064                    if (tic >= nTicxRow) {
    065                            ticInfo(logger, startTime, subject);
    066                            tic = 0;
    067                    }
    068                    return tic;
    069            }
    070
    071            public static void startTicer(Logger logger, long startTime, int nTicxRow, int subject) {
    072                    logger.info(".");
    073                    for (int i = 1; i <= nTicxRow; i++) {
    074                            logger.info(" ");
    075                    }
    076                    ticInfo(logger, startTime, subject);
    077            }
    078
    079            public static void endTicer(Logger logger, long startTime, int nTicxRow, int inTic, int subject) {
    080                    for (int i = inTic; i <= nTicxRow; i++) {
    081                            logger.info(" ");
    082                    }
    083                    ticInfo(logger, startTime, subject);
    084            }
    085
    086            private static void ticInfo(Logger logger, long startTime, int subject) {
    087                    logger.info("\t");
    088                    int a = 1000000;
    089                    if (subject != 0) {
    090                            while (subject/a == 0) {
    091                                    logger.info(" ");
    092                                    a /= 10;
    093                            }
    094                    } else {
    095                            logger.info("      ");
    096                    }
    097                    logger.info(subject);
    098                    logger.info("\t");
    099                    long time = (System.currentTimeMillis()-startTime)/1000;
    100                    a = 1000000;
    101                    if (time != 0) {
    102                            while (time/a == 0 ) {
    103                                    logger.info(" ");
    104                                    a /= 10;
    105                            }
    106                            logger.info(time);
    107                            logger.info("s");
    108                    } else {
    109                            logger.info("      0s");
    110                    }
    111                    logger.info("\t");
    112                    long memory =  (Runtime.getRuntime().totalMemory() -  Runtime.getRuntime().freeMemory())/1000000;
    113                    a = 1000000;
    114                    if (memory != 0) {
    115                            while (memory/a == 0 ) {
    116                                    logger.info(" ");
    117                                    a /= 10;
    118                            }
    119                            logger.info(memory);
    120                            logger.info("MB\n");
    121                    } else {
    122                            logger.info("      0MB\n");
    123                    }
    124            }
    125
    126            public static void copyfile(String source, String destination) throws MaltChainedException {
    127            try {
    128                    byte[] readBuffer = new byte[BUFFER];
    129                    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(source));
    130                    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destination), BUFFER);
    131                    int n = 0;
    132                        while ((n = bis.read(readBuffer, 0, BUFFER)) != -1) {
    133                            bos.write(readBuffer, 0, n);
    134                        }
    135                    bos.flush();
    136                    bos.close();
    137                    bis.close();
    138                    } catch (FileNotFoundException e) {
    139                            throw new MaltChainedException("The destination file '"+destination+"' cannot be created when coping the file. ", e);
    140                    } catch (IOException e) {
    141                            throw new MaltChainedException("The source file '"+source+"' cannot be copied to destination '"+destination+"'. ", e);
    142                    }
    143            }
    144
    145        /**
    146            * @param s the string to parse for the double value
    147            * @throws IllegalArgumentException if s is empty or represents NaN or Infinity
    148            * @throws NumberFormatException see {@link Double#parseDouble(String)}
    149            */
    150            public static double atof(String s) {
    151            if (s == null || s.length() < 1) throw new IllegalArgumentException("Can't convert empty string to integer");
    152            double d = Double.parseDouble(s);
    153            if (Double.isNaN(d) || Double.isInfinite(d)) {
    154                throw new IllegalArgumentException("NaN or Infinity in input: " + s);
    155            }
    156            return (d);
    157        }
    158
    159                /**
    160            * @param s the string to parse for the integer value
    161            * @throws IllegalArgumentException if s is empty
    162            * @throws NumberFormatException see {@link Integer#parseInt(String)}
    163            */
    164            public static int atoi(String s) throws NumberFormatException {
    165            if (s == null || s.length() < 1) throw new IllegalArgumentException("Can't convert empty string to integer");
    166            // Integer.parseInt doesn't accept '+' prefixed strings
    167            if (s.charAt(0) == '+') s = s.substring(1);
    168            return Integer.parseInt(s);
    169        }
    170
    171            public static void closeQuietly(Closeable c) {
    172            if (c == null) return;
    173            try {
    174                c.close();
    175            } catch (Throwable t) {}
    176        }
    177
    178        public static double[] copyOf(double[] original, int newLength) {
    179            double[] copy = new double[newLength];
    180            System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    181            return copy;
    182        }
    183
    184        public static int[] copyOf(int[] original, int newLength) {
    185            int[] copy = new int[newLength];
    186            System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    187            return copy;
    188        }
    189
    190        public static boolean equals(double[] a, double[] a2) {
    191            if (a == a2) return true;
    192            if (a == null || a2 == null) return false;
    193
    194            final int length = a.length;
    195            if (a2.length != length) return false;
    196
    197            for (int i = 0; i < length; i++)
    198                if (a[i] != a2[i]) return false;
    199
    200            return true;
    201        }
    202    }