Coverage Report

Coverage Report - org.apache.shiro.subject.SimplePrincipalCollection

Classes in this File

Line Coverage

Branch Coverage

Complexity

SimplePrincipalCollection

55%

69/125

42%

40/94

3.696

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.shiro.subject;
 
 import org.apache.shiro.util.CollectionUtils;
 import org.apache.shiro.util.StringUtils;
 
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.*;
 
 
 /**
  * A simple implementation of the {@link MutablePrincipalCollection} interface that tracks principals internally
  * by storing them in a {@link LinkedHashMap}.
  *
  * @since 0.9
  */
 @SuppressWarnings({"unchecked"})
 public class SimplePrincipalCollection implements MutablePrincipalCollection {
 
     // Serialization reminder:
     // You _MUST_ change this number if you introduce a change to this class
     // that is NOT serialization backwards compatible.  Serialization-compatible
     // changes do not require a change to this number.  If you need to generate
     // a new number in this case, use the JDK's 'serialver' program to generate it.
     private static final long serialVersionUID = -6305224034025797558L;
 
     //TODO - complete JavaDoc
 
     private Map<String, Set> realmPrincipals;
 
     private transient String cachedToString; //cached toString() result, as this can be printed many times in logging
 
     public SimplePrincipalCollection() {
     }
 
     public SimplePrincipalCollection(Object principal, String realmName) {
         if (principal instanceof Collection) {
             addAll((Collection) principal, realmName);
         } else {
             add(principal, realmName);
         }
     }
 
     public SimplePrincipalCollection(Collection principals, String realmName) {
         addAll(principals, realmName);
     }
 
     public SimplePrincipalCollection(PrincipalCollection principals) {
         addAll(principals);
     }
 
     protected Collection getPrincipalsLazy(String realmName) {
         if (realmPrincipals == null) {
             realmPrincipals = new LinkedHashMap<String, Set>();
         }
         Set principals = realmPrincipals.get(realmName);
         if (principals == null) {
             principals = new LinkedHashSet();
             realmPrincipals.put(realmName, principals);
         }
         return principals;
     }
 
     /**
      * Returns the first available principal from any of the {@code Realm} principals, or {@code null} if there are
      * no principals yet.
      * <p/>
      * The 'first available principal' is interpreted as the principal that would be returned by
      * <code>{@link #iterator() iterator()}.{@link java.util.Iterator#next() next()}.</code>
      *
      * @inheritDoc
      */
     public Object getPrimaryPrincipal() {
         if (isEmpty()) {
             return null;
         }
         return iterator().next();
     }
 
     public void add(Object principal, String realmName) {
         if (realmName == null) {
             throw new IllegalArgumentException("realmName argument cannot be null.");
         }
         if (principal == null) {
             throw new IllegalArgumentException("principal argument cannot be null.");
         }
         this.cachedToString = null;
         getPrincipalsLazy(realmName).add(principal);
     }
 
     public void addAll(Collection principals, String realmName) {
         if (realmName == null) {
             throw new IllegalArgumentException("realmName argument cannot be null.");
         }
         if (principals == null) {
             throw new IllegalArgumentException("principals argument cannot be null.");
         }
         if (principals.isEmpty()) {
             throw new IllegalArgumentException("principals argument cannot be an empty collection.");
         }
         this.cachedToString = null;
         getPrincipalsLazy(realmName).addAll(principals);
     }
 
     public void addAll(PrincipalCollection principals) {
         if (principals.getRealmNames() != null) {
             for (String realmName : principals.getRealmNames()) {
                 for (Object principal : principals.fromRealm(realmName)) {
                     add(principal, realmName);
                 }
             }
         }
     }
 
     public <T> T oneByType(Class<T> type) {
         if (realmPrincipals == null || realmPrincipals.isEmpty()) {
             return null;
         }
         Collection<Set> values = realmPrincipals.values();
         for (Set set : values) {
             for (Object o : set) {
                 if (type.isAssignableFrom(o.getClass())) {
                     return (T) o;
                 }
             }
         }
         return null;
     }
 
     public <T> Collection<T> byType(Class<T> type) {
         if (realmPrincipals == null || realmPrincipals.isEmpty()) {
             return Collections.EMPTY_SET;
         }
         Set<T> typed = new LinkedHashSet<T>();
         Collection<Set> values = realmPrincipals.values();
         for (Set set : values) {
             for (Object o : set) {
                 if (type.isAssignableFrom(o.getClass())) {
                     typed.add((T) o);
                 }
             }
         }
         if (typed.isEmpty()) {
             return Collections.EMPTY_SET;
         }
         return Collections.unmodifiableSet(typed);
     }
 
     public List asList() {
         Set all = asSet();
         if (all.isEmpty()) {
             return Collections.EMPTY_LIST;
         }
         return Collections.unmodifiableList(new ArrayList(all));
     }
 
     public Set asSet() {
         if (realmPrincipals == null || realmPrincipals.isEmpty()) {
             return Collections.EMPTY_SET;
         }
         Set aggregated = new LinkedHashSet();
         Collection<Set> values = realmPrincipals.values();
         for (Set set : values) {
             aggregated.addAll(set);
         }
         if (aggregated.isEmpty()) {
             return Collections.EMPTY_SET;
         }
         return Collections.unmodifiableSet(aggregated);
     }
 
     public Collection fromRealm(String realmName) {
         if (realmPrincipals == null || realmPrincipals.isEmpty()) {
             return Collections.EMPTY_SET;
         }
         Set principals = realmPrincipals.get(realmName);
         if (principals == null || principals.isEmpty()) {
             principals = Collections.EMPTY_SET;
         }
         return Collections.unmodifiableSet(principals);
     }
 
     public Set<String> getRealmNames() {
         if (realmPrincipals == null) {
             return null;
         } else {
             return realmPrincipals.keySet();
         }
     }
 
     public boolean isEmpty() {
         return realmPrincipals == null || realmPrincipals.isEmpty();
     }
 
     public void clear() {
         this.cachedToString = null;
         if (realmPrincipals != null) {
             realmPrincipals.clear();
             realmPrincipals = null;
         }
     }
 
     public Iterator iterator() {
         return asSet().iterator();
     }
 
     public boolean equals(Object o) {
         if (o == this) {
             return true;
         }
         if (o instanceof SimplePrincipalCollection) {
             SimplePrincipalCollection other = (SimplePrincipalCollection) o;
             return this.realmPrincipals != null ? this.realmPrincipals.equals(other.realmPrincipals) : other.realmPrincipals == null;
         }
         return false;
     }
 
     public int hashCode() {
         if (this.realmPrincipals != null && !realmPrincipals.isEmpty()) {
             return realmPrincipals.hashCode();
         }
         return super.hashCode();
     }
 
     /**
      * Returns a simple string representation suitable for printing.
      *
      * @return a simple string representation suitable for printing.
      * @since 1.0
      */
     public String toString() {
         if (this.cachedToString == null) {
             Set<Object> principals = asSet();
             if (!CollectionUtils.isEmpty(principals)) {
                 this.cachedToString = StringUtils.toString(principals.toArray());
             } else {
                 this.cachedToString = "empty";
             }
         }
         return this.cachedToString;
     }
 
 
     /**
      * Serialization write support.
      * <p/>
      * NOTE: Don't forget to change the serialVersionUID constant at the top of this class
      * if you make any backwards-incompatible serializatoin changes!!!
      * (use the JDK 'serialver' program for this)
      *
      * @param out output stream provided by Java serialization
      * @throws IOException if there is a stream error
      */
     private void writeObject(ObjectOutputStream out) throws IOException {
         out.defaultWriteObject();
         boolean principalsExist = !CollectionUtils.isEmpty(realmPrincipals);
         out.writeBoolean(principalsExist);
         if (principalsExist) {
             out.writeObject(realmPrincipals);
         }
     }
 
     /**
      * Serialization read support - reads in the Map principals collection if it exists in the
      * input stream.
      * <p/>
      * NOTE: Don't forget to change the serialVersionUID constant at the top of this class
      * if you make any backwards-incompatible serializatoin changes!!!
      * (use the JDK 'serialver' program for this)
      *
      * @param in input stream provided by
      * @throws IOException            if there is an input/output problem
      * @throws ClassNotFoundException if the underlying Map implementation class is not available to the classloader.
      */
     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
         in.defaultReadObject();
         boolean principalsExist = in.readBoolean();
         if (principalsExist) {
             this.realmPrincipals = (Map<String, Set>) in.readObject();
         }
     }
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one
3		* or more contributor license agreements. See the NOTICE file
4		* distributed with this work for additional information
5		* regarding copyright ownership. The ASF licenses this file
6		* to you under the Apache License, Version 2.0 (the
7		* "License"); you may not use this file except in compliance
8		* with the License. You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing,
13		* software distributed under the License is distributed on an
14		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15		* KIND, either express or implied. See the License for the
16		* specific language governing permissions and limitations
17		* under the License.
18		*/
19		package org.apache.shiro.subject;
20
21		import org.apache.shiro.util.CollectionUtils;
22		import org.apache.shiro.util.StringUtils;
23
24		import java.io.IOException;
25		import java.io.ObjectInputStream;
26		import java.io.ObjectOutputStream;
27		import java.util.*;
28
29
30		/**
31		* A simple implementation of the {@link MutablePrincipalCollection} interface that tracks principals internally
32		* by storing them in a {@link LinkedHashMap}.
33		*
34		* @since 0.9
35		*/
36		@SuppressWarnings({"unchecked"})
37		public class SimplePrincipalCollection implements MutablePrincipalCollection {
38
39		// Serialization reminder:
40		// You _MUST_ change this number if you introduce a change to this class
41		// that is NOT serialization backwards compatible. Serialization-compatible
42		// changes do not require a change to this number. If you need to generate
43		// a new number in this case, use the JDK's 'serialver' program to generate it.
44		private static final long serialVersionUID = -6305224034025797558L;
45
46		//TODO - complete JavaDoc
47
48		private Map<String, Set> realmPrincipals;
49
50		private transient String cachedToString; //cached toString() result, as this can be printed many times in logging
51
52	2	public SimplePrincipalCollection() {
53	2	}
54
55	160	public SimplePrincipalCollection(Object principal, String realmName) {
56	160	if (principal instanceof Collection) {
57	2	addAll((Collection) principal, realmName);
58		} else {
59	158	add(principal, realmName);
60		}
61	160	}
62
63	0	public SimplePrincipalCollection(Collection principals, String realmName) {
64	0	addAll(principals, realmName);
65	0	}
66
67	82	public SimplePrincipalCollection(PrincipalCollection principals) {
68	82	addAll(principals);
69	82	}
70
71		protected Collection getPrincipalsLazy(String realmName) {
72	248	if (realmPrincipals == null) {
73	244	realmPrincipals = new LinkedHashMap<String, Set>();
74		}
75	248	Set principals = realmPrincipals.get(realmName);
76	248	if (principals == null) {
77	246	principals = new LinkedHashSet();
78	246	realmPrincipals.put(realmName, principals);
79		}
80	248	return principals;
81		}
82
83		/**
84		* Returns the first available principal from any of the {@code Realm} principals, or {@code null} if there are
85		* no principals yet.
86		* <p/>
87		* The 'first available principal' is interpreted as the principal that would be returned by
88		* <code>{@link #iterator() iterator()}.{@link java.util.Iterator#next() next()}.</code>
89		*
90		* @inheritDoc
91		*/
92		public Object getPrimaryPrincipal() {
93	62	if (isEmpty()) {
94	0	return null;
95		}
96	62	return iterator().next();
97		}
98
99		public void add(Object principal, String realmName) {
100	246	if (realmName == null) {
101	0	throw new IllegalArgumentException("realmName argument cannot be null.");
102		}
103	246	if (principal == null) {
104	0	throw new IllegalArgumentException("principal argument cannot be null.");
105		}
106	246	this.cachedToString = null;
107	246	getPrincipalsLazy(realmName).add(principal);
108	246	}
109
110		public void addAll(Collection principals, String realmName) {
111	2	if (realmName == null) {
112	0	throw new IllegalArgumentException("realmName argument cannot be null.");
113		}
114	2	if (principals == null) {
115	0	throw new IllegalArgumentException("principals argument cannot be null.");
116		}
117	2	if (principals.isEmpty()) {
118	0	throw new IllegalArgumentException("principals argument cannot be an empty collection.");
119		}
120	2	this.cachedToString = null;
121	2	getPrincipalsLazy(realmName).addAll(principals);
122	2	}
123
124		public void addAll(PrincipalCollection principals) {
125	84	if (principals.getRealmNames() != null) {
126	84	for (String realmName : principals.getRealmNames()) {
127	84	for (Object principal : principals.fromRealm(realmName)) {
128	84	add(principal, realmName);
129	84	}
130	84	}
131		}
132	84	}
133
134		public <T> T oneByType(Class<T> type) {
135	10	if (realmPrincipals == null \|\| realmPrincipals.isEmpty()) {
136	0	return null;
137		}
138	10	Collection<Set> values = realmPrincipals.values();
139	10	for (Set set : values) {
140	10	for (Object o : set) {
141	18	if (type.isAssignableFrom(o.getClass())) {
142	10	return (T) o;
143		}
144	8	}
145	0	}
146	0	return null;
147		}
148
149		public <T> Collection<T> byType(Class<T> type) {
150	0	if (realmPrincipals == null \|\| realmPrincipals.isEmpty()) {
151	0	return Collections.EMPTY_SET;
152		}
153	0	Set<T> typed = new LinkedHashSet<T>();
154	0	Collection<Set> values = realmPrincipals.values();
155	0	for (Set set : values) {
156	0	for (Object o : set) {
157	0	if (type.isAssignableFrom(o.getClass())) {
158	0	typed.add((T) o);
159		}
160	0	}
161	0	}
162	0	if (typed.isEmpty()) {
163	0	return Collections.EMPTY_SET;
164		}
165	0	return Collections.unmodifiableSet(typed);
166		}
167
168		public List asList() {
169	2	Set all = asSet();
170	2	if (all.isEmpty()) {
171	0	return Collections.EMPTY_LIST;
172		}
173	2	return Collections.unmodifiableList(new ArrayList(all));
174		}
175
176		public Set asSet() {
177	132	if (realmPrincipals == null \|\| realmPrincipals.isEmpty()) {
178	0	return Collections.EMPTY_SET;
179		}
180	132	Set aggregated = new LinkedHashSet();
181	132	Collection<Set> values = realmPrincipals.values();
182	132	for (Set set : values) {
183	134	aggregated.addAll(set);
184	134	}
185	132	if (aggregated.isEmpty()) {
186	0	return Collections.EMPTY_SET;
187		}
188	132	return Collections.unmodifiableSet(aggregated);
189		}
190
191		public Collection fromRealm(String realmName) {
192	218	if (realmPrincipals == null \|\| realmPrincipals.isEmpty()) {
193	0	return Collections.EMPTY_SET;
194		}
195	218	Set principals = realmPrincipals.get(realmName);
196	218	if (principals == null \|\| principals.isEmpty()) {
197	16	principals = Collections.EMPTY_SET;
198		}
199	218	return Collections.unmodifiableSet(principals);
200		}
201
202		public Set<String> getRealmNames() {
203	164	if (realmPrincipals == null) {
204	0	return null;
205		} else {
206	164	return realmPrincipals.keySet();
207		}
208		}
209
210		public boolean isEmpty() {
211	568	return realmPrincipals == null \|\| realmPrincipals.isEmpty();
212		}
213
214		public void clear() {
215	0	this.cachedToString = null;
216	0	if (realmPrincipals != null) {
217	0	realmPrincipals.clear();
218	0	realmPrincipals = null;
219		}
220	0	}
221
222		public Iterator iterator() {
223	62	return asSet().iterator();
224		}
225
226		public boolean equals(Object o) {
227	0	if (o == this) {
228	0	return true;
229		}
230	0	if (o instanceof SimplePrincipalCollection) {
231	0	SimplePrincipalCollection other = (SimplePrincipalCollection) o;
232	0	return this.realmPrincipals != null ? this.realmPrincipals.equals(other.realmPrincipals) : other.realmPrincipals == null;
233		}
234	0	return false;
235		}
236
237		public int hashCode() {
238	0	if (this.realmPrincipals != null && !realmPrincipals.isEmpty()) {
239	0	return realmPrincipals.hashCode();
240		}
241	0	return super.hashCode();
242		}
243
244		/**
245		* Returns a simple string representation suitable for printing.
246		*
247		* @return a simple string representation suitable for printing.
248		* @since 1.0
249		*/
250		public String toString() {
251	296	if (this.cachedToString == null) {
252	68	Set<Object> principals = asSet();
253	68	if (!CollectionUtils.isEmpty(principals)) {
254	68	this.cachedToString = StringUtils.toString(principals.toArray());
255		} else {
256	0	this.cachedToString = "empty";
257		}
258		}
259	296	return this.cachedToString;
260		}
261
262
263		/**
264		* Serialization write support.
265		* <p/>
266		* NOTE: Don't forget to change the serialVersionUID constant at the top of this class
267		* if you make any backwards-incompatible serializatoin changes!!!
268		* (use the JDK 'serialver' program for this)
269		*
270		* @param out output stream provided by Java serialization
271		* @throws IOException if there is a stream error
272		*/
273		private void writeObject(ObjectOutputStream out) throws IOException {
274	0	out.defaultWriteObject();
275	0	boolean principalsExist = !CollectionUtils.isEmpty(realmPrincipals);
276	0	out.writeBoolean(principalsExist);
277	0	if (principalsExist) {
278	0	out.writeObject(realmPrincipals);
279		}
280	0	}
281
282		/**
283		* Serialization read support - reads in the Map principals collection if it exists in the
284		* input stream.
285		* <p/>
286		* NOTE: Don't forget to change the serialVersionUID constant at the top of this class
287		* if you make any backwards-incompatible serializatoin changes!!!
288		* (use the JDK 'serialver' program for this)
289		*
290		* @param in input stream provided by
291		* @throws IOException if there is an input/output problem
292		* @throws ClassNotFoundException if the underlying Map implementation class is not available to the classloader.
293		*/
294		private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
295	0	in.defaultReadObject();
296	0	boolean principalsExist = in.readBoolean();
297	0	if (principalsExist) {
298	0	this.realmPrincipals = (Map<String, Set>) in.readObject();
299		}
300	0	}
301		}