/*
* 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.components.elementprocessor.impl.poi.hssf.elements;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.avalon.framework.logger.AbstractLogEnabled;
import org.apache.cocoon.CascadingIOException;
import org.apache.cocoon.components.elementprocessor.ElementProcessor;
import org.apache.cocoon.components.elementprocessor.impl.poi.POIFSElementProcessor;
import org.apache.cocoon.components.elementprocessor.types.Attribute;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
/**
* The BaseElementProcessor class provides default behavior for
* classes that can handle a particular XML element's content.
*
* It is intended that all ElementProcessors should extend this class.
* This class is declared Abstract although it has no abstract
* methods. It can be used 'as is' for a no-op ElementProcessor, and
* an ElementProcessor that chooses to simply extend this class with
* no overrides will be a no-op ElementProcessor.
*
* @author Marc Johnson (marc_johnson27591@hotmail.com)
* @version CVS $Id$
*/
public abstract class BaseElementProcessor extends AbstractLogEnabled
implements POIFSElementProcessor
{
private Map _attributes;
private POIFSFileSystem _filesystem;
private BaseElementProcessor _parent;
private StringBuffer _data;
/**
* Constructor
*
* @param implied_attributes an array of Attributes which might
* not appear in the initialization call
* because they are implied, and the SAX
* processor will not automatically
* generate them.
*/
protected BaseElementProcessor(final Attribute [] implied_attributes) {
_attributes = new HashMap();
_filesystem = null;
_parent = null;
_data = new StringBuffer();
if (implied_attributes != null) {
for (int k = 0; k < implied_attributes.length; k++) {
_attributes.put(implied_attributes[ k ].getName(),
implied_attributes[ k ]);
}
}
}
/**
* @return the Attributes managed by this ElementProcessor. May be
* empty, but never null
*/
protected Iterator getAttributes() {
return _attributes.values().iterator();
}
/**
* Get the value of an attribute
*
* @param name the name of the attribute to look up
*
* @return the value of the specified attribute; will be null if
* the attribute doesn't exist
*/
protected String getValue(final String name) {
String value = null;
Attribute attr = ( Attribute ) _attributes.get(name);
if (attr != null) {
value = attr.getValue();
}
return value;
}
/**
* @return the POIFSFileSystem object
*/
protected POIFSFileSystem getFilesystem() {
return _filesystem;
}
/**
* @return the parent ElementProcessor; may be null
*/
protected ElementProcessor getParent() {
return _parent;
}
/**
* get the nearest ancestor that happens to be an instance of the
* specified class
*
* @param theclass the class we're looking for
*
* @return an ancestor of the specified class; null if no such
* ancestor exists
*/
protected ElementProcessor getAncestor(final Class theclass) {
ElementProcessor parent = getParent();
if (parent == null || parent.getClass().equals(theclass)) {
return parent;
} else {
return ((BaseElementProcessor)parent).getAncestor(theclass);
}
}
/**
* @return the data, both regular characters and whitespace
* characters, collected so far
*/
protected String getData() {
return _data.toString().trim();
}
/**
* get the workbook we're working on. If it isn't in this
* instance, check the parent
*
* @return the workbook we're working on. Never null
*
* @exception IOException if the workbook is missing
*/
protected Workbook getWorkbook() throws IOException {
if (_parent != null) {
return _parent.getWorkbook();
} else {
// hit the end of the containment hierarchy without
// finding it. This Is Bad
throw new IOException("Cannot find the workbook object");
}
}
/**
* get the current sheet we're working on. If it isn't in this
* instance, check the parent
*
* @return the current sheet we're working on. Never null
*
* @exception IOException if the sheet is missing
*/
protected Sheet getSheet() throws IOException {
if (_parent != null) {
return _parent.getSheet();
} else {
// hit the end of the containment hierarchy without
// finding it. This Is Bad
throw new IOException("Cannot find the sheet object");
}
}
/**
* get the current cell we're working on. If it isn't in this
* instance, check the parent
*
* @return the current cell we're working on. Never null
*
* @exception IOException if the cell is missing
*/
protected Cell getCell() throws IOException {
if (_parent != null) {
return _parent.getCell();
} else {
// hit the end of the containment hierarchy without
// finding it. This Is Bad
throw new IOException("Cannot find the cell object");
}
}
/* ********** START implementation of ElementProcessor ********** */
/**
* The implementation should walk the array of attributes and
* perform appropriate actions based on that data. The array of
* attributes is guaranteed never to be null, but it can be
* empty. An implementation can expect code like this to work
* without throwing runtime exceptions:
* <br>
* <code>
* for (int k = 0; k < attributes.length; k++)<br>
* {<br>
* Attribute attr = attributes[ k ];<br>
* // process attribute</br>
* }</br>
* </code>
* <br>
* <b>NOTE: if the XML DTD or schema includes <i>IMPLIED</i>
* attributes for an element, those attributes are not included in
* the Attribute array - they're not in the data provided in the
* startElement call. The constructor for the ElementProcessor
* should set those implied attributes itself, and allow them to
* be overridden if the XML source provided <i>explicit</i> values
* for them.</b>
* <br>
* The parent ElementProcessor is a reference to the
* ElementProcessor whose corresponding XML element contains this
* ElementProcessor's corresponding XML element. It will not be
* null unless this ElementProcessor's corresponding XML element
* is the top-level element in the XML document. Whether this
* ElementProcessor needs to establish a containment relationship
* with its parent or not, and whether it needs to do so at the
* beginning, middle, or end of its life cycle, are private
* matters left to the discretion of the individual
* ElementProcessor implementation. If the ElementProcessor needs
* to interact with its parent ElementProcessor, but is not ready
* to do so when the initialize method is called, it must cache
* the reference to its parent.
* <br>
*
* @param attributes the array of Attribute instances; may be
* empty, will never be null
* @param parent the parent ElementProcessor; may be null
*
* @exception IOException if anything is wrong
*/
public void initialize(final Attribute [] attributes,
final ElementProcessor parent) throws IOException {
try {
_parent = ( BaseElementProcessor ) parent;
} catch (ClassCastException ignored) {
throw new CascadingIOException(
"parent is not compatible with this serializer", ignored);
}
// can't trust the guarantee -- an overriding implementation
// may have screwed this up
if (attributes != null) {
for (int k = 0; k < attributes.length; k++) {
_attributes.put(attributes[ k ].getName(), attributes[ k ]);
}
}
}
/**
* The data provided in this method call comes from the
* corresponding XML element's contents. The array is guaranteed
* not to be null and will never be empty.
* <br>
* The POIFSSerializer will make 0 to many calls to this method;
* all such calls will occur after the initialize method is called
* and before the endProcessing method is called.
* <br>
* Calls to this method may be interleaved with calls to
* acceptWhitespaceCharacters. All calls to acceptCharacters and
* acceptWhitespaceCharacters are guaranteed to be in the same
* order as their data is in the element.
*
* @param data the character data
*/
public void acceptCharacters(final char [] data) {
if (data != null) {
_data.append(data);
}
}
/**
* The data provided in this method call comes from the
* corresponding XML element's contents. The array is guaranteed
* not to be null and will never be empty.
* <br>
* The POIFSSerializer will make 0 to many calls to this method;
* all such calls will occur after the initialize method is called
* and before the endProcessing method is called.
* <br>
* Calls to this method may be interleaved with calls to
* acceptCharacters. All calls to acceptCharacters and
* acceptWhitespaceCharacters are guaranteed to be in the same
* order as their data is in the element.
*
* @param data the whitespace characters
*/
public void acceptWhitespaceCharacters(final char [] data) {
if (data != null) {
_data.append(data);
}
}
/**
* This is the last method call executed by the
* POIFSSerializer. When this method is called, the
* ElementProcessor should finish its work and perform its final
* interactions with its parent ElementProcessor and the
* filesystem, if necessary.
* <br>
* If the implementation cached the parent ElementProcessor
* reference, the filesystem reference, or both, when the
* initialize method was called, it should null out those
* references.
*
* @exception IOException
*/
public void endProcessing() throws IOException {
_filesystem = null;
_parent = null;
}
/* ********** END implementation of ElementProcessor ********** */
/* ********** START implementation of POIFSElementProcessor ********** */
/**
* Set the POIFSFileSystem for the element processor
*
* @param fs the POIFSFileSystem instance
*/
public void setFilesystem(POIFSFileSystem fs) {
_filesystem = fs;
}
/* ********** END implementation of POIFSElementProcessor ********** */
} // end package scope abstract class BaseElementProcessor