/*
* 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.transformation;
import org.apache.avalon.framework.component.ComponentException;
import org.apache.avalon.framework.component.ComponentManager;
import org.apache.avalon.framework.component.Composable;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.caching.CacheValidity;
import org.apache.cocoon.caching.Cacheable;
import org.apache.cocoon.caching.IncludeCacheValidity;
import org.apache.cocoon.components.source.SourceUtil;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.xml.IncludeXMLConsumer;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.excalibur.source.Source;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import java.io.IOException;
import java.util.Map;
/**
* <p>This transformer triggers for the element <code>include</code> in the
* namespace "http://apache.org/cocoon/include/1.0".
* The <code>src</code> attribute contains the url which points to
* an xml resource which is include instead of the element.
* With the attributes <code>element</code>, <code>ns</code> and
* <code>prefix</code> it is possible to specify an element
* which surrounds the included content.</p>
*
* <p>Validity of cached pipelines is calculated not by comparing old and new
* IncludeCacheValidity objects (as in AggregatedCacheValidity) but by comparing
* timestamps. Validity object of cached pipeline contain two lists: source urls
* and timestamps. When it comes to checking validity of cached pipeline we know
* that generation/transformation steps before CIncludeTransformer are valid (otherwise
* we would have had discarded cached pipeline already) so source url list
* of new validity will be the same as of old one. Only timestamps have to be
* recalculated and compared.</p>
*
* @see IncludeTransformer (scratchpad)
* @author <a href="mailto:maciejka@tiger.com.pl">Maciek Kaminski</a>
* @deprecated This transformer violates the avalon/cocoon design principles. Use IncludeTransformer.
* @version $Id$
*/
public class CachingCIncludeTransformer extends AbstractTransformer
implements Composable, Cacheable {
public static final String CINCLUDE_NAMESPACE_URI = "http://apache.org/cocoon/include/1.0";
public static final String CINCLUDE_INCLUDE_ELEMENT = "include";
public static final String CINCLUDE_INCLUDE_ELEMENT_SRC_ATTRIBUTE = "src";
public static final String CINCLUDE_INCLUDE_ELEMENT_ELEMENT_ATTRIBUTE = "element";
public static final String CINCLUDE_INCLUDE_ELEMENT_NS_ATTRIBUTE = "ns";
public static final String CINCLUDE_INCLUDE_ELEMENT_PREFIX_ATTRIBUTE = "prefix";
/** The <code>SourceResolver</code> */
protected SourceResolver sourceResolver;
/** The current <code>ComponentManager</code>. */
protected ComponentManager manager = null;
/** The current <code>IncludeCacheValidity</code>. */
protected IncludeCacheValidity currentCacheValidity;
/** The current <code>IncludeXMLConsumer</code> that ommits start and endDocument events. */
protected IncludeXMLConsumer consumer;
/**
* Setup the component.
*/
public void setup(SourceResolver resolver, Map objectModel,
String source, Parameters parameters)
throws ProcessingException, SAXException, IOException {
this.sourceResolver = resolver;
}
/**
* Composable Interface
*/
public final void compose(final ComponentManager manager) throws ComponentException {
this.manager = manager;
}
/**
* Recycle the component
*/
public void recycle() {
super.recycle();
this.sourceResolver = null;
this.currentCacheValidity = null;
}
public void startElement(String uri, String name, String raw, Attributes attr)
throws SAXException {
if (uri != null && name != null
&& uri.equals(CINCLUDE_NAMESPACE_URI)
&& name.equals(CINCLUDE_INCLUDE_ELEMENT)) {
this.processCIncludeElement(attr.getValue("",CINCLUDE_INCLUDE_ELEMENT_SRC_ATTRIBUTE),
attr.getValue("",CINCLUDE_INCLUDE_ELEMENT_ELEMENT_ATTRIBUTE),
attr.getValue("",CINCLUDE_INCLUDE_ELEMENT_NS_ATTRIBUTE),
attr.getValue("",CINCLUDE_INCLUDE_ELEMENT_PREFIX_ATTRIBUTE));
} else {
super.startElement(uri, name, raw, attr);
}
}
public void endElement(String uri, String name, String raw) throws SAXException {
if (uri != null && name != null
&& uri.equals(CINCLUDE_NAMESPACE_URI)
&& name.equals(CINCLUDE_INCLUDE_ELEMENT)) {
return;
}
super.endElement(uri, name, raw);
}
public void endDocument()
throws SAXException {
super.endDocument();
if(currentCacheValidity != null) {
currentCacheValidity.setIsNew2False();
}
}
protected void processCIncludeElement(String src, String element, String ns, String prefix)
throws SAXException {
if (element == null) element="";
if (ns == null) ns="";
if (prefix == null) prefix="";
if (this.getLogger().isDebugEnabled()) {
getLogger().debug("Processing CInclude element: src=" + src
+ ", element=" + element
+ ", ns=" + ns
+ ", prefix=" + prefix);
}
// complete validity information
if(currentCacheValidity != null ) {
Source temp = null;
try {
temp = sourceResolver.resolveURI(src);
currentCacheValidity.add(src, temp.getLastModified());
if (this.getLogger().isDebugEnabled()) {
getLogger().debug("currentCacheValidity: " + currentCacheValidity);
}
} catch (Exception e) {
throw new SAXException("CachingCIncludeTransformer could not resolve resource", e);
} finally {
sourceResolver.release(temp);
}
}
if (!"".equals(element)) {
if (!ns.equals("")) {
super.startPrefixMapping(prefix, ns);
}
super.startElement(ns,
element,
(!ns.equals("") && !prefix.equals("") ? prefix+":"+element : element),
XMLUtils.EMPTY_ATTRIBUTES);
}
Source source = null;
try {
source = this.sourceResolver.resolveURI(src);
SourceUtil.parse(this.manager, source, getConsumer());
} catch (Exception e) {
throw new SAXException("CachingCIncludeTransformer could not read resource", e);
} finally {
sourceResolver.release(source);
}
if (!"".equals(element)) {
super.endElement(ns, element, (!ns.equals("") && !prefix.equals("") ? prefix+":"+element : element));
if (!ns.equals("")) {
super.endPrefixMapping(prefix);
}
}
}
/**
* Generate the unique key.
* This key must be unique inside the space of this component.
* CachingCIncludeTransformer always generates the same key since which documents
* are included depends only on former generation/transformation stages.
*
* @return The generated key hashes the src
*/
public long generateKey() {
return 1;
}
/**
* Generate the validity object.
* CachingCIncludeTransformer generates "empty" IncludeCacheValidity
* and completes it with validity data during transformation.
* See processCIncludeElement method.
*
* @return The generated validity object or <code>null</code> if the
* component is currently not cacheable.
*/
public CacheValidity generateValidity() {
try {
currentCacheValidity = new IncludeCacheValidity(sourceResolver);
return currentCacheValidity;
} catch (RuntimeException e) {
getLogger().warn("CachingCIncludeTransformer: could not generateKey", e);
return null;
}
}
protected IncludeXMLConsumer getConsumer() {
if(consumer == null) {
consumer = new IncludeXMLConsumer(this);
}
return consumer;
}
}