Utils.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:14k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.record;
  19. import java.io.DataInput;
  20. import java.io.DataOutput;
  21. import java.io.IOException;
  22. import org.apache.hadoop.io.WritableComparator;
  23. import org.apache.hadoop.io.WritableUtils;
  24. /**
  25.  * Various utility functions for Hadooop record I/O runtime.
  26.  */
  27. public class Utils {
  28.   
  29.   /** Cannot create a new instance of Utils */
  30.   private Utils() {
  31.   }
  32.   
  33.   public static final char[] hexchars = { '0', '1', '2', '3', '4', '5',
  34.                                           '6', '7', '8', '9', 'A', 'B',
  35.                                           'C', 'D', 'E', 'F' };
  36.   /**
  37.    *
  38.    * @param s
  39.    * @return
  40.    */
  41.   static String toXMLString(String s) {
  42.     StringBuffer sb = new StringBuffer();
  43.     for (int idx = 0; idx < s.length(); idx++) {
  44.       char ch = s.charAt(idx);
  45.       if (ch == '<') {
  46.         sb.append("&lt;");
  47.       } else if (ch == '&') {
  48.         sb.append("&amp;");
  49.       } else if (ch == '%') {
  50.         sb.append("%0025");
  51.       } else if (ch < 0x20 ||
  52.                  (ch > 0xD7FF && ch < 0xE000) ||
  53.                  (ch > 0xFFFD)) {
  54.         sb.append("%");
  55.         sb.append(hexchars[(ch & 0xF000) >> 12]);
  56.         sb.append(hexchars[(ch & 0x0F00) >> 8]);
  57.         sb.append(hexchars[(ch & 0x00F0) >> 4]);
  58.         sb.append(hexchars[(ch & 0x000F)]);
  59.       } else {
  60.         sb.append(ch);
  61.       }
  62.     }
  63.     return sb.toString();
  64.   }
  65.   
  66.   static private int h2c(char ch) {
  67.     if (ch >= '0' && ch <= '9') {
  68.       return ch - '0';
  69.     } else if (ch >= 'A' && ch <= 'F') {
  70.       return ch - 'A' + 10;
  71.     } else if (ch >= 'a' && ch <= 'f') {
  72.       return ch - 'a' + 10;
  73.     }
  74.     return 0;
  75.   }
  76.   
  77.   /**
  78.    *
  79.    * @param s
  80.    * @return
  81.    */
  82.   static String fromXMLString(String s) {
  83.     StringBuffer sb = new StringBuffer();
  84.     for (int idx = 0; idx < s.length();) {
  85.       char ch = s.charAt(idx++);
  86.       if (ch == '%') {
  87.         int ch1 = h2c(s.charAt(idx++)) << 12;
  88.         int ch2 = h2c(s.charAt(idx++)) << 8;
  89.         int ch3 = h2c(s.charAt(idx++)) << 4;
  90.         int ch4 = h2c(s.charAt(idx++));
  91.         char res = (char)(ch1 | ch2 | ch3 | ch4);
  92.         sb.append(res);
  93.       } else {
  94.         sb.append(ch);
  95.       }
  96.     }
  97.     return sb.toString();
  98.   }
  99.   
  100.   /**
  101.    *
  102.    * @param s
  103.    * @return
  104.    */
  105.   static String toCSVString(String s) {
  106.     StringBuffer sb = new StringBuffer(s.length()+1);
  107.     sb.append(''');
  108.     int len = s.length();
  109.     for (int i = 0; i < len; i++) {
  110.       char c = s.charAt(i);
  111.       switch(c) {
  112.       case '':
  113.         sb.append("%00");
  114.         break;
  115.       case 'n':
  116.         sb.append("%0A");
  117.         break;
  118.       case 'r':
  119.         sb.append("%0D");
  120.         break;
  121.       case ',':
  122.         sb.append("%2C");
  123.         break;
  124.       case '}':
  125.         sb.append("%7D");
  126.         break;
  127.       case '%':
  128.         sb.append("%25");
  129.         break;
  130.       default:
  131.         sb.append(c);
  132.       }
  133.     }
  134.     return sb.toString();
  135.   }
  136.   
  137.   /**
  138.    *
  139.    * @param s
  140.    * @throws java.io.IOException
  141.    * @return
  142.    */
  143.   static String fromCSVString(String s) throws IOException {
  144.     if (s.charAt(0) != ''') {
  145.       throw new IOException("Error deserializing string.");
  146.     }
  147.     int len = s.length();
  148.     StringBuffer sb = new StringBuffer(len-1);
  149.     for (int i = 1; i < len; i++) {
  150.       char c = s.charAt(i);
  151.       if (c == '%') {
  152.         char ch1 = s.charAt(i+1);
  153.         char ch2 = s.charAt(i+2);
  154.         i += 2;
  155.         if (ch1 == '0' && ch2 == '0') {
  156.           sb.append('');
  157.         } else if (ch1 == '0' && ch2 == 'A') {
  158.           sb.append('n');
  159.         } else if (ch1 == '0' && ch2 == 'D') {
  160.           sb.append('r');
  161.         } else if (ch1 == '2' && ch2 == 'C') {
  162.           sb.append(',');
  163.         } else if (ch1 == '7' && ch2 == 'D') {
  164.           sb.append('}');
  165.         } else if (ch1 == '2' && ch2 == '5') {
  166.           sb.append('%');
  167.         } else {
  168.           throw new IOException("Error deserializing string.");
  169.         }
  170.       } else {
  171.         sb.append(c);
  172.       }
  173.     }
  174.     return sb.toString();
  175.   }
  176.   
  177.   /**
  178.    *
  179.    * @param s
  180.    * @return
  181.    */
  182.   static String toXMLBuffer(Buffer s) {
  183.     return s.toString();
  184.   }
  185.   
  186.   /**
  187.    *
  188.    * @param s
  189.    * @throws java.io.IOException
  190.    * @return
  191.    */
  192.   static Buffer fromXMLBuffer(String s)
  193.     throws IOException {
  194.     if (s.length() == 0) { return new Buffer(); }
  195.     int blen = s.length()/2;
  196.     byte[] barr = new byte[blen];
  197.     for (int idx = 0; idx < blen; idx++) {
  198.       char c1 = s.charAt(2*idx);
  199.       char c2 = s.charAt(2*idx+1);
  200.       barr[idx] = (byte)Integer.parseInt(""+c1+c2, 16);
  201.     }
  202.     return new Buffer(barr);
  203.   }
  204.   
  205.   /**
  206.    *
  207.    * @param buf
  208.    * @return
  209.    */
  210.   static String toCSVBuffer(Buffer buf) {
  211.     StringBuffer sb = new StringBuffer("#");
  212.     sb.append(buf.toString());
  213.     return sb.toString();
  214.   }
  215.   
  216.   /**
  217.    * Converts a CSV-serialized representation of buffer to a new
  218.    * Buffer
  219.    * @param s CSV-serialized representation of buffer
  220.    * @throws java.io.IOException
  221.    * @return Deserialized Buffer
  222.    */
  223.   static Buffer fromCSVBuffer(String s)
  224.     throws IOException {
  225.     if (s.charAt(0) != '#') {
  226.       throw new IOException("Error deserializing buffer.");
  227.     }
  228.     if (s.length() == 1) { return new Buffer(); }
  229.     int blen = (s.length()-1)/2;
  230.     byte[] barr = new byte[blen];
  231.     for (int idx = 0; idx < blen; idx++) {
  232.       char c1 = s.charAt(2*idx+1);
  233.       char c2 = s.charAt(2*idx+2);
  234.       barr[idx] = (byte)Integer.parseInt(""+c1+c2, 16);
  235.     }
  236.     return new Buffer(barr);
  237.   }
  238.   
  239.   private static int utf8LenForCodePoint(final int cpt) throws IOException {
  240.     if (cpt >=0 && cpt <= 0x7F) {
  241.       return 1;
  242.     }
  243.     if (cpt >= 0x80 && cpt <= 0x07FF) {
  244.       return 2;
  245.     }
  246.     if ((cpt >= 0x0800 && cpt < 0xD800) ||
  247.         (cpt > 0xDFFF && cpt <= 0xFFFD)) {
  248.       return 3;
  249.     }
  250.     if (cpt >= 0x10000 && cpt <= 0x10FFFF) {
  251.       return 4;
  252.     }
  253.     throw new IOException("Illegal Unicode Codepoint "+
  254.                           Integer.toHexString(cpt)+" in string.");
  255.   }
  256.   
  257.   private static final int B10 =    Integer.parseInt("10000000", 2);
  258.   private static final int B110 =   Integer.parseInt("11000000", 2);
  259.   private static final int B1110 =  Integer.parseInt("11100000", 2);
  260.   private static final int B11110 = Integer.parseInt("11110000", 2);
  261.   private static final int B11 =    Integer.parseInt("11000000", 2);
  262.   private static final int B111 =   Integer.parseInt("11100000", 2);
  263.   private static final int B1111 =  Integer.parseInt("11110000", 2);
  264.   private static final int B11111 = Integer.parseInt("11111000", 2);
  265.   
  266.   private static int writeUtf8(int cpt, final byte[] bytes, final int offset)
  267.     throws IOException {
  268.     if (cpt >=0 && cpt <= 0x7F) {
  269.       bytes[offset] = (byte) cpt;
  270.       return 1;
  271.     }
  272.     if (cpt >= 0x80 && cpt <= 0x07FF) {
  273.       bytes[offset+1] = (byte) (B10 | (cpt & 0x3F));
  274.       cpt = cpt >> 6;
  275.       bytes[offset] = (byte) (B110 | (cpt & 0x1F));
  276.       return 2;
  277.     }
  278.     if ((cpt >= 0x0800 && cpt < 0xD800) ||
  279.         (cpt > 0xDFFF && cpt <= 0xFFFD)) {
  280.       bytes[offset+2] = (byte) (B10 | (cpt & 0x3F));
  281.       cpt = cpt >> 6;
  282.       bytes[offset+1] = (byte) (B10 | (cpt & 0x3F));
  283.       cpt = cpt >> 6;
  284.       bytes[offset] = (byte) (B1110 | (cpt & 0x0F));
  285.       return 3;
  286.     }
  287.     if (cpt >= 0x10000 && cpt <= 0x10FFFF) {
  288.       bytes[offset+3] = (byte) (B10 | (cpt & 0x3F));
  289.       cpt = cpt >> 6;
  290.       bytes[offset+2] = (byte) (B10 | (cpt & 0x3F));
  291.       cpt = cpt >> 6;
  292.       bytes[offset+1] = (byte) (B10 | (cpt & 0x3F));
  293.       cpt = cpt >> 6;
  294.       bytes[offset] = (byte) (B11110 | (cpt & 0x07));
  295.       return 4;
  296.     }
  297.     throw new IOException("Illegal Unicode Codepoint "+
  298.                           Integer.toHexString(cpt)+" in string.");
  299.   }
  300.   
  301.   static void toBinaryString(final DataOutput out, final String str)
  302.     throws IOException {
  303.     final int strlen = str.length();
  304.     byte[] bytes = new byte[strlen*4]; // Codepoints expand to 4 bytes max
  305.     int utf8Len = 0;
  306.     int idx = 0;
  307.     while(idx < strlen) {
  308.       final int cpt = str.codePointAt(idx);
  309.       idx += Character.isSupplementaryCodePoint(cpt) ? 2 : 1;
  310.       utf8Len += writeUtf8(cpt, bytes, utf8Len);
  311.     }
  312.     writeVInt(out, utf8Len);
  313.     out.write(bytes, 0, utf8Len);
  314.   }
  315.   
  316.   static boolean isValidCodePoint(int cpt) {
  317.     return !((cpt > 0x10FFFF) ||
  318.              (cpt >= 0xD800 && cpt <= 0xDFFF) ||
  319.              (cpt >= 0xFFFE && cpt <=0xFFFF));
  320.   }
  321.   
  322.   private static int utf8ToCodePoint(int b1, int b2, int b3, int b4) {
  323.     int cpt = 0;
  324.     cpt = (((b1 & ~B11111) << 18) |
  325.            ((b2 & ~B11) << 12) |
  326.            ((b3 & ~B11) << 6) |
  327.            (b4 & ~B11));
  328.     return cpt;
  329.   }
  330.   
  331.   private static int utf8ToCodePoint(int b1, int b2, int b3) {
  332.     int cpt = 0;
  333.     cpt = (((b1 & ~B1111) << 12) | ((b2 & ~B11) << 6) | (b3 & ~B11));
  334.     return cpt;
  335.   }
  336.   
  337.   private static int utf8ToCodePoint(int b1, int b2) {
  338.     int cpt = 0;
  339.     cpt = (((b1 & ~B111) << 6) | (b2 & ~B11));
  340.     return cpt;
  341.   }
  342.   
  343.   private static void checkB10(int b) throws IOException {
  344.     if ((b & B11) != B10) {
  345.       throw new IOException("Invalid UTF-8 representation.");
  346.     }
  347.   }
  348.   
  349.   static String fromBinaryString(final DataInput din) throws IOException {
  350.     final int utf8Len = readVInt(din);
  351.     final byte[] bytes = new byte[utf8Len];
  352.     din.readFully(bytes);
  353.     int len = 0;
  354.     // For the most commmon case, i.e. ascii, numChars = utf8Len
  355.     StringBuilder sb = new StringBuilder(utf8Len);
  356.     while(len < utf8Len) {
  357.       int cpt = 0;
  358.       final int b1 = bytes[len++] & 0xFF;
  359.       if (b1 <= 0x7F) {
  360.         cpt = b1;
  361.       } else if ((b1 & B11111) == B11110) {
  362.         int b2 = bytes[len++] & 0xFF;
  363.         checkB10(b2);
  364.         int b3 = bytes[len++] & 0xFF;
  365.         checkB10(b3);
  366.         int b4 = bytes[len++] & 0xFF;
  367.         checkB10(b4);
  368.         cpt = utf8ToCodePoint(b1, b2, b3, b4);
  369.       } else if ((b1 & B1111) == B1110) {
  370.         int b2 = bytes[len++] & 0xFF;
  371.         checkB10(b2);
  372.         int b3 = bytes[len++] & 0xFF;
  373.         checkB10(b3);
  374.         cpt = utf8ToCodePoint(b1, b2, b3);
  375.       } else if ((b1 & B111) == B110) {
  376.         int b2 = bytes[len++] & 0xFF;
  377.         checkB10(b2);
  378.         cpt = utf8ToCodePoint(b1, b2);
  379.       } else {
  380.         throw new IOException("Invalid UTF-8 byte "+Integer.toHexString(b1)+
  381.                               " at offset "+(len-1)+" in length of "+utf8Len);
  382.       }
  383.       if (!isValidCodePoint(cpt)) {
  384.         throw new IOException("Illegal Unicode Codepoint "+
  385.                               Integer.toHexString(cpt)+" in stream.");
  386.       }
  387.       sb.appendCodePoint(cpt);
  388.     }
  389.     return sb.toString();
  390.   }
  391.   
  392.   /** Parse a float from a byte array. */
  393.   public static float readFloat(byte[] bytes, int start) {
  394.     return WritableComparator.readFloat(bytes, start);
  395.   }
  396.   
  397.   /** Parse a double from a byte array. */
  398.   public static double readDouble(byte[] bytes, int start) {
  399.     return WritableComparator.readDouble(bytes, start);
  400.   }
  401.   
  402.   /**
  403.    * Reads a zero-compressed encoded long from a byte array and returns it.
  404.    * @param bytes byte array with decode long
  405.    * @param start starting index
  406.    * @throws java.io.IOException
  407.    * @return deserialized long
  408.    */
  409.   public static long readVLong(byte[] bytes, int start) throws IOException {
  410.     return WritableComparator.readVLong(bytes, start);
  411.   }
  412.   
  413.   /**
  414.    * Reads a zero-compressed encoded integer from a byte array and returns it.
  415.    * @param bytes byte array with the encoded integer
  416.    * @param start start index
  417.    * @throws java.io.IOException
  418.    * @return deserialized integer
  419.    */
  420.   public static int readVInt(byte[] bytes, int start) throws IOException {
  421.     return WritableComparator.readVInt(bytes, start);
  422.   }
  423.   
  424.   /**
  425.    * Reads a zero-compressed encoded long from a stream and return it.
  426.    * @param in input stream
  427.    * @throws java.io.IOException
  428.    * @return deserialized long
  429.    */
  430.   public static long readVLong(DataInput in) throws IOException {
  431.     return WritableUtils.readVLong(in);
  432.   }
  433.   
  434.   /**
  435.    * Reads a zero-compressed encoded integer from a stream and returns it.
  436.    * @param in input stream
  437.    * @throws java.io.IOException
  438.    * @return deserialized integer
  439.    */
  440.   public static int readVInt(DataInput in) throws IOException {
  441.     return WritableUtils.readVInt(in);
  442.   }
  443.   
  444.   /**
  445.    * Get the encoded length if an integer is stored in a variable-length format
  446.    * @return the encoded length
  447.    */
  448.   public static int getVIntSize(long i) {
  449.     return WritableUtils.getVIntSize(i);
  450.   }
  451.   
  452.   /**
  453.    * Serializes a long to a binary stream with zero-compressed encoding.
  454.    * For -112 <= i <= 127, only one byte is used with the actual value.
  455.    * For other values of i, the first byte value indicates whether the
  456.    * long is positive or negative, and the number of bytes that follow.
  457.    * If the first byte value v is between -113 and -120, the following long
  458.    * is positive, with number of bytes that follow are -(v+112).
  459.    * If the first byte value v is between -121 and -128, the following long
  460.    * is negative, with number of bytes that follow are -(v+120). Bytes are
  461.    * stored in the high-non-zero-byte-first order.
  462.    *
  463.    * @param stream Binary output stream
  464.    * @param i Long to be serialized
  465.    * @throws java.io.IOException
  466.    */
  467.   public static void writeVLong(DataOutput stream, long i) throws IOException {
  468.     WritableUtils.writeVLong(stream, i);
  469.   }
  470.   
  471.   /**
  472.    * Serializes an int to a binary stream with zero-compressed encoding.
  473.    *
  474.    * @param stream Binary output stream
  475.    * @param i int to be serialized
  476.    * @throws java.io.IOException
  477.    */
  478.   public static void writeVInt(DataOutput stream, int i) throws IOException {
  479.     WritableUtils.writeVInt(stream, i);
  480.   }
  481.   
  482.   /** Lexicographic order of binary data. */
  483.   public static int compareBytes(byte[] b1, int s1, int l1,
  484.                                  byte[] b2, int s2, int l2) {
  485.     return WritableComparator.compareBytes(b1, s1, l1, b2, s2, l2);
  486.   }
  487. }