import static com.google.common.base.Preconditions.checkArgument;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
+import java.io.Serial;
import java.util.Optional;
/**
* YangNumberExprs.
*
* @param <N> Type of YangNumberExpr
- * @author Robert Varga
*/
-@Beta
public abstract class AbstractYangXPathMathSupport<N extends YangNumberExpr> implements YangXPathMathSupport {
+ @Serial
private static final long serialVersionUID = 1L;
private final Class<N> numberClass;
*/
protected abstract YangExpr doEvaluate(YangBinaryOperator operator, N left, N right);
+ @Serial
protected abstract Object readResolve();
}
import static java.util.Objects.requireNonNull;
+import java.io.Serial;
import java.math.BigDecimal;
import org.eclipse.jdt.annotation.Nullable;
final class BigDecimalNumberExpr extends YangNumberExpr {
+ @Serial
private static final long serialVersionUID = 1L;
private final BigDecimal number;
*/
package org.opendaylight.yangtools.yang.xpath.api;
+import java.io.Serial;
import java.math.BigDecimal;
final class BigDecimalXPathMathSupport extends AbstractYangXPathMathSupport<BigDecimalNumberExpr> {
static final BigDecimalXPathMathSupport INSTANCE = new BigDecimalXPathMathSupport();
+ @Serial
private static final long serialVersionUID = 1L;
private static final BigDecimalNumberExpr ZERO = BigDecimalNumberExpr.of(BigDecimal.ZERO);
private static final BigDecimalNumberExpr ONE = BigDecimalNumberExpr.of(BigDecimal.ONE);
@Override
public BigDecimalNumberExpr createNumber(final String str) {
- switch (str) {
- case "0":
- return ZERO;
- case "1":
- return ONE;
- case "10":
- return TEN;
- default:
- return BigDecimalNumberExpr.of(new BigDecimal(str));
- }
+ return switch (str) {
+ case "0" -> ZERO;
+ case "1" -> ONE;
+ case "10" -> TEN;
+ default -> BigDecimalNumberExpr.of(new BigDecimal(str));
+ };
}
@Override
public BigDecimalNumberExpr createNumber(final int value) {
- switch (value) {
- case 0:
- return ZERO;
- case 1:
- return ONE;
- case 10:
- return TEN;
- default:
- return BigDecimalNumberExpr.of(BigDecimal.valueOf(value));
- }
+ return switch (value) {
+ case 0 -> ZERO;
+ case 1 -> ONE;
+ case 10 -> TEN;
+ default -> BigDecimalNumberExpr.of(BigDecimal.valueOf(value));
+ };
}
@Override
@Override
protected YangExpr doEvaluate(final YangBinaryOperator operator, final BigDecimalNumberExpr left,
final BigDecimalNumberExpr right) {
- final BigDecimal l = left.getNumber();
- final BigDecimal r = right.getNumber();
+ final var l = left.getNumber();
+ final var r = right.getNumber();
return switch (operator) {
case DIV -> BigDecimalNumberExpr.of(l.divide(r));
*/
package org.opendaylight.yangtools.yang.xpath.api;
+import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
final class DoubleNumberExpr extends YangNumberExpr {
+ @Serial
private static final long serialVersionUID = 1L;
private final double value;
@Override
public boolean equals(final @Nullable Object obj) {
- return this == obj || obj instanceof DoubleNumberExpr && bitEqual(((DoubleNumberExpr) obj).value);
+ return this == obj || obj instanceof DoubleNumberExpr other && bitEqual(other.value);
}
private boolean bitEqual(final double other) {
*/
package org.opendaylight.yangtools.yang.xpath.api;
+import java.io.Serial;
+
final class DoubleXPathMathSupport extends AbstractYangXPathMathSupport<DoubleNumberExpr> {
static final DoubleXPathMathSupport INSTANCE = new DoubleXPathMathSupport();
+ @Serial
private static final long serialVersionUID = 1L;
private DoubleXPathMathSupport() {
@Override
protected YangExpr doEvaluate(final YangBinaryOperator operator, final DoubleNumberExpr left,
final DoubleNumberExpr right) {
- final double l = left.getValue();
- final double r = right.getValue();
+ final var l = left.getValue();
+ final var r = right.getValue();
return switch (operator) {
case DIV -> DoubleNumberExpr.of(l / r);
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.AbstractQName;
/**
* An object referencing a QName, either resolved or unresolved.
- *
- * @author Robert Varga
*/
-@Beta
-public interface QNameReferent extends Immutable {
+public sealed interface QNameReferent extends Immutable
+ permits ResolvedQNameReferent, UnresolvedQNameReferent, YangQNameExpr, YangLocationPath.QNameStep {
/**
* Return the referenced {@link AbstractQName}.
*
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.common.QName;
/**
* A {@link QNameReferent} referencing a resolved QName.
- *
- * @author Robert Varga
*/
-@Beta
-public interface ResolvedQNameReferent extends QNameReferent {
+public non-sealed interface ResolvedQNameReferent extends QNameReferent {
/**
* Return the referenced QName.
*
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.common.UnresolvedQName;
/**
* A {@link QNameReferent} referencing an unresolved QName.
- *
- * @author Robert Varga
*/
-@Beta
-public interface UnresolvedQNameReferent extends QNameReferent {
+public non-sealed interface UnresolvedQNameReferent extends QNameReferent {
@Override
UnresolvedQName getQName();
}
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
+import java.io.Serial;
import java.util.Objects;
import org.eclipse.jdt.annotation.Nullable;
/**
* A binary expression formed of a {@link #getLeftExpr()}, an {@link #getOperator()} and a {@link #getRightExpr()}.
- *
- * @author Robert Varga
*/
-@Beta
public abstract sealed class YangBinaryExpr implements YangExpr permits YangBinaryOperator.Expr {
+ @Serial
private static final long serialVersionUID = 1L;
private final YangExpr leftExpr;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.io.Serial;
/**
* YANG XPath binary operator.
- *
- * @author Robert Varga
*/
-@Beta
public enum YangBinaryOperator {
/**
* Operands are equal.
@SuppressFBWarnings(value = "SE_INNER_CLASS", justification = "Outer class is a retained enumeration")
final class Expr extends YangBinaryExpr {
+ @Serial
private static final long serialVersionUID = 1L;
Expr(final YangExpr leftExpr, final YangExpr rightExpr) {
this.str = requireNonNull(str);
}
+ public YangBinaryExpr exprWith(final YangExpr leftExpr, final YangExpr rightExpr) {
+ return new Expr(leftExpr, rightExpr);
+ }
+
@Override
public String toString() {
return str;
}
-
- public YangBinaryExpr exprWith(final YangExpr leftExpr, final YangExpr rightExpr) {
- return new Expr(leftExpr, rightExpr);
- }
}
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
* <p>
* They also map these functions' names to the constant pool under their {@link YangFunctionCallExpr#getName()}
* identity. All users should use these constants in favor of their equivalent function calls.
- *
- * @author Robert Varga
*/
-@Beta
public enum YangBooleanConstantExpr implements YangConstantExpr<Boolean> {
/**
* A constant {@code false} expression.
}
public static Optional<YangFunctionCallExpr> forFunctionName(final String functionName) {
- switch (functionName) {
- case "false":
- return Optional.of(FALSE.function);
- case "true":
- return Optional.of(TRUE.function);
- default:
- return Optional.empty();
- }
+ return switch (functionName) {
+ case "false" -> Optional.of(FALSE.function);
+ case "true" -> Optional.of(TRUE.function);
+ default -> Optional.empty();
+ };
}
}
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
/**
* Common interface for all YANG XPath constant expressions. Each constant has a unique {@link QName}, which acts as its
* globally-unique identifier.
- *
- * @author Robert Varga
*/
-@Beta
public sealed interface YangConstantExpr<T> extends YangExpr, Identifiable<QName> permits YangBooleanConstantExpr {
/**
* Return this constant's value.
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import java.io.Serializable;
import org.opendaylight.yangtools.concepts.Immutable;
/**
* Common base interface for all YANG Expression components.
- *
- * @author Robert Varga
*/
-@Beta
public sealed interface YangExpr extends Immutable, Serializable
permits YangBinaryExpr,
YangConstantExpr,
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
+import java.io.Serial;
import java.util.Arrays;
import java.util.Collection;
import java.util.Objects;
import java.util.Set;
import org.eclipse.jdt.annotation.Nullable;
-@Beta
public sealed class YangFilterExpr implements YangExpr, YangPredicateAware {
private static final class WithPredicates extends YangFilterExpr {
private static final long serialVersionUID = 1L;
}
}
+ @Serial
private static final long serialVersionUID = 1L;
private final YangExpr expr;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.YangConstants;
*
* @author Robert Varga
*/
-@Beta
public enum YangFunction implements Identifiable<QName> {
// XPath 1.0 functions
BOOLEAN("boolean"),
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
-import java.util.Iterator;
+import java.io.Serial;
import java.util.List;
import java.util.Objects;
import org.eclipse.jdt.annotation.Nullable;
/**
* Function call invocation. Function names without a prefix are mapped into {@link YangConstants#RFC6020_YIN_MODULE},
* as they are required to be mapped into YANG as per RFC7950 definitions.
- *
- * @author Robert Varga
*/
-@Beta
public sealed class YangFunctionCallExpr implements YangExpr {
private static final class WithArgs extends YangFunctionCallExpr {
private static final long serialVersionUID = 1L;
}
}
+ @Serial
private static final long serialVersionUID = 1L;
private final QName name;
@Override
public final String toString() {
- final StringBuilder sb = new StringBuilder().append(getName()).append('(');
- final Iterator<YangExpr> it = getArguments().iterator();
+ final var sb = new StringBuilder().append(getName()).append('(');
+ final var it = getArguments().iterator();
if (it.hasNext()) {
sb.append(it.next());
while (it.hasNext()) {
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
+import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
/**
*
* <p>
* A more type-safe alternative is {@link YangQNameExpr}, which should be preferred and used whenever possible.
- *
- * @author Robert Varga
*/
-@Beta
public final class YangLiteralExpr implements YangExpr {
+ @Serial
private static final long serialVersionUID = 1L;
private static final YangLiteralExpr EMPTY = new YangLiteralExpr("");
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
import com.google.common.collect.ImmutableList;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.UnresolvedQName;
-@Beta
public abstract sealed class YangLocationPath implements YangExpr {
public abstract static sealed class Step implements Serializable, YangPredicateAware {
private static final long serialVersionUID = 1L;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableSet;
+import java.io.Serial;
import java.util.Objects;
import java.util.Set;
import org.eclipse.jdt.annotation.Nullable;
/**
* A {@link YangExpr} combining a {@link YangNaryOperator} with a set of expressions.
*/
-@Beta
public final class YangNaryExpr implements YangExpr {
+ @Serial
private static final long serialVersionUID = 1L;
private final YangNaryOperator operator;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
/**
- * YANG XPath binary operator.
- *
- * @author Robert Varga
+ * YANG XPath n-ary operator.
*/
-@Beta
public enum YangNaryOperator {
/**
* Logical 'and' operator on operands.
}
public YangExpr exprWith(final Collection<YangExpr> exprs) {
- final ImmutableSet<YangExpr> set = ImmutableSet.copyOf(exprs);
+ final var set = ImmutableSet.copyOf(exprs);
return set.size() == 1 ? set.iterator().next() : new YangNaryExpr(this, set);
}
}
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
+import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
-@Beta
public final class YangNegateExpr implements YangExpr {
+ @Serial
private static final long serialVersionUID = 1L;
private final YangExpr subExpr;
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
+import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
/**
* A number-bearing expression.
*/
-@Beta
public abstract sealed class YangNumberExpr implements YangExpr permits BigDecimalNumberExpr, DoubleNumberExpr {
+ @Serial
private static final long serialVersionUID = 1L;
public abstract Number getNumber();
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
+import java.io.Serial;
import java.util.Objects;
import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.Relative;
-@Beta
public sealed class YangPathExpr implements YangExpr {
private static final class WithLocation extends YangPathExpr {
+ @Serial
private static final long serialVersionUID = 1L;
private final Relative locationPath;
}
}
+ @Serial
private static final long serialVersionUID = 1L;
private final YangExpr filterExpr;
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import java.util.Set;
import org.opendaylight.yangtools.yang.xpath.api.YangLocationPath.Step;
/**
* Common interface for {@link YangFilterExpr} and {@link Step}, both of which can contain predicates. Predicates are
* expressed in terms of {@link YangExpr}.
- *
- * @author Robert Varga
*/
-@Beta
public interface YangPredicateAware {
default Set<YangExpr> getPredicates() {
return ImmutableSet.of();
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
+import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.UnresolvedQName;
* Parsers and users of this package are encouraged to use this class in place of {@link YangLiteralExpr} where
* appropriate, as it retains type safety and more semantic context.
*
- * @author Robert Varga
*/
-@Beta
public abstract sealed class YangQNameExpr implements YangExpr, QNameReferent {
public static final class Resolved extends YangQNameExpr implements ResolvedQNameReferent {
+ @Serial
private static final long serialVersionUID = 1L;
private final QName qname;
}
public static final class Unresolved extends YangQNameExpr implements UnresolvedQNameReferent {
+ @Serial
private static final long serialVersionUID = 1L;
private final UnresolvedQName qname;
}
}
+ @Serial
private static final long serialVersionUID = 1L;
public static Unresolved of(final UnresolvedQName qname) {
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
+import java.io.Serial;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
-@Beta
public final class YangVariableReferenceExpr implements YangExpr {
+ @Serial
private static final long serialVersionUID = 1L;
private final QName variableName;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import org.opendaylight.yangtools.yang.common.QName;
/**
* XPath evaluation axis, as defined in <a href="https://www.w3.org/TR/1999/REC-xpath-19991116/#axes">XPath 1.0</a>.
- *
- * @author Robert Varga
*/
-@Beta
public enum YangXPathAxis {
/**
* The {@code child} axis.
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import javax.xml.xpath.XPathExpressionException;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
* object model.
* </li>
* </ul>
- *
- * @author Robert Varga
*/
-@Beta
public interface YangXPathExpression extends Immutable {
/**
* A Qualified-bound expression. All {@link Qualified}s are eliminated and replaced with {@link QName}s.
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
-
/**
* {@link YangXPathParser} number compliance knobs. This enumeration defines what assumptions the parser can make --
* affecting its optimization properties around
* <a href="https://en.wikipedia.org/wiki/Constant_folding">constant folding</a> when number expressions are
* involved.
*/
-@Beta
public enum YangXPathMathMode {
/**
* All number expressions are treated as {@code double}. This in spirit of XPath 1.0 -- any number expression
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import java.io.Serializable;
import java.util.Optional;
/**
* Interface supporting mathematical operations. This interface should be implemented by subclassing
* {@link AbstractYangXPathMathSupport}, which provides type safety guards.
- *
- * @author Robert Varga
*/
-@Beta
public interface YangXPathMathSupport extends Serializable {
/**
* Create a {@link YangNumberExpr} backed by specified string.
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
-
/**
* XPath node type as defined in <a href="https://www.w3.org/TR/1999/REC-xpath-19991116/#NT-NodeType">XPath 1.0</a>.
- *
- * @author Robert Varga
*/
-@Beta
public enum YangXPathNodeType {
/**
* A {@code comment}.
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import javax.xml.xpath.XPathExpressionException;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
/**
* Interface for converting a String into a {@link YangXPathExpression}. Implementations of this interface are expected
* to be NOT thread-safe.
- *
- * @author Robert Varga
*/
-@Beta
public interface YangXPathParser {
/**
* A {@link YangXPathParser} bound to a {@link YangNamespaceContext}, producing Qualified-bound Expressions.
*
* @param xpath XPath expression string
* @return A parsed {@link YangXPathExpression}
- * @throws NullPointerException if {@code xpath} is null
+ * @throws NullPointerException if {@code xpath} is {@code null}
* @throws XPathExpressionException when the expression cannot be parsed
*/
YangXPathExpression parseExpression(String xpath) throws XPathExpressionException;
*/
package org.opendaylight.yangtools.yang.xpath.api;
-import com.google.common.annotations.Beta;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.YangNamespaceContext;
*
* @author Robert Varga
*/
-@Beta
public interface YangXPathParserFactory {
/**
* Return a {@link YangXPathParser} compliant with {@link YangXPathMathMode#IEEE754}. Returned parser will not
*
* @param mathMode Requested XPath number compliance
* @return An XPathParser
- * @throws NullPointerException if {@code mathMode} is null
+ * @throws NullPointerException if {@code mathMode} is {code null}
*/
YangXPathParser newParser(YangXPathMathMode mathMode);
*
* @param namespaceContext Prefix-to-namespace resolver, used to bind qualified node identifiers
* @return An XPathParser
- * @throws NullPointerException if {@code namespaceContext} is null
+ * @throws NullPointerException if {@code namespaceContext} is {code null}
*/
default YangXPathParser.QualifiedBound newParser(final YangNamespaceContext namespaceContext) {
return newParser(YangXPathMathMode.IEEE754, namespaceContext);
* @param mathMode Requested XPath number compliance
* @param namespaceContext Prefix-to-namespace resolver, used to bind qualified node identifiers
* @return An XPathParser
- * @throws NullPointerException if any argument is null
+ * @throws NullPointerException if any argument is {code null}
*/
YangXPathParser.QualifiedBound newParser(YangXPathMathMode mathMode, YangNamespaceContext namespaceContext);
* @param namespaceContext Prefix-to-namespace resolver, used to bind qualified node identifiers
* @param defaultNamespace Default namespace, used to bind unqualified node identifiers
* @return An XPathParser
- * @throws NullPointerException if any argument is null
+ * @throws NullPointerException if any argument is {code null}
*/
default YangXPathParser.UnqualifiedBound newParser(final YangNamespaceContext namespaceContext,
final QNameModule defaultNamespace) {
* @param namespaceContext Prefix-to-namespace resolver, used to bind qualified node identifiers
* @param defaultNamespace Default namespace, used to bind unqualified node identifiers
* @return An XPathParser
- * @throws NullPointerException if any argument is null
+ * @throws NullPointerException if any argument is {code null}
*/
YangXPathParser.UnqualifiedBound newParser(YangXPathMathMode mathMode, YangNamespaceContext namespaceContext,
QNameModule defaultNamespace);
Code Review / yangtools.git / commitdiff