org.wildfly.security.authz.Roles Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
The newest version!
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016 Red Hat, Inc., and individual contributors
* as indicated by the @author tags.
*
* Licensed 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.wildfly.security.authz;
import static org.wildfly.common.Assert.checkNotNullParam;
import static org.wildfly.common.Assert.checkNotEmptyParam;
import java.util.Collections;
import java.util.Iterator;
import java.util.Set;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.TreeSet;
import java.util.function.Consumer;
import org.wildfly.common.Assert;
/**
* A collection of roles.
*
* @author David M. Lloyd
*/
public interface Roles extends Iterable {
/**
* Determine if this collection contains the given role name.
*
* @param roleName the role name
* @return {@code true} if the role is contained in this collection, {@code false} otherwise
*/
boolean contains(String roleName);
/**
* Determine if this collection contains any of the given role names.
*
* @param desiredRoles the roles to check.
* @return {@code true} if this collection contains any of the desired roles, {@code false} otherwise.
*/
default boolean containsAny(Set desiredRoles) {
checkNotNullParam("desiredRoles", desiredRoles);
for (String current : desiredRoles) {
if (contains(current)) {
return true;
}
}
return false;
}
/**
* Determine if this collection contains all of the given role names.
*
* @param desiredRoles the roles to check.
* @return {@code true} if this collection contains all of the desired roles, {@code false} otherwise.
*/
default boolean containsAll(Set desiredRoles) {
checkNotNullParam("desiredRoles", desiredRoles);
checkNotEmptyParam("desiredRoles", desiredRoles);
for (String current : desiredRoles) {
if (contains(current) == false) {
return false;
}
}
return true;
}
/**
* Determine whether this roles collection is empty.
*
* @return {@code true} if the collection is empty, {@code false} otherwise
*/
default boolean isEmpty() {
return ! iterator().hasNext();
}
/**
* Create a {@link Spliterator} over this roles collection.
*
* @return the spliterator (not {@code null})
*/
default Spliterator spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), Spliterator.NONNULL | Spliterator.DISTINCT);
}
/**
* Construct a new roles collection from a set.
*
* @param set the set of role names (must not be {@code null})
* @return the roles collection (not {@code null})
*/
static Roles fromSet(Set set) {
Assert.checkNotNullParam("set", set);
if (set instanceof Roles) {
return (Roles) set;
}
return new Roles() {
public boolean contains(final String roleName) {
return set.contains(roleName);
}
public Iterator iterator() {
return set.iterator();
}
public Spliterator spliterator() {
return set.spliterator();
}
public void forEach(final Consumer action) {
set.forEach(action);
}
public boolean isEmpty() {
return set.isEmpty();
}
};
}
/**
* Returns a set (immutable) containing roles from a roles collection.
*
* @param roles collection (not {@code null})
* @return the set of role names (must not be {@code null})
*/
static Set toSet(Roles roles) {
Assert.checkNotNullParam("roles", roles);
Iterator iterator = roles.iterator();
if (!iterator.hasNext()) {
return Collections.emptySet();
}
String role = iterator.next();
if (!iterator.hasNext()) {
return Collections.singleton(role);
}
Set result = new TreeSet<>();
result.add(role);
while (iterator.hasNext()) {
result.add(iterator.next());
}
return Collections.unmodifiableSet(result);
}
/**
* Construct a role set consisting of a single role.
*
* @param role the role name (must not be {@code null})
* @return the role set (not {@code null})
*/
static Roles of(String role) {
Assert.checkNotNullParam("role", role);
return new OneRole(role);
}
/**
* Get the intersection of this collection and another.
*
* @param other the other roles collection (must not be {@code null})
* @return the intersection (not {@code null})
*/
default Roles and(Roles other) {
Assert.checkNotNullParam("other", other);
return isEmpty() || other.isEmpty() ? NONE : new IntersectionRoles(this, other);
}
/**
* Get the union of this collection and another.
*
* @param other the other roles collection (must not be {@code null})
* @return the union (not {@code null})
*/
default Roles or(Roles other) {
Assert.checkNotNullParam("other", other);
return isEmpty() ? other : other.isEmpty() ? this : new UnionRoles(this, other);
}
/**
* Get the disjunction of this collection and another.
*
* @param other the other roles collection (must not be {@code null})
* @return the disjunction (not {@code null})
*/
default Roles xor(Roles other) {
Assert.checkNotNullParam("other", other);
return isEmpty() ? other : other.isEmpty() ? this : new DisjunctionRoles(this, other);
}
/**
* Get a roles collection which consists of the roles in this collection minus the roles in the other collection.
*
* @param other the other collection (must not be {@code null})
* @return the difference (not {@code null})
*/
default Roles minus(Roles other) {
Assert.checkNotNullParam("other", other);
return isEmpty() ? NONE : other.isEmpty() ? this : new DifferenceRoles(this, other);
}
/**
* Get a roles collection which adds a suffix to all role names.
*
* @param suffix the suffix to add (must not be {@code null})
* @return the new roles collection (not {@code null})
*/
default Roles addSuffix(String suffix) {
Assert.checkNotNullParam("suffix", suffix);
return suffix.isEmpty() ? this : isEmpty() ? NONE : new AddSuffixRoles(this, suffix);
}
/**
* Get a roles collection which adds a prefix to all role names.
*
* @param prefix the prefix to add (must not be {@code null})
* @return the new roles collection (not {@code null})
*/
default Roles addPrefix(String prefix) {
Assert.checkNotNullParam("prefix", prefix);
return prefix.isEmpty() ? this : isEmpty() ? NONE : new AddPrefixRoles(this, prefix);
}
/**
* The empty roles collection.
*/
Roles NONE = new Roles() {
public boolean contains(final String roleName) {
return false;
}
public Iterator iterator() {
return Collections.emptyIterator();
}
public Spliterator spliterator() {
return Spliterators.emptySpliterator();
}
public Roles and(final Roles other) {
return this;
}
public Roles or(final Roles other) {
return other;
}
public Roles xor(final Roles other) {
return other;
}
public Roles minus(final Roles other) {
return this;
}
public Roles addSuffix(final String suffix) {
return this;
}
public Roles addPrefix(final String prefix) {
return this;
}
public boolean isEmpty() {
return true;
}
@Override
public String toString() {
return "NONE";
}
};
}