/*
* Copyright 2010, 2011 Chris Pheby
*
* 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.jadira.bindings.core.cdi;
import java.lang.annotation.Annotation;
import java.net.URL;
import javax.enterprise.event.Observes;
import javax.enterprise.inject.spi.Extension;
import javax.enterprise.inject.spi.ProcessAnnotatedType;
import org.jadira.bindings.core.api.Binding;
import org.jadira.bindings.core.api.Converter;
import org.jadira.bindings.core.api.FromUnmarshaller;
import org.jadira.bindings.core.api.ToMarshaller;
import org.jadira.bindings.core.binder.BasicBinder;
import org.jadira.bindings.core.binder.Binder;
import org.jadira.bindings.core.binder.ConverterKey;
import org.jadira.bindings.core.binder.RegisterableBinder;
/**
* A CDI Portable Extension that inspects beans being loaded by the container for bindings.
*/
public class BinderExtension implements Extension, Binder, RegisterableBinder {
/**
* Wrapped default binder
*/
private static final BasicBinder BINDING = new BasicBinder();
/**
* Create a new instance of BinderExtension
*/
public BinderExtension() {}
/**
* {@inheritDoc}
*/
/* @Override */
public <T, E> void processAnnotatedType(@Observes ProcessAnnotatedType<T> pat) {
Class<?> candidateClass = pat.getAnnotatedType().getJavaClass();
if (!candidateClass.isInterface()) {
try {
if (Binding.class.isAssignableFrom(candidateClass)) {
@SuppressWarnings("unchecked")
Class<? extends Binding<T, E>> bindingClass = (Class<? extends Binding<T, E>>) candidateClass;
Binding<T, E> myBinding = bindingClass.newInstance();
BINDING.registerBinding(myBinding.getBoundClass(), myBinding.getTargetClass(), myBinding);
} else if (ToMarshaller.class.isAssignableFrom(candidateClass)
|| FromUnmarshaller.class.isAssignableFrom(candidateClass)) {
if (ToMarshaller.class.isAssignableFrom(candidateClass)) {
@SuppressWarnings("unchecked")
Class<? extends ToMarshaller<T,E>> bindingClass = (Class<? extends ToMarshaller<T,E>>) candidateClass;
ToMarshaller<T,E> myBinding = bindingClass.newInstance();
BINDING.registerMarshaller(myBinding.getBoundClass(), myBinding.getTargetClass(), myBinding);
}
if (FromUnmarshaller.class.isAssignableFrom(candidateClass)) {
@SuppressWarnings("unchecked")
Class<? extends FromUnmarshaller<T,E>> bindingClass = (Class<? extends FromUnmarshaller<T,E>>) candidateClass;
FromUnmarshaller<T,E> myBinding = bindingClass.newInstance();
BINDING.registerUnmarshaller(myBinding.getBoundClass(), myBinding.getTargetClass(), myBinding);
}
} else if (Converter.class.isAssignableFrom(candidateClass)) {
@SuppressWarnings("unchecked")
Class<? extends Converter<T, E>> bindingClass = (Class<? extends Converter<T, E>>) candidateClass;
Converter<T,E> myConverter = bindingClass.newInstance();
BINDING.registerConverter(myConverter.getInputClass(), myConverter.getOutputClass(), myConverter);
} else {
BINDING.registerAnnotatedClasses(candidateClass);
}
} catch (InstantiationException e) {
throw new IllegalStateException("Cannot instantiate binding class: " + candidateClass);
} catch (IllegalAccessException e) {
throw new IllegalStateException("Cannot instantiate binding class: " + candidateClass);
}
}
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> T convertTo(Class<T> output, Object object) {
return BINDING.convertTo(output, object);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> T convertTo(Class<T> output, Object object,
Class<? extends Annotation> qualifier) {
return BINDING.convertTo(output, object, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> T convertTo(Class<S> sourceClass, Class<T> target, Object object) {
return BINDING.convertTo(sourceClass, target, object);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> T convertTo(Class<S> sourceClass, Class<T> target, Object object, Class<? extends Annotation> qualifier) {
return BINDING.convertTo(sourceClass, target, object, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> T convertTo(ConverterKey<S,T> key, Object object) {
return BINDING.convertTo(key, object);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> Binding<S, T> findBinding(Class<S> source, Class<T> target) {
return BINDING.findBinding(source, target);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> ToMarshaller<S, T> findMarshaller(Class<S> source, Class<T> target) {
return BINDING.findMarshaller(source, target);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> Converter<S, T> findConverter(Class<S> source, Class<T> target) {
return BINDING.findConverter(source, target);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> FromUnmarshaller<S, T> findUnmarshaller(Class<S> source, Class<T> target) {
return BINDING.findUnmarshaller(source, target);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> Binding<S, T> findBinding(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
return BINDING.findBinding(source, target, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> Binding<S,T> findBinding(ConverterKey<S,T> key) {
return BINDING.findBinding(key);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> ToMarshaller<S, T> findMarshaller(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
return BINDING.findMarshaller(source, target, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> ToMarshaller<S,T> findMarshaller(ConverterKey<S,T> key) {
return BINDING.findMarshaller(key);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> Converter<S, T> findConverter(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
return BINDING.findConverter(source, target, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> Converter<S,T> findConverter(ConverterKey<S,T> key) {
return BINDING.findConverter(key);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> FromUnmarshaller<S, T> findUnmarshaller(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
return BINDING.findUnmarshaller(source, target, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> FromUnmarshaller<S,T> findUnmarshaller(ConverterKey<S,T> key) {
return BINDING.findUnmarshaller(key);
}
/**
* {@inheritDoc}
*/
/* @Override */
public void registerConfiguration(URL nextLocation) {
BINDING.registerConfiguration(nextLocation);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerBinding(Class<S> sourceClass, Class<T> targetClass, Binding<S, T> converter) {
BINDING.registerBinding(sourceClass, targetClass, converter);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter) {
BINDING.registerUnmarshaller(sourceClass, targetClass, converter);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerMarshaller(Class<S> sourceClass, Class<T> targetClass, ToMarshaller<S, T> converter) {
BINDING.registerMarshaller(sourceClass, targetClass, converter);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerConverter(Class<S> sourceClass, Class<T> targetClass, Converter<S, T> converter) {
BINDING.registerConverter(sourceClass, targetClass, converter);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerBinding(Class<S> sourceClass, Class<T> targetClass, Binding<S, T> converter, Class<? extends Annotation> qualifier) {
BINDING.registerBinding(sourceClass, targetClass, converter, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerBinding(ConverterKey<S,T> key, Binding<S, T> converter) {
BINDING.registerBinding(key, converter);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter, Class<? extends Annotation> qualifier) {
BINDING.registerUnmarshaller(sourceClass, targetClass, converter, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerUnmarshaller(ConverterKey<S,T> key, FromUnmarshaller<S, T> converter) {
BINDING.registerUnmarshaller(key, converter);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerMarshaller(Class<S> sourceClass, Class<T> targetClass, ToMarshaller<S, T> converter, Class<? extends Annotation> qualifier) {
BINDING.registerMarshaller(sourceClass, targetClass, converter, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerMarshaller(ConverterKey<S,T> key, ToMarshaller<S, T> converter) {
BINDING.registerMarshaller(key, converter);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerConverter(Class<S> sourceClass, Class<T> targetClass, Converter<S, T> converter, Class<? extends Annotation> qualifier) {
BINDING.registerConverter(sourceClass, targetClass, converter, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S, T> void registerConverter(ConverterKey<S,T> key, Converter<S, T> converter) {
BINDING.registerConverter(key, converter);
}
/**
* {@inheritDoc}
*/
/* @Override */
public void registerAnnotatedClasses(Class<?>... classesToInspect) {
BINDING.registerAnnotatedClasses(classesToInspect);
}
/**
* {@inheritDoc}
*/
/* @Override */
public Iterable<ConverterKey<?,?>> getConverterEntries() {
return BINDING.getConverterEntries();
}
/**
* {@inheritDoc}
*/
/* @Override */
public <T> T convertFromString(Class<T> output, String object) {
return BINDING.convertFromString(output, object);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <T> T convertFromString(Class<T> output, String object,
Class<? extends Annotation> qualifier) {
return BINDING.convertFromString(output, object, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public String convertToString(Object object) {
return BINDING.convertToString(object);
}
/**
* {@inheritDoc}
*/
/* @Override */
public String convertToString(Object object,
Class<? extends Annotation> qualifier) {
return BINDING.convertToString(object, qualifier);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S> String convertToString(Class<S> input, Object object) {
return BINDING.convertToString(input, object);
}
/**
* {@inheritDoc}
*/
/* @Override */
public <S> String convertToString(Class<S> input, Object object,
Class<? extends Annotation> qualifier) {
return BINDING.convertToString(input, object, qualifier);
}
}