yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/spi/SubstatementValidator.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.yangtools.yang.parser.spi;
  10
  11 import com.google.common.base.Preconditions;
  12 import com.google.common.collect.ImmutableMap;
  13 import com.google.common.collect.Iterables;
  14 import com.google.common.collect.Maps;
  15 import java.util.HashMap;
  16 import java.util.Map;
  17 import java.util.Map.Entry;
  18 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  19 import org.opendaylight.yangtools.yang.parser.spi.meta.InvalidSubstatementException;
  20 import org.opendaylight.yangtools.yang.parser.spi.meta.MissingSubstatementException;
  21 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  22 import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
  23
  24 public final class SubstatementValidator {
  25     /**
  26      * @deprecated Deprecated since version 1.1.0. Use {@link Builder#addAny(StatementDefinition)},
  27      *             {@link Builder#addAtLeast(StatementDefinition, int)},
  28      *             {@link Builder#addMandatory(StatementDefinition)}, or
  29      *             {@link Builder#addMultiple(StatementDefinition)} instead.
  30      */
  31     @Deprecated
  32     public final static int MAX = Integer.MAX_VALUE;
  33
  34     private final Map<StatementDefinition, Cardinality> cardinalityMap;
  35     private final Map<StatementDefinition, Cardinality> mandatoryStatements;
  36     private final StatementDefinition currentStatement;
  37
  38     private SubstatementValidator(final Builder builder) {
  39         this.cardinalityMap = builder.cardinalityMap.build();
  40         this.currentStatement = builder.currentStatement;
  41         this.mandatoryStatements = ImmutableMap.copyOf(Maps.filterValues(cardinalityMap, c -> c.getMin() > 0));
  42     }
  43
  44     public static Builder builder(final StatementDefinition currentStatement) {
  45         return new Builder(currentStatement);
  46     }
  47
  48     public static class Builder {
  49         private static final Cardinality ONE_MAX = new Cardinality(1, Integer.MAX_VALUE);
  50         private static final Cardinality ONE_ONE = new Cardinality(1, 1);
  51         private static final Cardinality ZERO_MAX = new Cardinality(0, Integer.MAX_VALUE);
  52         private static final Cardinality ZERO_ONE = new Cardinality(0, 1);
  53
  54         private final ImmutableMap.Builder<StatementDefinition, Cardinality> cardinalityMap = ImmutableMap.builder();
  55         private final StatementDefinition currentStatement;
  56
  57         private Builder(final StatementDefinition currentStatement) {
  58             this.currentStatement = currentStatement;
  59         }
  60
  61         private Builder add(final StatementDefinition d, final Cardinality c) {
  62             cardinalityMap.put(d, c);
  63             return this;
  64         }
  65
  66         public Builder add(final StatementDefinition d, final int min, final int max) {
  67             if (max == Integer.MAX_VALUE) {
  68                 return addAtLeast(d, min);
  69             } else if (min == 0) {
  70                 return addAtMost(d, max);
  71             } else {
  72                 return add(d, new Cardinality(min, max));
  73             }
  74         }
  75
  76         // Equivalent to min .. Integer.MAX_VALUE
  77         public Builder addAtLeast(final StatementDefinition d, final int min) {
  78             switch (min) {
  79                 case 0:
  80                     return addAny(d);
  81                 case 1:
  82                     return addMultiple(d);
  83                 default:
  84                     return add(d, new Cardinality(min, Integer.MAX_VALUE));
  85             }
  86         }
  87
  88         // Equivalent to 0 .. max
  89         public Builder addAtMost(final StatementDefinition d, final int max) {
  90             return max == Integer.MAX_VALUE ? addAny(d) : add(d, new Cardinality(0, max));
  91         }
  92
  93         // Equivalent to 0 .. Integer.MAX_VALUE
  94         public Builder addAny(final StatementDefinition d) {
  95             return add(d, ZERO_MAX);
  96         }
  97
  98         // Equivalent to 1 .. 1
  99         public Builder addMandatory(final StatementDefinition d) {
 100             return add(d, ONE_ONE);
 101         }
 102
 103         // Equivalent to 1 .. MAX
 104         public Builder addMultiple(final StatementDefinition d) {
 105             return add(d, ONE_MAX);
 106         }
 107
 108         // Equivalent to 0 .. 1
 109         public Builder addOptional(final StatementDefinition d) {
 110             return add(d, ZERO_ONE);
 111         }
 112
 113         public SubstatementValidator build() {
 114             return new SubstatementValidator(this);
 115         }
 116     }
 117
 118     public void validate(final StmtContext<?, ?, ?> ctx) throws InvalidSubstatementException,
 119             MissingSubstatementException {
 120
 121         final Map<StatementDefinition, Counter> stmtCounts = new HashMap<>();
 122         for (StmtContext<?, ?, ?> stmtCtx : Iterables.concat(ctx.declaredSubstatements(), ctx.effectiveSubstatements())) {
 123             stmtCounts.computeIfAbsent(stmtCtx.getPublicDefinition(), key -> new Counter()).increment();
 124         }
 125
 126         // Mark all mandatory statements as not present. We are using a Map instead of a Set, as it provides us with
 127         // explicit value in case of failure (which is not important) and a more efficient instantiation performance
 128         // (which is important).
 129         final Map<StatementDefinition, Cardinality> missingMandatory = new HashMap<>(mandatoryStatements);
 130
 131         // Iterate over all statements
 132         for (Entry<StatementDefinition, Counter> entry : stmtCounts.entrySet()) {
 133             final StatementDefinition key = entry.getKey();
 134             final Cardinality cardinality = cardinalityMap.get(key);
 135             final int value = entry.getValue().getValue();
 136
 137             if (cardinality == null) {
 138                 if (ctx.getFromNamespace(ExtensionNamespace.class, key.getStatementName()) == null) {
 139                     throw new InvalidSubstatementException(ctx.getStatementSourceReference(),
 140                         "%s is not valid for %s. Error in module %s (%s)", key, currentStatement,
 141                         ctx.getRoot().getStatementArgument(),
 142                         ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot()));
 143                 }
 144
 145                 continue;
 146             }
 147
 148             if (cardinality.getMin() > 0) {
 149                 if (cardinality.getMin() > value) {
 150                     throw new InvalidSubstatementException(ctx.getStatementSourceReference(),
 151                         "Minimal count of %s for %s is %s, detected %s. Error in module %s (%s)", key, currentStatement,
 152                         cardinality.getMin(), value, ctx.getRoot().getStatementArgument(),
 153                         ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot()));
 154                 }
 155
 156                 // Encountered a mandatory statement, hence we are not missing it
 157                 missingMandatory.remove(key);
 158             }
 159             if (cardinality.getMax() < value) {
 160                 throw new InvalidSubstatementException(ctx.getStatementSourceReference(),
 161                     "Maximal count of %s for %s is %s, detected %s. Error in module %s (%s)", key, currentStatement,
 162                     cardinality.getMax(), value, ctx.getRoot().getStatementArgument(),
 163                     ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx.getRoot()));
 164             }
 165         }
 166
 167         // Check if there are any mandatory statements we have missed
 168         if (!missingMandatory.isEmpty()) {
 169             final Entry<StatementDefinition, Cardinality> e = missingMandatory.entrySet().iterator().next();
 170             final StmtContext<?, ?, ?> root = ctx.getRoot();
 171
 172             throw new MissingSubstatementException(ctx.getStatementSourceReference(),
 173                 "%s is missing %s. Minimal count is %s. Error in module %s (%s)", currentStatement, e.getKey(),
 174                 e.getValue().getMin(), root.getStatementArgument(), ctx.getFromNamespace(ModuleCtxToModuleQName.class,
 175                     root));
 176         }
 177     }
 178
 179     private static final class Cardinality {
 180         private final int min;
 181         private final int max;
 182
 183         private Cardinality(final int min, final int max) {
 184             Preconditions.checkArgument(min >= 0, "Min %s cannot be less than 0!");
 185             Preconditions.checkArgument(min <= max, "Min %s can not be greater than max %s!", min, max);
 186             this.min = min;
 187             this.max = max;
 188         }
 189
 190         private int getMax() {
 191             return max;
 192         }
 193
 194         private int getMin() {
 195             return min;
 196         }
 197     }
 198
 199     private static final class Counter {
 200         private int value;
 201
 202         void increment() {
 203             value++;
 204         }
 205
 206         int getValue() {
 207             return value;
 208         }
 209     }
 210 }