SimplePrincipalCollection.java
/*
* 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 serialization 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 serialization 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();
}
}
}