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

网格计算

开发平台:

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.IOException;
  20. import java.util.TreeMap;
  21. import java.util.ArrayList;
  22. import java.io.PrintStream;
  23. import java.io.OutputStream;
  24. import java.io.UnsupportedEncodingException;
  25. import java.util.Stack;
  26. /**
  27.  * XML Serializer.
  28.  */
  29. public class XmlRecordOutput implements RecordOutput {
  30.   private PrintStream stream;
  31.     
  32.   private int indent = 0;
  33.     
  34.   private Stack<String> compoundStack;
  35.     
  36.   private void putIndent() {
  37.     StringBuffer sb = new StringBuffer("");
  38.     for (int idx = 0; idx < indent; idx++) {
  39.       sb.append("  ");
  40.     }
  41.     stream.print(sb.toString());
  42.   }
  43.     
  44.   private void addIndent() {
  45.     indent++;
  46.   }
  47.     
  48.   private void closeIndent() {
  49.     indent--;
  50.   }
  51.     
  52.   private void printBeginEnvelope(String tag) {
  53.     if (!compoundStack.empty()) {
  54.       String s = compoundStack.peek();
  55.       if ("struct".equals(s)) {
  56.         putIndent();
  57.         stream.print("<member>n");
  58.         addIndent();
  59.         putIndent();
  60.         stream.print("<name>"+tag+"</name>n");
  61.         putIndent();
  62.         stream.print("<value>");
  63.       } else if ("vector".equals(s)) {
  64.         stream.print("<value>");
  65.       } else if ("map".equals(s)) {
  66.         stream.print("<value>");
  67.       }
  68.     } else {
  69.       stream.print("<value>");
  70.     }
  71.   }
  72.     
  73.   private void printEndEnvelope(String tag) {
  74.     if (!compoundStack.empty()) {
  75.       String s = compoundStack.peek();
  76.       if ("struct".equals(s)) {
  77.         stream.print("</value>n");
  78.         closeIndent();
  79.         putIndent();
  80.         stream.print("</member>n");
  81.       } else if ("vector".equals(s)) {
  82.         stream.print("</value>n");
  83.       } else if ("map".equals(s)) {
  84.         stream.print("</value>n");
  85.       }
  86.     } else {
  87.       stream.print("</value>n");
  88.     }
  89.   }
  90.     
  91.   private void insideVector(String tag) {
  92.     printBeginEnvelope(tag);
  93.     compoundStack.push("vector");
  94.   }
  95.     
  96.   private void outsideVector(String tag) throws IOException {
  97.     String s = compoundStack.pop();
  98.     if (!"vector".equals(s)) {
  99.       throw new IOException("Error serializing vector.");
  100.     }
  101.     printEndEnvelope(tag);
  102.   }
  103.     
  104.   private void insideMap(String tag) {
  105.     printBeginEnvelope(tag);
  106.     compoundStack.push("map");
  107.   }
  108.     
  109.   private void outsideMap(String tag) throws IOException {
  110.     String s = compoundStack.pop();
  111.     if (!"map".equals(s)) {
  112.       throw new IOException("Error serializing map.");
  113.     }
  114.     printEndEnvelope(tag);
  115.   }
  116.     
  117.   private void insideRecord(String tag) {
  118.     printBeginEnvelope(tag);
  119.     compoundStack.push("struct");
  120.   }
  121.     
  122.   private void outsideRecord(String tag) throws IOException {
  123.     String s = compoundStack.pop();
  124.     if (!"struct".equals(s)) {
  125.       throw new IOException("Error serializing record.");
  126.     }
  127.     printEndEnvelope(tag);
  128.   }
  129.     
  130.   /** Creates a new instance of XmlRecordOutput */
  131.   public XmlRecordOutput(OutputStream out) {
  132.     try {
  133.       stream = new PrintStream(out, true, "UTF-8");
  134.       compoundStack = new Stack<String>();
  135.     } catch (UnsupportedEncodingException ex) {
  136.       throw new RuntimeException(ex);
  137.     }
  138.   }
  139.     
  140.   public void writeByte(byte b, String tag) throws IOException {
  141.     printBeginEnvelope(tag);
  142.     stream.print("<ex:i1>");
  143.     stream.print(Byte.toString(b));
  144.     stream.print("</ex:i1>");
  145.     printEndEnvelope(tag);
  146.   }
  147.     
  148.   public void writeBool(boolean b, String tag) throws IOException {
  149.     printBeginEnvelope(tag);
  150.     stream.print("<boolean>");
  151.     stream.print(b ? "1" : "0");
  152.     stream.print("</boolean>");
  153.     printEndEnvelope(tag);
  154.   }
  155.     
  156.   public void writeInt(int i, String tag) throws IOException {
  157.     printBeginEnvelope(tag);
  158.     stream.print("<i4>");
  159.     stream.print(Integer.toString(i));
  160.     stream.print("</i4>");
  161.     printEndEnvelope(tag);
  162.   }
  163.     
  164.   public void writeLong(long l, String tag) throws IOException {
  165.     printBeginEnvelope(tag);
  166.     stream.print("<ex:i8>");
  167.     stream.print(Long.toString(l));
  168.     stream.print("</ex:i8>");
  169.     printEndEnvelope(tag);
  170.   }
  171.     
  172.   public void writeFloat(float f, String tag) throws IOException {
  173.     printBeginEnvelope(tag);
  174.     stream.print("<ex:float>");
  175.     stream.print(Float.toString(f));
  176.     stream.print("</ex:float>");
  177.     printEndEnvelope(tag);
  178.   }
  179.     
  180.   public void writeDouble(double d, String tag) throws IOException {
  181.     printBeginEnvelope(tag);
  182.     stream.print("<double>");
  183.     stream.print(Double.toString(d));
  184.     stream.print("</double>");
  185.     printEndEnvelope(tag);
  186.   }
  187.     
  188.   public void writeString(String s, String tag) throws IOException {
  189.     printBeginEnvelope(tag);
  190.     stream.print("<string>");
  191.     stream.print(Utils.toXMLString(s));
  192.     stream.print("</string>");
  193.     printEndEnvelope(tag);
  194.   }
  195.     
  196.   public void writeBuffer(Buffer buf, String tag)
  197.     throws IOException {
  198.     printBeginEnvelope(tag);
  199.     stream.print("<string>");
  200.     stream.print(Utils.toXMLBuffer(buf));
  201.     stream.print("</string>");
  202.     printEndEnvelope(tag);
  203.   }
  204.     
  205.   public void startRecord(Record r, String tag) throws IOException {
  206.     insideRecord(tag);
  207.     stream.print("<struct>n");
  208.     addIndent();
  209.   }
  210.     
  211.   public void endRecord(Record r, String tag) throws IOException {
  212.     closeIndent();
  213.     putIndent();
  214.     stream.print("</struct>");
  215.     outsideRecord(tag);
  216.   }
  217.     
  218.   public void startVector(ArrayList v, String tag) throws IOException {
  219.     insideVector(tag);
  220.     stream.print("<array>n");
  221.     addIndent();
  222.   }
  223.     
  224.   public void endVector(ArrayList v, String tag) throws IOException {
  225.     closeIndent();
  226.     putIndent();
  227.     stream.print("</array>");
  228.     outsideVector(tag);
  229.   }
  230.     
  231.   public void startMap(TreeMap v, String tag) throws IOException {
  232.     insideMap(tag);
  233.     stream.print("<array>n");
  234.     addIndent();
  235.   }
  236.     
  237.   public void endMap(TreeMap v, String tag) throws IOException {
  238.     closeIndent();
  239.     putIndent();
  240.     stream.print("</array>");
  241.     outsideMap(tag);
  242.   }
  243. }