From: Robert Varga Date: Wed, 1 Jul 2020 16:52:56 +0000 (+0200) Subject: Refactor PatternConstraintImpl X-Git-Tag: v5.0.4~53 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=49936c5730224b5b5d396499ba56888ce30c3946;p=yangtools.git Refactor PatternConstraintImpl We have two distinct cases for the definition here, where the smaller does not have metadata, where as the full does have. This saves four fields in under-documented cases. Also mark Pattern(Effective)Statement for further refactor so we do not have to play weird tricks with constraints. JIRA: YANGTOOLS-1065 Change-Id: I6748ca7fefdb4b2a088324ff9bba821c131fe7ab Signed-off-by: Robert Varga --- diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java index 31af61d5c7..e5b49c4f19 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternEffectiveStatement.java @@ -14,6 +14,9 @@ import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; @Beta +// FIXME: 6.0.0: change the over definition of the argument: +// - argument = XSD pattern string +// - the statement *implements* PatternConstraint public interface PatternEffectiveStatement extends EffectiveStatement { @Override default StatementDefinition statementDefinition() { diff --git a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java index 7ce9bd73fb..3134184ebf 100644 --- a/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java +++ b/yang/yang-model-api/src/main/java/org/opendaylight/yangtools/yang/model/api/stmt/PatternStatement.java @@ -16,6 +16,8 @@ import org.opendaylight.yangtools.yang.model.api.YangStmtMapping; import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition; import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; +// FIXME: 6.0.0: change the over definition of the argument: +// - argument = XSD pattern string public interface PatternStatement extends ConstrainedDocumentedDeclaredStatement { @Override default StatementDefinition statementDefinition() { diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternConstraint.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternConstraint.java new file mode 100644 index 0000000000..540450387d --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternConstraint.java @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; + +import static java.util.Objects.requireNonNull; + +import com.google.common.base.MoreObjects; +import com.google.common.base.MoreObjects.ToStringHelper; +import java.util.Objects; +import java.util.Optional; +import org.eclipse.jdt.annotation.Nullable; +import org.opendaylight.yangtools.concepts.Immutable; +import org.opendaylight.yangtools.yang.model.api.type.ModifierKind; +import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; + +abstract class AbstractPatternConstraint implements PatternConstraint, Immutable { + private final String regEx; + private final String rawRegEx; + private final String errorAppTag; + + AbstractPatternConstraint(final String regex, final String rawRegex, final String errorAppTag) { + this.regEx = requireNonNull(regex, "regex must not be null"); + this.rawRegEx = requireNonNull(rawRegex, "raw regex must not be null"); + // FIXME: 6.0.0: explain this assignment + this.errorAppTag = errorAppTag != null ? errorAppTag : "invalid-regular-expression"; + } + + @Override + public final String getJavaPatternString() { + return regEx; + } + + @Override + public final String getRegularExpressionString() { + return rawRegEx; + } + + @Override + public final Optional getDescription() { + return Optional.ofNullable(description()); + } + + @Override + public final Optional getErrorAppTag() { + return Optional.of(errorAppTag); + } + + @Override + public final Optional getErrorMessage() { + return Optional.ofNullable(errorMessage()); + } + + @Override + public final Optional getModifier() { + return Optional.ofNullable(modifier()); + } + + @Override + public final Optional getReference() { + return Optional.ofNullable(reference()); + } + + @Override + public final int hashCode() { + return Objects.hash(description(), errorAppTag, errorMessage(), reference(), regEx, modifier()); + } + + @Override + public final boolean equals(final Object obj) { + if (this == obj) { + return true; + } + if (!(obj instanceof AbstractPatternConstraint)) { + return false; + } + final AbstractPatternConstraint other = (AbstractPatternConstraint) obj; + return Objects.equals(description(), other.description()) && Objects.equals(errorAppTag, other.errorAppTag) + && Objects.equals(errorMessage(), other.errorMessage()) + && Objects.equals(reference(), other.reference()) && Objects.equals(regEx, other.regEx) + && Objects.equals(modifier(), other.modifier()); + } + + @Override + public final String toString() { + return addToStringAttributes(MoreObjects.toStringHelper(this).omitNullValues()).toString(); + } + + abstract @Nullable String description(); + + abstract @Nullable String reference(); + + abstract @Nullable String errorMessage(); + + abstract @Nullable ModifierKind modifier(); + + ToStringHelper addToStringAttributes(final ToStringHelper helper) { + return helper.add("regex", regEx).add("errorAppTag", errorAppTag); + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java index 2c3b487039..ec4888cd62 100644 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/AbstractPatternStatementSupport.java @@ -47,7 +47,7 @@ abstract class AbstractPatternStatementSupport return null; } - return new PatternConstraintImpl(pattern, value); + return new EmptyPatternConstraint(pattern, value); } @Override @@ -78,7 +78,7 @@ abstract class AbstractPatternStatementSupport return new SimplePatternEffectiveStatement(declared, substatements); } - return new RegularPatternEffectiveStatement(declared, new PatternConstraintImpl(declared.argument(), + return new RegularPatternEffectiveStatement(declared, new RegularPatternConstraint(declared.argument(), description, reference, errorAppTag, errorMessage, modifier), substatements); } diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternConstraint.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternConstraint.java new file mode 100644 index 0000000000..6de6093eba --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/EmptyPatternConstraint.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; + +import org.opendaylight.yangtools.yang.model.api.type.ModifierKind; + +final class EmptyPatternConstraint extends AbstractPatternConstraint { + EmptyPatternConstraint(final String regex, final String rawRegex) { + super(regex, rawRegex, null); + } + + @Override + String description() { + return null; + } + + @Override + String reference() { + return null; + } + + @Override + String errorMessage() { + return null; + } + + @Override + ModifierKind modifier() { + return null; + } +} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java deleted file mode 100644 index 9020579d55..0000000000 --- a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/PatternConstraintImpl.java +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; - -import static java.util.Objects.requireNonNull; - -import com.google.common.base.MoreObjects; -import java.util.Objects; -import java.util.Optional; -import org.opendaylight.yangtools.concepts.Immutable; -import org.opendaylight.yangtools.yang.model.api.type.ModifierKind; -import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; - -final class PatternConstraintImpl implements PatternConstraint, Immutable { - private final String regEx; - private final String rawRegEx; - private final String description; - private final String reference; - private final String errorAppTag; - private final String errorMessage; - private final ModifierKind modifier; - - private PatternConstraintImpl(final String regex, final String rawRegex, final String description, - final String reference, final String errorAppTag, final String errorMessage, final ModifierKind modifier) { - this.regEx = requireNonNull(regex, "regex must not be null"); - this.rawRegEx = requireNonNull(rawRegex, "raw regex must not be null"); - this.description = description; - this.reference = reference; - this.errorAppTag = errorAppTag != null ? errorAppTag : "invalid-regular-expression"; - this.errorMessage = errorMessage; - this.modifier = modifier; - } - - PatternConstraintImpl(final String regex, final String rawRegex) { - this(regex, rawRegex, null, null, null, null, null); - } - - PatternConstraintImpl(final PatternConstraint original, final String description, final String reference, - final String errorAppTag, final String errorMessage, final ModifierKind modifier) { - this(original.getJavaPatternString(), original.getRegularExpressionString(), description, reference, - errorAppTag, errorMessage, modifier); - } - - @Override - public String getJavaPatternString() { - return regEx; - } - - @Override - public String getRegularExpressionString() { - return rawRegEx; - } - - @Override - public Optional getDescription() { - return Optional.ofNullable(description); - } - - @Override - public Optional getErrorAppTag() { - return Optional.ofNullable(errorAppTag); - } - - @Override - public Optional getErrorMessage() { - return Optional.ofNullable(errorMessage); - } - - @Override - public Optional getModifier() { - return Optional.ofNullable(modifier); - } - - @Override - public Optional getReference() { - return Optional.ofNullable(reference); - } - - @Override - public int hashCode() { - return Objects.hash(description, errorAppTag, errorMessage, reference, regEx, modifier); - } - - @Override - public boolean equals(final Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - final PatternConstraintImpl other = (PatternConstraintImpl) obj; - return Objects.equals(description, other.description) && Objects.equals(errorAppTag, other.errorAppTag) - && Objects.equals(errorMessage, other.errorMessage) && Objects.equals(reference, other.reference) - && Objects.equals(regEx, other.regEx) && Objects.equals(modifier, other.modifier); - } - - @Override - public String toString() { - return MoreObjects.toStringHelper(this).omitNullValues().add("regex", regEx).add("description", description) - .add("reference", reference).add("errorAppTag", errorAppTag).add("errorMessage", errorMessage) - .add("modifier", modifier).toString(); - } -} diff --git a/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternConstraint.java b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternConstraint.java new file mode 100644 index 0000000000..37fd860db1 --- /dev/null +++ b/yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/pattern/RegularPatternConstraint.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.pattern; + +import com.google.common.base.MoreObjects.ToStringHelper; +import org.opendaylight.yangtools.yang.model.api.type.ModifierKind; +import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint; + +final class RegularPatternConstraint extends AbstractPatternConstraint { + private final String description; + private final String reference; + private final String errorMessage; + private final ModifierKind modifier; + + RegularPatternConstraint(final PatternConstraint original, final String description, final String reference, + final String errorAppTag, final String errorMessage, final ModifierKind modifier) { + super(original.getJavaPatternString(), original.getRegularExpressionString(), errorAppTag); + this.description = description; + this.reference = reference; + this.errorMessage = errorMessage; + this.modifier = modifier; + } + + @Override + String description() { + return description; + } + + @Override + String reference() { + return reference; + } + + @Override + String errorMessage() { + return errorMessage; + } + + @Override + ModifierKind modifier() { + return modifier; + } + + @Override + ToStringHelper addToStringAttributes(final ToStringHelper helper) { + return super.addToStringAttributes(helper).add("description", description).add("reference", reference) + .add("errorMessage", errorMessage).add("modifier", modifier); + } +}