/*
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2022 Nordix Foundation
+ * Copyright (C) 2021-2023 Nordix Foundation
+ * Modifications Copyright (C) 2023 TechMahindra Ltd
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import static org.onap.cps.cpspath.parser.CpsPathPrefixType.DESCENDANT;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.ArrayList;
+import java.util.List;
import org.onap.cps.cpspath.parser.antlr4.CpsPathBaseListener;
import org.onap.cps.cpspath.parser.antlr4.CpsPathParser;
import org.onap.cps.cpspath.parser.antlr4.CpsPathParser.AncestorAxisContext;
private static final String CLOSE_BRACKET = "]";
- final CpsPathQuery cpsPathQuery = new CpsPathQuery();
+ private final CpsPathQuery cpsPathQuery = new CpsPathQuery();
- final Map<String, Object> leavesData = new HashMap<>();
+ private final List<CpsPathQuery.DataLeaf> leavesData = new ArrayList<>();
- final StringBuilder normalizedXpathBuilder = new StringBuilder();
+ private final StringBuilder normalizedXpathBuilder = new StringBuilder();
- final StringBuilder normalizedAncestorPathBuilder = new StringBuilder();
+ private final StringBuilder normalizedAncestorPathBuilder = new StringBuilder();
- boolean processingAncestorAxis = false;
+ private boolean processingAncestorAxis = false;
+
+ private final List<String> containerNames = new ArrayList<>();
+
+ private final List<String> booleanOperators = new ArrayList<>();
+
+ private final List<String> comparativeOperators = new ArrayList<>();
@Override
public void exitInvalidPostFix(final CpsPathParser.InvalidPostFixContext ctx) {
cpsPathQuery.setXpathPrefix(normalizedXpathBuilder.toString());
}
+ @Override
+ public void exitParent(final CpsPathParser.ParentContext ctx) {
+ cpsPathQuery.setNormalizedParentPath(normalizedXpathBuilder.toString());
+ }
+
@Override
public void exitIncorrectPrefix(final IncorrectPrefixContext ctx) {
throw new PathParsingException("CPS path can only start with one or two slashes (/)");
@Override
public void exitLeafCondition(final LeafConditionContext ctx) {
- Object comparisonValue = null;
+ final Object comparisonValue;
if (ctx.IntegerLiteral() != null) {
comparisonValue = Integer.valueOf(ctx.IntegerLiteral().getText());
- }
- if (ctx.StringLiteral() != null) {
- final boolean wasWrappedInDoubleQuote = ctx.StringLiteral().getText().startsWith("\"");
- comparisonValue = stripFirstAndLastCharacter(ctx.StringLiteral().getText());
- if (wasWrappedInDoubleQuote) {
- comparisonValue = String.valueOf(comparisonValue).replace("'", "\\'");
- }
- } else if (comparisonValue == null) {
+ } else if (ctx.StringLiteral() != null) {
+ comparisonValue = unwrapQuotedString(ctx.StringLiteral().getText());
+ } else {
throw new PathParsingException("Unsupported comparison value encountered in expression" + ctx.getText());
}
- leavesData.put(ctx.leafName().getText(), comparisonValue);
- appendCondition(normalizedXpathBuilder, ctx.leafName().getText(), comparisonValue);
- if (processingAncestorAxis) {
- appendCondition(normalizedAncestorPathBuilder, ctx.leafName().getText(), comparisonValue);
- }
+ leafContext(ctx.leafName(), comparisonValue);
+ }
+
+ @Override
+ public void exitBooleanOperators(final CpsPathParser.BooleanOperatorsContext ctx) {
+ booleanOperators.add(ctx.getText());
+ }
+
+ @Override
+ public void exitComparativeOperators(final CpsPathParser.ComparativeOperatorsContext ctx) {
+ comparativeOperators.add(ctx.getText());
}
@Override
public void enterMultipleLeafConditions(final MultipleLeafConditionsContext ctx) {
normalizedXpathBuilder.append(OPEN_BRACKET);
leavesData.clear();
+ booleanOperators.clear();
+ comparativeOperators.clear();
}
@Override
@Override
public void exitTextFunctionCondition(final TextFunctionConditionContext ctx) {
cpsPathQuery.setTextFunctionConditionLeafName(ctx.leafName().getText());
- cpsPathQuery.setTextFunctionConditionValue(stripFirstAndLastCharacter(ctx.StringLiteral().getText()));
+ cpsPathQuery.setTextFunctionConditionValue(unwrapQuotedString(ctx.StringLiteral().getText()));
+ }
+
+ @Override
+ public void exitContainsFunctionCondition(final CpsPathParser.ContainsFunctionConditionContext ctx) {
+ cpsPathQuery.setContainsFunctionConditionLeafName(ctx.leafName().getText());
+ cpsPathQuery.setContainsFunctionConditionValue(unwrapQuotedString(ctx.StringLiteral().getText()));
}
@Override
CpsPathQuery build() {
cpsPathQuery.setNormalizedXpath(normalizedXpathBuilder.toString());
+ cpsPathQuery.setContainerNames(containerNames);
+ cpsPathQuery.setBooleanOperators(booleanOperators);
+ cpsPathQuery.setComparativeOperators(comparativeOperators);
return cpsPathQuery;
}
- private static String stripFirstAndLastCharacter(final String wrappedString) {
- return wrappedString.substring(1, wrappedString.length() - 1);
- }
-
@Override
public void exitContainerName(final CpsPathParser.ContainerNameContext ctx) {
+ final String containerName = ctx.getText();
normalizedXpathBuilder.append("/")
- .append(ctx.getText());
+ .append(containerName);
+ containerNames.add(containerName);
if (processingAncestorAxis) {
- normalizedAncestorPathBuilder.append("/").append(ctx.getText());
+ normalizedAncestorPathBuilder.append("/").append(containerName);
+ }
+ }
+
+ private void leafContext(final CpsPathParser.LeafNameContext ctx, final Object comparisonValue) {
+ leavesData.add(new CpsPathQuery.DataLeaf(ctx.getText(), comparisonValue));
+ appendCondition(normalizedXpathBuilder, ctx.getText(), comparisonValue);
+ if (processingAncestorAxis) {
+ appendCondition(normalizedAncestorPathBuilder, ctx.getText(), comparisonValue);
}
}
private void appendCondition(final StringBuilder currentNormalizedPathBuilder, final String name,
- final Object value) {
+ final Object value) {
final char lastCharacter = currentNormalizedPathBuilder.charAt(currentNormalizedPathBuilder.length() - 1);
- currentNormalizedPathBuilder.append(lastCharacter == '[' ? "" : " and ")
- .append("@")
- .append(name)
- .append("='")
- .append(value)
- .append("'");
+ final boolean isStartOfExpression = lastCharacter == '[';
+ if (!isStartOfExpression) {
+ currentNormalizedPathBuilder.append(" ").append(getLastElement(booleanOperators)).append(" ");
+ }
+ currentNormalizedPathBuilder.append("@")
+ .append(name)
+ .append(getLastElement(comparativeOperators))
+ .append("'")
+ .append(value.toString().replace("'", "''"))
+ .append("'");
+ }
+
+ private static String getLastElement(final List<String> listOfStrings) {
+ return listOfStrings.get(listOfStrings.size() - 1);
+ }
+
+ private static String unwrapQuotedString(final String wrappedString) {
+ final boolean wasWrappedInSingleQuote = wrappedString.startsWith("'");
+ final String value = stripFirstAndLastCharacter(wrappedString);
+ if (wasWrappedInSingleQuote) {
+ return value.replace("''", "'");
+ } else {
+ return value.replace("\"\"", "\"");
+ }
+ }
+
+ private static String stripFirstAndLastCharacter(final String wrappedString) {
+ return wrappedString.substring(1, wrappedString.length() - 1);
}
}