Changeset 974


Ignore:
Timestamp:
08/14/10 11:12:43 (18 months ago)
Author:
kasper
Message:

limited possibility of @Configured and @Provided to fields in order to make it easy to also get value of properties through PropertyDescriptor?.

Location:
AnalyzerBeans/trunk/src
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/annotations/Configured.java

    r931 r974  
    3838 */ 
    3939@Retention(RetentionPolicy.RUNTIME) 
    40 @Target({ ElementType.METHOD, ElementType.FIELD }) 
     40@Target({ ElementType.FIELD }) 
    4141@Documented 
    4242@Inherited 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/annotations/Provided.java

    r900 r974  
    4545 */ 
    4646@Retention(RetentionPolicy.RUNTIME) 
    47 @Target( { ElementType.METHOD, ElementType.FIELD }) 
     47@Target( { ElementType.FIELD }) 
    4848@Documented 
    4949@Inherited 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/AbstractBeanDescriptor.java

    r971 r974  
    5252                        Configured configuredAnnotation = field 
    5353                                        .getAnnotation(Configured.class); 
     54                        Provided providedAnnotation = field.getAnnotation(Provided.class); 
     55 
     56                        if (configuredAnnotation != null && providedAnnotation != null) { 
     57                                throw new DescriptorException( 
     58                                                "The field " 
     59                                                                + field 
     60                                                                + " is annotated with both @Configured and @Provided, which are mutually exclusive."); 
     61                        } 
     62 
    5463                        if (configuredAnnotation != null) { 
    5564                                if (!field.isAnnotationPresent(Inject.class)) { 
    … …  
    6271                        } 
    6372 
    64                         Provided providedAnnotation = field.getAnnotation(Provided.class); 
    6573                        if (providedAnnotation != null) { 
    6674                                if (!field.isAnnotationPresent(Inject.class)) { 
    … …  
    8795                Method[] methods = beanClass.getDeclaredMethods(); 
    8896                for (Method method : methods) { 
    89                         Configured configuredAnnotation = method 
    90                                         .getAnnotation(Configured.class); 
    91                         if (configuredAnnotation != null) { 
    92                                 if (!method.isAnnotationPresent(Inject.class)) { 
    93                                         logger.warn( 
    94                                                         "No @Inject annotation found for @Configured method: {}", 
    95                                                         method); 
    96                                 } 
    97                                 _configuredProperties.add(new ConfiguredPropertyDescriptorImpl( 
    98                                                 method)); 
    99                         } 
    100  
    101                         Provided providedAnnotation = method.getAnnotation(Provided.class); 
    102                         if (providedAnnotation != null) { 
    103                                 if (!method.isAnnotationPresent(Inject.class)) { 
    104                                         logger.warn( 
    105                                                         "No @Inject annotation found for @Provided method: {}", 
    106                                                         method); 
    107                                 } 
    108                                 _providedProperties.add(new ProvidedPropertyDescriptorImpl( 
    109                                                 method)); 
    110                         } 
    111  
    11297                        Initialize initializeAnnotation = method 
    11398                                        .getAnnotation(Initialize.class); 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/AbstractPropertyDescriptor.java

    r967 r974  
    33import java.lang.annotation.Annotation; 
    44import java.lang.reflect.Field; 
    5 import java.lang.reflect.Method; 
    65import java.lang.reflect.Type; 
    76import java.util.Set; 
    … …  
    1110import org.eobjects.analyzer.util.SchemaNavigator; 
    1211 
    13 public class AbstractPropertyDescriptor implements PropertyDescriptor { 
     12public class AbstractPropertyDescriptor implements PropertyDescriptor, 
     13                Comparable<AbstractPropertyDescriptor> { 
    1414 
    15         private final Method _method; 
    1615        private final Field _field; 
    1716        private final Class<?> _baseType; 
    1817        private final Type _genericType; 
    1918 
    20         public AbstractPropertyDescriptor(Method setterMethod) { 
    21                 _field = null; 
    22                 _method = setterMethod; 
    23                 _method.setAccessible(true); 
    24                 Class<?>[] parameterTypes = setterMethod.getParameterTypes(); 
    25                 if (parameterTypes.length != 1) { 
    26                         throw new DescriptorException("The method " + setterMethod 
    27                                         + " defines " + parameterTypes.length 
    28                                         + " parameters, a single parameter is required"); 
     19        public AbstractPropertyDescriptor(Field field) { 
     20                if (field == null) { 
     21                        throw new IllegalArgumentException("field cannot be null"); 
    2922                } 
    30                 _baseType = parameterTypes[0]; 
    31                 _genericType = _method.getGenericParameterTypes()[0]; 
    32                 init(); 
    33         } 
    34  
    35         public AbstractPropertyDescriptor(Field field) { 
    36                 _method = null; 
    3723                _field = field; 
    3824                _field.setAccessible(true); 
    … …  
    5238        @Override 
    5339        public String getName() { 
    54                 return (_method == null ? _field.getName() : _method.getName()); 
     40                return _field.getName(); 
    5541        } 
    5642 
    5743        @Override 
    58         public void assignValue(Object bean, Object value) 
     44        public void setValue(Object bean, Object value) 
    5945                        throws IllegalArgumentException { 
    6046                try { 
    61                         if (_method != null) { 
    62                                 _method.invoke(bean, value); 
    63                         } else { 
    64                                 _field.set(bean, value); 
    65                         } 
     47                        _field.set(bean, value); 
    6648                } catch (Exception e) { 
    6749                        throw new IllegalStateException("Could not assign value '" + value 
    68                                         + "' to " + (_method == null ? _field : _method), e); 
     50                                        + "' to " + _field, e); 
     51                } 
     52        } 
     53 
     54        @Override 
     55        public Object getValue(Object bean) throws IllegalArgumentException { 
     56                if (bean == null) { 
     57                        throw new IllegalArgumentException("bean cannot be null"); 
     58                } 
     59                try { 
     60                        return _field.get(bean); 
     61                } catch (Exception e) { 
     62                        throw new IllegalArgumentException("Could not retrieve property '" 
     63                                        + getName() + "' from bean: " + bean); 
    6964                } 
    7065        } 
    … …  
    7267        @Override 
    7368        public Set<Annotation> getAnnotations() { 
    74                 if (_field == null) { 
    75                         return CollectionUtils.set(_method.getAnnotations()); 
    76                 } else { 
    77                         return CollectionUtils.set(_field.getAnnotations()); 
    78                 } 
     69                return CollectionUtils.set(_field.getAnnotations()); 
    7970        } 
    8071 
    8172        @Override 
    8273        public <A extends Annotation> A getAnnotation(Class<A> annotationClass) { 
    83                 if (_field == null) { 
    84                         return _method.getAnnotation(annotationClass); 
    85                 } else { 
    86                         return _field.getAnnotation(annotationClass); 
    87                 } 
     74                return _field.getAnnotation(annotationClass); 
    8875        } 
    8976 
    … …  
    116103                int result = 1; 
    117104                result = prime * result + ((_field == null) ? 0 : _field.hashCode()); 
    118                 result = prime * result + ((_method == null) ? 0 : _method.hashCode()); 
    119105                return result; 
    120106        } 
    … …  
    134120                } else if (!_field.equals(other._field)) 
    135121                        return false; 
    136                 if (_method == null) { 
    137                         if (other._method != null) 
    138                                 return false; 
    139                 } else if (!_method.equals(other._method)) 
    140                         return false; 
    141122                return true; 
    142123        } 
    … …  
    144125        @Override 
    145126        public String toString() { 
    146                 if (_field == null) { 
    147                         return getClass().getSimpleName() + "[method=" + _method.getName() 
    148                                         + ",baseType=" + _baseType + "]"; 
    149                 } else { 
    150                         return getClass().getSimpleName() + "[field=" + _field.getName() 
    151                                         + ",baseType=" + _baseType + "]"; 
     127                return getClass().getSimpleName() + "[field=" + _field.getName() 
     128                                + ",baseType=" + _baseType + "]"; 
     129        } 
     130 
     131        @Override 
     132        public int compareTo(AbstractPropertyDescriptor o) { 
     133                Field otherField = o._field; 
     134                if (_field == otherField) { 
     135                        return 0; 
    152136                } 
     137                return _field.toString().compareTo(otherField.toString()); 
    153138        } 
    154139} 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/ConfiguredPropertyDescriptorImpl.java

    r967 r974  
    22 
    33import java.lang.reflect.Field; 
    4 import java.lang.reflect.Method; 
    54 
    65import org.eobjects.analyzer.annotations.Configured; 
    … …  
    1413        } 
    1514 
    16         public ConfiguredPropertyDescriptorImpl(Method method) throws DescriptorException { 
    17                 super(method); 
    18         } 
    19          
    2015        @Override 
    2116        public String getName() { 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/PropertyDescriptor.java

    r962 r974  
    99        public String getName(); 
    1010 
    11         public void assignValue(Object bean, Object value) 
     11        public void setValue(Object bean, Object value) 
    1212                        throws IllegalArgumentException; 
     13 
     14        public Object getValue(Object bean) throws IllegalArgumentException; 
    1315 
    1416        public Set<Annotation> getAnnotations(); 
    1517 
    1618        public <A extends Annotation> A getAnnotation(Class<A> annotationClass); 
    17          
     19 
    1820        public Class<?> getBaseType(); 
    1921 
    … …  
    2123 
    2224        public Type getTypeArgument(int i) throws IndexOutOfBoundsException; 
    23          
     25 
    2426        public boolean isArray(); 
    2527} 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/descriptors/ProvidedPropertyDescriptorImpl.java

    r967 r974  
    22 
    33import java.lang.reflect.Field; 
    4 import java.lang.reflect.Method; 
    54 
    65import org.eobjects.analyzer.util.ReflectionUtils; 
    … …  
    1413        public ProvidedPropertyDescriptorImpl(Field field) throws DescriptorException { 
    1514                super(field); 
    16         } 
    17  
    18         public ProvidedPropertyDescriptorImpl(Method method) throws DescriptorException { 
    19                 super(method); 
    2015        } 
    2116 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/lifecycle/AssignConfiguredCallback.java

    r968 r974  
    3030                        Object configuredValue = getValue(property); 
    3131                        if (configuredValue == null) { 
    32                                 property.assignValue(bean, null); 
     32                                property.setValue(bean, null); 
    3333                        } else { 
    3434                                if (property.isArray()) { 
    35                                         property.assignValue(bean, configuredValue); 
     35                                        property.setValue(bean, configuredValue); 
    3636                                } else { 
    3737                                        if (configuredValue.getClass().isArray()) { 
    … …  
    4242                                                } 
    4343                                        } 
    44                                         property.assignValue(bean, configuredValue); 
     44                                        property.setValue(bean, configuredValue); 
    4545                                } 
    4646                        } 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/lifecycle/AssignProvidedCallback.java

    r968 r974  
    3636                                List<?> list = collectionProvider.createList(providedDescriptor 
    3737                                                .getTypeArgument(0)); 
    38                                 providedDescriptor.assignValue(analyzerBean, list); 
     38                                providedDescriptor.setValue(analyzerBean, list); 
    3939                                providedCollections.add(list); 
    4040                        } else if (providedDescriptor.isMap()) { 
    … …  
    4242                                                providedDescriptor.getTypeArgument(0), 
    4343                                                providedDescriptor.getTypeArgument(1)); 
    44                                 providedDescriptor.assignValue(analyzerBean, map); 
     44                                providedDescriptor.setValue(analyzerBean, map); 
    4545                                providedCollections.add(map); 
    4646                        } else if (providedDescriptor.isDataContext()) { 
    47                                 providedDescriptor.assignValue(analyzerBean, 
     47                                providedDescriptor.setValue(analyzerBean, 
    4848                                                dataContextProvider.getDataContext()); 
    4949                        } else if (providedDescriptor.isSchemaNavigator()) { 
    50                                 providedDescriptor.assignValue(analyzerBean, 
     50                                providedDescriptor.setValue(analyzerBean, 
    5151                                                dataContextProvider.getSchemaNavigator()); 
    5252                        } 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/beans/JoinMatcherTest.java

    r962 r974  
    2525                assertEquals(4, configuredProperties.size()); 
    2626 
    27                 assertEquals("Left table join column", configuredProperties.get(0) 
     27                assertEquals("Right table", configuredProperties.get(0).getName()); 
     28                assertEquals("Left table join column", configuredProperties.get(1) 
    2829                                .getName()); 
    29                 assertEquals("Left table", configuredProperties.get(1).getName()); 
    30                 assertEquals("Right table", configuredProperties.get(2).getName()); 
    31                 assertEquals("Right table join column", configuredProperties.get(3) 
     30                assertEquals("Right table join column", configuredProperties.get(2) 
    3231                                .getName()); 
     32                assertEquals("Left table", configuredProperties.get(3).getName()); 
    3333        } 
    3434 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/beans/ReferentialIntegrityValidatorTest.java

    r962 r974  
    5454 
    5555                assertEquals( 
    56                                 "[ConfiguredPropertyDescriptorImpl[field=acceptNullForeignKey,baseType=boolean], " 
    57                                                 + "ConfiguredPropertyDescriptorImpl[field=foreignKeyColumn,baseType=class dk.eobjects.metamodel.schema.Column], " 
    58                                                 + "ConfiguredPropertyDescriptorImpl[field=primaryKeyColumn,baseType=class dk.eobjects.metamodel.schema.Column]]", 
     56                                "[ConfiguredPropertyDescriptorImpl[field=primaryKeyColumn,baseType=class dk.eobjects.metamodel.schema.Column], " 
     57                                                + "ConfiguredPropertyDescriptorImpl[field=acceptNullForeignKey,baseType=boolean], " 
     58                                                + "ConfiguredPropertyDescriptorImpl[field=foreignKeyColumn,baseType=class dk.eobjects.metamodel.schema.Column]]", 
    5959                                descriptor.getConfiguredProperties().toString()); 
    6060 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/beans/mock/ExploringAnalyzerMock.java

    r957 r974  
    4242        } 
    4343 
    44         // A method-level @Configured property 
     44        @Configured 
    4545        private Integer configured2; 
    46  
    47         @Configured 
    48         public void setConfigured2(Integer configured2) { 
    49                 this.configured2 = configured2; 
    50         } 
    51  
     46         
    5247        public Integer getConfigured2() { 
    5348                return configured2; 
    … …  
    6257        } 
    6358 
    64         // A method-level @Provided property 
     59        @Provided 
    6560        private List<Boolean> providedList; 
    66  
    67         @Provided 
    68         public void setProvidedList(List<Boolean> providedList) { 
    69                 this.providedList = providedList; 
    70         } 
    71  
     61         
    7262        public List<Boolean> getProvidedList() { 
    7363                return providedList; 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/beans/mock/RowProcessingAnalyzerMock.java

    r957 r974  
    4949        } 
    5050 
    51         // A method-level @Configured property 
     51        @Configured 
    5252        private Integer configured2; 
    53  
    54         @Configured 
    55         public void setConfigured2(Integer configured2) { 
    56                 this.configured2 = configured2; 
    57         } 
    5853 
    5954        public Integer getConfigured2() { 
    … …  
    6964        } 
    7065 
    71         // A method-level @Provided property 
     66        @Provided 
    7267        private List<Boolean> providedList; 
    73  
    74         @Provided 
    75         public void setProvidedList(List<Boolean> providedList) { 
    76                 this.providedList = providedList; 
    77         } 
    7868 
    7969        public List<Boolean> getProvidedList() { 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/descriptors/AnnotationBasedAnalyzerBeanDescriptorTest.java

    r971 r974  
    3232 
    3333                assertEquals( 
    34                                 "[ConfiguredPropertyDescriptorImpl[method=setConfigured2,baseType=class java.lang.Integer], ConfiguredPropertyDescriptorImpl[field=configured1,baseType=class java.lang.String]]", 
     34                                "[ConfiguredPropertyDescriptorImpl[field=configured2,baseType=class java.lang.Integer], ConfiguredPropertyDescriptorImpl[field=configured1,baseType=class java.lang.String]]", 
    3535                                Arrays.toString(descriptor.getConfiguredProperties().toArray())); 
    3636        } 
    … …  
    4545                                .getConfiguredProperties(); 
    4646                assertEquals( 
    47                                 "{ConfiguredPropertyDescriptorImpl[field=configured1,baseType=class java.lang.String],ConfiguredPropertyDescriptorImpl[method=setConfigured2,baseType=class java.lang.Integer],ConfiguredPropertyDescriptorImpl[field=columns,baseType=class [Lorg.eobjects.analyzer.data.InputColumn;]}", 
     47                                "{ConfiguredPropertyDescriptorImpl[field=configured1,baseType=class java.lang.String],ConfiguredPropertyDescriptorImpl[field=configured2,baseType=class java.lang.Integer],ConfiguredPropertyDescriptorImpl[field=columns,baseType=class [Lorg.eobjects.analyzer.data.InputColumn;]}", 
    4848                                ArrayUtils.toString(configuredProperties.toArray())); 
    4949 
    … …  
    5151                ConfiguredPropertyDescriptor configuredProperty = configuredProperties 
    5252                                .iterator().next(); 
    53                 configuredProperty.assignValue(analyzerBean, "foobar"); 
     53                configuredProperty.setValue(analyzerBean, "foobar"); 
    5454                assertEquals("foobar", analyzerBean.getConfigured1()); 
    5555        } 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/descriptors/ProvidedPropertyDescriptorImplTest.java

    r964 r974  
    22 
    33import java.lang.reflect.Field; 
    4 import java.lang.reflect.Method; 
    54import java.util.Map; 
    65 
    … …  
    1110public class ProvidedPropertyDescriptorImplTest extends TestCase { 
    1211 
    13         class SampleClass { 
    14                 @Provided 
    15                 Map<String, Boolean> stringMap; 
     12        @Provided 
     13        Map<String, Boolean> stringMap; 
    1614 
    17                 @Provided 
    18                 void setIntMap(Map<String, Integer> map) { 
    19  
    20                 } 
    21         } 
     15        @Provided 
     16        Map<String, Integer> intMap; 
    2217 
    2318        public void testGenericTypes() throws Exception { 
    24                 Field stringMapField = SampleClass.class.getDeclaredField("stringMap"); 
    25                 ProvidedPropertyDescriptorImpl descriptor = new ProvidedPropertyDescriptorImpl(stringMapField); 
     19                Field stringMapField = getClass().getDeclaredField("stringMap"); 
     20                ProvidedPropertyDescriptorImpl descriptor = new ProvidedPropertyDescriptorImpl( 
     21                                stringMapField); 
    2622 
    2723                assertEquals( 
    2824                                "ProvidedPropertyDescriptorImpl[field=stringMap,baseType=interface java.util.Map]", 
    2925                                descriptor.toString()); 
     26                 
     27                assertEquals(2, descriptor.getTypeArgumentCount()); 
     28                assertEquals(String.class, descriptor.getTypeArgument(0)); 
     29                assertEquals(Boolean.class, descriptor.getTypeArgument(1)); 
    3030 
    31                 Method method = SampleClass.class.getDeclaredMethod("setIntMap", 
    32                                 Map.class); 
    33                 descriptor = new ProvidedPropertyDescriptorImpl(method); 
     31                Field intMapField = getClass().getDeclaredField("intMap"); 
     32                descriptor = new ProvidedPropertyDescriptorImpl(intMapField); 
    3433                assertEquals( 
    35                                 "ProvidedPropertyDescriptorImpl[method=setIntMap,baseType=interface java.util.Map]", 
     34                                "ProvidedPropertyDescriptorImpl[field=intMap,baseType=interface java.util.Map]", 
    3635                                descriptor.toString()); 
     36                 
     37                assertEquals(2, descriptor.getTypeArgumentCount()); 
     38                assertEquals(String.class, descriptor.getTypeArgument(0)); 
     39                assertEquals(Integer.class, descriptor.getTypeArgument(1)); 
    3740        } 
    3841} 
Note: See TracChangeset for help on using the changeset viewer.