maint-5-2/tapestry-core/src/main/java/org/apache/tapestry5/internal/transform/CachedWorker.java

// Copyright 2008, 2010 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.tapestry5.internal.transform;

import java.lang.reflect.Modifier;
import java.util.List;

import org.apache.tapestry5.Binding;
import org.apache.tapestry5.BindingConstants;
import org.apache.tapestry5.ComponentResources;
import org.apache.tapestry5.annotations.Cached;
import org.apache.tapestry5.internal.TapestryInternalUtils;
import org.apache.tapestry5.ioc.services.PerThreadValue;
import org.apache.tapestry5.ioc.services.PerthreadManager;
import org.apache.tapestry5.model.MutableComponentModel;
import org.apache.tapestry5.runtime.Component;
import org.apache.tapestry5.services.*;

/**
 * Caches method return values for methods annotated with {@link Cached}.
 */
@SuppressWarnings("all")
public class CachedWorker implements ComponentClassTransformWorker
{
    private final BindingSource bindingSource;

    private final PerthreadManager perThreadManager;

    interface MethodResultCacheFactory
    {
        MethodResultCache create(Component instance);
    }

    /**
     * Handles the watching of a binding (usually a property or property expression), invalidating the
     * cache early if the watched binding's value changes.
     */
    private class SimpleMethodResultCache implements MethodResultCache
    {
        private boolean cached;
        private Object cachedValue;

        public void set(Object cachedValue)
        {
            cached = true;
            this.cachedValue = cachedValue;
        }

        public void reset()
        {
            cached = false;
            cachedValue = null;
        }

        public boolean isCached()
        {
            return cached;
        }

        public Object get()
        {
            return cachedValue;
        }
    }

    private class WatchedBindingMethodResultCache extends SimpleMethodResultCache
    {
        private final Binding binding;

        private Object cachedBindingValue;

        public WatchedBindingMethodResultCache(Binding binding)
        {
            this.binding = binding;
        }

        @Override
        public boolean isCached()
        {
            Object currentBindingValue = binding.get();

            if (!TapestryInternalUtils.isEqual(cachedBindingValue, currentBindingValue))
            {
                reset();

                cachedBindingValue = currentBindingValue;
            }

            return super.isCached();
        }
    }

    public CachedWorker(BindingSource bindingSource, PerthreadManager perthreadManager)
    {
        this.bindingSource = bindingSource;
        this.perThreadManager = perthreadManager;
    }

    public void transform(ClassTransformation transformation, MutableComponentModel model)
    {
        List<TransformMethod> methods = transformation.matchMethodsWithAnnotation(Cached.class);

        for (TransformMethod method : methods)
        {
            validateMethod(method);

            adviseMethod(transformation, method);
        }
    }

    private void adviseMethod(ClassTransformation transformation, TransformMethod method)
    {
        // The key needs to reflect not just the method name, but also the containing
        // page and component (otherwise, there would be unwanted sharing of cache
        // between different instances of the same component within or across pages). This
        // name can't be calculated until page instantiation time.

        FieldAccess fieldAccess = createPerThreadValueField(transformation, method);

        Cached annotation = method.getAnnotation(Cached.class);

        MethodResultCacheFactory factory = createFactory(transformation, annotation.watch(), method);

        ComponentMethodAdvice advice = createAdvice(fieldAccess, factory);

        method.addAdvice(advice);
    }

    private FieldAccess createPerThreadValueField(ClassTransformation transformation, TransformMethod method)
    {
        TransformField field = transformation.createField(Modifier.PROTECTED, PerThreadValue.class.getName(),
                "perThreadMethodCache$" + method.getName());

        // Each instance of the component will get a new PerThreadValue.
        field.injectIndirect(new ComponentValueProvider<PerThreadValue<MethodResultCache>>()
        {
            public PerThreadValue<MethodResultCache> get(ComponentResources resources)
            {
                return perThreadManager.createValue();
            }
        });

        return field.getAccess();
    }

    private ComponentMethodAdvice createAdvice(final FieldAccess perThreadValueAccess,
            final MethodResultCacheFactory factory)
    {
        return new ComponentMethodAdvice()
        {
            public void advise(ComponentMethodInvocation invocation)
            {
                MethodResultCache cache = getOrCreateCache(invocation);

                if (cache.isCached())
                {
                    invocation.overrideResult(cache.get());
                    return;
                }

                invocation.proceed();

                invocation.rethrow();

                cache.set(invocation.getResult());
            }

            private MethodResultCache getOrCreateCache(ComponentMethodInvocation invocation)
            {
                Component instance = invocation.getInstance();

                PerThreadValue<MethodResultCache> value = (PerThreadValue<MethodResultCache>) perThreadValueAccess
                        .read(instance);

                if (value.exists())
                    return value.get();

                return value.set(factory.create(instance));
            }
        };
    }

    private MethodResultCacheFactory createFactory(ClassTransformation transformation, final String watch,
            TransformMethod method)
    {
        if (watch.equals(""))
            return new MethodResultCacheFactory()
            {
                public MethodResultCache create(Component instance)
                {
                    return new SimpleMethodResultCache();
                }
            };

        // Each component instance will get its own Binding instance. That handles both different locales,
        // and reuse of a component (with a cached method) within a page or across pages.

        TransformField bindingField = transformation.createField(Modifier.PROTECTED, Binding.class.getName(),
                "cache$watchBinding$" + method.getName());

        final FieldAccess bindingAccess = bindingField.getAccess();

        transformation.getOrCreateMethod(TransformConstants.CONTAINING_PAGE_DID_LOAD_SIGNATURE).addAdvice(
                new ComponentMethodAdvice()
                {
                    public void advise(ComponentMethodInvocation invocation)
                    {
                        Binding binding = bindingSource.newBinding("@Cached watch", invocation.getComponentResources(),
                                BindingConstants.PROP, watch);

                        bindingAccess.write(invocation.getInstance(), binding);

                        invocation.proceed();
                    }
                });

        return new MethodResultCacheFactory()
        {
            public MethodResultCache create(Component instance)
            {
                Binding binding = (Binding) bindingAccess.read(instance);

                return new WatchedBindingMethodResultCache(binding);
            }
        };
    }

    private void validateMethod(TransformMethod method)
    {
        TransformMethodSignature signature = method.getSignature();

        if (signature.getReturnType().equals("void"))
            throw new IllegalArgumentException(String.format(
                    "Method %s may not be used with @Cached because it returns void.", method.getMethodIdentifier()));

        if (signature.getParameterTypes().length != 0)
            throw new IllegalArgumentException(String.format(
                    "Method %s may not be used with @Cached because it has parameters.", method.getMethodIdentifier()));
    }
}