Changeset 975


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

Made descriptors more type-safe by adding type parameter for bean type.

Location:
AnalyzerBeans/trunk/src
Files:
47 edited

Legend:

Unmodified
Added
Removed

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

    r974 r975  
    2424import org.slf4j.LoggerFactory; 
    2525 
    26 public abstract class AbstractBeanDescriptor implements BeanDescriptor { 
     26public abstract class AbstractBeanDescriptor<B> implements BeanDescriptor<B> { 
    2727 
    2828        protected final Logger logger = LoggerFactory.getLogger(getClass()); 
    2929 
    30         private final Class<?> _beanClass; 
     30        private final Class<B> _beanClass; 
    3131        protected final Set<InitializeMethodDescriptor> _initializeMethods = new HashSet<InitializeMethodDescriptor>(); 
    3232        protected final Set<ConfiguredPropertyDescriptor> _configuredProperties = new HashSet<ConfiguredPropertyDescriptor>(); 
    … …  
    3434        protected final Set<CloseMethodDescriptor> _closeMethods = new HashSet<CloseMethodDescriptor>(); 
    3535 
    36         public AbstractBeanDescriptor(Class<?> beanClass, 
     36        public AbstractBeanDescriptor(Class<B> beanClass, 
    3737                        boolean requireInputColumns) { 
    3838                if (beanClass == null) { 
    … …  
    144144 
    145145        @Override 
    146         public Class<?> getBeanClass() { 
     146        public Class<B> getBeanClass() { 
    147147                return _beanClass; 
    148148        } 
    … …  
    197197                } 
    198198                if (obj.getClass() == this.getClass()) { 
    199                         AbstractBeanDescriptor that = (AbstractBeanDescriptor) obj; 
     199                        AbstractBeanDescriptor<?> that = (AbstractBeanDescriptor<?>) obj; 
    200200                        return this._beanClass == that._beanClass; 
    201201                } 
    … …  
    204204 
    205205        @Override 
    206         public int compareTo(BeanDescriptor o) { 
     206        public int compareTo(BeanDescriptor<?> o) { 
    207207                if (o == null) { 
    208208                        return 1; 

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

    r962 r975  
    11package org.eobjects.analyzer.descriptors; 
    22 
    3 public interface AnalyzerBeanDescriptor extends BeanDescriptor { 
     3import org.eobjects.analyzer.beans.Analyzer; 
     4 
     5public interface AnalyzerBeanDescriptor<B extends Analyzer<?>> extends BeanDescriptor<B> { 
    46 
    57        public boolean isExploringAnalyzer(); 

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

    r967 r975  
    22 
    33import org.eobjects.analyzer.annotations.AnalyzerBean; 
     4import org.eobjects.analyzer.beans.Analyzer; 
    45import org.eobjects.analyzer.beans.ExploringAnalyzer; 
    56import org.eobjects.analyzer.beans.RowProcessingAnalyzer; 
    67import org.eobjects.analyzer.util.ReflectionUtils; 
    78 
    8 public final class AnnotationBasedAnalyzerBeanDescriptor extends 
    9                 AbstractBeanDescriptor implements AnalyzerBeanDescriptor { 
     9public final class AnnotationBasedAnalyzerBeanDescriptor<A extends Analyzer<?>> 
     10                extends AbstractBeanDescriptor<A> implements AnalyzerBeanDescriptor<A> { 
    1011 
    1112        private final String _displayName; 
    … …  
    1314        private final boolean _rowProcessingAnalyzer; 
    1415 
    15         public AnnotationBasedAnalyzerBeanDescriptor(Class<?> analyzerClass) 
     16        public static <A extends Analyzer<?>> AnnotationBasedAnalyzerBeanDescriptor<A> create( 
     17                        Class<A> analyzerClass) { 
     18                return new AnnotationBasedAnalyzerBeanDescriptor<A>(analyzerClass); 
     19        } 
     20 
     21        private AnnotationBasedAnalyzerBeanDescriptor(Class<A> analyzerClass) 
    1622                        throws DescriptorException { 
    1723                super(analyzerClass, ReflectionUtils.is(analyzerClass, 

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

    r967 r975  
    99import org.eobjects.analyzer.util.ReflectionUtils; 
    1010 
    11 public final class AnnotationBasedTransformerBeanDescriptor extends 
    12                 AbstractBeanDescriptor implements TransformerBeanDescriptor { 
     11public final class AnnotationBasedTransformerBeanDescriptor<T extends Transformer<?>> 
     12                extends AbstractBeanDescriptor<T> implements 
     13                TransformerBeanDescriptor<T> { 
    1314 
    1415        private final String _displayName; 
    1516 
    16         public AnnotationBasedTransformerBeanDescriptor(Class<?> transformerClass) 
     17        public static <T extends Transformer<?>> AnnotationBasedTransformerBeanDescriptor<T> create( 
     18                        Class<T> transformerClass) { 
     19                return new AnnotationBasedTransformerBeanDescriptor<T>(transformerClass); 
     20        } 
     21 
     22        private AnnotationBasedTransformerBeanDescriptor(Class<T> transformerClass) 
    1723                        throws DescriptorException { 
    1824                super(transformerClass, true); 

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

    r971 r975  
    66import org.eobjects.analyzer.data.DataTypeFamily; 
    77 
    8 public interface BeanDescriptor extends Comparable<BeanDescriptor> { 
     8/** 
     9 *  
     10 * @author Kasper SÞrensen 
     11 *  
     12 * @param <B> 
     13 *            the Bean type 
     14 */ 
     15public interface BeanDescriptor<B> extends Comparable<BeanDescriptor<?>> { 
    916 
    1017        public String getDisplayName(); 
    11          
     18 
    1219        public Set<Annotation> getAnnotations(); 
    1320 
    1421        public <A extends Annotation> A getAnnotation(Class<A> annotationClass); 
    1522 
    16         public Class<?> getBeanClass(); 
    17          
     23        public Class<B> getBeanClass(); 
     24 
    1825        public Set<ConfiguredPropertyDescriptor> getConfiguredProperties(); 
    19          
     26 
    2027        public ConfiguredPropertyDescriptor getConfiguredProperty(String name); 
    21          
     28 
    2229        public ConfiguredPropertyDescriptor getConfiguredPropertyForInput(); 
    23          
     30 
    2431        public Set<ProvidedPropertyDescriptor> getProvidedProperties(); 
    25          
     32 
    2633        public Set<InitializeMethodDescriptor> getInitializeMethods(); 
    27          
     34 
    2835        public Set<CloseMethodDescriptor> getCloseMethods(); 
    29          
     36 
    3037        public DataTypeFamily getInputDataTypeFamily(); 
    3138} 

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

    r971 r975  
    2525        private static final Logger logger = LoggerFactory 
    2626                        .getLogger(ClasspathScanDescriptorProvider.class); 
    27         private Map<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor> _analyzerBeanDescriptors = new HashMap<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor>(); 
    28         private Map<Class<? extends Transformer<?>>, TransformerBeanDescriptor> _transformerBeanDescriptors = new HashMap<Class<? extends Transformer<?>>, TransformerBeanDescriptor>(); 
     27        private Map<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor<?>> _analyzerBeanDescriptors = new HashMap<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor<?>>(); 
     28        private Map<Class<? extends Transformer<?>>, TransformerBeanDescriptor<?>> _transformerBeanDescriptors = new HashMap<Class<? extends Transformer<?>>, TransformerBeanDescriptor<?>>(); 
    2929        private Map<Class<? extends Renderer<?, ?>>, RendererBeanDescriptor> _rendererBeanDescriptors = new HashMap<Class<? extends Renderer<?, ?>>, RendererBeanDescriptor>(); 
    3030 
    … …  
    7676                                        Class<? extends Analyzer<?>> analyzerClass = (Class<? extends Analyzer<?>>) visitor 
    7777                                                        .getBeanClass(); 
    78                                         AnalyzerBeanDescriptor descriptor = _analyzerBeanDescriptors 
     78                                        AnalyzerBeanDescriptor<?> descriptor = _analyzerBeanDescriptors 
    7979                                                        .get(analyzerClass); 
    8080                                        if (descriptor == null) { 
    81                                                 descriptor = new AnnotationBasedAnalyzerBeanDescriptor( 
     81                                                descriptor = AnnotationBasedAnalyzerBeanDescriptor.create( 
    8282                                                                analyzerClass); 
    8383                                                _analyzerBeanDescriptors.put(analyzerClass, descriptor); 
    … …  
    8888                                        Class<? extends Transformer<?>> transformerClass = (Class<? extends Transformer<?>>) visitor 
    8989                                                        .getBeanClass(); 
    90                                         TransformerBeanDescriptor descriptor = _transformerBeanDescriptors 
     90                                        TransformerBeanDescriptor<?> descriptor = _transformerBeanDescriptors 
    9191                                                        .get(transformerClass); 
    9292                                        if (descriptor == null) { 
    93                                                 descriptor = new AnnotationBasedTransformerBeanDescriptor( 
     93                                                descriptor = AnnotationBasedTransformerBeanDescriptor.create( 
    9494                                                                transformerClass); 
    9595                                                _transformerBeanDescriptors.put(transformerClass, 
    … …  
    132132 
    133133        @Override 
    134         public Collection<AnalyzerBeanDescriptor> getAnalyzerBeanDescriptors() { 
     134        public Collection<AnalyzerBeanDescriptor<?>> getAnalyzerBeanDescriptors() { 
    135135                return Collections.unmodifiableCollection(_analyzerBeanDescriptors 
    136136                                .values()); 
    137137        } 
    138138 
     139        @SuppressWarnings("unchecked") 
    139140        @Override 
    140         public AnalyzerBeanDescriptor getAnalyzerBeanDescriptorForClass( 
    141                         Class<? extends Analyzer<?>> analyzerBeanClass) { 
    142                 return _analyzerBeanDescriptors.get(analyzerBeanClass); 
     141        public <A extends Analyzer<?>> AnalyzerBeanDescriptor<A> getAnalyzerBeanDescriptorForClass( 
     142                        Class<A> analyzerBeanClass) { 
     143                return (AnalyzerBeanDescriptor<A>) _analyzerBeanDescriptors 
     144                                .get(analyzerBeanClass); 
    143145        } 
    144146 
    145147        @Override 
    146         public Collection<TransformerBeanDescriptor> getTransformerBeanDescriptors() { 
     148        public Collection<TransformerBeanDescriptor<?>> getTransformerBeanDescriptors() { 
    147149                return Collections.unmodifiableCollection(_transformerBeanDescriptors 
    148150                                .values()); 
    149151        } 
    150152 
     153        @SuppressWarnings("unchecked") 
    151154        @Override 
    152         public TransformerBeanDescriptor getTransformerBeanDescriptorForClass( 
    153                         Class<? extends Transformer<?>> transformerBeanClass) { 
    154                 return _transformerBeanDescriptors.get(transformerBeanClass); 
     155        public <T extends Transformer<?>> TransformerBeanDescriptor<T> getTransformerBeanDescriptorForClass( 
     156                        Class<T> transformerBeanClass) { 
     157                return (TransformerBeanDescriptor<T>) _transformerBeanDescriptors 
     158                                .get(transformerBeanClass); 
    155159        } 
    156160 

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

    r971 r975  
    1414public interface DescriptorProvider { 
    1515 
    16         public Collection<AnalyzerBeanDescriptor> getAnalyzerBeanDescriptors(); 
     16        public Collection<AnalyzerBeanDescriptor<?>> getAnalyzerBeanDescriptors(); 
    1717 
    18         public AnalyzerBeanDescriptor getAnalyzerBeanDescriptorForClass( 
    19                         Class<? extends Analyzer<?>> analyzerBeanClass); 
     18        public <A extends Analyzer<?>> AnalyzerBeanDescriptor<A> getAnalyzerBeanDescriptorForClass( 
     19                        Class<A> analyzerBeanClass); 
    2020 
    21         public Collection<TransformerBeanDescriptor> getTransformerBeanDescriptors(); 
     21        public Collection<TransformerBeanDescriptor<?>> getTransformerBeanDescriptors(); 
    2222 
    23         public TransformerBeanDescriptor getTransformerBeanDescriptorForClass( 
    24                         Class<? extends Transformer<?>> transformerBeanClass); 
     23        public <T extends Transformer<?>> TransformerBeanDescriptor<T> getTransformerBeanDescriptorForClass( 
     24                        Class<T> transformerBeanClass); 
    2525 
    2626        public Collection<RendererBeanDescriptor> getRendererBeanDescriptors(); 

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

    r971 r975  
    1212public class LazyDescriptorProvider implements DescriptorProvider { 
    1313 
    14         private Map<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor> _analyzerBeanDescriptors = new HashMap<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor>(); 
    15         private Map<Class<? extends Transformer<?>>, TransformerBeanDescriptor> _transformerBeanDescriptors = new HashMap<Class<? extends Transformer<?>>, TransformerBeanDescriptor>(); 
     14        private Map<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor<?>> _analyzerBeanDescriptors = new HashMap<Class<? extends Analyzer<?>>, AnalyzerBeanDescriptor<?>>(); 
     15        private Map<Class<? extends Transformer<?>>, TransformerBeanDescriptor<?>> _transformerBeanDescriptors = new HashMap<Class<? extends Transformer<?>>, TransformerBeanDescriptor<?>>(); 
    1616        private Map<Class<? extends Renderer<?, ?>>, RendererBeanDescriptor> _rendererBeanDescriptors = new HashMap<Class<? extends Renderer<?, ?>>, RendererBeanDescriptor>(); 
    1717 
     18        @SuppressWarnings("unchecked") 
    1819        @Override 
    19         public AnalyzerBeanDescriptor getAnalyzerBeanDescriptorForClass( 
    20                         Class<? extends Analyzer<?>> analyzerBeanClass) { 
    21                 AnalyzerBeanDescriptor descriptor = _analyzerBeanDescriptors 
     20        public <A extends Analyzer<?>> AnalyzerBeanDescriptor<A> getAnalyzerBeanDescriptorForClass( 
     21                        Class<A> analyzerBeanClass) { 
     22                AnalyzerBeanDescriptor<?> descriptor = _analyzerBeanDescriptors 
    2223                                .get(analyzerBeanClass); 
    2324                if (descriptor == null) { 
    24                         descriptor = new AnnotationBasedAnalyzerBeanDescriptor( 
     25                        descriptor = AnnotationBasedAnalyzerBeanDescriptor.create( 
    2526                                        analyzerBeanClass); 
    2627                        _analyzerBeanDescriptors.put(analyzerBeanClass, descriptor); 
    2728                } 
    28                 return descriptor; 
     29                return (AnalyzerBeanDescriptor<A>) descriptor; 
    2930        } 
    3031 
    3132        @Override 
    32         public Collection<AnalyzerBeanDescriptor> getAnalyzerBeanDescriptors() { 
     33        public Collection<AnalyzerBeanDescriptor<?>> getAnalyzerBeanDescriptors() { 
    3334                return Collections.unmodifiableCollection(_analyzerBeanDescriptors 
    3435                                .values()); 
    … …  
    3637 
    3738        @Override 
    38         public Collection<TransformerBeanDescriptor> getTransformerBeanDescriptors() { 
     39        public Collection<TransformerBeanDescriptor<?>> getTransformerBeanDescriptors() { 
    3940                return Collections.unmodifiableCollection(_transformerBeanDescriptors 
    4041                                .values()); 
    4142        } 
    4243 
     44        @SuppressWarnings("unchecked") 
    4345        @Override 
    44         public TransformerBeanDescriptor getTransformerBeanDescriptorForClass( 
    45                         Class<? extends Transformer<?>> transformerBeanClass) { 
    46                 TransformerBeanDescriptor descriptor = _transformerBeanDescriptors 
     46        public <T extends Transformer<?>> TransformerBeanDescriptor<T> getTransformerBeanDescriptorForClass( 
     47                        Class<T> transformerBeanClass) { 
     48                TransformerBeanDescriptor<?> descriptor = _transformerBeanDescriptors 
    4749                                .get(transformerBeanClass); 
    4850                if (descriptor == null) { 
    49                         descriptor = new AnnotationBasedTransformerBeanDescriptor( 
     51                        descriptor = AnnotationBasedTransformerBeanDescriptor.create( 
    5052                                        transformerBeanClass); 
    5153                        _transformerBeanDescriptors.put(transformerBeanClass, descriptor); 
    5254                } 
    53                 return descriptor; 
     55                return (TransformerBeanDescriptor<T>) descriptor; 
    5456        } 
    5557 

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

    r971 r975  
    4242public class SimpleDescriptorProvider implements DescriptorProvider { 
    4343 
    44         private List<AnalyzerBeanDescriptor> _analyzerBeanDescriptors = new ArrayList<AnalyzerBeanDescriptor>(); 
    45         private List<TransformerBeanDescriptor> _transformerBeanDescriptors = new ArrayList<TransformerBeanDescriptor>(); 
     44        private List<AnalyzerBeanDescriptor<?>> _analyzerBeanDescriptors = new ArrayList<AnalyzerBeanDescriptor<?>>(); 
     45        private List<TransformerBeanDescriptor<?>> _transformerBeanDescriptors = new ArrayList<TransformerBeanDescriptor<?>>(); 
    4646        private List<RendererBeanDescriptor> _rendererBeanDescriptors = new ArrayList<RendererBeanDescriptor>(); 
    4747 
    … …  
    5050 
    5151        public void addAnalyzerBeanDescriptor( 
    52                         AnalyzerBeanDescriptor analyzerBeanDescriptor) { 
     52                        AnalyzerBeanDescriptor<?> analyzerBeanDescriptor) { 
    5353                _analyzerBeanDescriptors.add(analyzerBeanDescriptor); 
    5454        } 
    5555 
    5656        public void addTransformerBeanDescriptor( 
    57                         TransformerBeanDescriptor transformerBeanDescriptor) { 
     57                        TransformerBeanDescriptor<?> transformerBeanDescriptor) { 
    5858                _transformerBeanDescriptors.add(transformerBeanDescriptor); 
    5959        } 
    … …  
    6565 
    6666        @Override 
    67         public List<AnalyzerBeanDescriptor> getAnalyzerBeanDescriptors() { 
     67        public List<AnalyzerBeanDescriptor<?>> getAnalyzerBeanDescriptors() { 
    6868                return _analyzerBeanDescriptors; 
    6969        } 
    7070 
    7171        public void setAnalyzerBeanDescriptors( 
    72                         List<AnalyzerBeanDescriptor> descriptors) { 
     72                        List<AnalyzerBeanDescriptor<?>> descriptors) { 
    7373                _analyzerBeanDescriptors = descriptors; 
    7474        } 
    7575 
     76        @SuppressWarnings("unchecked") 
    7677        @Override 
    77         public AnalyzerBeanDescriptor getAnalyzerBeanDescriptorForClass( 
    78                         Class<? extends Analyzer<?>> analyzerBeanClass) { 
    79                 for (AnalyzerBeanDescriptor descriptor : _analyzerBeanDescriptors) { 
     78        public <A extends Analyzer<?>> AnalyzerBeanDescriptor<A> getAnalyzerBeanDescriptorForClass( 
     79                        Class<A> analyzerBeanClass) { 
     80                for (AnalyzerBeanDescriptor<?> descriptor : _analyzerBeanDescriptors) { 
    8081                        if (descriptor.getBeanClass() == analyzerBeanClass) { 
    81                                 return descriptor; 
     82                                return (AnalyzerBeanDescriptor<A>) descriptor; 
     83                        } 
     84                } 
     85                return null; 
     86        } 
     87 
     88        @SuppressWarnings("unchecked") 
     89        @Override 
     90        public <T extends Transformer<?>> TransformerBeanDescriptor<T> getTransformerBeanDescriptorForClass( 
     91                        Class<T> transformerBeanClass) { 
     92                for (TransformerBeanDescriptor<?> descriptor : _transformerBeanDescriptors) { 
     93                        if (descriptor.getBeanClass() == transformerBeanClass) { 
     94                                return (TransformerBeanDescriptor<T>) descriptor; 
    8295                        } 
    8396                } 
    … …  
    8699 
    87100        @Override 
    88         public TransformerBeanDescriptor getTransformerBeanDescriptorForClass( 
    89                         Class<? extends Transformer<?>> transformerBeanClass) { 
    90                 for (TransformerBeanDescriptor descriptor : _transformerBeanDescriptors) { 
    91                         if (descriptor.getBeanClass() == transformerBeanClass) { 
    92                                 return descriptor; 
    93                         } 
    94                 } 
    95                 return null; 
    96         } 
    97  
    98         @Override 
    99         public List<TransformerBeanDescriptor> getTransformerBeanDescriptors() { 
     101        public List<TransformerBeanDescriptor<?>> getTransformerBeanDescriptors() { 
    100102                return _transformerBeanDescriptors; 
    101103        } 
    102104 
    103105        public void setTransformerBeanDescriptors( 
    104                         List<TransformerBeanDescriptor> transformerBeanDescriptors) { 
     106                        List<TransformerBeanDescriptor<?>> transformerBeanDescriptors) { 
    105107                _transformerBeanDescriptors = transformerBeanDescriptors; 
    106108        } 
    … …  
    133135                        Class<? extends Analyzer<?>> c = (Class<? extends Analyzer<?>>) Class 
    134136                                        .forName(className); 
    135                         AnalyzerBeanDescriptor descriptor = getAnalyzerBeanDescriptorForClass(c); 
     137                        AnalyzerBeanDescriptor<?> descriptor = getAnalyzerBeanDescriptorForClass(c); 
    136138                        if (descriptor == null) { 
    137                                 addAnalyzerBeanDescriptor(new AnnotationBasedAnalyzerBeanDescriptor( 
    138                                                 c)); 
     139                                addAnalyzerBeanDescriptor(AnnotationBasedAnalyzerBeanDescriptor 
     140                                                .create(c)); 
    139141                        } 
    140142                } 
    … …  
    147149                        Class<? extends Transformer<?>> c = (Class<? extends Transformer<?>>) Class 
    148150                                        .forName(className); 
    149                         TransformerBeanDescriptor descriptor = getTransformerBeanDescriptorForClass(c); 
     151                        TransformerBeanDescriptor<?> descriptor = getTransformerBeanDescriptorForClass(c); 
    150152                        if (descriptor == null) { 
    151                                 addTransformerBeanDescriptor(new AnnotationBasedTransformerBeanDescriptor( 
    152                                                 c)); 
     153                                addTransformerBeanDescriptor(AnnotationBasedTransformerBeanDescriptor 
     154                                                .create(c)); 
    153155                        } 
    154156                } 

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

    r962 r975  
    11package org.eobjects.analyzer.descriptors; 
    22 
     3import org.eobjects.analyzer.beans.Transformer; 
    34import org.eobjects.analyzer.data.DataTypeFamily; 
    45 
    5 public interface TransformerBeanDescriptor extends BeanDescriptor { 
     6public interface TransformerBeanDescriptor<B extends Transformer<?>> extends BeanDescriptor<B> { 
    67 
    78        public DataTypeFamily getOutputDataTypeFamily(); 

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

    r962 r975  
    1111 
    1212@SuppressWarnings("unchecked") 
    13 class AbstractBeanJobBuilder<D extends BeanDescriptor, B> { 
     13class AbstractBeanJobBuilder<D extends BeanDescriptor<E>, E, B> { 
    1414 
    1515        private Map<ConfiguredPropertyDescriptor, Object> _properties = new HashMap<ConfiguredPropertyDescriptor, Object>(); 
    1616        private D _descriptor; 
    1717 
    18         public AbstractBeanJobBuilder(D descriptor, Class<B> builderClass) { 
     18        public AbstractBeanJobBuilder(D descriptor, Class<?> builderClass) { 
    1919                _descriptor = descriptor; 
    2020                if (!ReflectionUtils.is(getClass(), builderClass)) { 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/AbstractBeanWithInputColumnsBuilder.java

    r962 r975  
    1414 
    1515@SuppressWarnings("unchecked") 
    16 class AbstractBeanWithInputColumnsBuilder<D extends BeanDescriptor, B> extends 
    17                 AbstractBeanJobBuilder<D, B> { 
     16class AbstractBeanWithInputColumnsBuilder<D extends BeanDescriptor<E>, E, B> 
     17                extends AbstractBeanJobBuilder<D, E, B> { 
    1818 
    1919        private List<InputColumn<?>> _inputColumns = new ArrayList<InputColumn<?>>(); 
    2020 
    2121        public AbstractBeanWithInputColumnsBuilder(D descriptor, 
    22                         Class<B> builderClass) { 
     22                        Class<?> builderClass) { 
    2323                super(descriptor, builderClass); 
    2424        } 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/AnalysisJobBuilder.java

    r957 r975  
    2525        private DataContextProvider _dataContextProvider; 
    2626        private List<MetaModelInputColumn> _sourceColumns = new ArrayList<MetaModelInputColumn>(); 
    27         private List<TransformerJobBuilder> _transformerJobBuilders = new ArrayList<TransformerJobBuilder>(); 
    28         private List<RowProcessingAnalyzerJobBuilder> _analyzerJobBuilders = new ArrayList<RowProcessingAnalyzerJobBuilder>(); 
     27        private List<TransformerJobBuilder<?>> _transformerJobBuilders = new ArrayList<TransformerJobBuilder<?>>(); 
     28        private List<RowProcessingAnalyzerJobBuilder<?>> _analyzerJobBuilders = new ArrayList<RowProcessingAnalyzerJobBuilder<?>>(); 
    2929        private IdGenerator transformedColumnIdGenerator = new PrefixedIdGenerator( 
    3030                        "trans"); 
    … …  
    110110        } 
    111111 
    112         public TransformerJobBuilder addTransformer( 
    113                         Class<? extends Transformer<?>> transformerClass) { 
    114                 TransformerBeanDescriptor descriptor = _configuration 
     112        public <T extends Transformer<?>> TransformerJobBuilder<T> addTransformer( 
     113                        Class<T> transformerClass) { 
     114                TransformerBeanDescriptor<T> descriptor = _configuration 
    115115                                .getDescriptorProvider().getTransformerBeanDescriptorForClass( 
    116116                                                transformerClass); 
    … …  
    122122        } 
    123123 
    124         public List<TransformerJobBuilder> getTransformerJobBuilders() { 
     124        public List<TransformerJobBuilder<?>> getTransformerJobBuilders() { 
    125125                return Collections.unmodifiableList(_transformerJobBuilders); 
    126126        } 
    127127 
    128         public TransformerJobBuilder addTransformer( 
    129                         TransformerBeanDescriptor descriptor) { 
    130                 TransformerJobBuilder transformerJobBuilder = new TransformerJobBuilder( 
     128        public <T extends Transformer<?>> TransformerJobBuilder<T> addTransformer( 
     129                        TransformerBeanDescriptor<T> descriptor) { 
     130                TransformerJobBuilder<T> transformerJobBuilder = new TransformerJobBuilder<T>( 
    131131                                descriptor, transformedColumnIdGenerator); 
    132132                _transformerJobBuilders.add(transformerJobBuilder); 
    … …  
    134134        } 
    135135 
    136         public AnalysisJobBuilder removeTransformer(TransformerJobBuilder tjb) { 
     136        public AnalysisJobBuilder removeTransformer(TransformerJobBuilder<?> tjb) { 
    137137                _transformerJobBuilders.remove(tjb); 
    138138                return this; 
    139139        } 
    140140 
    141         public List<RowProcessingAnalyzerJobBuilder> getAnalyzerJobBuilders() { 
     141        public List<RowProcessingAnalyzerJobBuilder<?>> getAnalyzerJobBuilders() { 
    142142                return Collections.unmodifiableList(_analyzerJobBuilders); 
    143143        } 
    144144 
    145         public RowProcessingAnalyzerJobBuilder addAnalyzer( 
    146                         Class<? extends RowProcessingAnalyzer<?>> analyzerClass) { 
    147                 AnalyzerBeanDescriptor descriptor = _configuration 
     145        public <A extends RowProcessingAnalyzer<?>> RowProcessingAnalyzerJobBuilder<A> addAnalyzer( 
     146                        Class<A> analyzerClass) { 
     147                AnalyzerBeanDescriptor<A> descriptor = _configuration 
    148148                                .getDescriptorProvider().getAnalyzerBeanDescriptorForClass( 
    149149                                                analyzerClass); 
    … …  
    152152                                        + analyzerClass); 
    153153                } 
    154                 RowProcessingAnalyzerJobBuilder analyzerJobBuilder = new RowProcessingAnalyzerJobBuilder( 
     154                RowProcessingAnalyzerJobBuilder<A> analyzerJobBuilder = new RowProcessingAnalyzerJobBuilder<A>( 
    155155                                descriptor); 
    156156                _analyzerJobBuilders.add(analyzerJobBuilder); 
    … …  
    158158        } 
    159159 
    160         public AnalysisJobBuilder removeAnalyzer(RowProcessingAnalyzerJobBuilder ajb) { 
     160        public AnalysisJobBuilder removeAnalyzer( 
     161                        RowProcessingAnalyzerJobBuilder<?> ajb) { 
    161162                _analyzerJobBuilders.remove(ajb); 
    162163                return this; 
    … …  
    178179                } 
    179180 
    180                 for (TransformerJobBuilder transformerJobBuilder : _transformerJobBuilders) { 
     181                for (TransformerJobBuilder<?> transformerJobBuilder : _transformerJobBuilders) { 
    181182                        List<MutableInputColumn<?>> outputColumns = transformerJobBuilder 
    182183                                        .getOutputColumns(); 
    … …  
    205206                } 
    206207 
    207                 for (TransformerJobBuilder tjb : _transformerJobBuilders) { 
     208                for (TransformerJobBuilder<?> tjb : _transformerJobBuilders) { 
    208209                        if (!tjb.isConfigured()) { 
    209210                                return false; 
    … …  
    211212                } 
    212213 
    213                 for (RowProcessingAnalyzerJobBuilder ajb : _analyzerJobBuilders) { 
     214                for (RowProcessingAnalyzerJobBuilder<?> ajb : _analyzerJobBuilders) { 
    214215                        if (!ajb.isConfigured()) { 
    215216                                return false; 
    … …  
    227228 
    228229                Collection<TransformerJob> transformerJobs = new LinkedList<TransformerJob>(); 
    229                 for (TransformerJobBuilder tjb : _transformerJobBuilders) { 
     230                for (TransformerJobBuilder<?> tjb : _transformerJobBuilders) { 
    230231                        try { 
    231232                                TransformerJob transformerJob = tjb.toTransformerJob(); 
    … …  
    239240 
    240241                Collection<AnalyzerJob> analyzerJobs = new LinkedList<AnalyzerJob>(); 
    241                 for (RowProcessingAnalyzerJobBuilder ajb : _analyzerJobBuilders) { 
     242                for (RowProcessingAnalyzerJobBuilder<?> ajb : _analyzerJobBuilders) { 
    242243                        try { 
    243244                                AnalyzerJob analyzerJob = ajb.toAnalyzerJob(); 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/AnalyzerJob.java

    r938 r975  
    33import org.eobjects.analyzer.descriptors.AnalyzerBeanDescriptor; 
    44 
    5 public interface AnalyzerJob extends BeanJob<AnalyzerBeanDescriptor> { 
     5public interface AnalyzerJob extends BeanJob<AnalyzerBeanDescriptor<?>> { 
    66 
    77} 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/BeanJob.java

    r962 r975  
    44import org.eobjects.analyzer.descriptors.BeanDescriptor; 
    55 
    6 public interface BeanJob<E extends BeanDescriptor> { 
     6public interface BeanJob<E extends BeanDescriptor<?>> { 
    77 
    88        public E getDescriptor(); 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/ExploringAnalyzerJobBuilder.java

    r946 r975  
    11package org.eobjects.analyzer.job; 
    22 
     3import org.eobjects.analyzer.beans.ExploringAnalyzer; 
    34import org.eobjects.analyzer.descriptors.AnalyzerBeanDescriptor; 
    45 
    5 public class ExploringAnalyzerJobBuilder extends 
    6                 AbstractBeanJobBuilder<AnalyzerBeanDescriptor, ExploringAnalyzerJobBuilder> { 
     6public class ExploringAnalyzerJobBuilder<A extends ExploringAnalyzer<?>> 
     7                extends 
     8                AbstractBeanJobBuilder<AnalyzerBeanDescriptor<A>, A, ExploringAnalyzerJobBuilder<A>> { 
    79 
    8         public ExploringAnalyzerJobBuilder(AnalyzerBeanDescriptor descriptor) { 
     10        public ExploringAnalyzerJobBuilder(AnalyzerBeanDescriptor<A> descriptor) { 
    911                super(descriptor, ExploringAnalyzerJobBuilder.class); 
    1012        } 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/ImmutableAnalyzerJob.java

    r967 r975  
    66final class ImmutableAnalyzerJob implements AnalyzerJob { 
    77 
    8         private final AnalyzerBeanDescriptor _descriptor; 
     8        private final AnalyzerBeanDescriptor<?> _descriptor; 
    99        private final BeanConfiguration _beanConfiguration; 
    1010 
    11         public ImmutableAnalyzerJob(AnalyzerBeanDescriptor descriptor, 
     11        public ImmutableAnalyzerJob(AnalyzerBeanDescriptor<?> descriptor, 
    1212                        BeanConfiguration beanConfiguration) { 
    1313                _descriptor = descriptor; 
    … …  
    1616 
    1717        @Override 
    18         public AnalyzerBeanDescriptor getDescriptor() { 
     18        public AnalyzerBeanDescriptor<?> getDescriptor() { 
    1919                return _descriptor; 
    2020        } 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/ImmutableTransformerJob.java

    r967 r975  
    1212final class ImmutableTransformerJob implements TransformerJob { 
    1313 
    14         private final TransformerBeanDescriptor _descriptor; 
     14        private final TransformerBeanDescriptor<?> _descriptor; 
    1515        private final BeanConfiguration _beanConfiguration; 
    1616        private final List<MutableInputColumn<?>> _output; 
    1717 
    18         public ImmutableTransformerJob(TransformerBeanDescriptor descriptor, 
     18        public ImmutableTransformerJob(TransformerBeanDescriptor<?> descriptor, 
    1919                        BeanConfiguration beanConfiguration, 
    2020                        Collection<MutableInputColumn<?>> output) { 
    … …  
    2626 
    2727        @Override 
    28         public TransformerBeanDescriptor getDescriptor() { 
     28        public TransformerBeanDescriptor<?> getDescriptor() { 
    2929                return _descriptor; 
    3030        } 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/RowProcessingAnalyzerJobBuilder.java

    r946 r975  
    11package org.eobjects.analyzer.job; 
    22 
     3import org.eobjects.analyzer.beans.RowProcessingAnalyzer; 
    34import org.eobjects.analyzer.descriptors.AnalyzerBeanDescriptor; 
    45 
    5 public class RowProcessingAnalyzerJobBuilder extends 
    6                 AbstractBeanWithInputColumnsBuilder<AnalyzerBeanDescriptor, RowProcessingAnalyzerJobBuilder> { 
     6public class RowProcessingAnalyzerJobBuilder<A extends RowProcessingAnalyzer<?>> 
     7                extends 
     8                AbstractBeanWithInputColumnsBuilder<AnalyzerBeanDescriptor<A>, A, RowProcessingAnalyzerJobBuilder<A>> { 
    79 
    8         public RowProcessingAnalyzerJobBuilder(AnalyzerBeanDescriptor descriptor) { 
     10        public RowProcessingAnalyzerJobBuilder(AnalyzerBeanDescriptor<A> descriptor) { 
    911                super(descriptor, RowProcessingAnalyzerJobBuilder.class); 
    1012        } 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/TransformerJob.java

    r938 r975  
    44import org.eobjects.analyzer.descriptors.TransformerBeanDescriptor; 
    55 
    6 public interface TransformerJob extends BeanJob<TransformerBeanDescriptor> { 
     6public interface TransformerJob extends BeanJob<TransformerBeanDescriptor<?>> { 
    77         
    88        public MutableInputColumn<?>[] getOutput(); 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/TransformerJobBuilder.java

    r956 r975  
    55 
    66import org.eobjects.analyzer.beans.OutputColumns; 
     7import org.eobjects.analyzer.beans.Transformer; 
    78import org.eobjects.analyzer.data.DataTypeFamily; 
    89import org.eobjects.analyzer.data.MutableInputColumn; 
    … …  
    1718import org.eobjects.analyzer.lifecycle.TransformerBeanInstance; 
    1819 
    19 public class TransformerJobBuilder 
     20/** 
     21 * @author Kasper SÞrensen 
     22 *  
     23 * @param <T> 
     24 *            the transformer type being configured 
     25 */ 
     26public class TransformerJobBuilder<T extends Transformer<?>> 
    2027                extends 
    21                 AbstractBeanWithInputColumnsBuilder<TransformerBeanDescriptor, TransformerJobBuilder> { 
     28                AbstractBeanWithInputColumnsBuilder<TransformerBeanDescriptor<T>, T, TransformerJobBuilder<T>> { 
    2229 
    2330        private LinkedList<MutableInputColumn<?>> _outputColumns = new LinkedList<MutableInputColumn<?>>(); 
    2431        private IdGenerator _idGenerator; 
    2532 
    26         public TransformerJobBuilder(TransformerBeanDescriptor descriptor, 
     33        public TransformerJobBuilder(TransformerBeanDescriptor<T> descriptor, 
    2734                        IdGenerator idGenerator) { 
    2835                super(descriptor, TransformerJobBuilder.class); 

  • AnalyzerBeans/trunk/src/main/java/org/eobjects/analyzer/job/runner/AnalysisRunnerImpl.java

    r949 r975  
    8282                List<AnalyzerJob> rowProcessingJobs = new ArrayList<AnalyzerJob>(); 
    8383                for (AnalyzerJob analyzerJob : analyzerJobs) { 
    84                         AnalyzerBeanDescriptor descriptor = analyzerJob.getDescriptor(); 
     84                        AnalyzerBeanDescriptor<?> descriptor = analyzerJob.getDescriptor(); 
    8585                        if (descriptor.isExploringAnalyzer()) { 
    8686                                explorerJobs.add(analyzerJob); 

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

    r968 r975  
    1919        private final Logger logger = LoggerFactory.getLogger(getClass()); 
    2020 
    21         private final BeanDescriptor descriptor; 
     21        private final BeanDescriptor<?> descriptor; 
    2222        private final E bean; 
    2323        private final List<LifeCycleCallback> assignConfiguredCallbacks = new LinkedList<LifeCycleCallback>(); 
    … …  
    2727 
    2828        @SuppressWarnings("unchecked") 
    29         public AbstractBeanInstance(BeanDescriptor descriptor) { 
     29        public AbstractBeanInstance(BeanDescriptor<?> descriptor) { 
    3030                if (descriptor == null) { 
    3131                        throw new IllegalArgumentException("Descriptor cannot be null"); 
    … …  
    4545        } 
    4646 
    47         public BeanDescriptor getDescriptor() { 
     47        public BeanDescriptor<?> getDescriptor() { 
    4848                return descriptor; 
    4949        } 

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

    r968 r975  
    2323        private final List<AnalyzerLifeCycleCallback> returnResultsCallbacks = new LinkedList<AnalyzerLifeCycleCallback>(); 
    2424 
    25         public AnalyzerBeanInstance(AnalyzerBeanDescriptor descriptor) { 
     25        public AnalyzerBeanInstance(AnalyzerBeanDescriptor<?> descriptor) { 
    2626                super(descriptor); 
    2727        } 
    … …  
    5353                        List<AnalyzerLifeCycleCallback> callbacks, LifeCycleState state) { 
    5454                for (AnalyzerLifeCycleCallback lifeCycleCallback : callbacks) { 
    55                         lifeCycleCallback.onEvent(state, getBean(), (AnalyzerBeanDescriptor) getDescriptor()); 
     55                        lifeCycleCallback.onEvent(state, getBean(), (AnalyzerBeanDescriptor<?>) getDescriptor()); 
    5656                } 
    5757        } 

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

    r957 r975  
    77 
    88        public void onEvent(LifeCycleState state, Analyzer<?> analyzerBean, 
    9                         AnalyzerBeanDescriptor descriptor); 
     9                        AnalyzerBeanDescriptor<?> descriptor); 
    1010} 

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

    r974 r975  
    2222        @Override 
    2323        public void onEvent(LifeCycleState state, Object bean, 
    24                         BeanDescriptor descriptor) { 
     24                        BeanDescriptor<?> descriptor) { 
    2525                assert state == LifeCycleState.ASSIGN_CONFIGURED; 
    2626 
    … …  
    4848        } 
    4949 
    50         protected Object getValue( 
    51                         ConfiguredPropertyDescriptor propertyDescriptor) { 
     50        protected Object getValue(ConfiguredPropertyDescriptor propertyDescriptor) { 
    5251                logger.debug("Getting property from bean configuration"); 
    5352                Object value = _beanConfiguration.getProperty(propertyDescriptor); 

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

    r974 r975  
    2626        @Override 
    2727        public void onEvent(LifeCycleState state, Object analyzerBean, 
    28                         BeanDescriptor descriptor) { 
     28                        BeanDescriptor<?> descriptor) { 
    2929                assert state == LifeCycleState.ASSIGN_PROVIDED; 
    3030 

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

    r962 r975  
    1010        @Override 
    1111        public void onEvent(LifeCycleState state, Object analyzerBean, 
    12                         BeanDescriptor descriptor) { 
     12                        BeanDescriptor<?> descriptor) { 
    1313                assert state == LifeCycleState.CLOSE; 
    1414 

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

    r962 r975  
    1010        @Override 
    1111        public void onEvent(LifeCycleState state, Object analyzerBean, 
    12                         BeanDescriptor descriptor) { 
     12                        BeanDescriptor<?> descriptor) { 
    1313                assert state == LifeCycleState.INITIALIZE; 
    1414 

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

    r962 r975  
    66 
    77        public void onEvent(LifeCycleState state, Object bean, 
    8                         BeanDescriptor descriptor); 
     8                        BeanDescriptor<?> descriptor); 
    99} 

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

    r968 r975  
    1818        @Override 
    1919        public void onEvent(LifeCycleState state, Object analyzerBean, 
    20                         BeanDescriptor descriptor) { 
     20                        BeanDescriptor<?> descriptor) { 
    2121                assert state == LifeCycleState.CLOSE; 
    2222 

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

    r968 r975  
    1717        @Override 
    1818        public void onEvent(LifeCycleState state, Analyzer<?> analyzerBean, 
    19                         AnalyzerBeanDescriptor descriptor) { 
     19                        AnalyzerBeanDescriptor<?> descriptor) { 
    2020                assert state == LifeCycleState.RETURN_RESULTS; 
    2121                 

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

    r968 r975  
    1616        @Override 
    1717        public void onEvent(LifeCycleState state, Analyzer<?> analyzerBean, 
    18                         AnalyzerBeanDescriptor descriptor) { 
     18                        AnalyzerBeanDescriptor<?> descriptor) { 
    1919                assert state == LifeCycleState.RUN; 
    2020                assert descriptor.isExploringAnalyzer(); 

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

    r957 r975  
    66public class TransformerBeanInstance extends AbstractBeanInstance<Transformer<?>> { 
    77 
    8         public TransformerBeanInstance(TransformerBeanDescriptor descriptor) { 
     8        public TransformerBeanInstance(TransformerBeanDescriptor<?> descriptor) { 
    99                super(descriptor); 
    1010        } 

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

    r974 r975  
    1818 
    1919        public void testDescriptor() throws Exception { 
    20                 AnalyzerBeanDescriptor descriptor = new AnnotationBasedAnalyzerBeanDescriptor( 
    21                                 JoinMatcher.class); 
     20                AnalyzerBeanDescriptor<JoinMatcher> descriptor = AnnotationBasedAnalyzerBeanDescriptor 
     21                                .create(JoinMatcher.class); 
    2222 
    2323                List<ConfiguredPropertyDescriptor> configuredProperties = new ArrayList<ConfiguredPropertyDescriptor>( 

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

    r974 r975  
    4747 
    4848        public void testDescriptor() throws Exception { 
    49                 AnalyzerBeanDescriptor descriptor = new AnnotationBasedAnalyzerBeanDescriptor( 
     49                AnalyzerBeanDescriptor<ReferentialIntegrityValidator> descriptor = AnnotationBasedAnalyzerBeanDescriptor.create( 
    5050                                ReferentialIntegrityValidator.class); 
    5151                assertEquals( 

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

    r962 r975  
    1414 
    1515        public void testDescriptor() throws Exception { 
    16                 AnalyzerBeanDescriptor desc = new AnnotationBasedAnalyzerBeanDescriptor( 
     16                AnalyzerBeanDescriptor<?> desc = AnnotationBasedAnalyzerBeanDescriptor.create( 
    1717                                ValueDistributionAnalyzer.class); 
    1818                assertEquals(true, desc.isRowProcessingAnalyzer()); 

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

    r974 r975  
    2626 
    2727        public void testExploringType() throws Exception { 
    28                 AnalyzerBeanDescriptor descriptor = new AnnotationBasedAnalyzerBeanDescriptor( 
    29                                 ExploringAnalyzerMock.class); 
     28                AnalyzerBeanDescriptor<?> descriptor = AnnotationBasedAnalyzerBeanDescriptor 
     29                                .create(ExploringAnalyzerMock.class); 
    3030                assertEquals(true, descriptor.isExploringAnalyzer()); 
    3131                assertEquals(false, descriptor.isRowProcessingAnalyzer()); 
    … …  
    3737 
    3838        public void testRowProcessingType() throws Exception { 
    39                 AnalyzerBeanDescriptor descriptor = new AnnotationBasedAnalyzerBeanDescriptor( 
    40                                 RowProcessingAnalyzerMock.class); 
     39                AnalyzerBeanDescriptor<RowProcessingAnalyzerMock> descriptor = AnnotationBasedAnalyzerBeanDescriptor 
     40                                .create(RowProcessingAnalyzerMock.class); 
    4141                assertEquals(false, descriptor.isExploringAnalyzer()); 
    4242                assertEquals(true, descriptor.isRowProcessingAnalyzer()); 
    … …  
    5656 
    5757        public void testGetInputDataTypeFamily() throws Exception { 
    58                 AnalyzerBeanDescriptor descriptor = new AnnotationBasedAnalyzerBeanDescriptor( 
    59                                 StringAnalyzer.class); 
     58                AnalyzerBeanDescriptor<?> descriptor = AnnotationBasedAnalyzerBeanDescriptor 
     59                                .create(StringAnalyzer.class); 
    6060                assertEquals(DataTypeFamily.STRING, descriptor.getInputDataTypeFamily()); 
    6161 
    62                 descriptor = new AnnotationBasedAnalyzerBeanDescriptor( 
    63                                 ValueDistributionAnalyzer.class); 
     62                descriptor = AnnotationBasedAnalyzerBeanDescriptor 
     63                                .create(ValueDistributionAnalyzer.class); 
    6464                assertEquals(DataTypeFamily.UNDEFINED, 
    6565                                descriptor.getInputDataTypeFamily()); 
    … …  
    6868        public void testAbstractBeanClass() throws Exception { 
    6969                try { 
    70                         new AnnotationBasedAnalyzerBeanDescriptor(InvalidAnalyzer.class); 
     70                        AnnotationBasedAnalyzerBeanDescriptor.create(InvalidAnalyzer.class); 
    7171                        fail("Exception expected"); 
    7272                } catch (DescriptorException e) { 

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

    r962 r975  
    1212 
    1313        public void testGetDataTypeFamilies() throws Exception { 
    14                 TransformerBeanDescriptor descriptor = new AnnotationBasedTransformerBeanDescriptor( 
    15                                 TokenizerTransformer.class); 
     14                TransformerBeanDescriptor<?> descriptor = AnnotationBasedTransformerBeanDescriptor 
     15                                .create(TokenizerTransformer.class); 
    1616                assertEquals(DataTypeFamily.STRING, descriptor.getInputDataTypeFamily()); 
    1717                assertEquals(DataTypeFamily.STRING, 
    1818                                descriptor.getOutputDataTypeFamily()); 
    1919 
    20                 descriptor = new AnnotationBasedTransformerBeanDescriptor( 
    21                                 ConvertToNumberTransformer.class); 
     20                descriptor = AnnotationBasedTransformerBeanDescriptor 
     21                                .create(ConvertToNumberTransformer.class); 
    2222                assertEquals(DataTypeFamily.STRING, descriptor.getInputDataTypeFamily()); 
    2323                assertEquals(DataTypeFamily.NUMBER, 
    2424                                descriptor.getOutputDataTypeFamily()); 
    2525 
    26                 descriptor = new AnnotationBasedTransformerBeanDescriptor( 
    27                                 ConvertToStringTransformer.class); 
     26                descriptor = AnnotationBasedTransformerBeanDescriptor 
     27                                .create(ConvertToStringTransformer.class); 
    2828                assertEquals(DataTypeFamily.UNDEFINED, 
    2929                                descriptor.getInputDataTypeFamily()); 
    … …  
    3131                                descriptor.getOutputDataTypeFamily()); 
    3232        } 
    33          
     33 
    3434        public void testConcatenator() throws Exception { 
    35                 TransformerBeanDescriptor descriptor = new AnnotationBasedTransformerBeanDescriptor( 
    36                                 ConcatenatorTransformer.class); 
     35                TransformerBeanDescriptor<?> descriptor = AnnotationBasedTransformerBeanDescriptor 
     36                                .create(ConcatenatorTransformer.class); 
    3737                assertEquals(DataTypeFamily.UNDEFINED, 
    3838                                descriptor.getInputDataTypeFamily()); 
    3939                assertEquals(DataTypeFamily.STRING, 
    40                                 descriptor.getOutputDataTypeFamily());           
     40                                descriptor.getOutputDataTypeFamily()); 
    4141        } 
    4242} 

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

    r971 r975  
    1010        public void testScanNonExistingPackage() throws Exception { 
    1111                ClasspathScanDescriptorProvider provider = new ClasspathScanDescriptorProvider(); 
    12                 Collection<AnalyzerBeanDescriptor> analyzerDescriptors = provider 
     12                Collection<AnalyzerBeanDescriptor<?>> analyzerDescriptors = provider 
    1313                                .scanPackage("org.eobjects.analyzer.nonexistingbeans", true) 
    1414                                .getAnalyzerBeanDescriptors(); 
    … …  
    2121        public void testScanPackageRecursive() throws Exception { 
    2222                ClasspathScanDescriptorProvider descriptorProvider = new ClasspathScanDescriptorProvider(); 
    23                 Collection<AnalyzerBeanDescriptor> analyzerDescriptors = descriptorProvider 
     23                Collection<AnalyzerBeanDescriptor<?>> analyzerDescriptors = descriptorProvider 
    2424                                .scanPackage("org.eobjects.analyzer.beans.mock", true) 
    2525                                .getAnalyzerBeanDescriptors(); 
    … …  
    3030                                Arrays.toString(array)); 
    3131 
    32                 Collection<TransformerBeanDescriptor> transformerBeanDescriptors = descriptorProvider 
     32                Collection<TransformerBeanDescriptor<?>> transformerBeanDescriptors = descriptorProvider 
    3333                                .getTransformerBeanDescriptors(); 
    3434                assertEquals( 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/job/AnalysisJobBuilderTest.java

    r958 r975  
    5656 
    5757        public void testToString() throws Exception { 
    58                 RowProcessingAnalyzerJobBuilder ajb = analysisJobBuilder 
     58                RowProcessingAnalyzerJobBuilder<StringAnalyzer> ajb = analysisJobBuilder 
    5959                                .addAnalyzer(StringAnalyzer.class); 
    60                 TransformerJobBuilder tjb = analysisJobBuilder 
     60                TransformerJobBuilder<ConvertToStringTransformer> tjb = analysisJobBuilder 
    6161                                .addTransformer(ConvertToStringTransformer.class); 
    6262 
    … …  
    8181                                employeeTable.getColumnByName("EMAIL")); 
    8282 
    83                 TransformerJobBuilder transformerJobBuilder = analysisJobBuilder 
     83                TransformerJobBuilder<ConvertToStringTransformer> transformerJobBuilder = analysisJobBuilder 
    8484                                .addTransformer(ConvertToStringTransformer.class); 
    8585 
    … …  
    9797                assertFalse(analysisJobBuilder.isConfigured()); 
    9898 
    99                 RowProcessingAnalyzerJobBuilder analyzerJobBuilder = analysisJobBuilder 
     99                RowProcessingAnalyzerJobBuilder<StringAnalyzer> analyzerJobBuilder = analysisJobBuilder 
    100100                                .addAnalyzer(StringAnalyzer.class); 
    101101 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/job/TransformerJobBuilderTest.java

    r958 r975  
    2828 
    2929        public void testSetInvalidPropertyType() throws Exception { 
    30                 TransformerJobBuilder tjb = ajb 
     30                TransformerJobBuilder<TokenizerTransformer> tjb = ajb 
    3131                                .addTransformer(TokenizerTransformer.class); 
    3232                try { 
    … …  
    4141 
    4242        public void testIsConfigured() throws Exception { 
    43                 TransformerJobBuilder tjb = ajb 
     43                TransformerJobBuilder<TokenizerTransformer> tjb = ajb 
    4444                                .addTransformer(TokenizerTransformer.class); 
    4545                assertFalse(tjb.isConfigured()); 
    … …  
    6666 
    6767        public void testInvalidInputColumnType() throws Exception { 
    68                 TransformerJobBuilder tjb = ajb 
     68                TransformerJobBuilder<ConvertToNumberTransformer> tjb = ajb 
    6969                                .addTransformer(ConvertToNumberTransformer.class); 
    7070                assertEquals(1, tjb.getOutputColumns().size()); 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/job/runner/RowProcessingPublisherTest.java

    r958 r975  
    4343                ajb.addSourceColumn(physicalColumn); 
    4444 
    45                 TransformerJobBuilder tjb1 = ajb.addTransformer(TransformerMock.class) 
    46                                 .addInputColumn(ajb.getSourceColumns().get(0)); 
    47                 TransformerJobBuilder tjb2 = ajb.addTransformer(TransformerMock.class) 
    48                                 .addInputColumn(tjb1.getOutputColumns().get(0)); 
    49                 TransformerJobBuilder tjb3 = ajb.addTransformer( 
    50                                 ConvertToStringTransformer.class).addInputColumn( 
    51                                 tjb2.getOutputColumns().get(0)); 
     45                TransformerJobBuilder<TransformerMock> tjb1 = ajb.addTransformer( 
     46                                TransformerMock.class).addInputColumn( 
     47                                ajb.getSourceColumns().get(0)); 
     48                TransformerJobBuilder<TransformerMock> tjb2 = ajb.addTransformer( 
     49                                TransformerMock.class).addInputColumn( 
     50                                tjb1.getOutputColumns().get(0)); 
     51                TransformerJobBuilder<ConvertToStringTransformer> tjb3 = ajb 
     52                                .addTransformer(ConvertToStringTransformer.class) 
     53                                .addInputColumn(tjb2.getOutputColumns().get(0)); 
    5254 
    5355                ajb.addAnalyzer(StringAnalyzer.class).addInputColumn( 
    … …  
    9597                jobDependencies.add(transformerJobs.get(2)); 
    9698                jobDependencies.add(analyzerJobs.get(1)); 
    97                  
     99 
    98100                int jobDependenciesFound = 0; 
    99101                boolean analyzerJob1found = false; 
    … …  
    113115                        } 
    114116                } 
    115                  
     117 
    116118                assertTrue(analyzerJob1found); 
    117119                assertEquals(4, jobDependenciesFound); 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/lifecycle/RunExplorerCallbackTest.java

    r964 r975  
    2626                ExploringAnalyzer<?> analyzer = EasyMock 
    2727                                .createMock(ExploringAnalyzer.class); 
    28                 AnalyzerBeanDescriptor descriptor = EasyMock 
     28                AnalyzerBeanDescriptor<?> descriptor = EasyMock 
    2929                                .createMock(AnalyzerBeanDescriptor.class); 
    3030 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/test/full/scenarios/NameAndEmailPartEqualityTest.java

    r966 r975  
    7777                analysisJobBuilder.addSourceColumns(nameColumn, emailColumn); 
    7878 
    79                 TransformerJobBuilder nameTransformerJobBuilder = analysisJobBuilder 
     79                TransformerJobBuilder<NameStandardizerTransformer> nameTransformerJobBuilder = analysisJobBuilder 
    8080                                .addTransformer(NameStandardizerTransformer.class); 
    8181                nameTransformerJobBuilder.addInputColumn(analysisJobBuilder 
    … …  
    9494                assertEquals("Titulation", nameColumns.get(3).getName()); 
    9595 
    96                 TransformerJobBuilder emailTransformerJobBuilder = analysisJobBuilder 
     96                TransformerJobBuilder<EmailStandardizerTransformer> emailTransformerJobBuilder = analysisJobBuilder 
    9797                                .addTransformer(EmailStandardizerTransformer.class); 
    9898                emailTransformerJobBuilder.addInputColumn(analysisJobBuilder 
    … …  
    110110 
    111111                for (InputColumn<?> inputColumn : nameColumns) { 
    112                         RowProcessingAnalyzerJobBuilder analyzerJobBuilder = analysisJobBuilder 
     112                        RowProcessingAnalyzerJobBuilder<ValueDistributionAnalyzer> analyzerJobBuilder = analysisJobBuilder 
    113113                                        .addAnalyzer(ValueDistributionAnalyzer.class); 
    114114                        analyzerJobBuilder.addInputColumn(inputColumn); 
    … …  
    122122                } 
    123123 
    124                 RowProcessingAnalyzerJobBuilder equalsAnalyzerJobBuilder = analysisJobBuilder 
     124                RowProcessingAnalyzerJobBuilder<EqualityAnalyzer> equalsAnalyzerJobBuilder = analysisJobBuilder 
    125125                                .addAnalyzer(EqualityAnalyzer.class); 
    126126                equalsAnalyzerJobBuilder.addInputColumns( 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/test/full/scenarios/TokenizerAndValueDistributionTest.java

    r949 r975  
    6969                analysisJobBuilder.addSourceColumns(jobTitleColumn); 
    7070 
    71                 TransformerJobBuilder transformerJobBuilder = analysisJobBuilder 
     71                TransformerJobBuilder<TokenizerTransformer> transformerJobBuilder = analysisJobBuilder 
    7272                                .addTransformer(TokenizerTransformer.class); 
    7373                transformerJobBuilder.addInputColumn(analysisJobBuilder 
    … …  
    8484 
    8585                for (InputColumn<?> inputColumn : transformerOutput) { 
    86                         RowProcessingAnalyzerJobBuilder valueDistribuitionJobBuilder = analysisJobBuilder 
     86                        RowProcessingAnalyzerJobBuilder<ValueDistributionAnalyzer> valueDistribuitionJobBuilder = analysisJobBuilder 
    8787                                        .addAnalyzer(ValueDistributionAnalyzer.class); 
    8888                        valueDistribuitionJobBuilder.addInputColumn(inputColumn); 

  • AnalyzerBeans/trunk/src/test/java/org/eobjects/analyzer/test/full/scenarios/ValueDistributionAndStringAnalysisTest.java

    r949 r975  
    7272 
    7373                for (InputColumn<?> inputColumn : analysisJobBuilder.getSourceColumns()) { 
    74                         RowProcessingAnalyzerJobBuilder valueDistribuitionJobBuilder = analysisJobBuilder 
     74                        RowProcessingAnalyzerJobBuilder<ValueDistributionAnalyzer> valueDistribuitionJobBuilder = analysisJobBuilder 
    7575                                        .addAnalyzer(ValueDistributionAnalyzer.class); 
    7676                        valueDistribuitionJobBuilder.addInputColumn(inputColumn); 
    … …  
    8585                columns = table.getLiteralColumns(); 
    8686 
    87                 RowProcessingAnalyzerJobBuilder stringAnalyzerJob = analysisJobBuilder 
     87                RowProcessingAnalyzerJobBuilder<StringAnalyzer> stringAnalyzerJob = analysisJobBuilder 
    8888                                .addAnalyzer(StringAnalyzer.class); 
    8989                stringAnalyzerJob.addInputColumns(analysisJobBuilder 
Note: See TracChangeset for help on using the changeset viewer.