View Javadoc

1   package org.apache.turbine.services.intake.model;
2   
3   /*
4    * Copyright 2001-2005 The Apache Software Foundation.
5    *
6    * Licensed under the Apache License, Version 2.0 (the "License")
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  import org.apache.commons.lang.StringUtils;
20  
21  import org.apache.turbine.services.intake.IntakeException;
22  import org.apache.turbine.services.intake.validator.LongValidator;
23  import org.apache.turbine.services.intake.xmlmodel.XmlField;
24  
25  /***
26   * Processor for long fields.
27   *
28   * @author <a href="mailto:jmcnally@collab.net>John McNally</a>
29   * @author <a href="mailto:Colin.Chalmers@maxware.nl">Colin Chalmers</a>
30   * @version $Id: LongField.java 264148 2005-08-29 14:21:04Z henning $
31   */
32  public class LongField
33          extends Field
34  {
35  
36      /***
37       * Constructor.
38       *
39       * @param field xml field definition object
40       * @param group xml group definition object
41       * @throws IntakeException thrown by superclass
42       */
43      public LongField(XmlField field, Group group)
44              throws IntakeException
45      {
46          super(field, group);
47      }
48  
49      /***
50       * Sets the default value for an Long Field
51       *
52       * @param prop Parameter for the default values
53       */
54      public void setDefaultValue(String prop)
55      {
56          defaultValue = null;
57  
58          if (prop == null)
59          {
60              return;
61          }
62  
63          defaultValue = new Long(prop);
64      }
65  
66      /***
67       * Set the empty Value. This value is used if Intake
68       * maps a field to a parameter returned by the user and
69       * the corresponding field is either empty (empty string)
70       * or non-existant.
71       *
72       * @param prop The value to use if the field is empty.
73       */
74      public void setEmptyValue(String prop)
75      {
76          emptyValue = null;
77  
78          if (prop == null)
79          {
80              return;
81          }
82  
83          emptyValue = new Long(prop);
84      }
85  
86      /***
87       * Provides access to emptyValue such that the value returned will be
88       * acceptable as an argument parameter to Method.invoke.  Subclasses
89       * that deal with primitive types should ensure that they return an
90       * appropriate value wrapped in the object wrapper class for the
91       * primitive type.
92       *
93       * @return the value to use when the field is empty or an Object that
94       * wraps the empty value for primitive types.
95       */
96      protected Object getSafeEmptyValue()
97      {
98          if (isMultiValued)
99          {
100             return new long[0];
101         }
102         else
103         {
104             return (null == getEmptyValue()) ? new Long(0l) : getEmptyValue();
105         }
106     }
107 
108     /***
109      * A suitable validator.
110      *
111      * @return A suitable validator
112      */
113     protected String getDefaultValidator()
114     {
115         return LongValidator.class.getName();
116     }
117 
118     /***
119      * Sets the value of the field from data in the parser.
120      */
121     protected void doSetValue()
122     {
123         if (isMultiValued)
124         {
125             String[] inputs = parser.getStrings(getKey());
126             long[] values = new long[inputs.length];
127             for (int i = 0; i < inputs.length; i++)
128             {
129                 values[i] = StringUtils.isNotEmpty(inputs[i])
130                         ? new Long(inputs[i]).longValue()
131                         : ((Long) getEmptyValue()).longValue();
132             }
133             setTestValue(values);
134         }
135         else
136         {
137             String val = parser.getString(getKey());
138             setTestValue(StringUtils.isNotEmpty(val)
139                     ? new Long(val) : (Long) getEmptyValue());
140         }
141     }
142 
143 }