AbstractValidator now handles pre/post validate tasks and subclasses implement doValidate() for the validation.
Change-Id: Ia6d5cfe60ea8a37e87e55b478a1d802895822511
Signed-off-by: Ryan Vail <r.vail@cablelabs.com>
package org.opendaylight.controller.packetcable.provider.validation.impl.validators;
+import static com.google.common.base.Preconditions.checkNotNull;
+
import java.util.ArrayList;
import java.util.Collection;
import javax.annotation.concurrent.NotThreadSafe;
getErrorMessages().addAll(e.getErrorMessages());
}
}
+
+ @Override
+ public void validate(final T data, final Extent extent) throws ValidationException {
+ checkNotNull(extent);
+
+ doValidate(data, extent);
+
+ throwErrorsIfNeeded();
+ }
+
+ protected abstract void doValidate(final T data, final Extent extent);
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.ccaps;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.ccap.attributes.AmId;
private static final String AM_TAG = "amId.am-tag";
@Override
- public void validate(final AmId amId, Extent extent) throws ValidationException {
-
+ protected void doValidate(final AmId amId, Extent extent) {
if (amId == null) {
- throw new ValidationException("amId must exist");
+ getErrorMessages().add("amId must exist");
+ return;
}
mustExist(amId.getAmTag(), AM_TAG);
mustExist(amId.getAmType(), AM_TYPE);
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.ccaps;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.ccaps.Ccap;
private final ConnectionValidator connectionValidator = new ConnectionValidator();
@Override
- public void validate(final Ccap ccap, Extent extent) throws ValidationException {
+ protected void doValidate(final Ccap ccap, Extent extent) {
if (ccap == null) {
- throw new ValidationException("ccap must exist");
+ getErrorMessages().add("ccap must exist");
+ return;
}
mustExist(ccap.getCcapId(), CCAPID);
mustExist(ccap.getAmId(), AM_ID);
mustExist(ccap.getConnection(), CONNECTION);
}
-
- throwErrorsIfNeeded();
}
-
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.ccaps;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.Ccaps;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.ccaps.Ccap;
private final CcapValidator ccapValidator = new CcapValidator();
@Override
- public void validate(final Ccaps ccaps, Extent extent) throws ValidationException {
+ public void doValidate(final Ccaps ccaps, Extent extent) {
if (ccaps == null) {
- throw new ValidationException("ccaps must exist");
+ getErrorMessages().add("ccaps must exist");
+ return;
}
if (extent == Extent.NODE_AND_SUBTREE) {
- for (Ccap ccap : ccaps.getCcap()) {
- validateChild(ccapValidator, ccap);
+ if (ccaps.getCcap() != null) {
+ for (Ccap ccap : ccaps.getCcap()) {
+ validateChild(ccapValidator, ccap);
+ }
}
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.ccaps;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.ccap.attributes.Connection;
private static final String PORT = "connection.port";
@Override
- public void validate(final Connection connection, Extent extent) throws ValidationException {
+ protected void doValidate(final Connection connection, Extent extent) {
if (connection == null) {
- throw new ValidationException("connection must exist");
+ getErrorMessages().add("connection must exist");
+ return;
}
mustExist(connection.getIpAddress(), IP_ADDRESS);
// Note PortNumber validates range on creation so only existence needs to be checked
mustExist(connection.getPort(), PORT);
-
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.apps.App;
private final SubscribersValidator subscribersValidator = new SubscribersValidator();
@Override
- public void validate(final App app, final Extent extent) throws ValidationException {
+ protected void doValidate(final App app, final Extent extent) {
if (app == null) {
- throw new ValidationException("app must exist");
+ getErrorMessages().add("app must exist");
+ return;
}
mustExist(app.getAppId(), APP_ID);
if (extent == Extent.NODE_AND_SUBTREE) {
validateChild(subscribersValidator, app.getSubscribers());
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.Apps;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.apps.App;
private final AppValidator appValidator = new AppValidator();
@Override
- public void validate(final Apps apps, final Extent extent) throws ValidationException {
+ protected void doValidate(final Apps apps, final Extent extent) {
if (apps == null) {
- throw new ValidationException("apps must exist");
+ getErrorMessages().add("apps must exist");
+ return;
}
if (extent == Extent.NODE_AND_SUBTREE) {
for (App app : apps.getApp()) {
validateChild(appValidator, app);
}
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gate.spec.GateSpec;
private static final String DIRECTION = "gate-spec.direction";
@Override
- public void validate(final GateSpec gateSpec, final Extent extent) throws ValidationException {
+ protected void doValidate(final GateSpec gateSpec, final Extent extent) {
if (gateSpec == null) {
- throw new ValidationException("gate-spec must exist");
+ getErrorMessages().add("gate-spec must exist");
}
// everything is optional
// mustExist(gateSpec.getDirection(), DIRECTION);
//
// // dscp-tos-overwrite & dscp-tos-mask are optional
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos.classifier.ClassifiersValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.apps.app.subscribers.subscriber.gates.Gate;
private final ClassifiersValidator classifiersValidator = new ClassifiersValidator();
@Override
- public void validate(final Gate gate, final Extent extent) throws ValidationException {
+ protected void doValidate(final Gate gate, final Extent extent) {
if (gate == null) {
- throw new ValidationException("gate must exist");
+ getErrorMessages().add("gate must exist");
+ return;
}
mustExist(gate.getGateId(), GATE_ID);
validateChild(trafficProfileValidator, gate.getTrafficProfile());
validateChild(classifiersValidator, gate.getClassifiers());
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.apps.app.subscribers.subscriber.Gates;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.apps.app.subscribers.subscriber.gates.Gate;
private final GateValidator gateValidator = new GateValidator();
@Override
- public void validate(final Gates gates, final Extent extent) throws ValidationException {
+ protected void doValidate(final Gates gates, final Extent extent) {
if (gates == null) {
- throw new ValidationException("gates must exist");
+ getErrorMessages().add("gates must exist");
+ return;
}
if (extent == Extent.NODE_AND_SUBTREE) {
validateChild(gateValidator, gate);
}
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.apps.app.subscribers.Subscriber;
private final GatesValidator gatesValidator = new GatesValidator();
@Override
- public void validate(final Subscriber subscriber, final Extent extent) throws ValidationException {
+ protected void doValidate(final Subscriber subscriber, final Extent extent) {
if (subscriber == null) {
- throw new ValidationException("subscriber must exist");
+ getErrorMessages().add("subscriber must exist");
+ return;
}
mustExist(subscriber.getSubscriberId(), SUBSCRIBER_ID);
if (extent == Extent.NODE_AND_SUBTREE) {
validateChild(gatesValidator, subscriber.getGates());
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.apps.app.Subscribers;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.gates.apps.app.subscribers.Subscriber;
private final SubscriberValidator subscriberValidator = new SubscriberValidator();
@Override
- public void validate(final Subscribers subscribers, final Extent extent) throws ValidationException {
+ protected void doValidate(final Subscribers subscribers, final Extent extent) {
if (subscribers == null) {
- throw new ValidationException("subscribers must exist");
+ getErrorMessages().add("subscribers must exist");
+ return;
}
if (extent == Extent.NODE_AND_SUBTREE) {
validateChild(subscriberValidator , subscriber);
}
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.traffic.profile.TrafficProfile;
private static final String SCN = "service-class-name";
@Override
- public void validate(final TrafficProfile trafficProfile, final Extent extent) throws ValidationException {
- if (trafficProfile == null) {
- throw new ValidationException("traffic-profile must exist");
- }
+ protected void doValidate(final TrafficProfile trafficProfile, final Extent extent) {
+ if (trafficProfile == null) {
+ getErrorMessages().add("traffic-profile must exist");
+ return;
+ }
mustExist(trafficProfile.getServiceClassName(), SCN);
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos.classifier;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.classifier.attributes.classifiers.classifier.container.ClassifierChoice;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.classifier.attributes.classifiers.classifier.container.classifier.choice.ExtClassifierChoice;
private final Ipv6ClassifierValidator ipv6ClassifierValidator = new Ipv6ClassifierValidator();
@Override
- public void validate(final ClassifierChoice choice, final Extent extent) throws ValidationException {
+ protected void doValidate(final ClassifierChoice choice, final Extent extent) {
if (choice == null) {
- throw new ValidationException("classifier-choice must exist");
+ getErrorMessages().add("classifier-choice must exist");
+ return;
}
// Determine what type this choice is then validate it
else {
throw new IllegalStateException("Unknown ClassifierChoice Type: " + choice.getClass().getName());
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos.classifier;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.classifier.attributes.classifiers.ClassifierContainer;
private final ClassifierChoiceValidator classifierChoiceValidator = new ClassifierChoiceValidator();
@Override
- public void validate(final ClassifierContainer container, final Extent extent) throws ValidationException {
+ protected void doValidate(final ClassifierContainer container, final Extent extent) {
if (container == null) {
- throw new ValidationException("classifer-container must exist");
+ getErrorMessages().add("classifer-container must exist");
+ return;
}
mustExist(container.getClassifierChoice(), CLASSIFIER_CHOICE);
if (extent == Extent.NODE_AND_SUBTREE) {
validateChild(classifierChoiceValidator, container.getClassifierChoice());
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos.classifier;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.classifier.Classifier;
private static final String PROTOCOL = "classifer.protocol";
@Override
- public void validate(final Classifier classifier, final Extent extent) throws ValidationException {
-
+ protected void doValidate(final Classifier classifier, final Extent extent) {
if (classifier == null) {
- throw new ValidationException("classifer must exist");
+ getErrorMessages().add("classifer must exist");
+ return;
}
mustExist(classifier.getSrcIp(), SRC_IP);
mustExist(classifier.getTosMask(), TOS_MASK);
mustExist(classifier.getProtocol(), PROTOCOL);
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos.classifier;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.classifier.attributes.Classifiers;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.classifier.attributes.classifiers.ClassifierContainer;
private ClassifierContainerValidator classifierContainerValidator = new ClassifierContainerValidator();
@Override
- public void validate(final Classifiers classifiers, final Extent extent) throws ValidationException {
+ protected void doValidate(final Classifiers classifiers, final Extent extent) {
if (classifiers == null) {
- throw new ValidationException("classifiers must exist");
+ getErrorMessages().add("classifiers must exist");
+ return;
}
mustExistAndNotBeEmpty(classifiers.getClassifierContainer(), CLASSIFER_CONTAINER);
validateChild(classifierContainerValidator, classifier);
}
}
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos.classifier;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.ext.classifier.ExtClassifier;
private static final String DST_PORT_END = "ext-classifer.dstPort-end";
@Override
- public void validate(final ExtClassifier extClassifier, final Extent extent) throws ValidationException {
+ protected void doValidate(final ExtClassifier extClassifier, final Extent extent) {
+ if (extClassifier == null) {
+ getErrorMessages().add("ext-classifier must exist");
+ return;
+ }
mustExist(extClassifier.getSrcIp(), SRC_IP);
mustExist(extClassifier.getSrcIpMask(), SRC_MASK);
mustExist(extClassifier.getDstPortStart(), DST_PORT_START);
mustExist(extClassifier.getDstPortEnd(), DST_PORT_END);
-
- throwErrorsIfNeeded();
}
}
package org.opendaylight.controller.packetcable.provider.validation.impl.validators.qos.classifier;
-import org.opendaylight.controller.packetcable.provider.validation.ValidationException;
import org.opendaylight.controller.packetcable.provider.validation.impl.validators.AbstractValidator;
import org.opendaylight.yang.gen.v1.urn.packetcable.rev151101.pcmm.qos.ipv6.classifier.Ipv6Classifier;
private static final String DST_PORT_END = "ipv6-classifer.dstPort-end";
@Override
- public void validate(final Ipv6Classifier ipv6Classifier, final Extent extent) throws ValidationException {
+ protected void doValidate(final Ipv6Classifier ipv6Classifier, final Extent extent) {
if (ipv6Classifier == null) {
- throw new ValidationException("ipv6-classifer must exist");
+ getErrorMessages().add("ipv6-classifer must exist");
+ return;
}
mustExist(ipv6Classifier.getSrcIp6(), SRC_IP6);
mustExist(ipv6Classifier.getDstPortStart(), DST_PORT_START);
mustExist(ipv6Classifier.getDstPortEnd(), DST_PORT_END);
-
- throwErrorsIfNeeded();
}
}