Changeset 3134


Ignore:
Timestamp:
02/03/12 15:05:24 (4 months ago)
Author:
kasper
Message:

Updated transformer descriptions

Location:
AnalyzerBeans/trunk/core/src/main/java/org/eobjects/analyzer/beans/datastructures
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • AnalyzerBeans/trunk/core/src/main/java/org/eobjects/analyzer/beans/datastructures/BuildListTransformer.java

    r3102 r3134  
    2727import org.eobjects.analyzer.beans.api.Categorized; 
    2828import org.eobjects.analyzer.beans.api.Configured; 
     29import org.eobjects.analyzer.beans.api.Description; 
    2930import org.eobjects.analyzer.beans.api.OutputColumns; 
    3031import org.eobjects.analyzer.beans.api.Transformer; 
    … …  
    4445 */ 
    4546@TransformerBean("Build list") 
     47@Description("Build a list containing a variable amount of elements. Adds the capability to save multiple values in a single field.") 
    4648@Categorized(DataStructuresCategory.class) 
    4749public class BuildListTransformer implements Transformer<List<?>> { 
    4850 
    49         private static final Logger logger = LoggerFactory.getLogger(BuildMapTransformer.class); 
     51    private static final Logger logger = LoggerFactory 
     52            .getLogger(BuildMapTransformer.class); 
    5053 
    51         @Inject 
    52         @Configured 
    53         InputColumn<?>[] values; 
     54    @Inject 
     55    @Configured 
     56    InputColumn<?>[] values; 
    5457 
    55         @Inject 
    56         @Configured 
    57         boolean includeNullValues; 
    58          
    59         public void setIncludeNullValues(boolean includeNullValues) { 
    60                 this.includeNullValues = includeNullValues; 
    61         } 
    62          
    63         public void setValues(InputColumn<?>[] values) { 
    64                 this.values = values; 
    65         } 
     58    @Inject 
     59    @Configured 
     60    boolean includeNullValues; 
    6661 
    67         @Override 
    68         public OutputColumns getOutputColumns() { 
    69                 StringBuilder sb = new StringBuilder("List: "); 
    70                 for (int i = 0; i < values.length; i++) { 
    71                         String key = values[i].getName(); 
    72                         sb.append(key); 
    73                         if (sb.length() > 30) { 
    74                                 sb.append("..."); 
    75                                 break; 
    76                         } 
     62    public void setIncludeNullValues(boolean includeNullValues) { 
     63        this.includeNullValues = includeNullValues; 
     64    } 
    7765 
    78                         if (i + 1 < values.length) { 
    79                                 sb.append(","); 
    80                         } 
    81                 } 
    82                 OutputColumns outputColumns = new OutputColumns(new String[] { sb.toString() }, new Class[] { List.class }); 
    83                 return outputColumns; 
    84         } 
     66    public void setValues(InputColumn<?>[] values) { 
     67        this.values = values; 
     68    } 
    8569 
    86         @Override 
    87         public List<?>[] transform(InputRow row) { 
    88                 final List<Object> list = new ArrayList<Object>(values.length); 
    89                 for (InputColumn<?> column : values) { 
    90                         final Object value = row.getValue(column); 
    91                         if (!includeNullValues && value == null) { 
    92                                 logger.debug("Ignoring null value for {} in row: {}", column.getName(), row); 
    93                         } else { 
    94                                 list.add(value); 
    95                         } 
    96                 } 
     70    @Override 
     71    public OutputColumns getOutputColumns() { 
     72        StringBuilder sb = new StringBuilder("List: "); 
     73        for (int i = 0; i < values.length; i++) { 
     74            String key = values[i].getName(); 
     75            sb.append(key); 
     76            if (sb.length() > 30) { 
     77                sb.append("..."); 
     78                break; 
     79            } 
    9780 
    98                 final List<?>[] result = new List[] { list }; 
    99                 return result; 
    100         } 
     81            if (i + 1 < values.length) { 
     82                sb.append(","); 
     83            } 
     84        } 
     85        OutputColumns outputColumns = new OutputColumns( 
     86                new String[] { sb.toString() }, new Class[] { List.class }); 
     87        return outputColumns; 
     88    } 
     89 
     90    @Override 
     91    public List<?>[] transform(InputRow row) { 
     92        final List<Object> list = new ArrayList<Object>(values.length); 
     93        for (InputColumn<?> column : values) { 
     94            final Object value = row.getValue(column); 
     95            if (!includeNullValues && value == null) { 
     96                logger.debug("Ignoring null value for {} in row: {}", 
     97                        column.getName(), row); 
     98            } else { 
     99                list.add(value); 
     100            } 
     101        } 
     102 
     103        final List<?>[] result = new List[] { list }; 
     104        return result; 
     105    } 
    101106 
    102107} 

  • AnalyzerBeans/trunk/core/src/main/java/org/eobjects/analyzer/beans/datastructures/BuildMapTransformer.java

    r3102 r3134  
    4848@TransformerBean("Build key/value map") 
    4949@Alias("Build map") 
    50 @Description("Transformer capable of building a map of keys and values") 
     50@Description("Build a map with a variable amount of keys and values. Adds the capability to store complex structures with named entries within it.") 
    5151@Categorized(DataStructuresCategory.class) 
    5252public class BuildMapTransformer implements Transformer<Map<String, ?>> { 
    5353 
    54         private static final Logger logger = LoggerFactory.getLogger(BuildMapTransformer.class); 
     54    private static final Logger logger = LoggerFactory 
     55            .getLogger(BuildMapTransformer.class); 
    5556 
    56         @Inject 
    57         @Configured 
    58         InputColumn<?>[] values; 
     57    @Inject 
     58    @Configured 
     59    InputColumn<?>[] values; 
    5960 
    60         @Inject 
    61         @Configured 
    62         String[] keys; 
     61    @Inject 
     62    @Configured 
     63    String[] keys; 
    6364 
    64         @Inject 
    65         @Configured 
    66         boolean retainKeyOrder = false; 
     65    @Inject 
     66    @Configured 
     67    boolean retainKeyOrder = false; 
    6768 
    68         @Inject 
    69         @Configured 
    70         boolean includeNullValues = false; 
     69    @Inject 
     70    @Configured 
     71    boolean includeNullValues = false; 
    7172 
    72         public void setIncludeNullValues(boolean includeNullValues) { 
    73                 this.includeNullValues = includeNullValues; 
    74         } 
     73    public void setIncludeNullValues(boolean includeNullValues) { 
     74        this.includeNullValues = includeNullValues; 
     75    } 
    7576 
    76         public void setKeys(String[] keys) { 
    77                 this.keys = keys; 
    78         } 
     77    public void setKeys(String[] keys) { 
     78        this.keys = keys; 
     79    } 
    7980 
    80         public void setRetainKeyOrder(boolean retainKeyOrder) { 
    81                 this.retainKeyOrder = retainKeyOrder; 
    82         } 
     81    public void setRetainKeyOrder(boolean retainKeyOrder) { 
     82        this.retainKeyOrder = retainKeyOrder; 
     83    } 
    8384 
    84         public void setValues(InputColumn<?>[] values) { 
    85                 this.values = values; 
    86         } 
     85    public void setValues(InputColumn<?>[] values) { 
     86        this.values = values; 
     87    } 
    8788 
    88         @Override 
    89         public OutputColumns getOutputColumns() { 
    90                 StringBuilder sb = new StringBuilder("Map: "); 
    91                 for (int i = 0; i < keys.length; i++) { 
    92                         String key = keys[i]; 
    93                         sb.append(key); 
    94                         if (sb.length() > 30) { 
    95                                 sb.append("..."); 
    96                                 break; 
    97                         } 
     89    @Override 
     90    public OutputColumns getOutputColumns() { 
     91        StringBuilder sb = new StringBuilder("Map: "); 
     92        for (int i = 0; i < keys.length; i++) { 
     93            String key = keys[i]; 
     94            sb.append(key); 
     95            if (sb.length() > 30) { 
     96                sb.append("..."); 
     97                break; 
     98            } 
    9899 
    99                         if (i + 1 < keys.length) { 
    100                                 sb.append(","); 
    101                         } 
    102                 } 
    103                 OutputColumns outputColumns = new OutputColumns(new String[] { sb.toString() }, new Class[] { Map.class }); 
    104                 return outputColumns; 
    105         } 
     100            if (i + 1 < keys.length) { 
     101                sb.append(","); 
     102            } 
     103        } 
     104        OutputColumns outputColumns = new OutputColumns( 
     105                new String[] { sb.toString() }, new Class[] { Map.class }); 
     106        return outputColumns; 
     107    } 
    106108 
    107         @Override 
    108         public Map<String, ?>[] transform(InputRow row) { 
    109                 final Map<String, Object> map; 
    110                 if (retainKeyOrder) { 
    111                         map = new LinkedHashMap<String, Object>(); 
    112                 } else { 
    113                         map = new HashMap<String, Object>(); 
    114                 } 
    115                 for (int i = 0; i < keys.length; i++) { 
    116                         final String key = keys[i]; 
    117                         final Object value = row.getValue(values[i]); 
    118                         if (value == null && !includeNullValues) { 
    119                                 logger.debug("Ignoring null value for {} in row: {}", key, row); 
    120                         } else { 
    121                                 map.put(key, value); 
    122                         } 
    123                 } 
     109    @Override 
     110    public Map<String, ?>[] transform(InputRow row) { 
     111        final Map<String, Object> map; 
     112        if (retainKeyOrder) { 
     113            map = new LinkedHashMap<String, Object>(); 
     114        } else { 
     115            map = new HashMap<String, Object>(); 
     116        } 
     117        for (int i = 0; i < keys.length; i++) { 
     118            final String key = keys[i]; 
     119            final Object value = row.getValue(values[i]); 
     120            if (value == null && !includeNullValues) { 
     121                logger.debug("Ignoring null value for {} in row: {}", key, row); 
     122            } else { 
     123                map.put(key, value); 
     124            } 
     125        } 
    124126 
    125                 @SuppressWarnings("unchecked") 
    126                 Map<String, ?>[] result = new Map[] { map }; 
     127        @SuppressWarnings("unchecked") 
     128        Map<String, ?>[] result = new Map[] { map }; 
    127129 
    128                 return result; 
    129         } 
     130        return result; 
     131    } 
    130132 
    131133} 
Note: See TracChangeset for help on using the changeset viewer.