Coverage Report - org.apache.turbine.util.security.GroupSet
 
Classes in this File Line Coverage Branch Coverage Complexity
GroupSet
0%
0/38
0%
0/12
1,545
 
 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  0
         super();
 54  0
     }
 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  0
         super();
 67  0
         add(groups);
 68  0
     }
 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  0
         boolean res = contains(group);
 80  0
         nameMap.put(group.getName(), group);
 81  0
         idMap.put(group.getIdAsObj(), group);
 82  0
         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  0
         boolean res = false;
 96  0
         for (Group g : groups)
 97  
         {
 98  0
             res |= add(g);
 99  
         }
 100  0
         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  0
         boolean res = false;
 114  0
         for(Group g : groupSet)
 115  
         {
 116  0
             res |= add(g);
 117  
         }
 118  0
         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  0
         boolean res = contains(group);
 131  0
         nameMap.remove(group.getName());
 132  0
         idMap.remove(group.getIdAsObj());
 133  0
         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  0
         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  0
         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  0
         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  0
         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  0
         StringBuffer sb = new StringBuffer();
 196  0
         sb.append("GroupSet: ");
 197  
 
 198  0
         for(Iterator<Group> it = iterator(); it.hasNext();)
 199  
         {
 200  0
             Group g = it.next();
 201  0
             sb.append('[');
 202  0
             sb.append(g.getName());
 203  0
             sb.append(" -> ");
 204  0
             sb.append(g.getIdAsObj());
 205  0
             sb.append(']');
 206  0
             if (it.hasNext())
 207  
             {
 208  0
                 sb.append(", ");
 209  
             }
 210  0
         }
 211  
 
 212  0
         return sb.toString();
 213  
     }
 214  
 }