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 java.util.ArrayList;
27 import java.util.Arrays;
28 import java.util.List;
29
30 import net.sf.jasperreports.engine.JRException;
31 import net.sf.jasperreports.engine.JRExpression;
32 import net.sf.jasperreports.engine.JRField;
33 import net.sf.jasperreports.engine.JRPropertiesHolder;
34 import net.sf.jasperreports.engine.JRPropertiesMap;
35 import net.sf.jasperreports.engine.JRPropertyExpression;
36
37
38 /**
39  * @author Teodor Danciu (teodord@users.sourceforge.net)
40  */
41 public class JRFillField implements JRField
42 {
43
44
45     /**
46      *
47      */
48     protected JRField parent;
49     protected JRFillExpressionEvaluator expressionEvaluator;
50     protected List<JRPropertyExpression> propertyExpressions;
51     protected JRPropertiesMap staticProperties;
52     protected JRPropertiesMap mergedProperties;
53
54     /**
55      *
56      */
57     private Object previousOldValue;
58     private Object oldValue;
59     private Object value;
60     private Object savedValue;
61
62
63     /**
64      *
65      */
66     protected JRFillField(
67         JRField field, 
68         JRFillObjectFactory factory
69         )
70     {
71         factory.put(field, this);
72
73         parent = field;
74
75         expressionEvaluator = factory.getExpressionEvaluator();
76
77         staticProperties = field.hasProperties() ? field.getPropertiesMap().cloneProperties() : null;
78         mergedProperties = staticProperties;
79
80         JRPropertyExpression[] fieldPropertyExpressions = field.getPropertyExpressions();
81         propertyExpressions = 
82             fieldPropertyExpressions == null 
83             ? new ArrayList<JRPropertyExpression>(0)
84             : new ArrayList<JRPropertyExpression>(Arrays.asList(fieldPropertyExpressions));
85     }
86
87
88     @Override
89     public String getName()
90     {
91         return parent.getName();
92     }
93         
94     @Override
95     public String getDescription()
96     {
97         return parent.getDescription();
98     }
99         
100     @Override
101     public void setDescription(String description)
102     {
103     }
104     
105     @Override
106     public Class<?> getValueClass()
107     {
108         return parent.getValueClass();
109     }
110     
111     @Override
112     public String getValueClassName()
113     {
114         return parent.getValueClassName();
115     }
116     
117     /**
118      *
119      */
120     public Object getOldValue()
121     {
122         return oldValue;
123     }
124         
125     /**
126      *
127      */
128     public void setOldValue(Object oldValue)
129     {
130         this.oldValue = oldValue;
131     }
132
133     /**
134      *
135      */
136     public Object getValue()
137     {
138         return value;
139     }
140         
141     /**
142      *
143      */
144     public void setValue(Object value)
145     {
146         this.value = value;
147     }
148         
149     public Object getValue(byte evaluation)
150     {
151         Object returnValue;
152         switch (evaluation)
153         {
154             case JRExpression.EVALUATION_OLD:
155                 returnValue = oldValue;
156                 break;
157             default:
158                 returnValue = value;
159                 break;
160         }
161         return returnValue;
162     }
163     
164     public void overwriteValue(Object newValue, byte evaluation)
165     {
166         switch (evaluation)
167         {
168             case JRExpression.EVALUATION_OLD:
169                 savedValue = oldValue;
170                 oldValue = newValue;
171                 break;
172             default:
173                 savedValue = value;
174                 value = newValue;
175                 break;
176         }
177     }
178     
179     public void restoreValue(byte evaluation)
180     {
181         switch (evaluation)
182         {
183             case JRExpression.EVALUATION_OLD:
184                 oldValue = savedValue;
185                 break;
186             default:
187                 value = savedValue;
188                 break;
189         }
190         savedValue = null;
191     }
192
193
194     
195     public Object getPreviousOldValue()
196     {
197         return previousOldValue;
198     }
199
200
201     
202     public void setPreviousOldValue(Object previousOldValue)
203     {
204         this.previousOldValue = previousOldValue;
205     }
206
207     
208     @Override
209     public boolean hasProperties()
210     {
211         return mergedProperties != null && mergedProperties.hasProperties();
212     }
213
214
215     @Override
216     public JRPropertiesMap getPropertiesMap()
217     {
218         return mergedProperties;
219     }
220
221     
222     @Override
223     public JRPropertiesHolder getParentProperties()
224     {
225         return null;
226     }
227
228     
229     @Override
230     public JRPropertyExpression[] getPropertyExpressions()
231     {
232         return propertyExpressions.toArray(new JRPropertyExpression[propertyExpressions.size()]);
233     }
234
235
236     /**
237      *
238      */
239     protected void evaluateProperties() throws JRException
240     {
241         if (propertyExpressions.isEmpty())
242         {
243             mergedProperties = staticProperties;
244         }
245         else
246         {
247             JRPropertiesMap dynamicProperties = new JRPropertiesMap();
248             
249             for (JRPropertyExpression prop : propertyExpressions)
250             {
251                 String value = (String) evaluateExpression(prop.getValueExpression());
252                 //if (value != null) //is the null value significant for some field properties?
253                 {
254                     dynamicProperties.setProperty(prop.getName(), value);
255                 }
256             }
257             
258             mergedProperties = dynamicProperties.cloneProperties();
259             mergedProperties.setBaseProperties(staticProperties);
260         }
261     }
262
263     /**
264      *
265      */
266     protected final Object evaluateExpression(JRExpression expression) throws JRException
267     {
268         return expressionEvaluator.evaluate(expression, JRExpression.EVALUATION_DEFAULT);
269     }
270
271     @Override
272     public Object clone() 
273     {
274         throw new UnsupportedOperationException();
275     }
276 }
277