package bboss.org.apache.velocity.runtime.resource.loader;
/*
* 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.
*/
import java.io.InputStream;
import bboss.org.apache.velocity.runtime.RuntimeServices;
import bboss.org.apache.velocity.runtime.log.Log;
import bboss.org.apache.velocity.runtime.resource.Resource;
import bboss.org.apache.velocity.runtime.resource.ResourceCacheImpl;
import bboss.org.apache.velocity.exception.ResourceNotFoundException;
import bboss.org.apache.velocity.exception.VelocityException;
import org.apache.commons.collections.ExtendedProperties;
/**
* This is abstract class the all text resource loaders should
* extend.
*
* @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
* @author <a href="mailto:geirm@optonline.net">Geir Magnusson Jr.</a>
* @version $Id: ResourceLoader.java 832280 2009-11-03 02:47:55Z wglass $
*/
public abstract class ResourceLoader
{
/**
* Does this loader want templates produced with it
* cached in the Runtime.
*/
protected boolean isCachingOn = false;
/**
* This property will be passed on to the templates
* that are created with this loader.
*/
protected long modificationCheckInterval = 2;
/**
* Class name for this loader, for logging/debuggin
* purposes.
*/
protected String className = null;
protected RuntimeServices rsvc = null;
protected Log log = null;
/**
* This initialization is used by all resource
* loaders and must be called to set up common
* properties shared by all resource loaders
* @param rs
* @param configuration
*/
public void commonInit( RuntimeServices rs, ExtendedProperties configuration)
{
this.rsvc = rs;
this.log = rsvc.getLog();
/*
* these two properties are not required for all loaders.
* For example, for ClasspathLoader, what would cache mean?
* so adding default values which I think are the safest
*
* don't cache, and modCheckInterval irrelevant...
*/
try
{
isCachingOn = configuration.getBoolean("cache", false);
}
catch (Exception e)
{
isCachingOn = false;
String msg = "Exception parsing cache setting: "+configuration.getString("cache");
log.error(msg, e);
throw new VelocityException(msg, e);
}
try
{
modificationCheckInterval = configuration.getLong("modificationCheckInterval", 0);
}
catch (Exception e)
{
modificationCheckInterval = 0;
String msg = "Exception parsing modificationCheckInterval setting: "+configuration.getString("modificationCheckInterval");
log.error(msg, e);
throw new VelocityException(msg, e);
}
/*
* this is a must!
*/
className = ResourceCacheImpl.class.getName();
try
{
className = configuration.getString("class", className);
}
catch (Exception e)
{
String msg = "Exception retrieving resource cache class name";
log.error(msg, e);
throw new VelocityException(msg, e);
}
}
/**
* Initialize the template loader with a
* a resources class.
* @param configuration
*/
public abstract void init( ExtendedProperties configuration);
/**
* Get the InputStream that the Runtime will parse
* to create a template.
* @param source
* @return The input stream for the requested resource.
* @throws ResourceNotFoundException
*/
public abstract InputStream getResourceStream( String source )
throws ResourceNotFoundException;
/**
* Given a template, check to see if the source of InputStream
* has been modified.
* @param resource
* @return True if the resource has been modified.
*/
public abstract boolean isSourceModified(Resource resource);
/**
* Get the last modified time of the InputStream source
* that was used to create the template. We need the template
* here because we have to extract the name of the template
* in order to locate the InputStream source.
* @param resource
* @return Time in millis when the resource has been modified.
*/
public abstract long getLastModified(Resource resource);
/**
* Return the class name of this resource Loader
* @return Class name of the resource loader.
*/
public String getClassName()
{
return className;
}
/**
* Set the caching state. If true, then this loader
* would like the Runtime to cache templates that
* have been created with InputStreams provided
* by this loader.
* @param value
*/
public void setCachingOn(boolean value)
{
isCachingOn = value;
}
/**
* The Runtime uses this to find out whether this
* template loader wants the Runtime to cache
* templates created with InputStreams provided
* by this loader.
* @return True if this resource loader caches.
*/
public boolean isCachingOn()
{
return isCachingOn;
}
/**
* Set the interval at which the InputStream source
* should be checked for modifications.
* @param modificationCheckInterval
*/
public void setModificationCheckInterval(long modificationCheckInterval)
{
this.modificationCheckInterval = modificationCheckInterval;
}
/**
* Get the interval at which the InputStream source
* should be checked for modifications.
* @return The modification check interval.
*/
public long getModificationCheckInterval()
{
return modificationCheckInterval;
}
/**
* Check whether any given resource exists. This is not really
* a very efficient test and it can and should be overridden in the
* subclasses extending ResourceLoader.
*
* @param resourceName The name of a resource.
* @return true if a resource exists and can be accessed.
* @since 1.6
*/
public boolean resourceExists(final String resourceName)
{
InputStream is = null;
try
{
is = getResourceStream(resourceName);
}
catch (ResourceNotFoundException e)
{
if (log.isDebugEnabled())
{
log.debug("Could not load resource '" + resourceName
+ "' from ResourceLoader " + this.getClass().getName()
+ ": " + e.getMessage());
}
}
finally
{
try
{
if (is != null)
{
is.close();
}
}
catch (Exception e)
{
if (log.isErrorEnabled())
{
String msg = "While closing InputStream for resource '" + resourceName
+ "' from ResourceLoader "+this.getClass().getName();
log.error(msg, e);
throw new VelocityException(msg, e);
}
}
}
return (is != null);
}
}