public static  void bind(ServiceBinder binder) 
{
        binder.bind(LoggingDecorator.class, LoggingDecoratorImpl.class);
        binder.bind(ChainBuilder.class, ChainBuilderImpl.class);
        binder.bind(PropertyAccess.class, PropertyAccessImpl.class);
        binder.bind(StrategyBuilder.class, StrategyBuilderImpl.class);
        binder.bind(PropertyShadowBuilder.class, PropertyShadowBuilderImpl.class);
        binder.bind(PipelineBuilder.class, PipelineBuilderImpl.class);
        binder.bind(DefaultImplementationBuilder.class, DefaultImplementationBuilderImpl.class);
        binder.bind(ExceptionTracker.class, ExceptionTrackerImpl.class);
        binder.bind(ExceptionAnalyzer.class, ExceptionAnalyzerImpl.class);
        binder.bind(TypeCoercer.class, TypeCoercerImpl.class);
        binder.bind(ThreadLocale.class, ThreadLocaleImpl.class);
        binder.bind(SymbolSource.class, SymbolSourceImpl.class);
        binder.bind(SymbolProvider.class, MapSymbolProvider.class).withId("ApplicationDefaults")
                .withMarker(ApplicationDefaults.class);
        binder.bind(SymbolProvider.class, MapSymbolProvider.class).withId("FactoryDefaults")
                .withMarker(FactoryDefaults.class);
        binder.bind(Runnable.class, RegistryStartup.class).withId("RegistryStartup");
        binder.bind(MasterObjectProvider.class, MasterObjectProviderImpl.class);
        binder.bind(ClassNameLocator.class, ClassNameLocatorImpl.class);
        binder.bind(AspectDecorator.class, AspectDecoratorImpl.class);
        binder.bind(ClasspathURLConverter.class, ClasspathURLConverterImpl.class);
}

 public static ServiceLifecycleSource build(Map<String, ServiceLifecycle> configuration) 
{
        return new ServiceLifecycleSource()
        {
            public ServiceLifecycle get(String scope)
            {
                return configuration.get(scope);
            }
        };
}

Provides access to additional service lifecycles. One lifecycles is built in ("singleton") but additional ones are accessed via this service (and its mapped configuration). Only proxiable services (those with explicit service interfaces) can be managed in terms of a lifecycle.

 public static  void contributeMasterObjectProvider(OrderedConfiguration<ObjectProvider> configuration,
    ObjectLocator locator) 
{
        configuration.add("Value", locator.autobuild(ValueObjectProvider.class));
        configuration.add("Symbol", locator.autobuild(SymbolObjectProvider.class));
}

Value

Supports the org.apache.tapestry5.ioc.annotations.Value annotation

Symbol

Supports the org.apache.tapestry5.ioc.annotations.Symbol annotations

 public  void contributeServiceLifecycleSource(MappedConfiguration<String, ServiceLifecycle> configuration,
    ObjectLocator locator) 
{
        configuration.add(ScopeConstants.PERTHREAD, locator.autobuild(PerThreadServiceLifecycle.class));
}

Contributes the "perthread" scope.

 public static  void contributeSymbolSource(OrderedConfiguration<SymbolProvider> configuration,
    SymbolProvider applicationDefaults,
    SymbolProvider factoryDefaults) 
{
        configuration.add("SystemProperties", new SystemPropertiesSymbolProvider(), "before:*");
        configuration.add("ApplicationDefaults", applicationDefaults, "after:SystemProperties");
        configuration.add("FactoryDefaults", factoryDefaults, "after:ApplicationDefaults");
}

 public static  void contributeTypeCoercer(Configuration<CoercionTuple> configuration) 
{
        add(configuration, Object.class, String.class, new Coercion< Object, String >()
        {
            public String coerce(Object input)
            {
                return input.toString();
            }
        });
        add(configuration, String.class, Double.class, new Coercion< String, Double >()
        {
            public Double coerce(String input)
            {
                return new Double(input);
            }
        });
        // String to BigDecimal is important, as String- >Double- >BigDecimal would lose
        // precision.
        add(configuration, String.class, BigDecimal.class, new Coercion< String, BigDecimal >()
        {
            public BigDecimal coerce(String input)
            {
                return new BigDecimal(input);
            }
        });
        add(configuration, BigDecimal.class, Double.class, new Coercion< BigDecimal, Double >()
        {
            public Double coerce(BigDecimal input)
            {
                return input.doubleValue();
            }
        });
        add(configuration, String.class, BigInteger.class, new Coercion< String, BigInteger >()
        {
            public BigInteger coerce(String input)
            {
                return new BigInteger(input);
            }
        });
        add(configuration, String.class, Long.class, new Coercion< String, Long >()
        {
            public Long coerce(String input)
            {
                return new Long(input);
            }
        });
        add(configuration, Long.class, Byte.class, new Coercion< Long, Byte >()
        {
            public Byte coerce(Long input)
            {
                return input.byteValue();
            }
        });
        add(configuration, Long.class, Short.class, new Coercion< Long, Short >()
        {
            public Short coerce(Long input)
            {
                return input.shortValue();
            }
        });
        add(configuration, Long.class, Integer.class, new Coercion< Long, Integer >()
        {
            public Integer coerce(Long input)
            {
                return input.intValue();
            }
        });
        add(configuration, Number.class, Long.class, new Coercion< Number, Long >()
        {
            public Long coerce(Number input)
            {
                return input.longValue();
            }
        });
        add(configuration, Double.class, Float.class, new Coercion< Double, Float >()
        {
            public Float coerce(Double input)
            {
                return input.floatValue();
            }
        });
        add(configuration, Long.class, Double.class, new Coercion< Long, Double >()
        {
            public Double coerce(Long input)
            {
                return input.doubleValue();
            }
        });
        add(configuration, String.class, Boolean.class, new Coercion< String, Boolean >()
        {
            public Boolean coerce(String input)
            {
                String trimmed = input.trim();
                if (trimmed.equalsIgnoreCase("false") || trimmed.length() == 0) return false;
                // Any non-blank string but "false"
                return true;
            }
        });
        add(configuration, Long.class, Boolean.class, new Coercion< Long, Boolean >()
        {
            public Boolean coerce(Long input)
            {
                return input.longValue() != 0;
            }
        });
        add(configuration, void.class, Boolean.class, new Coercion< Void, Boolean >()
        {
            public Boolean coerce(Void input)
            {
                return false;
            }
        });
        add(configuration, Collection.class, Boolean.class, new Coercion< Collection, Boolean >()
        {
            public Boolean coerce(Collection input)
            {
                return !input.isEmpty();
            }
        });
        add(configuration, Object.class, List.class, new Coercion< Object, List >()
        {
            public List coerce(Object input)
            {
                return Collections.singletonList(input);
            }
        });
        add(configuration, Object[].class, List.class, new Coercion< Object[], List >()
        {
            public List coerce(Object[] input)
            {
                return Arrays.asList(input);
            }
        });
        add(configuration, Float.class, Double.class, new Coercion< Float, Double >()
        {
            public Double coerce(Float input)
            {
                return input.doubleValue();
            }
        });
        Coercion primitiveArrayCoercion = new Coercion< Object, List >()
        {
            public List< Object > coerce(Object input)
            {
                int length = Array.getLength(input);
                Object[] array = new Object[length];
                for (int i = 0; i <  length; i++)
                {
                    array[i] = Array.get(input, i);
                }
                return Arrays.asList(array);
            }
        };
        add(configuration, byte[].class, List.class, primitiveArrayCoercion);
        add(configuration, short[].class, List.class, primitiveArrayCoercion);
        add(configuration, int[].class, List.class, primitiveArrayCoercion);
        add(configuration, long[].class, List.class, primitiveArrayCoercion);
        add(configuration, float[].class, List.class, primitiveArrayCoercion);
        add(configuration, double[].class, List.class, primitiveArrayCoercion);
        add(configuration, char[].class, List.class, primitiveArrayCoercion);
        add(configuration, boolean[].class, List.class, primitiveArrayCoercion);
        add(configuration, String.class, File.class, new Coercion< String, File >()
        {
            public File coerce(String input)
            {
                return new File(input);
            }
        });
        add(configuration, String.class, TimeInterval.class, new Coercion< String, TimeInterval >()
        {
            public TimeInterval coerce(String input)
            {
                return new TimeInterval(input);
            }
        });
        add(configuration, TimeInterval.class, Long.class, new Coercion< TimeInterval, Long >()
        {
            public Long coerce(TimeInterval input)
            {
                return input.milliseconds();
            }
        });
        add(configuration, Object.class, Object[].class, new Coercion< Object, Object[] >()
        {
            public Object[] coerce(Object input)
            {
                return new Object[] {input};
            }
        });
        add(configuration, Collection.class, Object[].class, new Coercion< Collection, Object[] >()
        {
            public Object[] coerce(Collection input)
            {
                return input.toArray();
            }
        });
}

Contributes a set of standard type coercions to the TypeCoercer service:
• Object to String
• String to Double
• String to BigDecimal
• BigDecimal to Double
• Double to BigDecimal
• String to BigInteger
• BigInteger to Long
• String to Long
• Long to Byte
• Long to Short
• Long to Integer
• Double to Long
• Double to Float
• Float to Double
• Long to Double
• String to Boolean ("false" is always false, other non-blank strings are true)
• Long to Boolean (true if long value is non zero)
• Null to Boolean (always false)
• Collection to Boolean (false if empty)
• Object[] to List
• primitive[] to List
• Object to List (by wrapping as a singleton list)
• String to File
• String to org.apache.tapestry5.ioc.util.TimeInterval
• org.apache.tapestry5.ioc.util.TimeInterval to Long
• Object to Object[] (wrapping the object as an array)
• Collection to Object[] (via the toArray() method)