com.sun.xml.internal.ws.policy.spi.PolicyAssertionValidator.Fitness Java Examples

/**
 * Checks if the PolicyMap has only single alternative in the scope.
 *
 * @param policyMap
 *      PolicyMap that needs to be validated.
 */
private void validateServerPolicyMap(PolicyMap policyMap) {
    try {
        final ValidationProcessor validationProcessor = ValidationProcessor.getInstance();

        for (Policy policy : policyMap) {

            // TODO:  here is a good place to check if the actual policy has only one alternative...

            for (AssertionSet assertionSet : policy) {
                for (PolicyAssertion assertion : assertionSet) {
                    Fitness validationResult = validationProcessor.validateServerSide(assertion);
                    if (validationResult != Fitness.SUPPORTED) {
                        throw new PolicyException(PolicyMessages.WSP_1015_SERVER_SIDE_ASSERTION_VALIDATION_FAILED(
                                assertion.getName(),
                                validationResult));
                    }
                }
            }
        }
    } catch (PolicyException e) {
        throw new WebServiceException(e);
    }
}
 

/**
 * Checks if the PolicyMap has only single alternative in the scope.
 *
 * @param policyMap
 *      PolicyMap that needs to be validated.
 */
private void validateServerPolicyMap(PolicyMap policyMap) {
    try {
        final ValidationProcessor validationProcessor = ValidationProcessor.getInstance();

        for (Policy policy : policyMap) {

            // TODO:  here is a good place to check if the actual policy has only one alternative...

            for (AssertionSet assertionSet : policy) {
                for (PolicyAssertion assertion : assertionSet) {
                    Fitness validationResult = validationProcessor.validateServerSide(assertion);
                    if (validationResult != Fitness.SUPPORTED) {
                        throw new PolicyException(PolicyMessages.WSP_1015_SERVER_SIDE_ASSERTION_VALIDATION_FAILED(
                                assertion.getName(),
                                validationResult));
                    }
                }
            }
        }
    } catch (PolicyException e) {
        throw new WebServiceException(e);
    }
}
 

/**
 * Checks if the PolicyMap has only single alternative in the scope.
 *
 * @param policyMap
 *      PolicyMap that needs to be validated.
 */
private void validateServerPolicyMap(PolicyMap policyMap) {
    try {
        final ValidationProcessor validationProcessor = ValidationProcessor.getInstance();

        for (Policy policy : policyMap) {

            // TODO:  here is a good place to check if the actual policy has only one alternative...

            for (AssertionSet assertionSet : policy) {
                for (PolicyAssertion assertion : assertionSet) {
                    Fitness validationResult = validationProcessor.validateServerSide(assertion);
                    if (validationResult != Fitness.SUPPORTED) {
                        throw new PolicyException(PolicyMessages.WSP_1015_SERVER_SIDE_ASSERTION_VALIDATION_FAILED(
                                assertion.getName(),
                                validationResult));
                    }
                }
            }
        }
    } catch (PolicyException e) {
        throw new WebServiceException(e);
    }
}
 

/**
 * Checks if the PolicyMap has only single alternative in the scope.
 *
 * @param policyMap
 *      PolicyMap that needs to be validated.
 */
private void validateServerPolicyMap(PolicyMap policyMap) {
    try {
        final ValidationProcessor validationProcessor = ValidationProcessor.getInstance();

        for (Policy policy : policyMap) {

            // TODO:  here is a good place to check if the actual policy has only one alternative...

            for (AssertionSet assertionSet : policy) {
                for (PolicyAssertion assertion : assertionSet) {
                    Fitness validationResult = validationProcessor.validateServerSide(assertion);
                    if (validationResult != Fitness.SUPPORTED) {
                        throw new PolicyException(PolicyMessages.WSP_1015_SERVER_SIDE_ASSERTION_VALIDATION_FAILED(
                                assertion.getName(),
                                validationResult));
                    }
                }
            }
        }
    } catch (PolicyException e) {
        throw new WebServiceException(e);
    }
}
 

public Fitness validateServerSide(PolicyAssertion assertion) {
    final QName assertionName = assertion.getName();
    if (ManagedServiceAssertion.MANAGED_SERVICE_QNAME.equals(assertionName)) {
        return Fitness.SUPPORTED;
    }
    else if (ManagedClientAssertion.MANAGED_CLIENT_QNAME.equals(assertionName)) {
        return Fitness.UNSUPPORTED;
    }
    else {
        return Fitness.UNKNOWN;
    }
}
 

public Fitness validateServerSide(PolicyAssertion assertion) {
    QName assertionName = assertion.getName();
    if (serverSideSupportedAssertions.contains(assertionName)) {
        return Fitness.SUPPORTED;
    } else if (clientSideSupportedAssertions.contains(assertionName)) {
        return Fitness.UNSUPPORTED;
    } else {
        return Fitness.UNKNOWN;
    }
}
 

public Fitness validateClientSide(PolicyAssertion assertion) {
    final QName assertionName = assertion.getName();
    if (ManagedClientAssertion.MANAGED_CLIENT_QNAME.equals(assertionName)) {
        return Fitness.SUPPORTED;
    }
    else if (ManagedServiceAssertion.MANAGED_SERVICE_QNAME.equals(assertionName)) {
        return Fitness.UNSUPPORTED;
    }
    else {
        return Fitness.UNKNOWN;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
        case UNSUPPORTED:
            return PARTIALLY_SUPPORTED;
        case SUPPORTED:
            return SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
            return UNKNOWN;
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

public Fitness validateClientSide(PolicyAssertion assertion) {
    final QName assertionName = assertion.getName();
    if (ManagedClientAssertion.MANAGED_CLIENT_QNAME.equals(assertionName)) {
        return Fitness.SUPPORTED;
    }
    else if (ManagedServiceAssertion.MANAGED_SERVICE_QNAME.equals(assertionName)) {
        return Fitness.UNSUPPORTED;
    }
    else {
        return Fitness.UNKNOWN;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
            return UNKNOWN;
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return PARTIALLY_SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

public Fitness validateServerSide(PolicyAssertion assertion) {
    QName assertionName = assertion.getName();
    if (serverSideSupportedAssertions.contains(assertionName)) {
        return Fitness.SUPPORTED;
    } else if (clientSideSupportedAssertions.contains(assertionName)) {
        return Fitness.UNSUPPORTED;
    } else {
        return Fitness.UNKNOWN;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
        case UNSUPPORTED:
        case SUPPORTED:
            return PARTIALLY_SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

public Fitness validateServerSide(PolicyAssertion assertion) {
    QName assertionName = assertion.getName();
    if (serverSideSupportedAssertions.contains(assertionName)) {
        return Fitness.SUPPORTED;
    } else if (clientSideSupportedAssertions.contains(assertionName)) {
        return Fitness.UNSUPPORTED;
    } else {
        return Fitness.UNKNOWN;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
        case UNSUPPORTED:
            return PARTIALLY_SUPPORTED;
        case SUPPORTED:
            return SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
        case UNSUPPORTED:
            return PARTIALLY_SUPPORTED;
        case SUPPORTED:
            return SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

public Fitness validateServerSide(PolicyAssertion assertion) {
    QName assertionName = assertion.getName();
    if (serverSideSupportedAssertions.contains(assertionName)) {
        return Fitness.SUPPORTED;
    } else if (clientSideSupportedAssertions.contains(assertionName)) {
        return Fitness.UNSUPPORTED;
    } else {
        return Fitness.UNKNOWN;
    }
}
 

public Fitness validateServerSide(PolicyAssertion assertion) {
    final QName assertionName = assertion.getName();
    if (ManagedServiceAssertion.MANAGED_SERVICE_QNAME.equals(assertionName)) {
        return Fitness.SUPPORTED;
    }
    else if (ManagedClientAssertion.MANAGED_CLIENT_QNAME.equals(assertionName)) {
        return Fitness.UNSUPPORTED;
    }
    else {
        return Fitness.UNKNOWN;
    }
}
 

public Fitness validateServerSide(PolicyAssertion assertion) {
    final QName assertionName = assertion.getName();
    if (ManagedServiceAssertion.MANAGED_SERVICE_QNAME.equals(assertionName)) {
        return Fitness.SUPPORTED;
    }
    else if (ManagedClientAssertion.MANAGED_CLIENT_QNAME.equals(assertionName)) {
        return Fitness.UNSUPPORTED;
    }
    else {
        return Fitness.UNKNOWN;
    }
}
 

public Fitness validateServerSide(PolicyAssertion assertion) {
    final QName assertionName = assertion.getName();
    if (ManagedServiceAssertion.MANAGED_SERVICE_QNAME.equals(assertionName)) {
        return Fitness.SUPPORTED;
    }
    else if (ManagedClientAssertion.MANAGED_CLIENT_QNAME.equals(assertionName)) {
        return Fitness.UNSUPPORTED;
    }
    else {
        return Fitness.UNKNOWN;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
            return UNKNOWN;
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return PARTIALLY_SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
            return UNKNOWN;
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return PARTIALLY_SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return PARTIALLY_SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
        case UNSUPPORTED:
        case SUPPORTED:
            return PARTIALLY_SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
            return UNKNOWN;
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return PARTIALLY_SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
        case UNSUPPORTED:
            return PARTIALLY_SUPPORTED;
        case SUPPORTED:
            return SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
            return UNKNOWN;
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

AlternativeFitness combine(final Fitness assertionFitness) {
    switch (assertionFitness) {
        case UNKNOWN:
            return UNKNOWN;
        case UNSUPPORTED:
            return UNSUPPORTED;
        case SUPPORTED:
            return SUPPORTED;
        case INVALID:
            return INVALID;
        default:
            return UNEVALUATED;
    }
}
 

public Fitness validateClientSide(PolicyAssertion assertion) {
    final QName assertionName = assertion.getName();
    if (ManagedClientAssertion.MANAGED_CLIENT_QNAME.equals(assertionName)) {
        return Fitness.SUPPORTED;
    }
    else if (ManagedServiceAssertion.MANAGED_SERVICE_QNAME.equals(assertionName)) {
        return Fitness.UNSUPPORTED;
    }
    else {
        return Fitness.UNKNOWN;
    }
}