RELEASE_2_1_13/src/blocks/poi/java/org/apache/cocoon/serialization/ElementProcessorSerializer.java - cocoon - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.cocoon.serialization;

 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Stack;

 import org.apache.avalon.framework.logger.AbstractLogEnabled;
 import org.apache.avalon.framework.service.ServiceManager;
 import org.apache.avalon.framework.service.Serviceable;

 import org.apache.cocoon.components.elementprocessor.CannotCreateElementProcessorException;
 import org.apache.cocoon.components.elementprocessor.ElementProcessor;
 import org.apache.cocoon.components.elementprocessor.ElementProcessorFactory;
 import org.apache.cocoon.components.elementprocessor.types.Attribute;

 import org.xml.sax.Attributes;
 import org.xml.sax.Locator;
 import org.xml.sax.SAXException;

 /**
  * An implementation of nearly all of the methods included in the
  * org.apache.poi.serialization.Serializer interface
  *
  * This is an abstract class. Concrete extensions need to implement
  * the following methods:
  * <ul>
  *    <li>String getMimeType()</li>
  *    <li>void endDocument()</li>
  *    <li>ElementProcessorFactory getElementProcessorFactory()</li>
  *    <li>void doPreInitialization(ElementProcessor processor)</li>
  * </ul>
  *
  * @author Marc Johnson (marc_johnson27591@hotmail.com)
  * @author Nicola Ken Barozzi (nicolaken@apache.org)
  * @version $Id$
  */
 public abstract class ElementProcessorSerializer
     extends AbstractLogEnabled implements Serializer, Serviceable {

     private final Stack openElements;

     protected ServiceManager manager;

     private OutputStream outputStream;
     private Locator locator;

     /**
      * Constructor
      */
     public ElementProcessorSerializer() {
         this.openElements = new Stack();
     }

     public void service(ServiceManager manager) {
         this.manager = manager;
     }

     /**
      * get the appropriate ElementProcessorFactory
      *
      * @return an ElementProcessorFactory suitable for the file type
      */
     protected abstract ElementProcessorFactory getElementProcessorFactory();

     /**
      * perform whatever pre-initialization seems good on the
      * ElementProcessor
      *
      * @param processor the processor to be initialized
      *
      * @exception SAXException on errors
      */
     protected abstract void doPreInitialization(ElementProcessor processor) throws SAXException;

     /**
      * @return the output stream
      */
     protected OutputStream getOutputStream() {
         return this.outputStream;
     }

     /**
      * Create a new SAXException
      *
      * @param message the exception message
      * @param e the underlying exception (may be null)
      *
      * @return new SAXException
      */
     protected SAXException SAXExceptionFactory(final String message, final Exception e) {
         StringBuffer message_buffer = new StringBuffer();

         message_buffer.append((message == null) ? "" : message);
         if (this.locator != null) {
             message_buffer.append("; System id: \"");
             message_buffer.append(this.locator.getSystemId());
             message_buffer.append("\"; public id: \"");
             message_buffer.append(this.locator.getPublicId());
             message_buffer.append("\"; line number: ");
             message_buffer.append(this.locator.getLineNumber());
             message_buffer.append("; column number: ");
             message_buffer.append(this.locator.getColumnNumber());
         }
         SAXException rval = null;

         if (e != null) {
             rval = new SAXException(message_buffer.toString(), e);
         } else {
             rval = new SAXException(message_buffer.toString());
         }
         return rval;
     }

     /**
      * Create a SAXException
      *
      * @param message the exception message
      *
      * @return new SAXException
      */
     protected SAXException SAXExceptionFactory(final String message) {
         return SAXExceptionFactory(message, null);
     }

     private ElementProcessor getCurrentElementProcessor() {
         return this.openElements.empty() ? null
                                          : (ElementProcessor)this.openElements.peek();
     }

     private char [] cleanupArray(final char [] array, final int start, final int length) {
         char[] output = new char[length];
         System.arraycopy(array, start, output, 0, length);
         return output;
     }

     /* ********** START implementation of SitemapOutputComponent ********** */

     /**
      * Set the OutputStream where the requested resource should be
      * serialized.
      *
      * @param out the OutputStream to which the serialized data will
      *            be written
      */
     public void setOutputStream(final OutputStream out) {
         this.outputStream = out;
     }

     /**
      * Test if the component wants to set the content length.
      *
      * @return false
      */
     public boolean shouldSetContentLength() {
         return false;
     }

     /* **********  END  implementation of SitemapOutputComponent ********** */
     /* ********** START implementation of LexicalHandler ********** */

     /**
      * Report an XML comment anywhere in the document. We don't really
      * care.
      */
     public void comment(final char [] ch, final int start, final int length) {
     }

     /**
      * Report the end of a CDATA section. We don't really care.
      */
     public void endCDATA() {
     }

     /**
      * Report the end of DTD declarations. We don't really care.
      */
     public void endDTD() {
     }

     /**
      * Report the end of an entity. We don't really care.
      */
     public void endEntity(final String name) {
     }

     /**
      * Report the start of a CDATA section. We don't really care.
      */
     public void startCDATA() {
     }

     /**
      * Report the start of DTD declarations, if any. We don't really
      * care.
      */
     public void startDTD(final String name, final String publicId, final String systemId) {
     }

     /**
      * Report the beginning of some internal and external XML
      * entities. We don't really care.
      */
     public void startEntity(final String name) {
     }

     /* **********  END  implementation of LexicalHandler ********** */
     /* ********** START implementation of ContentHandler ********** */

     /**
      * Receive notification of character data.
      *
      * @param ch the character array
      * @param start the start index in ch
      * @param length the length of the valid part of ch
      *
      * @exception SAXException if anything goes wrong in processing
      *            the character data
      */
     public void characters(final char [] ch, final int start, final int length) throws SAXException {
         ElementProcessor currentElementProcessor = getCurrentElementProcessor();
         if (currentElementProcessor != null) {
             currentElementProcessor.acceptCharacters(cleanupArray(ch, start, length));
         }
     }

     /**
      * Receive notification of the end of an element.
      *
      * @exception SAXException on any errors processing the event.
      */
     public void endElement(final String namespaceURI, final String localName,
             final String qName) throws SAXException {
         try {
             getCurrentElementProcessor().endProcessing();
             this.openElements.pop();
         } catch (IOException e) {
             throw SAXExceptionFactory("could not process endElement event", e);
         }
     }

     /**
      * End the scope of a prefix-URI mapping. We don't really care.
      */
     public void endPrefixMapping(final String prefix) {
     }

     /**
      * Receive notification of ignorable whitespace in element
      * content.
      *
      * @param ch the character array
      * @param start the start index in ch
      * @param length the length of the valid part of ch
      *
      * @exception SAXException if anything goes wrong in processing
      *            the character data
      */
     public void ignorableWhitespace(final char [] ch, final int start, final int length) throws SAXException {
         ElementProcessor currentElementProcessor = getCurrentElementProcessor();
         if (currentElementProcessor != null) {
             currentElementProcessor.acceptWhitespaceCharacters(cleanupArray(ch, start, length));
         }
     }

     /**
      * Receive notification of a processing instruction. We don't
      * really care.
      */
     public void processingInstruction(final String target, final String data) {
     }

     /**
      * Receive an object for locating the origin of SAX document
      * events.
      *
      * @param locator the Locator object
      */
     public void setDocumentLocator(final Locator locator) {
         this.locator = locator;
     }

     /**
      * Receive notification of a skipped entity. We don't really care.
      */
     public void skippedEntity(final String name) {
     }

     /**
      * Receive notification of the beginning of a document.
      */
     public void startDocument() {
         // nothing to do; should be ready as soon as we were
         // constructed
     }

     /**
      * Receive notification of the beginning of an element.
      *
      * @param namespaceURI the namespace this element is in
      * @param localName the local name of the element
      * @param qName the qualified name of the element
      * @param atts the Attributes, if any, of the element
      *
      * @exception SAXException if we cannot create an ElementProcessor
      *            to handle the element
      */
     public void startElement(final String namespaceURI, final String localName,
             final String qName, final Attributes atts) throws SAXException {
         String name = "";

         if (localName != null && localName.length() != 0) {
             name = localName;
         } else if (qName != null && qName.length() != 0) {
             name = qName;
         }
         ElementProcessor processor;

         try {
             processor = getElementProcessorFactory().createElementProcessor(name);
         } catch (CannotCreateElementProcessorException e) {
             throw SAXExceptionFactory("could not process startElement event", e);
         }
         doPreInitialization(processor);
         Attribute[] attributes = (atts == null) ? new Attribute[0]
                                                 : new Attribute[atts.getLength()];

         for (int j = 0; j < attributes.length; j++) {
             attributes[j] = new Attribute(atts.getQName(j), atts.getValue(j));
         }
         try {
             processor.initialize(attributes, getCurrentElementProcessor());
         } catch (IOException e) {
             throw SAXExceptionFactory("Exception processing startElement", e);
         }
         this.openElements.push(processor);
     }

     /**
      * Begin the scope of a prefix-URI Namespace mapping. We don't
      * really care.
      */
     public void startPrefixMapping(final String prefix, final String uri) {
     }
     /* **********  END  implementation of ContentHandler ********** */

 }   // end public abstract class ElementProcessorSerializer
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package org.apache.cocoon.serialization;

	import java.io.IOException;
	import java.io.OutputStream;
	import java.util.Stack;

	import org.apache.avalon.framework.logger.AbstractLogEnabled;
	import org.apache.avalon.framework.service.ServiceManager;
	import org.apache.avalon.framework.service.Serviceable;

	import org.apache.cocoon.components.elementprocessor.CannotCreateElementProcessorException;
	import org.apache.cocoon.components.elementprocessor.ElementProcessor;
	import org.apache.cocoon.components.elementprocessor.ElementProcessorFactory;
	import org.apache.cocoon.components.elementprocessor.types.Attribute;

	import org.xml.sax.Attributes;
	import org.xml.sax.Locator;
	import org.xml.sax.SAXException;

	/**
	* An implementation of nearly all of the methods included in the
	* org.apache.poi.serialization.Serializer interface
	*
	* This is an abstract class. Concrete extensions need to implement
	* the following methods:
	* <ul>
	* <li>String getMimeType()</li>
	* <li>void endDocument()</li>
	* <li>ElementProcessorFactory getElementProcessorFactory()</li>
	* <li>void doPreInitialization(ElementProcessor processor)</li>
	* </ul>
	*
	* @author Marc Johnson (marc_johnson27591@hotmail.com)
	* @author Nicola Ken Barozzi (nicolaken@apache.org)
	* @version $Id$
	*/
	public abstract class ElementProcessorSerializer
	extends AbstractLogEnabled implements Serializer, Serviceable {

	private final Stack openElements;

	protected ServiceManager manager;

	private OutputStream outputStream;
	private Locator locator;

	/**
	* Constructor
	*/
	public ElementProcessorSerializer() {
	this.openElements = new Stack();
	}

	public void service(ServiceManager manager) {
	this.manager = manager;
	}

	/**
	* get the appropriate ElementProcessorFactory
	*
	* @return an ElementProcessorFactory suitable for the file type
	*/
	protected abstract ElementProcessorFactory getElementProcessorFactory();

	/**
	* perform whatever pre-initialization seems good on the
	* ElementProcessor
	*
	* @param processor the processor to be initialized
	*
	* @exception SAXException on errors
	*/
	protected abstract void doPreInitialization(ElementProcessor processor) throws SAXException;

	/**
	* @return the output stream
	*/
	protected OutputStream getOutputStream() {
	return this.outputStream;
	}

	/**
	* Create a new SAXException
	*
	* @param message the exception message
	* @param e the underlying exception (may be null)
	*
	* @return new SAXException
	*/
	protected SAXException SAXExceptionFactory(final String message, final Exception e) {
	StringBuffer message_buffer = new StringBuffer();

	message_buffer.append((message == null) ? "" : message);
	if (this.locator != null) {
	message_buffer.append("; System id: \"");
	message_buffer.append(this.locator.getSystemId());
	message_buffer.append("\"; public id: \"");
	message_buffer.append(this.locator.getPublicId());
	message_buffer.append("\"; line number: ");
	message_buffer.append(this.locator.getLineNumber());
	message_buffer.append("; column number: ");
	message_buffer.append(this.locator.getColumnNumber());
	}
	SAXException rval = null;

	if (e != null) {
	rval = new SAXException(message_buffer.toString(), e);
	} else {
	rval = new SAXException(message_buffer.toString());
	}
	return rval;
	}

	/**
	* Create a SAXException
	*
	* @param message the exception message
	*
	* @return new SAXException
	*/
	protected SAXException SAXExceptionFactory(final String message) {
	return SAXExceptionFactory(message, null);
	}

	private ElementProcessor getCurrentElementProcessor() {
	return this.openElements.empty() ? null
	: (ElementProcessor)this.openElements.peek();
	}

	private char [] cleanupArray(final char [] array, final int start, final int length) {
	char[] output = new char[length];
	System.arraycopy(array, start, output, 0, length);
	return output;
	}

	/* ******** START implementation of SitemapOutputComponent ******** */

	/**
	* Set the OutputStream where the requested resource should be
	* serialized.
	*
	* @param out the OutputStream to which the serialized data will
	* be written
	*/
	public void setOutputStream(final OutputStream out) {
	this.outputStream = out;
	}

	/**
	* Test if the component wants to set the content length.
	*
	* @return false
	*/
	public boolean shouldSetContentLength() {
	return false;
	}

	/* ******** END implementation of SitemapOutputComponent ******** */
	/* ******** START implementation of LexicalHandler ******** */

	/**
	* Report an XML comment anywhere in the document. We don't really
	* care.
	*/
	public void comment(final char [] ch, final int start, final int length) {
	}

	/**
	* Report the end of a CDATA section. We don't really care.
	*/
	public void endCDATA() {
	}

	/**
	* Report the end of DTD declarations. We don't really care.
	*/
	public void endDTD() {
	}

	/**
	* Report the end of an entity. We don't really care.
	*/
	public void endEntity(final String name) {
	}

	/**
	* Report the start of a CDATA section. We don't really care.
	*/
	public void startCDATA() {
	}

	/**
	* Report the start of DTD declarations, if any. We don't really
	* care.
	*/
	public void startDTD(final String name, final String publicId, final String systemId) {
	}

	/**
	* Report the beginning of some internal and external XML
	* entities. We don't really care.
	*/
	public void startEntity(final String name) {
	}

	/* ******** END implementation of LexicalHandler ******** */
	/* ******** START implementation of ContentHandler ******** */

	/**
	* Receive notification of character data.
	*
	* @param ch the character array
	* @param start the start index in ch
	* @param length the length of the valid part of ch
	*
	* @exception SAXException if anything goes wrong in processing
	* the character data
	*/
	public void characters(final char [] ch, final int start, final int length) throws SAXException {
	ElementProcessor currentElementProcessor = getCurrentElementProcessor();
	if (currentElementProcessor != null) {
	currentElementProcessor.acceptCharacters(cleanupArray(ch, start, length));
	}
	}

	/**
	* Receive notification of the end of an element.
	*
	* @exception SAXException on any errors processing the event.
	*/
	public void endElement(final String namespaceURI, final String localName,
	final String qName) throws SAXException {
	try {
	getCurrentElementProcessor().endProcessing();
	this.openElements.pop();
	} catch (IOException e) {
	throw SAXExceptionFactory("could not process endElement event", e);
	}
	}

	/**
	* End the scope of a prefix-URI mapping. We don't really care.
	*/
	public void endPrefixMapping(final String prefix) {
	}

	/**
	* Receive notification of ignorable whitespace in element
	* content.
	*
	* @param ch the character array
	* @param start the start index in ch
	* @param length the length of the valid part of ch
	*
	* @exception SAXException if anything goes wrong in processing
	* the character data
	*/
	public void ignorableWhitespace(final char [] ch, final int start, final int length) throws SAXException {
	ElementProcessor currentElementProcessor = getCurrentElementProcessor();
	if (currentElementProcessor != null) {
	currentElementProcessor.acceptWhitespaceCharacters(cleanupArray(ch, start, length));
	}
	}

	/**
	* Receive notification of a processing instruction. We don't
	* really care.
	*/
	public void processingInstruction(final String target, final String data) {
	}

	/**
	* Receive an object for locating the origin of SAX document
	* events.
	*
	* @param locator the Locator object
	*/
	public void setDocumentLocator(final Locator locator) {
	this.locator = locator;
	}

	/**
	* Receive notification of a skipped entity. We don't really care.
	*/
	public void skippedEntity(final String name) {
	}

	/**
	* Receive notification of the beginning of a document.
	*/
	public void startDocument() {
	// nothing to do; should be ready as soon as we were
	// constructed
	}

	/**
	* Receive notification of the beginning of an element.
	*
	* @param namespaceURI the namespace this element is in
	* @param localName the local name of the element
	* @param qName the qualified name of the element
	* @param atts the Attributes, if any, of the element
	*
	* @exception SAXException if we cannot create an ElementProcessor
	* to handle the element
	*/
	public void startElement(final String namespaceURI, final String localName,
	final String qName, final Attributes atts) throws SAXException {
	String name = "";

	if (localName != null && localName.length() != 0) {
	name = localName;
	} else if (qName != null && qName.length() != 0) {
	name = qName;
	}
	ElementProcessor processor;

	try {
	processor = getElementProcessorFactory().createElementProcessor(name);
	} catch (CannotCreateElementProcessorException e) {
	throw SAXExceptionFactory("could not process startElement event", e);
	}
	doPreInitialization(processor);
	Attribute[] attributes = (atts == null) ? new Attribute[0]
	: new Attribute[atts.getLength()];

	for (int j = 0; j < attributes.length; j++) {
	attributes[j] = new Attribute(atts.getQName(j), atts.getValue(j));
	}
	try {
	processor.initialize(attributes, getCurrentElementProcessor());
	} catch (IOException e) {
	throw SAXExceptionFactory("Exception processing startElement", e);
	}
	this.openElements.push(processor);
	}

	/**
	* Begin the scope of a prefix-URI Namespace mapping. We don't
	* really care.
	*/
	public void startPrefixMapping(final String prefix, final String uri) {
	}
	/* ******** END implementation of ContentHandler ******** */

	} // end public abstract class ElementProcessorSerializer