MessageValidator.java

  1. /*
  2.  * Copyright 2019 Providence Authors
  3.  *
  4.  * Licensed to the Apache Software Foundation (ASF) under one
  5.  * or more contributor license agreements. See the NOTICE file
  6.  * distributed with this work for additional information
  7.  * regarding copyright ownership. The ASF licenses this file
  8.  * to you under the Apache License, Version 2.0 (the
  9.  * "License"); you may not use this file except in compliance
  10.  * with the License. You may obtain a copy of the License at
  11.  *
  12.  *   http://www.apache.org/licenses/LICENSE-2.0
  13.  *
  14.  * Unless required by applicable law or agreed to in writing,
  15.  * software distributed under the License is distributed on an
  16.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17.  * KIND, either express or implied. See the License for the
  18.  * specific language governing permissions and limitations
  19.  * under the License.
  20.  */
  21. package net.morimekta.providence.util;

  23. import net.morimekta.providence.PMessage;
  24. import net.morimekta.providence.PMessageOrBuilder;
  25. import net.morimekta.providence.descriptor.PField;
  26. import net.morimekta.providence.descriptor.PMessageDescriptor;

  28. import javax.annotation.Nonnull;
  29. import java.util.function.Consumer;
  30. import java.util.function.Function;
  31. import java.util.function.Predicate;

  33. /**
  34.  * Class that handles validation of the structure or content of a message
  35.  * type. This this can do much more fine grained validation than just assigning
  36.  * required fields.
  37.  *
  38.  * @param <M> The message type to be validated.
  39.  * @param <E> The exception to be thrown on validation failure.
  40.  * @deprecated Use {@link MessageValidation}.
  41.  */
  42. @Deprecated
  43. public class MessageValidator<
  44.         M extends PMessage<M>,
  45.         E extends Exception> {
  46.     private final MessageValidation<M, E> validation;

  48.     /**
  49.      * Validate a message using the built expectations.
  50.      *
  51.      * @param message The message to be validated.
  52.      * @throws E On not valid message.
  53.      */
  54.     @SuppressWarnings("unchecked")
  55.     public void validate(PMessageOrBuilder<M> message) throws E {
  56.         validation.validate(message);
  57.     }

  59.     /**
  60.      * Just see if the message is valid or not. Does not
  61.      *
  62.      * @param message The message to be validated.
  63.      * @return True if the message is valid, false otherwise.
  64.      */
  65.     @SuppressWarnings("unchecked")
  66.     public boolean isValid(PMessageOrBuilder<M> message) {
  67.         return validation.isValid(message);
  68.     }

  70.     /**
  71.      * Just see if the message is valid or not. Does not
  72.      *
  73.      * @param message         The message to be validated.
  74.      * @param messageConsumer Consumer of validation errors on the message.
  75.      */
  76.     @SuppressWarnings("unchecked")
  77.     public void collectValidationErrors(PMessageOrBuilder<M> message, Consumer<String> messageConsumer) {
  78.         try {
  79.             validation.validate(message);
  80.         } catch (Exception e) {
  81.             messageConsumer.accept(e.getMessage());
  82.         }
  83.     }


  86.     /**
  87.      * Create a message validator that throws specific exception on failure.
  88.      *
  89.      * @param descriptor The message type descriptor to be validated.
  90.      * @param onMismatch Function producer for thrown exceptions.
  91.      * @param <M>        Message type.
  92.      * @param <E>        Exception type.
  93.      * @return The message validator builder.
  94.      */
  95.     public static <M extends PMessage<M>, E extends Exception>
  96.     MessageValidator.Builder<M, E> builder(
  97.             @Nonnull PMessageDescriptor<M> descriptor,
  98.             @Nonnull Function<String, E> onMismatch) {
  99.         return new Builder<>(descriptor, onMismatch);
  100.     }

  102.     /**
  103.      * Builder vlass for message validators.
  104.      *
  105.      * @param <M> Message type.
  106.      * @param <E> Exception type.
  107.      * @deprecated Use {@link MessageValidation}.
  108.      */
  109.     @Deprecated
  110.     public static class Builder<
  111.             M extends PMessage<M>,
  112.             E extends Exception> {
  113.         /**
  114.          * Build the validator.
  115.          *
  116.          * @return The validator instance.
  117.          */
  118.         @Nonnull
  119.         public MessageValidator<M, E> build() {
  120.             return new MessageValidator<>(this);
  121.         }

  123.         /**
  124.          * Make a specific expectation for the message.
  125.          *
  126.          * @param text      The message text on expectation failure.
  127.          * @param predicate Expectation predicate.
  128.          * @return The builder instance.
  129.          */
  130.         @Nonnull
  131.         public Builder<M, E> expect(@Nonnull String text,
  132.                                     @Nonnull Predicate<M> predicate) {
  133.             builder.expect(new MessageValidation.PredicateExpectation<>(predicate, text));
  134.             return this;
  135.         }

  137.         /**
  138.          * Given the field and type descriptor (which must match the field type),
  139.          * build an inner validator to check the value of the field.
  140.          *
  141.          * @param field           The field to check.
  142.          * @param descriptor      The message descriptor matching the field.
  143.          * @param builderConsumer Consumer to configure the inner validator.
  144.          * @param <M2>            The inner message type.
  145.          * @return The builder instance.
  146.          */
  147.         @Nonnull
  148.         public <M2 extends PMessage<M2>>
  149.         Builder<M, E> expect(@Nonnull PField<M> field,
  150.                              @Nonnull PMessageDescriptor<M2> descriptor,
  151.                              @Nonnull Consumer<Builder<M2, E>> builderConsumer) {
  152.             builder.expectIfPresent(field, descriptor, b2 -> {
  153.                 builderConsumer.accept(new Builder<>(b2));
  154.             });
  155.             return this;
  156.         }

  158.         /**
  159.          * Expect the message to be non-null value.
  160.          *
  161.          * @return The builder instance.
  162.          */
  163.         @Nonnull
  164.         public Builder<M, E> expectNotNull() {
  165.             builder.expectNotNull();
  166.             return this;
  167.         }

  169.         /**
  170.          * Expect the message to be non-null value.
  171.          *
  172.          * @param text The failure message on null value.
  173.          * @return The builder instance.
  174.          */
  175.         @Nonnull
  176.         public Builder<M, E> expectNotNull(@Nonnull String text) {
  177.             builder.expectNotNull();
  178.             return this;
  179.         }

  181.         /**
  182.          * Expect field to be present on message.
  183.          *
  184.          * @param fields The fields to be present.
  185.          * @return The builder instance.
  186.          */
  187.         @Nonnull
  188.         @SafeVarargs
  189.         public final Builder<M, E> expectPresent(@Nonnull PField<M>... fields) {
  190.             builder.expectPresent(fields);
  191.             return this;
  192.         }

  194.         /**
  195.          * Expect field to be present on message.
  196.          *
  197.          * @param text  The failure message on missing field.
  198.          * @param field The field to be present.
  199.          * @return The builder instance.
  200.          */
  201.         @Nonnull
  202.         public Builder<M, E> expectPresent(@Nonnull String text, @Nonnull PField<M> field) {
  203.             builder.expect(new MessageValidation.PredicateExpectation<>(message -> message.has(field), text));
  204.             return this;
  205.         }

  207.         /**
  208.          * Expect field to be present on message.
  209.          *
  210.          * @param fields The fields to be present.
  211.          * @return The builder instance.
  212.          */
  213.         @Nonnull
  214.         @SafeVarargs
  215.         public final Builder<M, E> expectMissing(@Nonnull PField<M>... fields) {
  216.             builder.expectMissing(fields);
  217.             return this;
  218.         }

  220.         /**
  221.          * Expect field to be present on message.
  222.          *
  223.          * @param text  The failure message on present field.
  224.          * @param field The field to be present.
  225.          * @return The builder instance.
  226.          */
  227.         @Nonnull
  228.         public Builder<M, E> expectMissing(@Nonnull String text, @Nonnull PField<M> field) {
  229.             builder.expect(new MessageValidation.PredicateExpectation<>(message -> !message.has(field), text));
  230.             return this;
  231.         }

  233.         private Builder(PMessageDescriptor<M> descriptor, @Nonnull Function<String, E> onMismatch) {
  234.             builder = MessageValidation.builder(descriptor, e -> onMismatch.apply(e.getMessage()));
  235.         }
  236.         private Builder(MessageValidation.Builder<M, E> builder) {
  237.             this.builder = builder;
  238.         }

  240.         private final MessageValidation.Builder<M, E> builder;
  241.     }

  243.     private MessageValidator(Builder<M, E> builder) {
  244.         validation = builder.builder.build();
  245.     }
  246. }
Created with JaCoCo 0.8.5.201910111838