Java > Open Source Codes > net > sf > jasperreports > engine > fill > JRLongIncrementerFactory


1 /*
2  * ============================================================================
3  * GNU Lesser General Public License
4  * ============================================================================
5  *
6  * JasperReports - Free Java report-generating library.
7  * Copyright (C) 2001-2006 JasperSoft Corporation http://www.jaspersoft.com
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
22  *
23  * JasperSoft Corporation
24  * 303 Second Street, Suite 450 North
25  * San Francisco, CA 94107
26  * http://www.jaspersoft.com
27  */
28 package net.sf.jasperreports.engine.fill;
29
30 import net.sf.jasperreports.engine.JRVariable;
31
32
33 /**
34  * @author Teodor Danciu (teodord@users.sourceforge.net)
35  * @version $Id: JRLongIncrementerFactory.java 1347 2006-07-19 15:31:07 +0300 (Wed, 19 Jul 2006) teodord $
36  */
37 public class JRLongIncrementerFactory extends JRAbstractExtendedIncrementerFactory
38 {
39
40
41     /**
42      *
43      */
44     protected static final Long ZERO = new Long (0);
45
46
47     /**
48      *
49      */
50     private static JRLongIncrementerFactory mainInstance = new JRLongIncrementerFactory();
51
52
53     /**
54      *
55      */
56     private JRLongIncrementerFactory()
57     {
58     }
59
60
61     /**
62      *
63      */
64     public static JRLongIncrementerFactory getInstance()
65     {
66         return mainInstance;
67     }
68
69
70     /**
71      *
72      */
73     public JRExtendedIncrementer getExtendedIncrementer(byte calculation)
74     {
75         JRExtendedIncrementer incrementer = null;
76
77         switch (calculation)
78         {
79             case JRVariable.CALCULATION_COUNT :
80             {
81                 incrementer = JRLongCountIncrementer.getInstance();
82                 break;
83             }
84             case JRVariable.CALCULATION_SUM :
85             {
86                 incrementer = JRLongSumIncrementer.getInstance();
87                 break;
88             }
89             case JRVariable.CALCULATION_AVERAGE :
90             {
91                 incrementer = JRLongAverageIncrementer.getInstance();
92                 break;
93             }
94             case JRVariable.CALCULATION_LOWEST :
95             case JRVariable.CALCULATION_HIGHEST :
96             {
97                 incrementer = JRComparableIncrementerFactory.getInstance().getExtendedIncrementer(calculation);
98                 break;
99             }
100             case JRVariable.CALCULATION_STANDARD_DEVIATION :
101             {
102                 incrementer = JRLongStandardDeviationIncrementer.getInstance();
103                 break;
104             }
105             case JRVariable.CALCULATION_VARIANCE :
106             {
107                 incrementer = JRLongVarianceIncrementer.getInstance();
108                 break;
109             }
110             case JRVariable.CALCULATION_DISTINCT_COUNT :
111             {
112                 incrementer = JRLongDistinctCountIncrementer.getInstance();
113                 break;
114             }
115             case JRVariable.CALCULATION_SYSTEM :
116             case JRVariable.CALCULATION_NOTHING :
117             case JRVariable.CALCULATION_FIRST :
118             default :
119             {
120                 incrementer = JRDefaultIncrementerFactory.getInstance().getExtendedIncrementer(calculation);
121                 break;
122             }
123         }
124         
125         return incrementer;
126     }
127
128
129 }
130
131
132 /**
133  *
134  */
135 class JRLongCountIncrementer extends JRAbstractExtendedIncrementer
136 {
137     /**
138      *
139      */
140     private static JRLongCountIncrementer mainInstance = new JRLongCountIncrementer();
141
142     /**
143      *
144      */
145     private JRLongCountIncrementer()
146     {
147     }
148
149     /**
150      *
151      */
152     public static JRLongCountIncrementer getInstance()
153     {
154         return mainInstance;
155     }
156
157     /**
158      *
159      */
160     public Object increment(
161         JRCalculable variable,
162         Object expressionValue,
163         AbstractValueProvider valueProvider
164         )
165     {
166         Number value = (Number )variable.getIncrementedValue();
167
168         if (value == null || variable.isInitialized())
169         {
170             value = JRLongIncrementerFactory.ZERO;
171         }
172
173         if (expressionValue == null)
174         {
175             return value;
176         }
177
178         return new Long (value.longValue() + 1);
179     }
180
181     
182     public Object combine(JRCalculable calculable, JRCalculable calculableValue, AbstractValueProvider valueProvider)
183     {
184         Number value = (Number )calculable.getIncrementedValue();
185         Number combineValue = (Number ) calculableValue.getValue();
186
187         if (value == null || calculable.isInitialized())
188         {
189             value = JRLongIncrementerFactory.ZERO;
190         }
191
192         if (combineValue == null)
193         {
194             return value;
195         }
196
197         return new Long (value.longValue() + combineValue.longValue());
198     }
199
200     
201     public Object initialValue()
202     {
203         return JRLongIncrementerFactory.ZERO;
204     }
205 }
206
207
208 /**
209  *
210  */
211 class JRLongDistinctCountIncrementer extends JRAbstractExtendedIncrementer
212 {
213     /**
214      *
215      */
216     private static JRLongDistinctCountIncrementer mainInstance = new JRLongDistinctCountIncrementer();
217
218     /**
219      *
220      */
221     private JRLongDistinctCountIncrementer()
222     {
223     }
224
225     /**
226      *
227      */
228     public static JRLongDistinctCountIncrementer getInstance()
229     {
230         return mainInstance;
231     }
232
233     /**
234      *
235      */
236     public Object increment(
237         JRCalculable variable,
238         Object expressionValue,
239         AbstractValueProvider valueProvider
240         )
241     {
242         DistinctCountHolder holder =
243             (DistinctCountHolder)valueProvider.getValue(variable.getHelperVariable(JRCalculable.HELPER_COUNT));
244         
245         if (variable.isInitialized())
246         {
247             holder.init();
248         }
249
250         return new Long (holder.getCount());
251     }
252
253     public Object combine(JRCalculable calculable, JRCalculable calculableValue, AbstractValueProvider valueProvider)
254     {
255         DistinctCountHolder holder =
256             (DistinctCountHolder)valueProvider.getValue(calculable.getHelperVariable(JRCalculable.HELPER_COUNT));
257         
258         return new Long (holder.getCount());
259     }
260     
261     public Object initialValue()
262     {
263         return JRLongIncrementerFactory.ZERO;
264     }
265 }
266
267
268 /**
269  *
270  */
271 class JRLongSumIncrementer extends JRAbstractExtendedIncrementer
272 {
273     /**
274      *
275      */
276     private static JRLongSumIncrementer mainInstance = new JRLongSumIncrementer();
277
278     /**
279      *
280      */
281     private JRLongSumIncrementer()
282     {
283     }
284
285     /**
286      *
287      */
288     public static JRLongSumIncrementer getInstance()
289     {
290         return mainInstance;
291     }
292
293     /**
294      *
295      */
296     public Object increment(
297         JRCalculable variable,
298         Object expressionValue,
299         AbstractValueProvider valueProvider
300         )
301     {
302         Number value = (Number )variable.getIncrementedValue();
303         Number newValue = (Number )expressionValue;
304
305         if (newValue == null)
306         {
307             if (variable.isInitialized())
308             {
309                 return null;
310             }
311
312             return value;
313         }
314
315         if (value == null || variable.isInitialized())
316         {
317             value = JRLongIncrementerFactory.ZERO;
318         }
319
320         return new Long (value.longValue() + newValue.longValue());
321     }
322
323     
324     public Object initialValue()
325     {
326         return JRLongIncrementerFactory.ZERO;
327     }
328 }
329
330
331 /**
332  *
333  */
334 class JRLongAverageIncrementer extends JRAbstractExtendedIncrementer
335 {
336     /**
337      *
338      */
339     private static JRLongAverageIncrementer mainInstance = new JRLongAverageIncrementer();
340
341     /**
342      *
343      */
344     private JRLongAverageIncrementer()
345     {
346     }
347
348     /**
349      *
350      */
351     public static JRLongAverageIncrementer getInstance()
352     {
353         return mainInstance;
354     }
355
356     /**
357      *
358      */
359     public Object increment(
360         JRCalculable variable,
361         Object expressionValue,
362         AbstractValueProvider valueProvider
363         )
364     {
365         if (expressionValue == null)
366         {
367             if (variable.isInitialized())
368             {
369                 return null;
370             }
371             return variable.getValue();
372         }
373         Number countValue = (Number )valueProvider.getValue(variable.getHelperVariable(JRCalculable.HELPER_COUNT));
374         Number sumValue = (Number )valueProvider.getValue(variable.getHelperVariable(JRCalculable.HELPER_SUM));
375         return new Long (sumValue.longValue() / countValue.longValue());
376     }
377
378     
379     public Object initialValue()
380     {
381         return JRLongIncrementerFactory.ZERO;
382     }
383 }
384
385
386 /**
387  *
388  */
389 class JRLongStandardDeviationIncrementer extends JRAbstractExtendedIncrementer
390 {
391     /**
392      *
393      */
394     private static JRLongStandardDeviationIncrementer mainInstance = new JRLongStandardDeviationIncrementer();
395
396     /**
397      *
398      */
399     private JRLongStandardDeviationIncrementer()
400     {
401     }
402
403     /**
404      *
405      */
406     public static JRLongStandardDeviationIncrementer getInstance()
407     {
408         return mainInstance;
409     }
410
411     /**
412      *
413      */
414     public Object increment(
415         JRCalculable variable,
416         Object expressionValue,
417         AbstractValueProvider valueProvider
418         )
419     {
420         if (expressionValue == null)
421         {
422             if (variable.isInitialized())
423             {
424                 return null;
425             }
426             return variable.getValue();
427         }
428         Number varianceValue = (Number )valueProvider.getValue(variable.getHelperVariable(JRCalculable.HELPER_VARIANCE));
429         return new Long ( (long)Math.sqrt(varianceValue.doubleValue()) );
430     }
431
432     
433     public Object initialValue()
434     {
435         return JRLongIncrementerFactory.ZERO;
436     }
437 }
438
439
440 /**
441  *
442  */
443 class JRLongVarianceIncrementer extends JRAbstractExtendedIncrementer
444 {
445     /**
446      *
447      */
448     private static JRLongVarianceIncrementer mainInstance = new JRLongVarianceIncrementer();
449
450     /**
451      *
452      */
453     private JRLongVarianceIncrementer()
454     {
455     }
456
457     /**
458      *
459      */
460     public static JRLongVarianceIncrementer getInstance()
461     {
462         return mainInstance;
463     }
464
465     /**
466      *
467      */
468     public Object increment(
469         JRCalculable variable,
470         Object expressionValue,
471         AbstractValueProvider valueProvider
472         )
473     {
474         Number value = (Number )variable.getIncrementedValue();
475         Number newValue = (Number )expressionValue;
476         
477         if (newValue == null)
478         {
479             if (variable.isInitialized())
480             {
481                 return null;
482             }
483             return value;
484         }
485         else if (value == null || variable.isInitialized())
486         {
487             return JRLongIncrementerFactory.ZERO;
488         }
489         else
490         {
491             Number countValue = (Number )valueProvider.getValue(variable.getHelperVariable(JRCalculable.HELPER_COUNT));
492             Number sumValue = (Number )valueProvider.getValue(variable.getHelperVariable(JRCalculable.HELPER_SUM));
493             return
494                 new Long (
495                     (countValue.longValue() - 1) * value.longValue() / countValue.longValue() +
496                     ( sumValue.longValue() / countValue.longValue() - newValue.longValue() ) *
497                     ( sumValue.longValue() / countValue.longValue() - newValue.longValue() ) /
498                     (countValue.longValue() - 1)
499                     );
500         }
501     }
502
503     
504     public Object combine(JRCalculable calculable, JRCalculable calculableValue, AbstractValueProvider valueProvider)
505     {
506         Number value = (Number )calculable.getIncrementedValue();
507         
508         if (calculableValue.getValue() == null)
509         {
510             if (calculable.isInitialized())
511             {
512                 return null;
513             }
514
515             return value;
516         }
517         else if (value == null || calculable.isInitialized())
518         {
519             return new Long (((Number ) calculableValue.getIncrementedValue()).longValue());
520         }
521
522         double v1 = value.doubleValue();
523         double c1 = ((Number ) valueProvider.getValue(calculable.getHelperVariable(JRCalculable.HELPER_COUNT))).doubleValue();
524         double s1 = ((Number ) valueProvider.getValue(calculable.getHelperVariable(JRCalculable.HELPER_SUM))).doubleValue();
525
526         double v2 = ((Number ) calculableValue.getIncrementedValue()).doubleValue();
527         double c2 = ((Number ) valueProvider.getValue(calculableValue.getHelperVariable(JRCalculable.HELPER_COUNT))).doubleValue();
528         double s2 = ((Number ) valueProvider.getValue(calculableValue.getHelperVariable(JRCalculable.HELPER_SUM))).doubleValue();
529
530         c1 -= c2;
531         s1 -= s2;
532         
533         double c = c1 + c2;
534
535         return new Long (
536                 (long) (
537                 c1 / c * v1 +
538                 c2 / c * v2 +
539                 c2 / c1 * s1 / c * s1 / c +
540                 c1 / c2 * s2 / c * s2 / c -
541                 2 * s1 / c * s2 /c
542                 ));
543     }
544
545     
546     public Object initialValue()
547     {
548         return JRLongIncrementerFactory.ZERO;
549     }
550 }
551

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags