tapestry/tapestry-framework/src/java/org/apache/tapestry/services/impl/ExpressionCacheImpl.java

// Copyright 2004, 2005 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.tapestry.services.impl;

import edu.emory.mathcs.backport.java.util.concurrent.locks.ReentrantLock;
import ognl.ClassCacheInspector;
import ognl.Node;
import ognl.Ognl;
import ognl.OgnlRuntime;
import org.apache.hivemind.ApplicationRuntimeException;
import org.apache.tapestry.AbstractComponent;
import org.apache.tapestry.event.ReportStatusEvent;
import org.apache.tapestry.event.ReportStatusListener;
import org.apache.tapestry.event.ResetEventListener;
import org.apache.tapestry.services.ExpressionCache;
import org.apache.tapestry.services.ExpressionEvaluator;

import java.beans.Introspector;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;

/**
 * @author Howard M. Lewis Ship
 * @since 4.0
 */
public class ExpressionCacheImpl implements ExpressionCache, ResetEventListener, ReportStatusListener, ClassCacheInspector {

    private final ReentrantLock _lock = new ReentrantLock();
    
    private String _serviceId;

    private Map _cache = new WeakHashMap();
    
    private Map _objectCache = new WeakHashMap();
    
    private ExpressionEvaluator _evaluator;

    private final boolean _cachingDisabled = Boolean.getBoolean("org.apache.tapestry.disable-caching");

    public void initializeService()
    {
        if (_cachingDisabled)
        {
            OgnlRuntime.setClassCacheInspector(this);
        }
    }

    public void resetEventDidOccur()
    {
        try {
            
            _lock.lock();
            
            _cache.clear();
            _objectCache.clear();

            Introspector.flushCaches();

        } finally {
            
            _lock.unlock();
        }
    }

    public boolean shouldCache(Class type)
    {
        if (!_cachingDisabled || type == null
            || AbstractComponent.class.isAssignableFrom(type))
            return false;

        return true;
    }

    public void reportStatus(ReportStatusEvent event)
    {
        event.title(_serviceId);

        event.property("cached expression count", _cache.size());
        event.collection("cached expressions", _cache.keySet());
        
        event.property("cached object expression count", _objectCache.size());
    }
    
    public Object getCompiledExpression(Object target, String expression)
    {
        try {   
            
            _lock.lock();
            
            Map cached = (Map)_objectCache.get(target.getClass());
            
            if (cached == null)
            {    
                cached = new HashMap();
                _objectCache.put(target.getClass(), cached);
            }
            
            Node result = (Node)cached.get(expression);
            
            if (result == null || result.getAccessor() == null)
            {
                result = parse(target, expression);
                cached.put(expression, result);
            }
            
            return result;
            
        } finally {

            _lock.unlock();
        }
    }
    
    public Object getCompiledExpression(String expression)
    {
        try {
            
            _lock.lock();
            
            Object result = _cache.get(expression);

            if (result == null)
            {
                result = parse(expression);
                _cache.put(expression, result);
            }
            
            return result;
        } finally {

            _lock.unlock();
        }
    }

    private Node parse(Object target, String expression)
    {
        try
        {
            return Ognl.compileExpression(_evaluator.createContext(target), target, expression);
        }
        catch (Exception ex)
        {
            throw new ApplicationRuntimeException(ImplMessages.unableToParseExpression(expression,ex), ex);
        }
    }
    
    private Object parse(String expression)
    {
        try
        {
            return Ognl.parseExpression(expression);
        }
        catch (Exception ex)
        {
            throw new ApplicationRuntimeException(ImplMessages.unableToParseExpression(expression, ex), ex);
        }
    }

    public void setServiceId(String serviceId)
    {
        _serviceId = serviceId;
    }
    
    public void setEvaluator(ExpressionEvaluator evaluator)
    {
        _evaluator = evaluator;
    }
    
}