/*
* Copyright 1999-2004 The Apache Software Foundation.
*
* Licensed 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.helpers;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.apache.excalibur.source.SourceValidity;
import org.apache.excalibur.source.impl.validity.ExpiresValidity;
/**
* This object encapsulates a "caching session". A caching session has the
* duration of one single request.
* This object is used by the {@link IncludeCacheManager} and holds all required
* configuration for performing the caching of this request.
*
* The session can be configured during construction with the following parameters:
* - purge (boolean/false) : Turn on/off purging the cache
* - preemptive (boolean/false) : Turn on/off preemptive caching
* - parallel (boolean/false) : Turn on/off parallel processing
* - expires (long/0) : The lifetime of the cached content
*
* @author <a href="mailto:cziegeler@apache.org">Carsten Ziegeler</a>
* @version CVS $Id: IncludeCacheManagerSession.java,v 1.6 2004/03/05 13:03:00 bdelacretaz Exp $
* @since 2.1
*/
public final class IncludeCacheManagerSession {
/** The expires information */
private long expires;
/** Should we purge the cache */
private boolean purge;
/** Should we load preemptive */
private boolean preemptive;
/** Should we process everything in parallel */
private boolean parallel;
/** The used {@link IncludeCacheStorageProxy} */
private IncludeCacheStorageProxy storage;
/** The list of all threads */
private Map threadList;
/** Cache the expires validity object */
private SourceValidity validity;
/** Cache the source objects */
private Map sourceList = new HashMap(10);
/**
* Constructor
* @param configuration The parameters configuring this session
* @param proxy The proxy used to cache the data
*/
IncludeCacheManagerSession(Parameters configuration,
IncludeCacheStorageProxy proxy) {
this.expires = configuration.getParameterAsLong("expires", 0);
this.purge = configuration.getParameterAsBoolean("purge", false);
this.preemptive = configuration.getParameterAsBoolean("preemptive", false);
this.parallel = configuration.getParameterAsBoolean("parallel", false);
this.storage = proxy;
}
/**
* Get the used storage proxy
*/
IncludeCacheStorageProxy getCacheStorageProxy() {
return this.storage;
}
/**
* Get the expiration information
*/
public long getExpires() {
return this.expires;
}
public SourceValidity getExpiresValidity() {
if ( this.expires > 0 && this.validity == null) {
this.validity = new ExpiresValidity( this.expires * 1000 ); // milliseconds
}
return this.validity;
}
/**
* Is the cache purged?
*/
public boolean isPurging() {
return this.purge;
}
/**
* Do we use preemptive caching?
*/
public boolean isPreemptive() {
return this.preemptive;
}
/**
* Do we process the includes in parallel?
*/
public boolean isParallel() {
return this.parallel;
}
/**
* Add another object to the thread list
* @param uri The absolute URI
* @param object The thread
*/
void add(String uri, Object object) {
if ( null == this.threadList ) {
this.threadList = new HashMap(10);
}
this.threadList.put(uri, object);
}
/**
* Get the thread object.
* @param uri The URI
* @return Object The thread.
*/
Object get(String uri) {
if ( null != this.threadList ) {
return this.threadList.get( uri );
}
return null;
}
/**
* Turn off/on preemptive caching
*/
void setPreemptive(boolean value) {
this.preemptive = value;
}
/**
* Lookup a source object and cache it
* @param uri Absolute URI
* @return Source The source obejct
*/
public Source resolveURI(String uri, SourceResolver resolver)
throws IOException {
Source source = (Source)this.sourceList.get(uri);
if ( null == source ) {
source = resolver.resolveURI( uri );
this.sourceList.put( source.getURI(), source );
}
return source;
}
/**
* Cleanup
* @param resolver The source resolver to release cached sources
*/
void cleanup(SourceResolver resolver) {
Iterator iter = this.sourceList.values().iterator();
while ( iter.hasNext() ) {
final Source source = (Source) iter.next();
resolver.release( source );
}
}
/**
* Print a representation of this object
*/
public String toString() {
return "CacheManagerSession(" + this.hashCode() + ") -" +
" expires: " + this.expires +
" parallel: " + this.parallel +
" preemptive: " + this.preemptive +
" purge: " + this.purge;
}
}