KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > jetspeed > om > registry > base > BaseSkinEntry


1 /*
2  * Copyright 2000-2001,2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package org.apache.jetspeed.om.registry.base;
18
19 import org.apache.jetspeed.om.registry.*;
20
21 import java.util.*;
22
23 /**
24  * The BaseSkinEntry is a bean like implementation of the SkinEntry
25  * interface suitable for Castor XML serialization
26  *
27  * @see org.apache.jetspeed.om.registry.SkinEntry
28  * @author <a HREF="mailto:raphael@apache.org">Raphaël Luta</a>
29  * @version $Id: BaseSkinEntry.java,v 1.4 2004/02/23 03:08:26 jford Exp $
30  */
31 public class BaseSkinEntry extends BaseRegistryEntry implements SkinEntry
32 {
33
34     private Vector parameter = new Vector();
35
36     private transient Map nameIdx = null;
37
38     /**
39      * Implements the equals operation so that 2 elements are equal if
40      * all their member values are equal.
41      */
42     public boolean equals(Object JavaDoc object)
43     {
44         if (object==null)
45         {
46             return false;
47         }
48
49         BaseSkinEntry obj = (BaseSkinEntry)object;
50
51         Iterator i = parameter.iterator();
52         Iterator i2 = obj.parameter.iterator();
53         while(i.hasNext())
54         {
55             BaseParameter c1 = (BaseParameter)i.next();
56             BaseParameter c2 = null;
57
58             if (i2.hasNext())
59             {
60                 c2 = (BaseParameter)i2.next();
61             }
62             else
63             {
64                 return false;
65             }
66
67             if (!c1.equals(c2))
68             {
69                 return false;
70             }
71         }
72
73         if (i2.hasNext())
74         {
75             return false;
76         }
77
78         return super.equals(object);
79     }
80
81     /** @return an enumeration of this entry parameter names */
82     public Iterator getParameterNames()
83     {
84         synchronized (parameter)
85         {
86             if (nameIdx == null)
87             {
88                 buildNameIndex();
89             }
90         }
91
92         return nameIdx.keySet().iterator();
93     }
94
95     /** Search for a named parameter and return the associated
96      * parameter object. The search is case sensitive.
97      *
98      * @return the parameter object for a given parameter name
99      * @param name the parameter name to look for
100      */
101     public Parameter getParameter( String JavaDoc name )
102     {
103         synchronized (parameter)
104         {
105             if (nameIdx == null)
106             {
107                 buildNameIndex();
108             }
109         }
110
111         if (name != null)
112         {
113             Integer JavaDoc pos = (Integer JavaDoc)nameIdx.get(name);
114
115             if (pos != null)
116             {
117                 return (Parameter)parameter.elementAt(pos.intValue());
118             }
119         }
120
121         return null;
122     }
123
124
125     /** Returns a map of parameter values keyed on the parameter names
126      * @return the parameter values map
127      */
128     public Map getParameterMap()
129     {
130         Hashtable params = new Hashtable();
131         Enumeration en = parameter.elements();
132         while(en.hasMoreElements())
133         {
134             Parameter param = (Parameter)en.nextElement();
135             params.put(param.getName(),param.getValue());
136         }
137
138         return params;
139
140     }
141
142     /** Adds a new parameter for this entry
143      * @param name the new parameter name
144      * @param value the new parameter value
145      */
146     public void addParameter( String JavaDoc name, String JavaDoc value )
147     {
148         if (name != null)
149         {
150             Parameter p = getParameter(name);
151             if (p == null)
152             {
153                 p = new BaseParameter();
154                 p.setName(name);
155             }
156
157             p.setValue(value);
158
159             addParameter(p);
160
161         }
162     }
163
164     /** Adds a new parameter for this entry
165      * @param parameter the new parameter to add
166      */
167     public void addParameter( Parameter param )
168     {
169         synchronized (parameter)
170         {
171             parameter.addElement( param );
172             nameIdx.put( param.getName(), new Integer JavaDoc( parameter.size()-1 ) );
173         }
174     }
175
176     /** Removes all parameter values associated with the
177      * name
178      *
179      * @param name the parameter name to remove
180      */
181     public void removeParameter( String JavaDoc name )
182     {
183         if (name == null) return;
184
185         synchronized (parameter)
186         {
187             Iterator i = parameter.iterator();
188             while(i.hasNext())
189             {
190                 Parameter param = (Parameter)i.next();
191                 if (param.getName().equals(name))
192                 {
193                     i.remove();
194                 }
195             }
196
197             buildNameIndex();
198         }
199     }
200
201     /** This method recreates the paramter name index for quick retrieval
202      * of parameters by name. Shoule be called whenever a complete index
203      * of parameter should be rebuilt (eg removing a parameter or setting
204      * a parameters vector)
205      */
206     private void buildNameIndex()
207     {
208         Hashtable idx = new Hashtable();
209
210         Iterator i = parameter.iterator();
211         int count = 0;
212         while( i.hasNext() )
213         {
214             Parameter p = (Parameter)i.next();
215             idx.put( p.getName(), new Integer JavaDoc(count) );
216             count++;
217         }
218
219         this.nameIdx = idx;
220     }
221
222     // Castor serialization accessor methods
223
224     /** Needed for Castor 0.8.11 XML serialization for retrieving the
225      * parameters objects associated to this object
226      */
227     public Vector getParameters()
228     {
229         return this.parameter;
230     }
231
232     public void setParameters(Vector parameters)
233     {
234         this.parameter = parameters;
235     }
236
237 }
Popular Tags