View Javadoc
1   package org.apache.turbine.util;
2   
3   
4   /*
5    * Licensed to the Apache Software Foundation (ASF) under one
6    * or more contributor license agreements.  See the NOTICE file
7    * distributed with this work for additional information
8    * regarding copyright ownership.  The ASF licenses this file
9    * to you under the Apache License, Version 2.0 (the
10   * "License"); you may not use this file except in compliance
11   * with the License.  You may obtain a copy of the License at
12   *
13   *   http://www.apache.org/licenses/LICENSE-2.0
14   *
15   * Unless required by applicable law or agreed to in writing,
16   * software distributed under the License is distributed on an
17   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
18   * KIND, either express or implied.  See the License for the
19   * specific language governing permissions and limitations
20   * under the License.
21   */
22  
23  
24  import java.util.Hashtable;
25  import java.util.Iterator;
26  import java.util.List;
27  import java.util.Vector;
28  
29  /**
30   * Used for adding and accessing messages that relate to a specific
31   * form and field.  Allows to query for messages by form name and
32   * field name.  Used together with FormMessage class.
33   *
34   * @author <a href="mailto:neeme@one.lv">Neeme Praks</a>
35   * @version $Id: FormMessages.java 1152507 2011-07-30 20:14:38Z tv $
36   */
37  public class FormMessages
38  {
39      private final Hashtable<String, Vector<String>> forms_messages;
40      private final Hashtable<String, Vector<String>> fields_messages;
41      private final Hashtable<String, Vector<String>> messages_fields;
42      private final Hashtable<String, Vector<String>> forms_fields;
43  
44      /**
45       * Constructor.
46       */
47      public FormMessages()
48      {
49          forms_messages = new Hashtable<String, Vector<String>>();
50          fields_messages = new Hashtable<String, Vector<String>>();
51          messages_fields = new Hashtable<String, Vector<String>>();
52          forms_fields = new Hashtable<String, Vector<String>>();
53      }
54  
55      /**
56       * Sets a message for a field of a form.  The message is given as
57       * a long representing a return code.
58       *
59       * @param formName A String with the form name.
60       * @param fieldName A String with the field name.
61       * @param returnCode A long with the return code.
62       */
63      public void setMessage(String formName,
64                             String fieldName,
65                             long returnCode)
66      {
67          setMessage(formName, fieldName, String.valueOf(returnCode));
68      }
69  
70      /**
71       * Sets a message for a field of a form.  The message is given as
72       * a String.
73       *
74       * @param formName A String with the form name.
75       * @param fieldName A String with the field name.
76       * @param messageName A String with the message.
77       */
78      public void setMessage(String formName,
79                             String fieldName,
80                             String messageName)
81      {
82          fieldName = formName + "-" + fieldName;
83          addValue(forms_messages, formName, messageName);
84          addValue(fields_messages, fieldName, messageName);
85          addValue(messages_fields, messageName, fieldName);
86          addValue(forms_fields, formName, fieldName);
87      }
88  
89      /**
90       * Adds a pair key/value to a table, making sure not to add
91       * duplicate keys.
92       *
93       * @param table A Hashtable.
94       * @param key A String with the key.
95       * @param value A String with value.
96       */
97      private void addValue(Hashtable<String, Vector<String>> table,
98                            String key,
99                            String value)
100     {
101         Vector<String> values;
102 
103         if (!table.containsKey(key))
104         {
105             values = new Vector<String>();
106             values.addElement(value);
107             table.put(key, values);
108         }
109         else
110         {
111             values = table.get(key);
112             if (!values.contains(value))
113                 values.addElement(value);
114         }
115     }
116 
117     /**
118      * Gets a pair key/value from a table.
119      *
120      * @param table A Hashtable.
121      * @param key A String with the key.
122      * @return A Vector with the pair key/value, or null.
123      */
124     private final Vector<String> getValues(Hashtable<String, Vector<String>> table, String key)
125     {
126         return table.get(key);
127     }
128 
129     /**
130      * Gets all form messages for a given form.
131      *
132      * @param formName A String with the form name.
133      * @return A FormMessage[].
134      */
135     public FormMessage[] getFormMessages(String formName)
136     {
137         Vector<String> messages, fields;
138         String messageName, fieldName;
139         messages = getValues(forms_messages, formName);
140         if (messages != null)
141         {
142             FormMessage[] result = new FormMessage[messages.size()];
143             for (int i = 0; i < messages.size(); i++)
144             {
145                 result[i] = new FormMessage(formName);
146                 messageName = messages.elementAt(i);
147                 result[i].setMessage(messageName);
148                 fields = getValues(messages_fields, messageName);
149                 for (int j = 0; j < fields.size(); j++)
150                 {
151                     fieldName = fields.elementAt(j);
152                     if (formHasField(formName, fieldName))
153                     {
154                         result[i].setFieldName(fieldName);
155                     }
156                 }
157             }
158             return result;
159         }
160         return null;
161     }
162 
163     /**
164      * Get form messages for a given form and field.
165      *
166      * @param formName A String with the form name.
167      * @param fieldName A String with the field name.
168      * @return A FormMessage[].
169      */
170     public FormMessage[] getFormMessages(String formName, String fieldName)
171     {
172         String key = formName + "-" + fieldName;
173 
174         Vector<String> messages = getValues(fields_messages, key);
175         String messageName;
176 
177         if (messages != null)
178         {
179             FormMessage[] result = new FormMessage[messages.size()];
180             for (int i = 0; i < messages.size(); i++)
181             {
182                 result[i] = new FormMessage(formName, fieldName);
183                 messageName = messages.elementAt(i);
184                 result[i].setMessage(messageName);
185             }
186             return result;
187         }
188         return null;
189     }
190 
191     /**
192      * Check whether a form as a field.
193      *
194      * @param formName A String with the form name.
195      * @param fieldName A String with the field name.
196      * @return True if form has the field.
197      */
198     private boolean formHasField(String formName,
199                                  String fieldName)
200     {
201         List<String> fields = getValues(forms_fields, formName);
202         for (Iterator<String> iter = fields.iterator(); iter.hasNext();)
203         {
204             if (fieldName.equals(iter.next().toString()))
205             {
206                 return true;
207             }
208         }
209         return false;
210     }
211 }