//

// 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.

* The root module for Tapestry.

*/

    public static void bind(ServiceBinder binder)

    {

        binder.bind(ClasspathAssetAliasManager.class, ClasspathAssetAliasManagerImpl.class);

        binder.bind(PersistentLocale.class, PersistentLocaleImpl.class);

        binder.bind(ApplicationStateManager.class, ApplicationStateManagerImpl.class);

        binder.bind(ApplicationStatePersistenceStrategySource.class,

                    ApplicationStatePersistenceStrategySourceImpl.class);

        binder.bind(BindingSource.class, BindingSourceImpl.class);

        binder.bind(PersistentFieldManager.class, PersistentFieldManagerImpl.class);

        binder.bind(FieldValidatorSource.class, FieldValidatorSourceImpl.class);

        binder.bind(ApplicationGlobals.class, ApplicationGlobalsImpl.class);

        binder.bind(AssetSource.class, AssetSourceImpl.class);

        binder.bind(Cookies.class, CookiesImpl.class);

        binder.bind(Environment.class, EnvironmentImpl.class);

        binder.bind(FieldValidatorDefaultSource.class, FieldValidatorDefaultSourceImpl.class);

        binder.bind(RequestGlobals.class, RequestGlobalsImpl.class);

        binder.bind(ResourceDigestGenerator.class, ResourceDigestGeneratorImpl.class);

        binder.bind(ValidationConstraintGenerator.class, ValidationConstraintGeneratorImpl.class);

        binder.bind(EnvironmentalShadowBuilder.class, EnvironmentalShadowBuilderImpl.class);

        binder.bind(ComponentSource.class, ComponentSourceImpl.class);

        binder.bind(BeanModelSource.class, BeanModelSourceImpl.class);

        binder.bind(BeanBlockSource.class, BeanBlockSourceImpl.class);

        binder.bind(ComponentDefaultProvider.class, ComponentDefaultProviderImpl.class);

        binder.bind(MarkupWriterFactory.class, MarkupWriterFactoryImpl.class);

        binder.bind(FieldValidationSupport.class, FieldValidationSupportImpl.class);

        binder.bind(TemplateParser.class, TemplateParserImpl.class);

        binder.bind(PageResponseRenderer.class, PageResponseRendererImpl.class);

        binder.bind(PageMarkupRenderer.class, PageMarkupRendererImpl.class);

        binder.bind(ComponentInvocationMap.class, NoOpComponentInvocationMap.class);

        binder.bind(ObjectRenderer.class, LocationRenderer.class).withId("LocationRenderer");

        binder.bind(UpdateListenerHub.class, UpdateListenerHubImpl.class);

        binder.bind(ObjectProvider.class, AssetObjectProvider.class).withId("AssetObjectProvider");

        binder.bind(LinkFactory.class, LinkFactoryImpl.class);

        binder.bind(LocalizationSetter.class, LocalizationSetterImpl.class);

        binder.bind(PageElementFactory.class, PageElementFactoryImpl.class);

        binder.bind(ClassNameLocator.class, ClassNameLocatorImpl.class);

        binder.bind(RequestExceptionHandler.class, DefaultRequestExceptionHandler.class);

        binder.bind(ResourceStreamer.class, ResourceStreamerImpl.class);

        binder.bind(ClientPersistentFieldStorage.class, ClientPersistentFieldStorageImpl.class);

        binder.bind(RequestEncodingInitializer.class, RequestEncodingInitializerImpl.class);

        binder.bind(ComponentEventResultProcessor.class, ComponentInstanceResultProcessor.class).withId(

                "ComponentInstanceResultProcessor");

        binder.bind(PageRenderQueue.class, PageRenderQueueImpl.class);

        binder.bind(AjaxPartialResponseRenderer.class, AjaxPartialResponseRendererImpl.class);

        binder.bind(PageContentTypeAnalyzer.class, PageContentTypeAnalyzerImpl.class);

        binder.bind(ResponseRenderer.class, ResponseRendererImpl.class);

        binder.bind(RequestPathOptimizer.class, RequestPathOptimizerImpl.class);

        binder.bind(NullFieldStrategySource.class, NullFieldStrategySourceImpl.class);

        binder.bind(HttpServletRequestFilter.class, IgnoredPathsFilter.class).withId("IgnoredPathsFilter");

        binder.bind(PageResourcesSource.class, PageResourcesSourceImpl.class);

        binder.bind(ContextValueEncoder.class, ContextValueEncoderImpl.class);

    }

    public static Alias build(Logger logger,

                              @Inject @Symbol(InternalConstants.TAPESTRY_ALIAS_MODE_SYMBOL)

                              String mode,

                              @InjectService("AliasOverrides")

                              AliasManager overridesManager,

                              Collection<AliasContribution> configuration)

    {

        AliasManager manager = new AliasManagerImpl(logger, configuration);

        return new AliasImpl(manager, mode, overridesManager);

    }

    /**

     * A companion service to {@linkplain #build(org.slf4j.Logger, String, AliasManager, java.util.Collection)}  the

     * Alias service} whose configuration contribution define spot overrides to specific services.

     */

    public static AliasManager buildAliasOverrides(Logger logger, Collection<AliasContribution> configuration)

    {

        return new AliasManagerImpl(logger, configuration);

    }

    /**

     * Contributes the factory for serveral built-in binding prefixes ("asset", "block", "component", "literal", prop",

     * "nullfieldstrategy", "message", "validate", "translate", "var").

     */

    public static void contributeBindingSource(MappedConfiguration<String, BindingFactory> configuration,

                                               AssetSource assetSource,

                                               @InjectService("PropBindingFactory")

                                               BindingFactory propBindingFactory,

                                               FieldValidatorSource fieldValidatorSource,

                                               TranslatorSource translatorSource,

                                               ObjectLocator locator)

    {

        configuration.add(TapestryConstants.LITERAL_BINDING_PREFIX, new LiteralBindingFactory());

        configuration.add(TapestryConstants.PROP_BINDING_PREFIX, propBindingFactory);

        configuration.add("component", new ComponentBindingFactory());

        configuration.add("message", new MessageBindingFactory());

        configuration.add("validate", new ValidateBindingFactory(fieldValidatorSource));

        configuration.add("translate", new TranslateBindingFactory(translatorSource));

        configuration.add("block", new BlockBindingFactory());

        configuration.add("asset", locator.autobuild(AssetBindingFactory.class));

        configuration.add("var", new RenderVariableBindingFactory());

        configuration.add("nullfieldstrategy", locator.autobuild(NullFieldStrategyBindingFactory.class));

    }

    public static void contributeClasspathAssetAliasManager(MappedConfiguration<String, String> configuration,

                                                            // @Inject not needed, because this isn't a service builder method

                                                            @Symbol("tapestry.scriptaculous.path")

                                                            String scriptaculousPath,

                                                            @Symbol("tapestry.datepicker.path")

                                                            String datepickerPath)

    {

        configuration.add("tapestry", "org/apache/tapestry");

        configuration.add("scriptaculous", scriptaculousPath);

        configuration.add("datepicker", datepickerPath);

    }

    public static void contributeComponentClassResolver(Configuration<LibraryMapping> configuration)

    {

        configuration.add(new LibraryMapping("core", "org.apache.tapestry.corelib"));

    }

    /**

     * Adds a number of standard component class transform workers: <dl> <dt>Retain </dt> <dd> allows fields to retain

     * their values between requests</dd> <dt>Persist </dt> <dd> allows fields to store their their value persistently

     * between requests</dd> <dt>Parameter </dt> <dd> identifies parameters based on the {@link

     * org.apache.tapestry.annotations.Parameter} annotation</dd> <dt>Component </dt> <dd> identifies embedded

     * components based on the {@link org.apache.tapestry.annotations.Component} annotation</dd> <dt>Mixin </dt> <dd>

     * adds a mixin as part of a component's implementation</dd> <dt>Environment </dt> <dd> allows fields to contain

     * values extracted from the {@link Environment} service</dd> <dt>Inject </dt> <dd> used with the {@link Inject}

     * annotation, when a value is supplied</dd> <dt>InjectPage </dt> <dd> adds code to allow access to other pages via

     * the {@link InjectPage} field annotation</dd> <dt>InjectBlock </dt> <dd> allows a block from the template to be

     * injected into a field</dd> <dt>IncludeStylesheet </dt> <dd> supports the {@link

     * org.apache.tapestry.annotations.IncludeStylesheet} annotation</dd> <dt>IncludeJavaScriptLibrary </dt> <dd>

     * supports the {@link org.apache.tapestry.annotations.IncludeJavaScriptLibrary} annotation</dd>

     * <dt>SupportsInformalParameters </dt> <dd> checks for the annotation</dd> <dt>Meta </dt> <dd> checks for meta data

     * and adds it to the component model <dt>ApplicationState </dt> <dd> converts fields that reference application

     * state objects <dt>UnclaimedField </dt> <dd> identifies unclaimed fields and resets them to null/0/false at the

     * end of the request</dd> <dt>RenderCommand </dt> <dd> ensures all components also implement {@link

     * RenderCommand}</dd> <dt>SetupRender, BeginRender, etc. </dt> <dd> correspond to component render phases and

     * annotations</dd> <dt>InvokePostRenderCleanupOnResources </dt> <dd> makes sure {@link

     * org.apache.tapestry.internal.InternalComponentResources#postRenderCleanup()} is invoked after a component

     * finishes rendering</dd> <dt>ContentType</dt> <dd>Checks for {@link org.apache.tapestry.annotations.ContentType}

     * annotation</dd> <dt>ResponseEncoding</dt> <dd>Checks for the {@link ResponseEncoding} annotation</dd> </dl>

     */

    public static void contributeComponentClassTransformWorker(

            OrderedConfiguration<ComponentClassTransformWorker> configuration,

            ObjectLocator locator,

            InjectionProvider injectionProvider,

            Environment environment,

            ComponentClassResolver resolver,

            RequestPageCache requestPageCache,

            BindingSource bindingsource)

    {

        // TODO: Proper scheduling of all of this. Since a given field or method should

        // only have a single annotation, the order doesn't matter so much, as long as

        // UnclaimedField is last.

        configuration.add("Meta", new MetaWorker());

        configuration.add("ApplicationState", locator.autobuild(ApplicationStateWorker.class));

        configuration.add("Inject", new InjectWorker(locator, injectionProvider));

        configuration.add("MixinAfter", new MixinAfterWorker());

        configuration.add("Component", new ComponentWorker(resolver));

        configuration.add("Environment", new EnvironmentalWorker(environment));

        configuration.add("Mixin", new MixinWorker(resolver));

        configuration.add("OnEvent", new OnEventWorker());

        configuration.add("SupportsInformalParameters", new SupportsInformalParametersWorker());

        configuration.add("InjectPage", new InjectPageWorker(requestPageCache, resolver));

        configuration.add("InjectComponent", new InjectContainerWorker());

        configuration.add("RenderCommand", new RenderCommandWorker());

        // Default values for parameters are often some form of injection, so make sure

        // that Parameter fields are processed after injections.

        configuration.add("Parameter", new ParameterWorker(bindingsource), "after:Inject*");

        // Workers for the component rendering state machine methods; this is in typical

        // execution order.

        add(configuration, TransformConstants.SETUP_RENDER_SIGNATURE, SetupRender.class, false);

        add(configuration, TransformConstants.BEGIN_RENDER_SIGNATURE, BeginRender.class, false);

        add(configuration, TransformConstants.BEFORE_RENDER_TEMPLATE_SIGNATURE, BeforeRenderTemplate.class, false);

        add(configuration, TransformConstants.BEFORE_RENDER_BODY_SIGNATURE, BeforeRenderBody.class, false);

        // These phases operate in reverse order.

        add(configuration, TransformConstants.AFTER_RENDER_BODY_SIGNATURE, AfterRenderBody.class, true);

        add(configuration, TransformConstants.AFTER_RENDER_TEMPLATE_SIGNATURE, AfterRenderTemplate.class, true);

        add(configuration, TransformConstants.AFTER_RENDER_SIGNATURE, AfterRender.class, true);

        add(configuration, TransformConstants.CLEANUP_RENDER_SIGNATURE, CleanupRender.class, true);

        // Ideally, these should be ordered pretty late in the process to make sure there are no

        // side effects with other workers that do work inside the page lifecycle methods.

        add(configuration, PageLoaded.class, TransformConstants.CONTAINING_PAGE_DID_LOAD_SIGNATURE, "pageLoaded");

        add(configuration, PageAttached.class, TransformConstants.CONTAINING_PAGE_DID_ATTACH_SIGNATURE, "pageAttached");

        add(configuration, PageDetached.class, TransformConstants.CONTAINING_PAGE_DID_DETACH_SIGNATURE, "pageDetached");

        configuration.add("Retain", new RetainWorker());

        configuration.add("Persist", new PersistWorker());

        configuration.add("IncludeStylesheet", locator.autobuild(IncludeStylesheetWorker.class), "after:SetupRender");

        configuration.add("IncludeJavaScriptLibrary", locator.autobuild(IncludeJavaScriptLibraryWorker.class),

                          "after:SetupRender");

        configuration.add("InvokePostRenderCleanupOnResources", new InvokePostRenderCleanupOnResourcesWorker());

        configuration.add("ContentType", new ContentTypeWorker());

        configuration.add("ResponseEncoding", new ResponseEncodingWorker());

        // This one is always last. Any additional private fields that aren't annotated will

        // be converted to clear out at the end of the request.

        configuration.add("UnclaimedField", new UnclaimedFieldWorker(), "after:*");

    }

    /**

     * <dl> <dt>Annotation</dt> <dd>Checks for {@link org.apache.tapestry.beaneditor.DataType} annotation</dd>

     * <dt>Default  (ordered last)</dt> <dd>{@link org.apache.tapestry.internal.services.DefaultDataTypeAnalyzer}

     * service ({@link #contributeDefaultDataTypeAnalyzer(org.apache.tapestry.ioc.MappedConfiguration)} })</dd> </dl>

     */

    public static void contributeDataTypeAnalyzer(OrderedConfiguration<DataTypeAnalyzer> configuration,

                                                  @InjectService("DefaultDataTypeAnalyzer")

                                                  DataTypeAnalyzer defaultDataTypeAnalyzer)

    {

        configuration.add("Annotation", new AnnotationDataTypeAnalyzer());

        configuration.add("Default", defaultDataTypeAnalyzer, "after:*");

    }

    /**

     * Maps property types to data type names: <ul> <li>String --&gt; text <li>Number --&gt; text <li>Enum --&gt; enum

     * <li>Boolean --&gt; checkbox <li>Date --&gt; date </ul>

     */

    public static void contributeDefaultDataTypeAnalyzer(MappedConfiguration<Class, String> configuration)

    {

        // This is a special case contributed to avoid exceptions when a property type can't be

        // matched. DefaultDataTypeAnalyzer converts the empty string to null.

        configuration.add(Object.class, "");

        configuration.add(String.class, "text");

        // This may change; as currently implemented, "text" refers more to the edit component

        // (TextField) than to the "flavor" of data.

        configuration.add(Number.class, "text");

        configuration.add(Enum.class, "enum");

        configuration.add(Boolean.class, "checkbox");

        configuration.add(Date.class, "date");

    }

    public static void contributeBeanBlockSource(Configuration<BeanBlockContribution> configuration)

    {

        addEditBlock(configuration, "text");

        addEditBlock(configuration, "enum");

        addEditBlock(configuration, "checkbox");

        addEditBlock(configuration, "date");

        addEditBlock(configuration, "password");

        // longtext uses a text area, not a text field

        addEditBlock(configuration, "longtext");

        addDisplayBlock(configuration, "enum");

        addDisplayBlock(configuration, "date");

        // Password and long text have special output needs.

        addDisplayBlock(configuration, "password");

        addDisplayBlock(configuration, "longtext");

    }

    private static void addEditBlock(Configuration<BeanBlockContribution> configuration, String dataType)

    {

        addEditBlock(configuration, dataType, dataType);

    }

    private static void addEditBlock(Configuration<BeanBlockContribution> configuration, String dataType,

                                     String blockId)

    {

        configuration.add(new BeanBlockContribution(dataType, "PropertyEditBlocks", blockId, true));

    }

    private static void addDisplayBlock(Configuration<BeanBlockContribution> configuration, String dataType)

    {

        addDisplayBlock(configuration, dataType, dataType);

    }

    private static void addDisplayBlock(Configuration<BeanBlockContribution> configuration, String dataType,

                                        String blockId)

    {

        configuration.add(new BeanBlockContribution(dataType, "PropertyDisplayBlocks", blockId, false));

    }

    /**

     * Contributes the basic set of validators: <ul> <li>required</li> <li>minlength</li> <li>maxlength</li>

     * <li>min</li> <li>max</li> <li>regexp</li> </ul>

     */

    public static void contributeFieldValidatorSource(MappedConfiguration<String, Validator> configuration)

    {

        configuration.add("required", new Required());

        configuration.add("minlength", new MinLength());

        configuration.add("maxlength", new MaxLength());

        configuration.add("min", new Min());

        configuration.add("max", new Max());

        configuration.add("regexp", new Regexp());

    }

    /**

     * Contributes the base set of injection providers: <dl> <dt>Default</dt> <dd>based on {@link

     * MasterObjectProvider}</dd> <dt>Block</dt> <dd>injects fields of type Block</dd> <dt>ComponentResources</dt>

     * <dd>give component access to its resources</dd> <dt>CommonResources</dt> <dd>access to properties of resources

     * (log, messages, etc.)</dd> <dt>Asset</dt> <dd>injection of assets (triggered via {@link Path} annotation), with

     * the path relative to the component class</dd> <dt>Service</dt> <dd>ordered last, for use when Inject is present

     * and nothing else works, matches field type against Tapestry IoC services</dd> </dl>

     */

    public static void contributeInjectionProvider(OrderedConfiguration<InjectionProvider> configuration,

                                                   MasterObjectProvider masterObjectProvider,

                                                   ObjectLocator locator,

                                                   SymbolSource symbolSource,

                                                   AssetSource assetSource)

    {

        configuration.add("Default", new DefaultInjectionProvider(masterObjectProvider, locator));

        configuration.add("ComponentResources", new ComponentResourcesInjectionProvider());

        // This comes after default, to deal with conflicts between injecting a String as the

        // component id, and injecting a string with @Symbol or @Value.

        configuration.add("CommonResources", new CommonResourcesInjectionProvider(), "after:Default");

        configuration.add("Asset", new AssetInjectionProvider(symbolSource, assetSource), "before:Default");

        configuration.add("Block", new BlockInjectionProvider(), "before:Default");

        // This needs to be the last one, since it matches against services

        // and might blow up if there is no match.

        configuration.add("Service", new ServiceInjectionProvider(locator), "after:*");

    }

    /**

     * Contributes two object providers: <dl> <dt>Alias</dt> <dd> Searches by type among {@linkplain AliasContribution

     * contributions} to the {@link Alias} service</dd> <dt>Asset<dt> <dd> Checks for the {@link Path} annotation, and

     * injects an {@link Asset}</dd> <dt>Service</dt> <dd>Injects based on the {@link Service} annotation, if

     * present</dd> </dl>

     */

    public static void contributeMasterObjectProvider(OrderedConfiguration<ObjectProvider> configuration,

                                                      @InjectService("Alias")

                                                      final Alias alias,

                                                      @InjectService("AssetObjectProvider")

                                                      ObjectProvider assetObjectProvider)

    {

        // There's a nasty web of dependencies related to Alias; this wrapper class lets us

        // defer instantiating the Alias service implementation just long enough to defuse those

        // dependencies.

        ObjectProvider wrapper = new ObjectProvider()

        {

            public <T> T provide(Class<T> objectType, AnnotationProvider annotationProvider, ObjectLocator locator)

            {

                return alias.getObjectProvider().provide(objectType, annotationProvider, locator);

            }

        };

        configuration.add("Alias", wrapper, "after:Value");

        configuration.add("Asset", assetObjectProvider, "before:Alias");

        configuration.add("Service", new ServiceAnnotationObjectProvider(), "before:Alias");

    }

    public static void contributeHttpServletRequestHandler(OrderedConfiguration<HttpServletRequestFilter> configuration,

                                                           @InjectService("IgnoredPathsFilter")

                                                           HttpServletRequestFilter ignoredPathsFilter)

    {

        configuration.add("IgnoredPaths", ignoredPathsFilter);

    }

    /**

     * Continues a number of filters into the RequestHandler service: <dl> <dt>StaticFiles</dt> <dd>Checks to see if the

     * request is for an actual file, if so, returns true to let the servlet container process the request</dd>

     * <dt>CheckForUpdates</dt> <dd>Periodically fires events that checks to see if the file system sources for any

     * cached data has changed (see {@link org.apache.tapestry.internal.services.CheckForUpdatesFilter}).

     * <dt>ErrorFilter</dt> <dd>Catches request errors and lets the {@link org.apache.tapestry.services.RequestExceptionHandler}

     * handle them</dd> <dt>Localization</dt> <dd>Determines the locale for the current request from header data or

     * cookies in the request</dd>

     * <dt>StoreIntoGlobals</dt> <dd>Stores the request and response into the {@link

     * org.apache.tapestry.services.RequestGlobals} service (this is repeated at the end of the pipeline, in case any

     * filter substitutes the request or response). </dl>

     */

    public void contributeRequestHandler(OrderedConfiguration<RequestFilter> configuration, Context context,

                                         final RequestExceptionHandler exceptionHandler,

                                         // @Inject not needed because its a long, not a String

                                         @Symbol(TapestryConstants.FILE_CHECK_INTERVAL_SYMBOL)

                                         @IntermediateType(TimeInterval.class)

                                         long checkInterval,

                                         @Symbol(TapestryConstants.FILE_CHECK_UPDATE_TIMEOUT_SYMBOL)

                                         @IntermediateType(TimeInterval.class)

                                         long updateTimeout,

                                         LocalizationSetter localizationSetter)

    {

        RequestFilter staticFilesFilter = new StaticFilesFilter(context);

        RequestFilter errorFilter = new RequestFilter()

        {

            public boolean service(Request request, Response response, RequestHandler handler) throws IOException

            {

                try

                {

                    return handler.service(request, response);

                }

                catch (IOException ex)

                {

                    // Pass it through.

                    throw ex;

                }

                catch (Throwable ex)

                {

                    exceptionHandler.handleRequestException(ex);

                    // We assume a reponse has been sent and there's no need to handle the request

                    // further.

                    return true;

                }

            }

        };

        RequestFilter storeIntoGlobals = new RequestFilter()

        {

            public boolean service(Request request, Response response, RequestHandler handler) throws IOException

            {

                _requestGlobals.store(request, response);

                return handler.service(request, response);

            }

        };

        configuration.add("CheckForUpdates",

                          new CheckForUpdatesFilter(_updateListenerHub, checkInterval, updateTimeout), "before:*");

        configuration.add("StaticFiles", staticFilesFilter);

        configuration.add("ErrorFilter", errorFilter);

        configuration.add("StoreIntoGlobals", storeIntoGlobals);

        configuration.add("Localization", new LocalizationFilter(localizationSetter), "after:ErrorFilter");

    }

    /**

     * Contributes the basic set of named translators: <ul>  <li>string</li>  <li>byte</li> <li>integer</li>

     * <li>long</li> <li>float</li> <li>double</li> </ul>

     */

    public static void contributeTranslatorSource(MappedConfiguration<String, Translator> configuration)

    {

        configuration.add("string", new StringTranslator());

        configuration.add("byte", new ByteTranslator());

        configuration.add("integer", new IntegerTranslator());

        configuration.add("long", new LongTranslator());

        configuration.add("float", new FloatTranslator());

        configuration.add("double", new DoubleTranslator());

    }

    /**

     * Adds coercions: <ul> <li>String to {@link SelectModel} <li>Map to {@link SelectModel} <li>Collection to {@link

     * GridDataSource} <li>null to {@link GridDataSource} <li>String to {@link GridPagerPosition} <li>List to {@link

     * SelectModel} <li>{@link ComponentResourcesAware} (typically, a component) to {@link ComponentResources} </ul>

     */

    public static void contributeTypeCoercer(Configuration<CoercionTuple> configuration)

    {

        add(configuration, String.class, SelectModel.class, new Coercion<String, SelectModel>()

        {

            public SelectModel coerce(String input)

            {

                return TapestryInternalUtils.toSelectModel(input);

            }

        });

        add(configuration, Map.class, SelectModel.class, new Coercion<Map, SelectModel>()

        {

            @SuppressWarnings("unchecked")

            public SelectModel coerce(Map input)

            {

                return TapestryInternalUtils.toSelectModel(input);

            }

        });

        add(configuration, Collection.class, GridDataSource.class, new Coercion<Collection, GridDataSource>()

        {

            public GridDataSource coerce(Collection input)

            {

                return new CollectionGridDataSource(input);

            }

        });

        add(configuration, void.class, GridDataSource.class, new Coercion<Void, GridDataSource>()

        {

            private final GridDataSource _source = new NullDataSource();

            public GridDataSource coerce(Void input)

            {

                return _source;

            }

        });

        add(configuration, String.class, GridPagerPosition.class,

            new StringToEnumCoercion<GridPagerPosition>(GridPagerPosition.class));

        add(configuration, List.class, SelectModel.class, new Coercion<List, SelectModel>()

        {

            @SuppressWarnings("unchecked")

            public SelectModel coerce(List input)

            {

                return TapestryInternalUtils.toSelectModel(input);

            }

        });

        add(configuration, String.class, Pattern.class, new Coercion<String, Pattern>()

        {

            public Pattern coerce(String input)

            {

                return Pattern.compile(input);

            }

        });

        add(configuration, ComponentResourcesAware.class, ComponentResources.class,

            new Coercion<ComponentResourcesAware, ComponentResources>()

            {

                public ComponentResources coerce(ComponentResourcesAware input)

                {

                    return input.getComponentResources();

                }

            });

    }

    /**

     * Adds built-in constraint generators: <ul> <li>PrimtiveField -- primitive fields are always required

     * <li>ValidateAnnotation -- adds constraints from a {@link Validate} annotation </ul>

     */

    public static void contributeValidationConstraintGenerator(

            OrderedConfiguration<ValidationConstraintGenerator> configuration)

    {

        configuration.add("PrimitiveField", new PrimitiveFieldConstraintGenerator());

        configuration.add("ValidateAnnotation", new ValidateAnnotationConstraintGenerator());

    }

    private static <S, T> void add(Configuration<CoercionTuple> configuration, Class<S> sourceType, Class<T> targetType,

                                   Coercion<S, T> coercion)

    {

        CoercionTuple<S, T> tuple = new CoercionTuple<S, T>(sourceType, targetType, coercion);

        configuration.add(tuple);

    }

    private static void add(OrderedConfiguration<ComponentClassTransformWorker> configuration,

                            Class<? extends Annotation> annotationClass,

                            TransformMethodSignature lifecycleMethodSignature, String methodAlias)

    {

        ComponentClassTransformWorker worker = new PageLifecycleAnnotationWorker(annotationClass,

                                                                                 lifecycleMethodSignature, methodAlias);

        String name = TapestryInternalUtils.lastTerm(annotationClass.getName());

        configuration.add(name, worker);

    }

    private static void add(OrderedConfiguration<ComponentClassTransformWorker> configuration,

                            TransformMethodSignature signature, Class<? extends Annotation> annotationClass,

                            boolean reverse)

    {

        // make the name match the annotation class name.

        String name = annotationClass.getSimpleName();

        configuration.add(name, new ComponentLifecycleMethodWorker(signature, annotationClass, reverse));

    }

    private final PipelineBuilder _pipelineBuilder;

    private final ApplicationGlobals _applicationGlobals;

    private final PropertyShadowBuilder _shadowBuilder;

    private final RequestPageCache _requestPageCache;

    private final Environment _environment;

    private final StrategyBuilder _strategyBuilder;

    private final PropertyAccess _propertyAccess;

    private final ClassFactory _componentClassFactory;

    private final ComponentInstantiatorSource _componentInstantiatorSource;

    private final ComponentTemplateSource _componentTemplateSource;

    private final UpdateListenerHub _updateListenerHub;

    private final ThreadCleanupHub _threadCleanupHub;

    private final ChainBuilder _chainBuilder;

    private final Request _request;

    private final Response _response;

    private final ThreadLocale _threadLocale;

    private final RequestGlobals _requestGlobals;

    private final ActionRenderResponseGenerator _actionRenderResponseGenerator;

    public TapestryModule(PipelineBuilder pipelineBuilder,

                          PropertyShadowBuilder shadowBuilder,

                          RequestGlobals requestGlobals,

                          ApplicationGlobals applicationGlobals,

                          ChainBuilder chainBuilder,

                          RequestPageCache requestPageCache,

                          Environment environment,

                          StrategyBuilder strategyBuilder,

                          ComponentInstantiatorSource componentInstantiatorSource,

                          PropertyAccess propertyAccess,

                          @ComponentLayer ClassFactory componentClassFactory,

                          UpdateListenerHub updateListenerHub, ThreadCleanupHub threadCleanupHub,

                          ComponentTemplateSource componentTemplateSource,

                          Request request,

                          Response response,

                          ThreadLocale threadLocale,

                          ActionRenderResponseGenerator actionRenderResponseGenerator)

    {

        _pipelineBuilder = pipelineBuilder;

        _shadowBuilder = shadowBuilder;

        _requestGlobals = requestGlobals;

        _applicationGlobals = applicationGlobals;

        _chainBuilder = chainBuilder;

        _requestPageCache = requestPageCache;

        _environment = environment;

        _strategyBuilder = strategyBuilder;

        _componentInstantiatorSource = componentInstantiatorSource;

        _propertyAccess = propertyAccess;

        _componentClassFactory = componentClassFactory;

        _updateListenerHub = updateListenerHub;

        _threadCleanupHub = threadCleanupHub;

        _componentTemplateSource = componentTemplateSource;

        _request = request;

        _response = response;

        _threadLocale = threadLocale;

        _actionRenderResponseGenerator = actionRenderResponseGenerator;

    }

    public Context build(ApplicationGlobals globals)

    {

        return _shadowBuilder.build(globals, "context", Context.class);

    }

    public ComponentClassResolver buildComponentClassResolver(ServiceResources resources)

    {

        ComponentClassResolverImpl service = resources.autobuild(ComponentClassResolverImpl.class);

        // Allow the resolver to clean its cache when the source is invalidated

        _componentInstantiatorSource.addInvalidationListener(service);

        return service;

    }

    /**

     * Builds the source of {@link Messages} containing validation messages. The contributions are paths to message

     * bundles (resource paths within the classpath); the default contribution is "org/apache/tapestry/internal/ValidationMessages".

     */

    public ValidationMessagesSource build(Collection<String> configuration, UpdateListenerHub updateListenerHub,

                                          @ClasspathProvider AssetFactory classpathAssetFactory)

    {

        ValidationMessagesSourceImpl service = new ValidationMessagesSourceImpl(configuration,

                                                                                classpathAssetFactory.getRootResource());

        updateListenerHub.addUpdateListener(service);

        return service;

    }

    public MetaDataLocator buildMetaDataLocator(ServiceResources resources)

    {

        MetaDataLocatorImpl service = resources.autobuild(MetaDataLocatorImpl.class);

        _componentInstantiatorSource.addInvalidationListener(service);

        return service;

    }

    /**

     * Builds a proxy to the current {@link org.apache.tapestry.PageRenderSupport} inside this thread's {@link

     * Environment}.

     */

    public PageRenderSupport buildPageRenderSupport(EnvironmentalShadowBuilder builder)

    {

        return builder.build(PageRenderSupport.class);

    }

    /**

     * Builds a proxy to the current {@link org.apache.tapestry.services.FormSupport} inside this thread's {@link

     * org.apache.tapestry.services.Environment}.

     */

    public FormSupport buildFormSupport(EnvironmentalShadowBuilder builder)

    {

        return builder.build(FormSupport.class);

    }

    /**

     * Allows the exact steps in the component class transformation process to be defined.

     */

    public ComponentClassTransformWorker build(List<ComponentClassTransformWorker> configuration)

    {

        return _chainBuilder.build(ComponentClassTransformWorker.class, configuration);

    }

    /**

     * Analyzes properties to determine the data types, used to {@linkplain #contributeBeanBlockSource(org.apache.tapestry.ioc.Configuration)}

     * locale display and edit blocks} for properties.  The default behaviors look for a {@link

     * org.apache.tapestry.beaneditor.DataType} annotation before deriving the data type from the property type.

     */

    @Marker(Primary.class)

    public DataTypeAnalyzer build(List<DataTypeAnalyzer> configuration)

    {

        return _chainBuilder.build(DataTypeAnalyzer.class, configuration);

    }

    /**

     * A chain of command for providing values for {@link Inject}-ed fields in component classes. The service's

     * configuration can be extended to allow for different automatic injections (based on some combination of field

     * type and field name).

     */

    public InjectionProvider build(List<InjectionProvider> configuration)

    {

        return _chainBuilder.build(InjectionProvider.class, configuration);

    }

    /**

     * Initializes the application.

     */

    @Marker(Primary.class)

    public ApplicationInitializer build(Logger logger, List<ApplicationInitializerFilter> configuration)

    {

        ApplicationInitializer terminator = new ApplicationInitializer()

        {

            public void initializeApplication(Context context)

            {

                _applicationGlobals.store(context);

            }

        };

        return _pipelineBuilder.build(logger, ApplicationInitializer.class, ApplicationInitializerFilter.class,

                                      configuration, terminator);

    }

    public HttpServletRequestHandler build(Logger logger, List<HttpServletRequestFilter> configuration,

                                           @Primary

                                           final RequestHandler handler)

    {

        HttpServletRequestHandler terminator = new HttpServletRequestHandler()

        {

            public boolean service(HttpServletRequest servletRequest, HttpServletResponse servletResponse)

                    throws IOException

            {

                _requestGlobals.store(servletRequest, servletResponse);

                Request request = new RequestImpl(servletRequest);

                Response response = new ResponseImpl(servletResponse);

                // Transition from the Servlet API-based pipeline, to the Tapestry-based pipeline.

                return handler.service(request, response);

            }

        };

        return _pipelineBuilder.build(logger, HttpServletRequestHandler.class, HttpServletRequestFilter.class,

                                      configuration, terminator);

    }

    @Marker(Primary.class)

    public RequestHandler build(Logger logger, List<RequestFilter> configuration,

                                @Primary

                                final Dispatcher masterDispatcher)

    {

        RequestHandler terminator = new RequestHandler()

        {

            public boolean service(Request request, Response response) throws IOException

            {

                _requestGlobals.store(request, response);

                return masterDispatcher.dispatch(request, response);

            }

        };

        return _pipelineBuilder.build(logger, RequestHandler.class, RequestFilter.class, configuration, terminator);

    }

    public ServletApplicationInitializer build(Logger logger, List<ServletApplicationInitializerFilter> configuration,

                                               @Primary

                                               final ApplicationInitializer initializer)

    {

        ServletApplicationInitializer terminator = new ServletApplicationInitializer()

        {

            public void initializeApplication(ServletContext context)

            {

                _applicationGlobals.store(context);

                // And now, down the (Web) ApplicationInitializer pipeline ...

                initializer.initializeApplication(new ContextImpl(context));

            }

        };

        return _pipelineBuilder.build(logger, ServletApplicationInitializer.class,

                                      ServletApplicationInitializerFilter.class, configuration, terminator);

    }

    /**

     * The component event result processor used for normal component requests.

     */

    @Marker({Primary.class, Traditional.class})

    public ComponentEventResultProcessor buildComponentEventResultProcessor(

            Map<Class, ComponentEventResultProcessor> configuration)

    {

        return constructComponentEventResultProcessor(configuration);

    }

    /**

     * The component event result processor used for Ajax-oriented component requests.

     */

    @Marker(Ajax.class)

    public ComponentEventResultProcessor buildAjaxComponentEventResultProcessor(

            Map<Class, ComponentEventResultProcessor> configuration)

    {

        return constructComponentEventResultProcessor(configuration);

    }

    private ComponentEventResultProcessor constructComponentEventResultProcessor(

            Map<Class, ComponentEventResultProcessor> configuration)

    {

        Set<Class> handledTypes = CollectionFactory.newSet(configuration.keySet());

        // A slight hack!

        configuration.put(Object.class, new ObjectComponentEventResultProcessor(handledTypes));

        StrategyRegistry<ComponentEventResultProcessor> registry = StrategyRegistry.newInstance(

                ComponentEventResultProcessor.class, configuration);

        return _strategyBuilder.build(registry);

    }

    /**

     * The default data type analyzer is the final analyzer consulted and identifies the type entirely pased on the

     * property type, working against its own configuration (mapping property type class to data type).

     */

    public DataTypeAnalyzer buildDefaultDataTypeAnalyzer(ServiceResources resources)

    {

        DefaultDataTypeAnalyzer service = resources.autobuild(DefaultDataTypeAnalyzer.class);

        _componentInstantiatorSource.addInvalidationListener(service);

        return service;

    }

    public TranslatorSource buildTranslatorSource(ServiceResources resources)

    {

        TranslatorSourceImpl service = resources

                .autobuild(TranslatorSourceImpl.class);

        _componentInstantiatorSource.addInvalidationListener(service);

        return service;

    }

    @Marker(Primary.class)

    public ObjectRenderer build(Map<Class, ObjectRenderer> configuration)

    {

        StrategyRegistry<ObjectRenderer> registry = StrategyRegistry.newInstance(ObjectRenderer.class, configuration);

        return _strategyBuilder.build(registry);

    }

    public static ComponentMessagesSource build(UpdateListenerHub updateListenerHub,

                                                @ContextProvider AssetFactory contextAssetFactory,

                                                @Inject @Value("WEB-INF/${tapestry.app-name}.properties")

                                                String appCatalog)

    {

        ComponentMessagesSourceImpl service = new ComponentMessagesSourceImpl(contextAssetFactory

                .getRootResource(), appCatalog);

        updateListenerHub.addUpdateListener(service);

        return service;

    }

    /**

     * Returns a {@link ClassFactory} that can be used to create extra classes around component classes. This

     * ClassFactory will be cleared whenever an underlying component class is discovered to have changed. Use of this

     * class factory implies that your code will become aware of this (if necessary) to discard any cached object (alas,

     * this currently involves dipping into the internals side to register for the correct notifications). Failure to

     * properly clean up can result in really nasty PermGen space memory leaks.

     */

    @Marker(ComponentLayer.class)

    public ClassFactory buildComponentClassFactory()

    {

        return _shadowBuilder.build(_componentInstantiatorSource, "classFactory", ClassFactory.class);

    }