Changeset 976 for AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/AbstractBeanJobBuilder.java

Timestamp:

08/14/10 15:10:12 (22 months ago)

Author:

kasper

Message:

Made it possible to configure jobs using "configurable bean" acting as a prototype for actual executed beans

File:

• AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/AbstractBeanJobBuilder.java (modified) (3 diffs)

AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/AbstractBeanJobBuilder.java

@@ -5 +5 @@
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Set;
 
 import org.eobjects.analyzer.descriptors.BeanDescriptor;
 import org.eobjects.analyzer.descriptors.ConfiguredPropertyDescriptor;
 import org.eobjects.analyzer.util.ReflectionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 @SuppressWarnings("unchecked")
 class AbstractBeanJobBuilder<D extends BeanDescriptor<E>, E, B> {
 
-        private Map<ConfiguredPropertyDescriptor, Object> _properties = new HashMap<ConfiguredPropertyDescriptor, Object>();
+        private final Logger logger = LoggerFactory.getLogger(getClass());
+
         private D _descriptor;
+        private E _configurableBean;
 
         public AbstractBeanJobBuilder(D descriptor, Class<?> builderClass) {
+                if (descriptor == null) {
+                        throw new IllegalArgumentException("descriptor cannot be null");
+                }
+                if (builderClass == null) {
+                        throw new IllegalArgumentException("builderClass cannot be null");
+                }
                 _descriptor = descriptor;
                 if (!ReflectionUtils.is(getClass(), builderClass)) {
                         throw new IllegalArgumentException(
                                         "Builder class does not correspond to actual class of builder");
+                }
+                try {
+                        _configurableBean = _descriptor.getBeanClass().newInstance();
+                } catch (Exception e) {
+                        throw new IllegalArgumentException(
+                                        "Could not instantiate bean class: "
+                                                        + _descriptor.getBeanClass(), e);
                 }
         }
@@ -28 +46 @@
         }
 
+        public E getConfigurableBean() {
+                return _configurableBean;
+        }
+
         public boolean isConfigured() {
                 for (ConfiguredPropertyDescriptor configuredProperty : _descriptor
                                 .getConfiguredProperties()) {
-                        if (!getConfiguredProperties().containsKey(configuredProperty)) {
-                                return false;
+                        if (configuredProperty.isRequired()) {
+                                if (!getConfiguredProperties().containsKey(configuredProperty)) {
+                                        logger.debug("Configured property is not set: "
+                                                        + configuredProperty);
+                                        return false;
+                                }
                         }
                 }
@@ -86 +112 @@
                         }
                 }
-                _properties.put(configuredProperty, value);
+
+                configuredProperty.setValue(_configurableBean, value);
                 return (B) this;
         }
 
         public Map<ConfiguredPropertyDescriptor, Object> getConfiguredProperties() {
-                return Collections.unmodifiableMap(_properties);
+                Map<ConfiguredPropertyDescriptor, Object> map = new HashMap<ConfiguredPropertyDescriptor, Object>();
+                Set<ConfiguredPropertyDescriptor> configuredProperties = getDescriptor()
+                                .getConfiguredProperties();
+                for (ConfiguredPropertyDescriptor propertyDescriptor : configuredProperties) {
+                        Object value = propertyDescriptor.getValue(getConfigurableBean());
+                        if (value != null) {
+                                map.put(propertyDescriptor, value);
+                        }
+                }
+                return Collections.unmodifiableMap(map);
         }
 }