    001// Licensed under the Apache License, Version 2.0 (the "License");
    002// you may not use this file except in compliance with the License.
    003// You may obtain a copy of the License at
    004//
    005// http://www.apache.org/licenses/LICENSE-2.0
    006//
    007// Unless required by applicable law or agreed to in writing, software
    008// distributed under the License is distributed on an "AS IS" BASIS,
    009// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    010// See the License for the specific language governing permissions and
    011// limitations under the License.
    012
    013package org.apache.tapestry5.ioc.internal.services;
    014
    015import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
    016import org.apache.tapestry5.ioc.services.PlasticProxyFactory;
    017import org.apache.tapestry5.plastic.*;
    018import org.slf4j.Logger;
    019
    020import java.util.Iterator;
    021import java.util.List;
    022
    023/**
    024 * Used by the {@link org.apache.tapestry5.ioc.internal.services.PipelineBuilderImpl} to create bridge classes and to
    025 * create instances of bridge classes. A bridge class implements the <em>service</em> interface. Within the chain,
    026 * bridge 1 is passed to filter 1. Invoking methods on bridge 1 will invoke methods on filter 2.
    027 */
    028public class BridgeBuilder<S, F>
    029{
    030    private final Logger logger;
    031
    032    private final Class<S> serviceInterface;
    033
    034    private final Class<F> filterInterface;
    035
    036    private final FilterMethodAnalyzer filterMethodAnalyzer;
    037
    038    private final PlasticProxyFactory proxyFactory;
    039
    040    private ClassInstantiator<S> instantiator;
    041
    042    public BridgeBuilder(Logger logger, Class<S> serviceInterface, Class<F> filterInterface, PlasticProxyFactory proxyFactory)
    043    {
    044        this.logger = logger;
    045        this.serviceInterface = serviceInterface;
    046        this.filterInterface = filterInterface;
    047
    048        this.proxyFactory = proxyFactory;
    049
    050        filterMethodAnalyzer = new FilterMethodAnalyzer(serviceInterface);
    051    }
    052
    053    /**
    054     * Instantiates a bridge object.
    055     *
    056     * @param nextBridge
    057     *         the next Bridge object in the pipeline, or the terminator service
    058     * @param filter
    059     *         the filter object for this step of the pipeline
    060     */
    061    public S instantiateBridge(S nextBridge, F filter)
    062    {
    063        if (instantiator == null)
    064            createInstantiator();
    065
    066        return instantiator.with(filterInterface, filter).with(serviceInterface, nextBridge).newInstance();
    067    }
    068
    069    private void createInstantiator()
    070    {
    071        instantiator = proxyFactory.createProxy(serviceInterface, new PlasticClassTransformer()
    072        {
    073            @Override
    074            public void transform(PlasticClass plasticClass)
    075            {
    076                PlasticField filterField = plasticClass.introduceField(filterInterface, "filter")
    077                        .injectFromInstanceContext();
    078                PlasticField nextField = plasticClass.introduceField(serviceInterface, "next")
    079                        .injectFromInstanceContext();
    080
    081                processMethods(plasticClass, filterField, nextField);
    082
    083                plasticClass.addToString(String.format("<PipelineBridge from %s to %s>", serviceInterface.getName(),
    084                        filterInterface.getName()));
    085            }
    086        });
    087    }
    088
    089    private void processMethods(PlasticClass plasticClass, PlasticField filterField, PlasticField nextField)
    090    {
    091        List<MethodSignature> serviceMethods = CollectionFactory.newList();
    092        List<MethodSignature> filterMethods = CollectionFactory.newList();
    093
    094        MethodIterator mi = new MethodIterator(serviceInterface);
    095
    096        while (mi.hasNext())
    097        {
    098            serviceMethods.add(mi.next());
    099        }
    100
    101        mi = new MethodIterator(filterInterface);
    102
    103        while (mi.hasNext())
    104        {
    105            filterMethods.add(mi.next());
    106        }
    107
    108        while (!serviceMethods.isEmpty())
    109        {
    110            MethodSignature ms = serviceMethods.remove(0);
    111
    112            addBridgeMethod(plasticClass, filterField, nextField, ms, filterMethods);
    113        }
    114
    115        reportExtraFilterMethods(filterMethods);
    116    }
    117
    118    private void reportExtraFilterMethods(List filterMethods)
    119    {
    120        Iterator i = filterMethods.iterator();
    121
    122        while (i.hasNext())
    123        {
    124            MethodSignature ms = (MethodSignature) i.next();
    125
    126            logger.error("Method {} of filter interface {} does not have a matching method in {}.", ms, filterInterface.getName(), serviceInterface.getName());
    127        }
    128    }
    129
    130    /**
    131     * Finds a matching method in filterMethods for the given service method. A matching method has the same signature
    132     * as the service interface method, but with an additional parameter matching the service interface itself.
    133     *
    134     * The matching method signature from the list of filterMethods is removed and code generation strategies for making
    135     * the two methods call each other are added.
    136     */
    137    private void addBridgeMethod(PlasticClass plasticClass, PlasticField filterField, PlasticField nextField,
    138                                 final MethodSignature ms, List filterMethods)
    139    {
    140        PlasticMethod method = plasticClass.introduceMethod(ms.getMethod());
    141
    142        Iterator i = filterMethods.iterator();
    143
    144        while (i.hasNext())
    145        {
    146            MethodSignature fms = (MethodSignature) i.next();
    147
    148            int position = filterMethodAnalyzer.findServiceInterfacePosition(ms, fms);
    149
    150            if (position >= 0)
    151            {
    152                bridgeServiceMethodToFilterMethod(method, filterField, nextField, position, ms, fms);
    153                i.remove();
    154                return;
    155            }
    156        }
    157
    158        method.changeImplementation(new InstructionBuilderCallback()
    159        {
    160            @Override
    161            public void doBuild(InstructionBuilder builder)
    162            {
    163                String message = String.format("Method %s has no match in filter interface %s.", ms, filterInterface.getName());
    164
    165                logger.error(message);
    166
    167                builder.throwException(RuntimeException.class, message);
    168            }
    169        });
    170    }
    171
    172    private void bridgeServiceMethodToFilterMethod(PlasticMethod method, final PlasticField filterField,
    173                                                   final PlasticField nextField, final int position, MethodSignature ms, final MethodSignature fms)
    174    {
    175        method.changeImplementation(new InstructionBuilderCallback()
    176        {
    177            @Override
    178            public void doBuild(InstructionBuilder builder)
    179            {
    180                builder.loadThis().getField(filterField);
    181
    182                int argumentIndex = 0;
    183
    184                for (int i = 0; i < fms.getParameterTypes().length; i++)
    185                {
    186                    if (i == position)
    187                    {
    188                        builder.loadThis().getField(nextField);
    189                    } else
    190                    {
    191                        builder.loadArgument(argumentIndex++);
    192                    }
    193                }
    194
    195                builder.invoke(fms.getMethod()).returnResult();
    196            }
    197        });
    198    }
    199
    200}