1 /*
2  * JasperReports - Free Java Reporting Library.
3  * Copyright (C) 2001 - 2019 TIBCO Software Inc. All rights reserved.
4  * http://www.jaspersoft.com
5  *
6  * Unless you have purchased a commercial license agreement from Jaspersoft,
7  * the following license terms apply:
8  *
9  * This program is part of JasperReports.
10  *
11  * JasperReports is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * JasperReports is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * along with JasperReports. If not, see <http://www.gnu.org/licenses/>.
23  */
24 package net.sf.jasperreports.engine.fill;
25
26 import net.sf.jasperreports.engine.JRExpression;
27 import net.sf.jasperreports.engine.JRGroup;
28 import net.sf.jasperreports.engine.JRVariable;
29 import net.sf.jasperreports.engine.type.CalculationEnum;
30 import net.sf.jasperreports.engine.type.IncrementTypeEnum;
31 import net.sf.jasperreports.engine.type.ResetTypeEnum;
32
33
34 /**
35  * @author Teodor Danciu (teodord@users.sourceforge.net)
36  */
37 public class JRFillVariable implements JRVariable, JRCalculable
38 {
39
40
41     /**
42      *
43      */
44     protected JRVariable parent;
45
46     /**
47      *
48      */
49     private JRGroup resetGroup;
50     private JRGroup incrementGroup;
51
52     /**
53      *
54      */
55     private Object previousIncrementedValue;
56     private Object previousOldValue;
57     private Object oldValue;
58     private Object estimatedValue;
59     private Object incrementedValue;
60     private Object value;
61     private boolean isInitialized;
62     private Object savedValue;
63     
64     private JRFillVariable[] helperVariables;
65
66     /**
67      *
68      */
69     private JRIncrementer incrementer;
70
71
72     /**
73      *
74      */
75     protected JRFillVariable(
76         JRVariable variable, 
77         JRFillObjectFactory factory
78         )
79     {
80         factory.put(variable, this);
81
82         parent = variable;
83         
84         resetGroup = factory.getGroup(variable.getResetGroup());
85         incrementGroup = factory.getGroup(variable.getIncrementGroup());
86         
87         helperVariables = new JRFillVariable[JRCalculable.HELPER_SIZE];
88     }
89
90     protected JRVariable getParent()
91     {
92         return parent;
93     }
94
95     protected void reset()
96     {
97         previousOldValue = null;
98         oldValue = null;
99         estimatedValue = null;
100         incrementedValue = null;
101         value = null;
102         isInitialized = false;
103         savedValue = null;
104     }
105
106
107     @Override
108     public String getName()
109     {
110         return parent.getName();
111     }
112
113     @Override
114     public String getDescription()
115     {
116         return parent.getDescription();
117     }
118         
119     @Override
120     public void setDescription(String description)
121     {
122     }
123     
124     @Override
125     public Class<?> getValueClass()
126     {
127         return parent.getValueClass();
128     }
129         
130     @Override
131     public String getValueClassName()
132     {
133         return parent.getValueClassName();
134     }
135         
136     @Override
137     public Class<?> getIncrementerFactoryClass()
138     {
139         return parent.getIncrementerFactoryClass();
140     }
141         
142     @Override
143     public String getIncrementerFactoryClassName()
144     {
145         return parent.getIncrementerFactoryClassName();
146     }
147         
148     @Override
149     public JRExpression getExpression()
150     {
151         return parent.getExpression();
152     }
153         
154     @Override
155     public JRExpression getInitialValueExpression()
156     {
157         return parent.getInitialValueExpression();
158     }
159         
160     @Override
161     public ResetTypeEnum getResetTypeValue()
162     {
163         return parent.getResetTypeValue();
164     }
165         
166     @Override
167     public IncrementTypeEnum getIncrementTypeValue()
168     {
169         return parent.getIncrementTypeValue();
170     }
171         
172     @Override
173     public CalculationEnum getCalculationValue()
174     {
175         return parent.getCalculationValue();
176     }
177         
178     @Override
179     public boolean isSystemDefined()
180     {
181         return parent.isSystemDefined();
182     }
183
184     @Override
185     public JRGroup getResetGroup()
186     {
187         return resetGroup;
188     }
189         
190     @Override
191     public JRGroup getIncrementGroup()
192     {
193         return incrementGroup;
194     }
195     
196     /**
197      *
198      */
199     public Object getOldValue()
200     {
201         return oldValue;
202     }
203         
204     /**
205      *
206      */
207     public void setOldValue(Object oldValue)
208     {
209         this.oldValue = oldValue;
210     }
211
212     /**
213      *
214      */
215     public Object getEstimatedValue()
216     {
217         return estimatedValue;
218     }
219         
220     /**
221      *
222      */
223     public void setEstimatedValue(Object estimatedValue)
224     {
225         this.estimatedValue = estimatedValue;
226     }
227
228     @Override
229     public Object getIncrementedValue()
230     {
231         return incrementedValue;
232     }
233         
234     /**
235      *
236      */
237     public void setIncrementedValue(Object incrementedValue)
238     {
239         this.incrementedValue = incrementedValue;
240     }
241
242     /**
243      *
244      */
245     public Object getPreviousIncrementedValue()
246     {
247         return previousIncrementedValue;
248     }
249         
250     /**
251      *
252      */
253     public void setPreviousIncrementedValue(Object previousIncrementedValue)
254     {
255         this.previousIncrementedValue = previousIncrementedValue;
256     }
257
258     @Override
259     public Object getValue()
260     {
261         return value;
262     }
263         
264     /**
265      *
266      */
267     public void setValue(Object value)
268     {
269         this.value = value;
270     }
271
272     @Override
273     public boolean isInitialized()
274     {
275         return isInitialized;
276     }
277         
278     @Override
279     public void setInitialized(boolean isInitialized)
280     {
281         this.isInitialized = isInitialized;
282     }
283
284         
285     /**
286      *
287      */
288     public JRIncrementer getIncrementer()
289     {
290         if (incrementer == null)
291         {
292             Class<?> incrementerFactoryClass = getIncrementerFactoryClass();
293             
294             JRIncrementerFactory incrementerFactory;
295             if (incrementerFactoryClass == null)
296             {
297                 incrementerFactory = JRDefaultIncrementerFactory.getFactory(getValueClass());
298             }
299             else
300             {
301                 incrementerFactory = JRIncrementerFactoryCache.getInstance(incrementerFactoryClass); 
302             }
303             
304             incrementer = incrementerFactory.getIncrementer(getCalculationValue().getValue());
305         }
306         
307         return incrementer;
308     }
309
310     
311     /**
312      * Sets a helper variable.
313      * 
314      * @param helperVariable the helper variable
315      * @param type the helper type
316      * @return the previous helper variable for the type
317      */
318     public JRFillVariable setHelperVariable(JRFillVariable helperVariable, byte type)
319     {
320         JRFillVariable old = helperVariables[type]; 
321         helperVariables[type] = helperVariable;
322         return old;
323     }
324     
325     
326     /**
327      * Returns a helper variable.
328      * 
329      * @param type the helper type
330      * @return the helper variable for the specified type
331      */
332     @Override
333     public JRCalculable getHelperVariable(byte type)
334     {
335         return helperVariables[type];
336     }
337     
338     
339     public Object getValue(byte evaluation)
340     {
341         Object returnValue;
342         switch (evaluation)
343         {
344             case JRExpression.EVALUATION_OLD:
345                 returnValue = oldValue;
346                 break;
347             case JRExpression.EVALUATION_ESTIMATED:
348                 returnValue = estimatedValue;
349                 break;
350             default:
351                 returnValue = value;
352                 break;
353         }
354         return returnValue;
355     }
356     
357     public void overwriteValue(Object newValue, byte evaluation)
358     {
359         switch (evaluation)
360         {
361             case JRExpression.EVALUATION_OLD:
362                 savedValue = oldValue;
363                 oldValue = newValue;
364                 break;
365             case JRExpression.EVALUATION_ESTIMATED:
366                 savedValue = estimatedValue;
367                 estimatedValue = newValue;
368                 break;
369             default:
370                 savedValue = value;
371                 value = newValue;
372                 break;
373         }
374     }
375     
376     public void restoreValue(byte evaluation)
377     {
378         switch (evaluation)
379         {
380             case JRExpression.EVALUATION_OLD:
381                 oldValue = savedValue;
382                 break;
383             case JRExpression.EVALUATION_ESTIMATED:
384                 estimatedValue = savedValue;
385                 break;
386             default:
387                 value = savedValue;
388                 break;
389         }
390         savedValue = null;
391     }
392
393
394     
395     public Object getPreviousOldValue()
396     {
397         return previousOldValue;
398     }
399
400
401     
402     public void setPreviousOldValue(Object previousOldValue)
403     {
404         this.previousOldValue = previousOldValue;
405     }
406
407     @Override
408     public Object clone() 
409     {
410         throw new UnsupportedOperationException();
411     }
412
413 }
414