org.apache.neethi.util.PolicyIntersector Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neethi Show documentation
Show all versions of neethi Show documentation
Apache Neethi provides general framework for the programmers to use WS Policy. It is compliant with latest WS Policy specification which was published in March 2006. This framework is specifically written to enable the Apache Web services stack to use WS Policy as a way of expressing it's requirements and capabilities.
/**
* 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.neethi.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import org.apache.neethi.All;
import org.apache.neethi.Assertion;
import org.apache.neethi.ExactlyOne;
import org.apache.neethi.IntersectableAssertion;
import org.apache.neethi.Policy;
import org.apache.neethi.PolicyComponent;
import org.apache.neethi.PolicyContainingAssertion;
/**
* This class contains methods dealing with policy intersection.
* Intersection of two assertions, i.e. computation if a compatible assertion,
* is domain specific and relies on AssertionBuilder.buildCompatible.
* See Section 4.5 in http://www.w3.org/TR/2006/WD-ws-policy-20061117.
*/
public class PolicyIntersector {
private boolean strict;
public PolicyIntersector() {
strict = true;
}
public PolicyIntersector(boolean s) {
strict = s;
}
public boolean isStrict() {
return strict;
}
public void setStrict(boolean s) {
strict = s;
}
private Assertion intersect(Assertion a1, Assertion a2) {
if (a1 instanceof IntersectableAssertion) {
if (!((IntersectableAssertion)a1).isCompatible(a2, strict)) {
return null;
}
return ((IntersectableAssertion)a1).intersect(a2, strict);
}
//the assertion doesn't implement IntersectableAssertion so we
//need to try doing a basic intersect ourself
if (a1.getName().equals(a2.getName())) {
if (a1 instanceof PolicyContainingAssertion
&& a2 instanceof PolicyContainingAssertion) {
PolicyContainingAssertion pc1 = (PolicyContainingAssertion)a1;
PolicyContainingAssertion pc2 = (PolicyContainingAssertion)a2;
Policy p1 = pc1.getPolicy();
Policy p2 = pc2.getPolicy();
PolicyIntersector pi = new PolicyIntersector(strict);
if (pi.compatiblePolicies(p1, p2)) {
return a1;
}
} else {
return a1;
}
}
return null;
}
private Assertion findCompatibleAssertion(Assertion assertion,
Collection alt,
boolean remove) {
Iterator iterator = alt.iterator();
while (iterator.hasNext()) {
PolicyComponent a = iterator.next();
if (a instanceof Assertion) {
Assertion compatible = intersect(assertion, (Assertion)a);
if (null != compatible) {
if (remove) {
iterator.remove();
}
return compatible;
}
}
}
return null;
}
boolean compatibleAlternatives(Collection alt1,
Collection alt2) {
if (alt1.isEmpty() && alt2.isEmpty()) {
return true;
}
All all = createCompatibleAlternatives(alt1, alt2, true);
if (all == null) {
return false;
}
return !all.getAssertions().isEmpty();
}
All createCompatibleAlternatives(Collection alt1,
Collection alt2,
boolean remove) {
All all = new All();
if (alt1.isEmpty() && alt2.isEmpty()) {
return all;
}
alt1 = new ArrayList(alt1);
alt2 = new ArrayList(alt2);
Iterator iterator = alt1.iterator();
while (iterator.hasNext()) {
PolicyComponent a1 = iterator.next();
if (a1 instanceof Assertion) {
Assertion assertion = findCompatibleAssertion((Assertion)a1, alt2, remove);
if (assertion != null) {
if (remove) {
iterator.remove();
}
all.addPolicyComponent(assertion);
} else if (!strict && ((Assertion)a1).isIgnorable()) {
all.addPolicyComponent(a1);
} else if (strict || !((Assertion)a1).isIgnorable()) {
return null;
}
}
}
iterator = alt2.iterator();
while (iterator.hasNext()) {
PolicyComponent a2 = iterator.next();
if (a2 instanceof Assertion) {
Assertion assertion = findCompatibleAssertion((Assertion)a2, alt1, remove);
if (assertion != null) {
all.addPolicyComponent(assertion);
} else if (!strict && ((Assertion)a2).isIgnorable()) {
all.addPolicyComponent(a2);
} else if (strict || !((Assertion)a2).isIgnorable()) {
return null;
}
}
}
return all;
}
public boolean compatiblePolicies(Policy p1, Policy p2) {
Iterator> i1 = p1.getAlternatives();
while (i1.hasNext()) {
List alt1 = i1.next();
Iterator> i2 = p2.getAlternatives();
if (!i2.hasNext() && alt1.isEmpty()) {
return true;
}
while (i2.hasNext()) {
List alt2 = i2.next();
if (compatibleAlternatives(alt1, alt2)) {
return true;
}
}
}
return false;
}
public Policy intersect(Policy p1, Policy p2) {
return intersect(p1, p2, false);
}
public Policy intersect(Policy p1, Policy p2, boolean allowDups) {
Policy compatible = new Policy(p1.getPolicyRegistry(), p1.getNamespace());
ExactlyOne eo = new ExactlyOne(compatible);
if (!compatiblePolicies(p1, p2)) {
return compatible;
}
Iterator> i1 = p1.getAlternatives();
while (i1.hasNext()) {
List alt1 = i1.next();
Iterator> i2 = p2.getAlternatives();
while (i2.hasNext()) {
List alt2 = i2.next();
All all = createCompatibleAlternatives(alt1, alt2, !allowDups);
if (all != null) {
eo.addPolicyComponent(all);
}
}
}
return compatible;
}
}