public String getLoaderNameForResource(String resourceName) 
{
        /*
         *  loop through our loaders...
         */
        for (Iterator it = resourceLoaders.iterator(); it.hasNext(); )
        {
            ResourceLoader resourceLoader = (ResourceLoader) it.next();
            InputStream is = null;
            /*
             *  if we find one that can provide the resource,
             *  return the name of the loaders's Class
             */
            try
            {
                is = resourceLoader.getResourceStream(resourceName);
                if (is != null)
                {
                    return resourceLoader.getClass().toString();
                }
            }
            catch (ResourceNotFoundException rnfe)
            {
                /*
                 * this isn't a problem.  keep going
                 */
            }
            finally
            {
                /*
                 *  if we did find one, clean up because we were
                 *  returned an open stream
                 */
                if (is != null)
                {
                    try
                    {
                        is.close();
                    }
                    catch (IOException supressed)
                    { }
                }
            }
        }
        return null;
}

Determines if a template exists, and returns name of the loader that provides it. This is a slightly less hokey way to support the Velocity.templateExists() utility method, which was broken when per-template encoding was introduced. We can revisit this.

 public Resource getResource(String resourceName,
    int resourceType) throws Exception, ResourceNotFoundException, ParseErrorException 
{
        return getResource(resourceName, resourceType, RuntimeConstants.ENCODING_DEFAULT);
}

Gets the named resource. Returned class type corresponds to specified type (i.e. Template to RESOURCE_TEMPLATE).

 public synchronized Resource getResource(String resourceName,
    int resourceType,
    String encoding) throws Exception, ResourceNotFoundException, ParseErrorException 
{
        /*
         * Check to see if the resource was placed in the cache.
         * If it was placed in the cache then we will use
         * the cached version of the resource. If not we
         * will load it.
         *
         * Note: the type is included in the key to differentiate ContentResource
         * (static content from #include) with a Template.
         */
        String resourceKey = resourceType + resourceName;
        Resource resource = globalCache.get(resourceKey);
        if (resource != null)
        {
            /*
             *  refresh the resource
             */
            try
            {
                refreshResource(resource, encoding);
            }
            catch (ResourceNotFoundException rnfe)
            {
                /*
                 *  something exceptional happened to that resource
                 *  this could be on purpose,
                 *  so clear the cache and try again
                 */
                globalCache.remove(resourceKey);
                return getResource(resourceName, resourceType, encoding);
            }
            catch (ParseErrorException pee)
            {
                log.error("ResourceManager.getResource() exception", pee);
                throw pee;
            }
            catch (RuntimeException re)
            {
        	throw re;
            }
            catch (Exception e)
            {
                log.error("ResourceManager.getResource() exception", e);
                throw e;
            }
        }
        else
        {
            try
            {
                /*
                 *  it's not in the cache, so load it.
                 */
                resource = loadResource(resourceName, resourceType, encoding);
                if (resource.getResourceLoader().isCachingOn())
                {
                    globalCache.put(resourceKey, resource);
                }
            }
            catch (ResourceNotFoundException rnfe)
            {
                log.error("ResourceManager : unable to find resource '" +
                          resourceName + "' in any resource loader.");
                throw rnfe;
            }
            catch (ParseErrorException pee)
            {
                log.error("ResourceManager.getResource() parse exception", pee);
                throw pee;
            }
            catch (RuntimeException re)
            {
    		throw re;
            }
            catch (Exception e)
            {
                log.error("ResourceManager.getResource() exception new", e);
                throw e;
            }
        }
        return resource;
}

Gets the named resource. Returned class type corresponds to specified type (i.e. Template to RESOURCE_TEMPLATE).

 public synchronized  void initialize(RuntimeServices rsvc) throws Exception 
{
                              
	if (isInit)
	{
	    log.warn("Re-initialization of ResourceLoader attempted!");
	    return;
	}
        ResourceLoader resourceLoader = null;
        this.rsvc = rsvc;
        log = rsvc.getLog();
        log.debug("Default ResourceManager initializing. (" + this.getClass() + ")");
        assembleResourceLoaderInitializers();
        for (Iterator it = sourceInitializerList.iterator(); it.hasNext();)
        {
            /**
             * Resource loader can be loaded either via class name or be passed
             * in as an instance.
             */
            ExtendedProperties configuration = (ExtendedProperties) it.next();
            String loaderClass = StringUtils.nullTrim(configuration.getString("class"));
            ResourceLoader loaderInstance = (ResourceLoader) configuration.get("instance");
            if (loaderInstance != null)
            {
                resourceLoader = loaderInstance;
            }
            else if (loaderClass != null)
            {
                resourceLoader = ResourceLoaderFactory.getLoader(rsvc, loaderClass);
            }
            else
            {
                log.error("Unable to find '" +
                          configuration.getString(RESOURCE_LOADER_IDENTIFIER) +
                          ".resource.loader.class' specification in configuration." +
                          " This is a critical value.  Please adjust configuration.");
                continue; // for(...
            }
            resourceLoader.commonInit(rsvc, configuration);
            resourceLoader.init(configuration);
            resourceLoaders.add(resourceLoader);
        }
        /*
         * now see if this is overridden by configuration
         */
        logWhenFound = rsvc.getBoolean(RuntimeConstants.RESOURCE_MANAGER_LOGWHENFOUND, true);
        /*
         *  now, is a global cache specified?
         */
        String cacheClassName = rsvc.getString(RuntimeConstants.RESOURCE_MANAGER_CACHE_CLASS);
        Object cacheObject = null;
        if (org.apache.commons.lang.StringUtils.isNotEmpty(cacheClassName))
        {
            try
            {
                cacheObject = ClassUtils.getNewInstance(cacheClassName);
            }
            catch (ClassNotFoundException cnfe)
            {
                log.error("The specified class for ResourceCache (" + cacheClassName +
                          ") does not exist or is not accessible to the current classloader.");
                cacheObject = null;
            }
            if (!(cacheObject instanceof ResourceCache))
            {
                log.error("The specified class for ResourceCache (" + cacheClassName +
                          ") does not implement " + ResourceCache.class.getName() +
                          " ResourceManager. Using default ResourceCache implementation.");
                cacheObject = null;
            }
        }
        /*
         *  if we didn't get through that, just use the default.
         */
        if (cacheObject == null)
        {
            cacheObject = new ResourceCacheImpl();
        }
        globalCache = (ResourceCache) cacheObject;
        globalCache.initialize(rsvc);
        log.trace("Default ResourceManager initialization complete.");
}

Initialize the ResourceManager.

 protected Resource loadResource(String resourceName,
    int resourceType,
    String encoding) throws Exception, ResourceNotFoundException, ParseErrorException 
{
        Resource resource = ResourceFactory.getResource(resourceName, resourceType);
        resource.setRuntimeServices(rsvc);
        resource.setName(resourceName);
        resource.setEncoding(encoding);
        /*
         * Now we have to try to find the appropriate
         * loader for this resource. We have to cycle through
         * the list of available resource loaders and see
         * which one gives us a stream that we can use to
         * make a resource with.
         */
        long howOldItWas = 0;
        for (Iterator it = resourceLoaders.iterator(); it.hasNext();)
        {
            ResourceLoader resourceLoader = (ResourceLoader) it.next();
            resource.setResourceLoader(resourceLoader);
            /*
             *  catch the ResourceNotFound exception
             *  as that is ok in our new multi-loader environment
             */
            try
            {
                if (resource.process())
                {
                    /*
                     *  FIXME  (gmj)
                     *  moved in here - technically still
                     *  a problem - but the resource needs to be
                     *  processed before the loader can figure
                     *  it out due to to the new
                     *  multi-path support - will revisit and fix
                     */
                    if (logWhenFound && log.isDebugEnabled())
                    {
                        log.debug("ResourceManager : found " + resourceName +
                                  " with loader " +
                                  resourceLoader.getClassName());
                    }
                    howOldItWas = resourceLoader.getLastModified(resource);
                    break;
                }
            }
            catch (ResourceNotFoundException rnfe)
            {
                /*
                 *  that's ok - it's possible to fail in
                 *  multi-loader environment
                 */
            }
        }
        /*
         * Return null if we can't find a resource.
         */
        if (resource.getData() == null)
        {
            throw new ResourceNotFoundException("Unable to find resource '" + resourceName + "'");
        }
        /*
         *  some final cleanup
         */
        resource.setLastModified(howOldItWas);
        resource.setModificationCheckInterval(resource.getResourceLoader().getModificationCheckInterval());
        resource.touch();
        return resource;
}

Loads a resource from the current set of resource loaders.

 protected  void refreshResource(Resource resource,
    String encoding) throws Exception, ResourceNotFoundException, ParseErrorException 
{
        /*
         * The resource knows whether it needs to be checked
         * or not, and the resource's loader can check to
         * see if the source has been modified. If both
         * these conditions are true then we must reload
         * the input stream and parse it to make a new
         * AST for the resource.
         */
        if (resource.requiresChecking())
        {
            /*
             *  touch() the resource to reset the counters
             */
            resource.touch();
            if (resource.isSourceModified())
            {
                /*
                 *  now check encoding info.  It's possible that the newly declared
                 *  encoding is different than the encoding already in the resource
                 *  this strikes me as bad...
                 */
                if (!org.apache.commons.lang.StringUtils.equals(resource.getEncoding(), encoding))
                {
                    log.warn("Declared encoding for template '" +
                             resource.getName() +
                             "' is different on reload. Old = '" +
                             resource.getEncoding() + "' New = '" + encoding);
                    resource.setEncoding(encoding);
                }
                /*
                 *  read how old the resource is _before_
                 *  processing (= >reading) it
                 */
                long howOldItWas = resource.getResourceLoader().getLastModified(resource);
                /*
                 *  read in the fresh stream and parse
                 */
                resource.process();
                /*
                 *  now set the modification info and reset
                 *  the modification check counters
                 */
                resource.setLastModified(howOldItWas);
            }
        }
}

Takes an existing resource, and 'refreshes' it. This generally means that the source of the resource is checked for changes according to some cache/check algorithm and if the resource changed, then the resource data is reloaded and re-parsed.