model/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/ElementCountConstraint.java

   1 /*
   2  * Copyright (c) 2013 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 package org.opendaylight.yangtools.yang.model.api;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11
  12 import com.google.common.annotations.Beta;
  13 import com.google.common.base.MoreObjects;
  14 import java.util.Objects;
  15 import java.util.Optional;
  16 import org.eclipse.jdt.annotation.NonNull;
  17 import org.eclipse.jdt.annotation.Nullable;
  18
  19 /**
  20  * Contains method which returns various data constraints for a list-like YANG element
  21  * (e.g. min or max number of elements).
  22  */
  23 @Beta
  24 public abstract class ElementCountConstraint {
  25     private static final class Min extends ElementCountConstraint {
  26         private final int minElements;
  27
  28         Min(final int minElements) {
  29             checkArgument(minElements >= 0);
  30             this.minElements = minElements;
  31         }
  32
  33         @Override
  34         public Integer getMinElements() {
  35             return minElements;
  36         }
  37
  38         @Override
  39         public Integer getMaxElements() {
  40             return null;
  41         }
  42     }
  43
  44     private static final class Max extends ElementCountConstraint {
  45         private final int maxElements;
  46
  47         Max(final int maxElements) {
  48             checkArgument(maxElements >= 0);
  49             this.maxElements = maxElements;
  50         }
  51
  52         @Override
  53         public Integer getMinElements() {
  54             return null;
  55         }
  56
  57         @Override
  58         public Integer getMaxElements() {
  59             return maxElements;
  60         }
  61     }
  62
  63     private static final class MinMax extends ElementCountConstraint {
  64         private final int minElements;
  65         private final int maxElements;
  66
  67         MinMax(final int minElements, final int maxElements) {
  68             checkArgument(minElements >= 0);
  69             checkArgument(maxElements >= 0);
  70             checkArgument(minElements <= maxElements);
  71             this.minElements = minElements;
  72             this.maxElements = maxElements;
  73         }
  74
  75         @Override
  76         public Integer getMinElements() {
  77             return minElements;
  78         }
  79
  80         @Override
  81         public Integer getMaxElements() {
  82             return maxElements;
  83         }
  84     }
  85
  86     ElementCountConstraint() {
  87         // Hidden on purpose
  88     }
  89
  90     public static @NonNull ElementCountConstraint atLeast(final int minElements) {
  91         return new Min(minElements);
  92     }
  93
  94     public static @NonNull ElementCountConstraint atMost(final int maxElements) {
  95         return new Max(maxElements);
  96     }
  97
  98     public static @NonNull ElementCountConstraint inRange(final int minElements, final int maxElements) {
  99         return new MinMax(minElements, maxElements);
 100     }
 101
 102     public static @NonNull Optional<ElementCountConstraint> forNullable(final @Nullable Integer minElements,
 103             final @Nullable Integer maxElements) {
 104         if (minElements == null) {
 105             return maxElements != null ? Optional.of(new Max(maxElements)) : Optional.empty();
 106         }
 107
 108         return Optional.of(maxElements != null ? new MinMax(minElements, maxElements) : new Min(minElements));
 109     }
 110
 111     /**
 112      * Returns the minimum required number of data elements for node where this
 113      * constraint is specified.
 114      *
 115      * <p>
 116      * The returning value equals to value of the argument of the
 117      * <b>min-elements</b> YANG substatement.
 118      * It is used with YANG statements leaf-list, list, deviate.
 119      *
 120      * @return integer with minimal number of elements, or null if no minimum is defined
 121      */
 122     public abstract @Nullable Integer getMinElements();
 123
 124     /**
 125      * Returns the maximum admissible number of data elements for node where
 126      * this constraint is specified.
 127      *
 128      * <p>
 129      * The returning value equals to value of the argument of the
 130      * <b>max-elements</b> YANG substatement.
 131      * It is used with YANG statements leaf-list, list, deviate.
 132      *
 133      * @return integer with maximum number of elements, or null if no maximum is defined
 134      */
 135     public abstract @Nullable Integer getMaxElements();
 136
 137     @Override
 138     public final int hashCode() {
 139         return Objects.hash(getMinElements(), getMaxElements());
 140     }
 141
 142     @Override
 143     public final boolean equals(final Object obj) {
 144         if (this == obj) {
 145             return true;
 146         }
 147         if (!(obj instanceof ElementCountConstraint)) {
 148             return false;
 149         }
 150         final ElementCountConstraint other = (ElementCountConstraint) obj;
 151         return Objects.equals(getMinElements(), other.getMinElements())
 152                 && Objects.equals(getMaxElements(), other.getMaxElements());
 153     }
 154
 155     @Override
 156     public final String toString() {
 157         return MoreObjects.toStringHelper(ElementCountConstraint.class).omitNullValues()
 158                 .add("minElements", getMinElements())
 159                 .add("maxElements", getMaxElements()).toString();
 160     }
 161 }