org.jdal.vaadin.ui.form.AnnotationFieldFactory.java Source code

Introduction

Here is the source code for org.jdal.vaadin.ui.form.AnnotationFieldFactory.java

Source

/*
 * Copyright 2009-2011 the original author or authors.
 *
 * 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.jdal.vaadin.ui.form;

import java.lang.annotation.Annotation;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import javax.persistence.ManyToOne;

import org.apache.commons.lang.ArrayUtils;
import org.jdal.service.PersistentServiceFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ReflectionUtils;

import com.vaadin.data.Item;
import com.vaadin.data.util.BeanItem;
import com.vaadin.ui.Component;
import com.vaadin.ui.Field;

/**
 * FieldFactory that create fields based on Annotations.
 * 
 * @author Jose Luis Martin - (jlm@joseluismartin.info)
 */
public class AnnotationFieldFactory extends ConfigurableFieldFactory {

    @Autowired
    private transient PersistentServiceFactory persistentServiceFactory;

    private Map<Class<? extends Annotation>, FieldBuilder> annotationMap = Collections
            .synchronizedMap(new HashMap<Class<? extends Annotation>, FieldBuilder>());

    public AnnotationFieldFactory() {
    }

    public void init() {
        configureDefaults();
    }

    /**
     * {@inheritDoc}
     */
    public Field createField(Item item, Object propertyId, Component uiContext) {
        if (item instanceof BeanItem<?>) {
            BeanItem<?> bi = (BeanItem<?>) item;
            String name = (String) propertyId;
            Class<?> clazz = bi.getBean().getClass();
            java.lang.reflect.Field field = ReflectionUtils.findField(clazz, name);
            Annotation[] fa = new Annotation[] {};
            if (field != null) {
                fa = field.getAnnotations();
            }
            java.lang.reflect.Method method = BeanUtils.getPropertyDescriptor(clazz, name).getReadMethod();
            Annotation[] ma = method.getAnnotations();
            Annotation[] annotations = (Annotation[]) ArrayUtils.addAll(fa, ma);
            Field f = null;
            for (Annotation a : annotations) {
                f = findField(a, clazz, name);
                if (f != null) {
                    f.setCaption(createCaptionByPropertyId(propertyId));
                    applyFieldProcessors(f, propertyId);
                    return f;
                }
            }
        }
        // fall back to default
        return super.createField(item, propertyId, uiContext);
    }

    /**
     * Find a field instance for Annotation
     * @param a Annotation
     * @param name 
     * @param clazz 
     * @return Field instance
     */
    protected Field findField(Annotation a, Class<?> clazz, String name) {
        FieldBuilder builder = annotationMap.get(a.annotationType());

        return builder != null ? builder.build(clazz, name) : null;
    }

    /**
     * 
     */
    private void configureDefaults() {
        ComboBoxFieldBuilder comboBuilder = new ComboBoxFieldBuilder(persistentServiceFactory);
        annotationMap.put(ManyToOne.class, comboBuilder);
    }

    /**
     * @return the persistentServiceFactory
     */
    public PersistentServiceFactory getPersistentServiceFactory() {
        return persistentServiceFactory;
    }

    /**
     * @param persistentServiceFactory the persistentServiceFactory to set
     */
    public void setPersistentServiceFactory(PersistentServiceFactory persistentServiceFactory) {
        this.persistentServiceFactory = persistentServiceFactory;
    }

    /**
     * @return the annotationMap
     */
    public Map<Class<? extends Annotation>, FieldBuilder> getAnnotationMap() {
        return annotationMap;
    }

    /**
     * @param annotationMap the annotationMap to set
     */
    public void setAnnotationMap(Map<Class<? extends Annotation>, FieldBuilder> annotationMap) {
        this.annotationMap.clear();
        this.annotationMap.putAll(annotationMap);
    }

}