View Javadoc

1   package org.apache.turbine.util.security;
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.Collection;
25  import java.util.Iterator;
26  
27  import org.apache.commons.lang.StringUtils;
28  import org.apache.turbine.om.security.Group;
29  
30  /**
31   * This class represents a set of Groups. It's useful for building
32   * administration UI.  It enforces that only
33   * Group objects are allowed in the set and only relevant methods
34   * are available.
35   *
36   * @author <a href="mailto:john.mcnally@clearink.com">John D. McNally</a>
37   * @author <a href="mailto:bmclaugh@algx.net">Brett McLaughlin</a>
38   * @author <a href="mailto:marco@intermeta.de">Marco Kn&uuml;ttel</a>
39   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
40   * @version $Id: GroupSet.java 1073174 2011-02-21 22:18:45Z tv $
41   */
42  public class GroupSet
43          extends SecuritySet<Group>
44  {
45      /** Serial version */
46  	private static final long serialVersionUID = -80412911083063489L;
47  
48  	/**
49       * Constructs an empty GroupSet
50       */
51      public GroupSet()
52      {
53          super();
54      }
55  
56      /**
57       * Constructs a new GroupSet with specified contents.
58       *
59       * If the given collection contains multiple objects that are
60       * identical WRT equals() method, some objects will be overwritten.
61       *
62       * @param groups A collection of groups to be contained in the set.
63       */
64      public GroupSet(Collection<Group> groups)
65      {
66          super();
67          add(groups);
68      }
69  
70      /**
71       * Adds a Group to this GroupSet.
72       *
73       * @param group A Group.
74       * @return True if Group was added; false if GroupSet
75       * already contained the Group.
76       */
77      public boolean add(Group group)
78      {
79          boolean res = contains(group);
80          nameMap.put(group.getName(), group);
81          idMap.put(group.getIdAsObj(), group);
82          return res;
83      }
84  
85      /**
86       * Adds the Groups in a Collection to this GroupSet.
87       *
88       * @param groups A Collection of Groups.
89       * @return True if this GroupSet changed as a result; false
90       * if no change to this GroupSet occurred (this GroupSet
91       * already contained all members of the added GroupSet).
92       */
93      public boolean add(Collection<Group> groups)
94      {
95          boolean res = false;
96          for (Group g : groups)
97          {
98              res |= add(g);
99          }
100         return res;
101     }
102 
103     /**
104      * Adds the Groups in another GroupSet to this GroupSet.
105      *
106      * @param groupSet A GroupSet.
107      * @return True if this GroupSet changed as a result; false
108      * if no change to this GroupSet occurred (this GroupSet
109      * already contained all members of the added GroupSet).
110      */
111     public boolean add(GroupSet groupSet)
112     {
113         boolean res = false;
114         for(Group g : groupSet)
115         {
116             res |= add(g);
117         }
118         return res;
119     }
120 
121     /**
122      * Removes a Group from this GroupSet.
123      *
124      * @param group A Group.
125      * @return True if this GroupSet contained the Group
126      * before it was removed.
127      */
128     public boolean remove(Group group)
129     {
130         boolean res = contains(group);
131         nameMap.remove(group.getName());
132         idMap.remove(group.getIdAsObj());
133         return res;
134     }
135 
136     /**
137      * Checks whether this GroupSet contains a Group.
138      *
139      * @param group A Group.
140      * @return True if this GroupSet contains the Group,
141      * false otherwise.
142      */
143     public boolean contains(Group group)
144     {
145         return nameMap.containsValue(group);
146     }
147 
148     /**
149      * Returns a Group with the given name, if it is contained in
150      * this GroupSet.
151      *
152      * @param groupName Name of Group.
153      * @return Group if argument matched a Group in this
154      * GroupSet; null if no match.
155      */
156     public Group getGroupByName(String groupName)
157     {
158         return (StringUtils.isNotEmpty(groupName))
159                 ? (Group) nameMap.get(groupName) : null;
160     }
161 
162     /**
163      * Returns a Group with the given id, if it is contained in
164      * this GroupSet.
165      *
166      * @param groupId Id of the group
167      * @return Group if argument matched a Group in this
168      * GroupSet; null if no match.
169      */
170     public Group getGroupById(int groupId)
171     {
172         return (groupId != 0)
173                 ? (Group) idMap.get(new Integer(groupId)) : null;
174     }
175 
176     /**
177      * Returns an Array of Groups in this GroupSet.
178      *
179      * @return An Array of Group objects.
180      */
181     public Group[] getGroupsArray()
182     {
183         return getSet().toArray(new Group[0]);
184     }
185 
186     /**
187      * Print out a GroupSet as a String
188      *
189      * @returns The Group Set as String
190      *
191      */
192     @Override
193     public String toString()
194     {
195         StringBuffer sb = new StringBuffer();
196         sb.append("GroupSet: ");
197 
198         for(Iterator<Group> it = iterator(); it.hasNext();)
199         {
200             Group g = it.next();
201             sb.append('[');
202             sb.append(g.getName());
203             sb.append(" -> ");
204             sb.append(g.getIdAsObj());
205             sb.append(']');
206             if (it.hasNext())
207             {
208                 sb.append(", ");
209             }
210         }
211 
212         return sb.toString();
213     }
214 }