content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE 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 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE 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 AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code 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
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package jaxp.sun.org.apache.xalan.internal.xsltc.trax;
  
  import jaxp.xml.stream.XMLStreamException;
  import jaxp.xml.stream.XMLStreamWriter;
  
  import org.xml.sax.Attributes;
  import org.xml.sax.SAXException;
  import org.xml.sax.ext.Locator2;
  
  /**
   * @author Sunitha Reddy
   */
  
  public class SAX2StAXStreamWriter extends SAX2StAXBaseWriter {
  
  
          private XMLStreamWriter writer;
  
          private boolean needToCallStartDocument = false;
  
          public SAX2StAXStreamWriter() {
  
          }
  
          public SAX2StAXStreamWriter(XMLStreamWriter writer) {
  
                  this.writer = writer;
  
          }
  
  
          public XMLStreamWriter getStreamWriter() {
  
                  return writer;
  
          }
  
  
          public void setStreamWriter(XMLStreamWriter writer) {
  
                  this.writer = writer;
  
          }
  
          public void startDocument() throws SAXException {
  
                  super.startDocument();
                  // Encoding and version info will be available only after startElement
                  // is called for first time. So, defer START_DOCUMENT event of StAX till
                  // that point of time.
                  needToCallStartDocument = true;
          }
  
          public void endDocument() throws SAXException {
  
                  try {
  
                          writer.writeEndDocument();
  
                  } catch (XMLStreamException e) {
  
                          throw new SAXException(e);
  
                  }
  
                  super.endDocument();
  
          }
  
          public void startElement(String uri, String localName, String qName,
                          Attributes attributes) throws SAXException {
  
                  if (needToCallStartDocument) {
                      try {
                          if (docLocator == null)
                              writer.writeStartDocument();
                          else {
                              try{
                                  writer.writeStartDocument(((Locator2)docLocator).getXMLVersion());
                              }catch(ClassCastException e){
                                  writer.writeStartDocument();
                              }
                          }
  
                      } catch (XMLStreamException e) {
  
                              throw new SAXException(e);
  
                      }
                      needToCallStartDocument = false;
                  }
  
                  try {
  
                          String[] qname = {null, null};
                          parseQName(qName, qname);
                          //Do not call writeStartElement with prefix and namespaceURI, as it writes out
                          //namespace declaration.
                          //writer.writeStartElement(qname[0], qname[1], uri);
                          writer.writeStartElement(qName);
  
  
                          // No need to write namespaces, as they are written as part of attributes.
                          /*if (namespaces != null) {
  
                              final int nDecls = namespaces.size();
                              for (int i = 0; i < nDecls; i++) {
                                  final String prefix = (String) namespaces.elementAt(i);
                                  if (prefix.length() == 0) {
                                      writer.setDefaultNamespace((String)namespaces.elementAt(++i));
                                  } else {
                                      writer.setPrefix(prefix, (String) namespaces.elementAt(++i));
                                  }
  
                                  writer.writeNamespace(prefix, (String)namespaces.elementAt(i));
                              }
  
  
                          }*/
  
                          // write attributes
                          for (int i = 0, s = attributes.getLength(); i < s; i++) {
  
                                  parseQName(attributes.getQName(i), qname);
  
                                  String attrPrefix = qname[0];
                                  String attrLocal = qname[1];
  
                                  String attrQName = attributes.getQName(i);
                                  String attrValue = attributes.getValue(i);
                                  String attrURI = attributes.getURI(i);
  
                                  if ("xmlns".equals(attrPrefix) || "xmlns".equals(attrQName)) {
  
                                          // namespace declaration disguised as an attribute.
                                          // write it as an namespace
  
                                          if (attrLocal.length() == 0) {
  
                                              writer.setDefaultNamespace(attrValue);
  
                                          } else {
  
                                              writer.setPrefix(attrLocal, attrValue);
  
                                          }
  
                                          writer.writeNamespace(attrLocal, attrValue);
  
                                  } else if (attrPrefix.length() > 0) {
  
                                          writer.writeAttribute(attrPrefix, attrURI, attrLocal,
                                                          attrValue);
  
                                  } else {
                                          writer.writeAttribute(attrQName, attrValue);
                                  }
  
                          }
  
                  } catch (XMLStreamException e) {
                          throw new SAXException(e);
  
                  } finally {
  
                          super.startElement(uri, localName, qName, attributes);
  
                  }
  
          }
  
          public void endElement(String uri, String localName, String qName)
                          throws SAXException {
  
                  try {
  
                          writer.writeEndElement();
  
                  } catch (XMLStreamException e) {
  
                          throw new SAXException(e);
  
                  } finally {
  
                          super.endElement(uri, localName, qName);
  
                  }
  
          }
  
          public void comment(char[] ch, int start, int length) throws SAXException {
  
                  super.comment(ch, start, length);
                  try {
  
                          writer.writeComment(new String(ch, start, length));
  
                  } catch (XMLStreamException e) {
  
                          throw new SAXException(e);
  
                  }
  
          }
  
          public void characters(char[] ch, int start, int length)
                          throws SAXException {
  
                  super.characters(ch, start, length);
                  try {
  
                          if (!isCDATA) {
  
                                  writer.writeCharacters(ch, start, length);
  
                          }
  
                  } catch (XMLStreamException e) {
  
                          throw new SAXException(e);
  
                  }
  
          }
  
          public void endCDATA() throws SAXException {
  
                  try {
  
                          writer.writeCData(CDATABuffer.toString());
  
                  } catch (XMLStreamException e) {
  
                          throw new SAXException(e);
  
                  }
  
                  super.endCDATA();
  
          }
  
          public void ignorableWhitespace(char[] ch, int start, int length)
                          throws SAXException {
  
                  super.ignorableWhitespace(ch, start, length);
                  try {
  
                          writer.writeCharacters(ch, start, length);
  
                  } catch (XMLStreamException e) {
  
                          throw new SAXException(e);
  
                  }
  
          }
  
          public void processingInstruction(String target, String data)
                          throws SAXException {
  
                  super.processingInstruction(target, data);
                  try {
  
                          writer.writeProcessingInstruction(target, data);
  
                  } catch (XMLStreamException e) {
  
                          throw new SAXException(e);
  
                  }
  
          }
  
  }
  