1
24 package net.sf.jasperreports.engine.fill;
25
26 import net.sf.jasperreports.engine.type.CalculationEnum;
27
28
29
32 public final class JRDefaultIncrementerFactory extends JRAbstractExtendedIncrementerFactory
33 {
34
35
36
39 private static JRDefaultIncrementerFactory mainInstance = new JRDefaultIncrementerFactory();
40
41
42
45 private JRDefaultIncrementerFactory()
46 {
47 }
48
49
50
53 public static JRDefaultIncrementerFactory getInstance()
54 {
55 return mainInstance;
56 }
57
58
59 @Override
60 public JRExtendedIncrementer getExtendedIncrementer(CalculationEnum calculation)
61 {
62 JRExtendedIncrementer incrementer = null;
63
64 switch (calculation)
65 {
66 case SYSTEM :
67 {
68 incrementer = JRDefaultSystemIncrementer.getInstance();
69 break;
70 }
71 case FIRST :
72 {
73 incrementer = JRDefaultFirstIncrementer.getInstance();
74 break;
75 }
76 case NOTHING :
77 case COUNT :
78 case SUM :
79 case AVERAGE :
80 case LOWEST :
81 case HIGHEST :
82 case STANDARD_DEVIATION :
83 case VARIANCE :
84 case DISTINCT_COUNT :
85 default :
86 {
87 incrementer = JRDefaultNothingIncrementer.getInstance();
88 break;
89 }
90 }
91
92 return incrementer;
93 }
94
95
96 public static JRExtendedIncrementerFactory getFactory (Class<?> valueClass)
97 {
98 JRExtendedIncrementerFactory factory;
99
100 if (java.math.BigDecimal.class.equals(valueClass))
101 {
102 factory = JRBigDecimalIncrementerFactory.getInstance();
103 }
104 else if (
105 java.lang.Number.class.equals(valueClass)
106 || java.lang.Double.class.equals(valueClass)
107 )
108 {
109 factory = JRDoubleIncrementerFactory.getInstance();
110 }
111 else if (java.lang.Float.class.equals(valueClass))
112 {
113 factory = JRFloatIncrementerFactory.getInstance();
114 }
115 else if (java.lang.Long.class.equals(valueClass))
116 {
117 factory = JRLongIncrementerFactory.getInstance();
118 }
119 else if (java.lang.Integer.class.equals(valueClass))
120 {
121 factory = JRIntegerIncrementerFactory.getInstance();
122 }
123 else if (java.lang.Short.class.equals(valueClass))
124 {
125 factory = JRShortIncrementerFactory.getInstance();
126 }
127 else if (java.lang.Byte.class.equals(valueClass))
128 {
129 factory = JRByteIncrementerFactory.getInstance();
130 }
131 else if (java.lang.Comparable.class.isAssignableFrom(valueClass))
132 {
133 factory = JRComparableIncrementerFactory.getInstance();
134 }
135 else
136 {
137 factory = JRDefaultIncrementerFactory.getInstance();
138 }
139
140 return factory;
141 }
142 }
143
144
145
148 final class JRDefaultNothingIncrementer extends JRAbstractExtendedIncrementer
149 {
150
151
152
155 private static JRDefaultNothingIncrementer mainInstance = new JRDefaultNothingIncrementer();
156
157
158
161 private JRDefaultNothingIncrementer()
162 {
163 }
164
165
166
169 public static JRDefaultNothingIncrementer getInstance()
170 {
171 return mainInstance;
172 }
173
174
175 @Override
176 public Object increment(
177 JRCalculable variable,
178 Object expressionValue,
179 AbstractValueProvider valueProvider
180 )
181 {
182 return expressionValue;
183 }
184
185
186 @Override
187 public Object combine(JRCalculable calculable, JRCalculable calculableValue, AbstractValueProvider valueProvider)
188 {
189 if (!calculableValue.isInitialized())
190 {
191 return calculableValue.getValue();
192 }
193
194 if (!calculable.isInitialized())
195 {
196 return calculable.getValue();
197 }
198
199 return null;
200 }
201
202 @Override
203 public Object initialValue()
204 {
205 return null;
206 }
207
208 @Override
209 public boolean ignoresNullValues()
210 {
211 return false;
212 }
213
214 }
215
216
217
220 final class JRDefaultSystemIncrementer extends JRAbstractExtendedIncrementer
221 {
222
225 private static JRDefaultSystemIncrementer mainInstance = new JRDefaultSystemIncrementer();
226
227
230 private JRDefaultSystemIncrementer()
231 {
232 }
233
234
237 public static JRDefaultSystemIncrementer getInstance()
238 {
239 return mainInstance;
240 }
241
242 @Override
243 public Object increment(
244 JRCalculable variable,
245 Object expressionValue,
246 AbstractValueProvider valueProvider
247 )
248 {
249 return variable.getValue();
250 }
251
252 @Override
253 public Object combine(JRCalculable calculable, JRCalculable calculableValue, AbstractValueProvider valueProvider)
254 {
255 return calculable.getValue();
256 }
257
258 @Override
259 public Object initialValue()
260 {
261 return null;
262 }
263 }
264
265 final class JRDefaultFirstIncrementer extends JRAbstractExtendedIncrementer
266 {
267 private static final JRDefaultFirstIncrementer instance = new JRDefaultFirstIncrementer();
268
269 private JRDefaultFirstIncrementer()
270 {
271 }
272
273 public static JRDefaultFirstIncrementer getInstance()
274 {
275 return instance;
276 }
277
278 @Override
279 public Object initialValue()
280 {
281 return null;
282 }
283
284 @Override
285 public Object combine(JRCalculable calculable, JRCalculable calculableValue, AbstractValueProvider valueProvider)
286 {
287 if (!calculable.isInitialized())
288 {
289 return calculable.getValue();
290 }
291
292 if (!calculableValue.isInitialized())
293 {
294 return calculableValue.getValue();
295 }
296
297 return null;
298 }
299
300 @Override
301 public Object increment(JRCalculable calculable, Object expressionValue, AbstractValueProvider valueProvider)
302 {
303 if (calculable.isInitialized())
304 {
305 return expressionValue;
306 }
307
308 return calculable.getIncrementedValue();
309 }
310
311 @Override
312 public boolean ignoresNullValues()
313 {
314 return false;
315 }
316 }
317