dom/mdsal-dom-api/src/main/java/org/opendaylight/mdsal/dom/api/query/DOMQueryPredicate.java

   1 /*
   2  * Copyright (c) 2020 PANTHEON.tech, s.r.o. 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.mdsal.dom.api.query;
   9
  10 import static java.util.Objects.requireNonNull;
  11
  12 import com.google.common.annotations.Beta;
  13 import com.google.common.base.MoreObjects;
  14 import com.google.common.base.MoreObjects.ToStringHelper;
  15 import java.util.function.Predicate;
  16 import java.util.regex.Pattern;
  17 import org.eclipse.jdt.annotation.NonNull;
  18 import org.eclipse.jdt.annotation.Nullable;
  19 import org.opendaylight.yangtools.concepts.Immutable;
  20 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  21 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  22 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  23
  24 @Beta
  25 public abstract class DOMQueryPredicate implements Immutable, Predicate<NormalizedNode<?, ?>> {
  26     abstract static class AbstractLeafDOMQueryPredicate extends DOMQueryPredicate {
  27         AbstractLeafDOMQueryPredicate(final YangInstanceIdentifier relativePath) {
  28             super(relativePath);
  29         }
  30
  31         @Override
  32         public final boolean test(final NormalizedNode<?, ?> data) {
  33             return testValue(data instanceof LeafNode ? ((LeafNode<?>) data).getValue() : null);
  34         }
  35
  36         abstract boolean testValue(Object data);
  37     }
  38
  39     abstract static class AbstractValueDOMQueryPredicate<T> extends AbstractLeafDOMQueryPredicate {
  40         private final @NonNull T value;
  41
  42         AbstractValueDOMQueryPredicate(final YangInstanceIdentifier relativePath, final T value) {
  43             super(relativePath);
  44             this.value = requireNonNull(value);
  45         }
  46
  47         final @NonNull T value() {
  48             return value;
  49         }
  50
  51         @Override
  52         ToStringHelper addToStringAttributes(final ToStringHelper helper) {
  53             return helper.add("value", value);
  54         }
  55     }
  56
  57     abstract static class AbstractComparableDOMQueryPredicate<T extends Comparable<T>>
  58             extends AbstractValueDOMQueryPredicate<T> {
  59         AbstractComparableDOMQueryPredicate(final YangInstanceIdentifier relativePath, final T value) {
  60             super(relativePath, value);
  61         }
  62
  63         @Override
  64         @SuppressWarnings("unchecked")
  65         public final boolean testValue(final Object data) {
  66             return data != null && test(value().compareTo((T) data));
  67         }
  68
  69         abstract boolean test(int valueToData);
  70     }
  71
  72     abstract static class AbstractStringDOMQueryPredicate extends AbstractValueDOMQueryPredicate<String> {
  73         AbstractStringDOMQueryPredicate(final YangInstanceIdentifier relativePath, final String value) {
  74             super(relativePath, value);
  75         }
  76
  77         @Override
  78         public final boolean testValue(final Object data) {
  79             return data instanceof String && test((String) data);
  80         }
  81
  82         abstract boolean test(@NonNull String str);
  83     }
  84
  85     public static final class Exists extends DOMQueryPredicate {
  86         public Exists(final YangInstanceIdentifier relativePath) {
  87             super(relativePath);
  88         }
  89
  90         @Override
  91         public boolean test(final NormalizedNode<?, ?> data) {
  92             return data != null;
  93         }
  94     }
  95
  96     public static final class NotExists extends DOMQueryPredicate {
  97         public NotExists(final YangInstanceIdentifier relativePath) {
  98             super(relativePath);
  99         }
 100
 101         @Override
 102         public boolean test(final NormalizedNode<?, ?> data) {
 103             return data == null;
 104         }
 105     }
 106
 107     public static final class ValueEquals<T> extends AbstractValueDOMQueryPredicate<T> {
 108         public ValueEquals(final YangInstanceIdentifier relativePath, final T value) {
 109             super(relativePath, value);
 110         }
 111
 112         @Override
 113         public boolean testValue(final Object data) {
 114             return value().equals(data);
 115         }
 116     }
 117
 118     public static final class GreaterThan<T extends Comparable<T>> extends AbstractComparableDOMQueryPredicate<T> {
 119         public GreaterThan(final YangInstanceIdentifier relativePath, final T value) {
 120             super(relativePath, value);
 121         }
 122
 123         @Override
 124         boolean test(final int valueToData) {
 125             return valueToData <= 0;
 126         }
 127     }
 128
 129     public static final class GreaterThanOrEqual<T extends Comparable<T>>
 130             extends AbstractComparableDOMQueryPredicate<T> {
 131         public GreaterThanOrEqual(final YangInstanceIdentifier relativePath, final T value) {
 132             super(relativePath, value);
 133         }
 134
 135         @Override
 136         boolean test(final int valueToData) {
 137             return valueToData < 0;
 138         }
 139     }
 140
 141     public static final class LessThan<T extends Comparable<T>> extends AbstractComparableDOMQueryPredicate<T> {
 142         public LessThan(final YangInstanceIdentifier relativePath, final T value) {
 143             super(relativePath, value);
 144         }
 145
 146         @Override
 147         boolean test(final int valueToData) {
 148             return valueToData >= 0;
 149         }
 150     }
 151
 152     public static final class LessThanOrEqual<T extends Comparable<T>> extends AbstractComparableDOMQueryPredicate<T> {
 153         public LessThanOrEqual(final YangInstanceIdentifier relativePath, final T value) {
 154             super(relativePath, value);
 155         }
 156
 157         @Override
 158         boolean test(final int valueToData) {
 159             return valueToData > 0;
 160         }
 161     }
 162
 163     public static final class StartsWith extends AbstractStringDOMQueryPredicate {
 164         public StartsWith(final YangInstanceIdentifier relativePath, final String str) {
 165             super(relativePath, str);
 166         }
 167
 168         @Override
 169         boolean test(final String str) {
 170             return str.startsWith(value());
 171         }
 172     }
 173
 174     public static final class EndsWith extends AbstractStringDOMQueryPredicate {
 175         public EndsWith(final YangInstanceIdentifier relativePath, final String str) {
 176             super(relativePath, str);
 177         }
 178
 179         @Override
 180         boolean test(final String str) {
 181             return str.endsWith(value());
 182         }
 183     }
 184
 185     public static final class Contains extends AbstractStringDOMQueryPredicate {
 186         public Contains(final YangInstanceIdentifier relativePath, final String str) {
 187             super(relativePath, str);
 188         }
 189
 190         @Override
 191         boolean test(final String str) {
 192             return str.contains(value());
 193         }
 194     }
 195
 196     public static final class MatchesPattern extends AbstractLeafDOMQueryPredicate {
 197         private final Pattern pattern;
 198
 199         public MatchesPattern(final YangInstanceIdentifier relativePath, final Pattern pattern) {
 200             super(relativePath);
 201             this.pattern = requireNonNull(pattern);
 202         }
 203
 204         @Override
 205         public boolean testValue(final Object data) {
 206             return data instanceof CharSequence && pattern.matcher((CharSequence) data).matches();
 207         }
 208
 209         @Override
 210         ToStringHelper addToStringAttributes(final ToStringHelper helper) {
 211             return helper.add("pattern", pattern);
 212         }
 213     }
 214
 215     private final @NonNull YangInstanceIdentifier relativePath;
 216
 217     DOMQueryPredicate(final YangInstanceIdentifier relativePath) {
 218         this.relativePath = requireNonNull(relativePath);
 219     }
 220
 221     public final @NonNull YangInstanceIdentifier getPath() {
 222         return relativePath;
 223     }
 224
 225     @Override
 226     public abstract boolean test(@Nullable NormalizedNode<?, ?> data);
 227
 228     @Override
 229     public String toString() {
 230         return addToStringAttributes(MoreObjects.toStringHelper(this).add("path", relativePath)).toString();
 231     }
 232
 233     ToStringHelper addToStringAttributes(final ToStringHelper helper) {
 234         return helper;
 235     }
 236 }