KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > portal > test > core > security > PortalPermission


1 /*****************************************
2  * *
3  * JBoss Portal: The OpenSource Portal *
4  * *
5  * Distributable under LGPL license. *
6  * See terms of license at gnu.org. *
7  * *
8  *****************************************/
9 package org.jboss.portal.test.core.security;
10
11 import java.security.Permission JavaDoc;
12 import java.util.Set JavaDoc;
13 import java.util.regex.Matcher JavaDoc;
14 import java.util.regex.Pattern JavaDoc;
15
16 /**
17  * The portal permission.
18  *
19  * @author <a HREF="mailto:julien@jboss.org">Julien Viet</a>
20  * @version $Revision: 1.3 $
21  */
22 public class PortalPermission extends Permission JavaDoc
23 {
24    // State differenciator
25 private boolean matcher;
26
27    // Common state
28 private int hash;
29    private String JavaDoc actions;
30    private Set JavaDoc levelSet;
31
32    // State for definition
33 private Pattern JavaDoc[] patterns;
34    private Set JavaDoc impliedLevelSet;
35
36    // State for test
37 private String JavaDoc[] test;
38
39    public PortalPermission(String JavaDoc[] test/*, Level level*/) throws IllegalArgumentException JavaDoc
40    {
41       super(toName(test));
42 /*
43       if (level == null)
44       {
45          throw new IllegalArgumentException("level cannot be null");
46       }
47       matcher = false;
48       hash = 0;
49       actions = null;
50       this.test = test;
51       levelSet = Collections.singleton(level);
52 */
53    }
54
55    public PortalPermission(String JavaDoc name, String JavaDoc actions)
56    {
57       super(name);
58       if (name == null)
59       {
60          throw new IllegalArgumentException JavaDoc("name must not be null");
61       }
62       if (actions == null)
63       {
64          throw new IllegalArgumentException JavaDoc("actions must not be null");
65       }
66 /*
67       matcher = true;
68       hash = 0;
69       this.actions = null;
70       impliedLevelSet = new HashSet();
71       levelSet = new HashSet();
72       if (actions != null)
73       {
74          StringTokenizer st = new StringTokenizer(actions, ",");
75          while (st.hasMoreTokens())
76          {
77             String action = st.nextToken();
78             Level level = Level.forName(action);
79             if (level != null)
80             {
81                levelSet.add(level);
82                impliedLevelSet.addAll(level.getImpliedSet());
83             }
84          }
85       }
86       String[] test = name.split(":");
87       patterns = new Pattern[test.length];
88       for (int i = 0;i < test.length;i++)
89       {
90          String regex = "^" + test[i] + "$";
91          patterns[i] = Pattern.compile(regex);
92       }
93 */
94    }
95
96    public boolean equals(Object JavaDoc obj)
97    {
98       if (obj == this)
99       {
100          return true;
101       }
102       if (obj instanceof PortalPermission)
103       {
104          PortalPermission other = (PortalPermission)obj;
105
106          if (matcher)
107          {
108             // Compare length
109 if (other.patterns.length != patterns.length)
110             {
111                return false;
112             }
113
114             //
115 for (int i = 0;i < patterns.length;i++)
116             {
117                if (patterns[i].equals(other.patterns[i]))
118                {
119                   return false;
120                }
121             }
122
123             //
124 return impliedLevelSet.equals(other.impliedLevelSet);
125          }
126          else
127          {
128             // Compare length
129 if (other.test.length != test.length)
130             {
131                return false;
132             }
133
134             //
135 for (int i = 0;i < test.length;i++)
136             {
137                if (test[i].equals(other.test[i]))
138                {
139                   return false;
140                }
141             }
142
143             //
144 return levelSet.equals(other.levelSet);
145          }
146       }
147       return false;
148    }
149
150    public int hashCode()
151    {
152 /*
153       if (hash == 0)
154       {
155          if (matcher)
156          {
157             for (int i = 0;i < patterns.length;i++)
158             {
159                Pattern p = patterns[i];
160                hash = hash * 43 + p.hashCode();
161             }
162             for (Iterator i = levelSet.iterator();i.hasNext();)
163             {
164                Level level = (Level)i.next();
165                hash = hash * 43 + level.hashCode();
166             }
167          }
168          else
169          {
170             for (int i = 0;i < test.length;i++)
171             {
172                String s = test[i];
173                hash = hash * 43 + s.hashCode();
174             }
175             for (Iterator i = levelSet.iterator();i.hasNext();)
176             {
177                Level level = (Level)i.next();
178                hash = hash * 43 + level.hashCode();
179             }
180          }
181       }
182 */
183       return hash;
184    }
185
186    public String JavaDoc getActions()
187    {
188 /*
189       if (actions == null)
190       {
191          StringBuffer tmp = new StringBuffer();
192          if (matcher)
193          {
194             for (Iterator i = levelSet.iterator();i.hasNext();)
195             {
196                Level level = (Level)i.next();
197                tmp.append(level);
198                if (i.hasNext())
199                {
200                   tmp.append(',');
201                }
202             }
203          }
204          else
205          {
206             for (Iterator i = levelSet.iterator();i.hasNext();)
207             {
208                Level level = (Level)i.next();
209                tmp.append(level);
210                if (i.hasNext())
211                {
212                   tmp.append(',');
213                }
214             }
215          }
216          actions = tmp.toString();
217       }
218 */
219       return actions;
220    }
221
222    public boolean implies(Permission JavaDoc permission)
223    {
224       if (permission instanceof PortalPermission)
225       {
226          PortalPermission other = (PortalPermission)permission;
227
228          // Must not be a matcher permission
229 if (other.matcher)
230          {
231             return false;
232          }
233
234          // Compare length
235 if (other.test.length > patterns.length)
236          {
237             return false;
238          }
239
240          // Validate all the test items
241 for (int i = 0;i < other.test.length;i++)
242          {
243             Pattern JavaDoc pattern = patterns[i];
244             Matcher JavaDoc matcher = pattern.matcher(other.test[i]);
245             if (!matcher.matches())
246             {
247                return false;
248             }
249          }
250
251          // Contains all
252 return impliedLevelSet.containsAll(other.levelSet);
253       }
254       return false;
255    }
256
257    private static String JavaDoc toName(String JavaDoc[] test) throws IllegalArgumentException JavaDoc
258    {
259       if (test == null)
260       {
261          throw new IllegalArgumentException JavaDoc("test array cannot be null");
262       }
263       StringBuffer JavaDoc buffer = new StringBuffer JavaDoc();
264       for (int i = 0;i < test.length;i++)
265       {
266          if (i > 0)
267          {
268             buffer.append(":");
269          }
270          String JavaDoc s = test[i];
271          if (s == null)
272          {
273             throw new IllegalArgumentException JavaDoc("test array item #" + i + " cannot be null");
274          }
275          buffer.append(s);
276       }
277       return buffer.toString();
278    }
279 }
280
Popular Tags