X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=cps-service%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fcps%2Fspi%2Fmodel%2FDataNodeBuilder.java;h=e212933388406cc6323c7c6747b0b4118c116c79;hb=fe25cdbf4e97fb4d3bdbb32d5b0c02b75f80ba72;hp=67e93dd82b76ada0309fae7284bc9b78744b8215;hpb=50f56b64870ac6c988cf75e84da3836ca015c1e6;p=cps.git diff --git a/cps-service/src/main/java/org/onap/cps/spi/model/DataNodeBuilder.java b/cps-service/src/main/java/org/onap/cps/spi/model/DataNodeBuilder.java index 67e93dd82..e21293338 100644 --- a/cps-service/src/main/java/org/onap/cps/spi/model/DataNodeBuilder.java +++ b/cps-service/src/main/java/org/onap/cps/spi/model/DataNodeBuilder.java @@ -2,6 +2,8 @@ * ============LICENSE_START======================================================= * Copyright (C) 2021 Bell Canada. All rights reserved. * Modifications Copyright (C) 2021 Pantheon.tech + * Modifications Copyright (C) 2022-2023 Nordix Foundation. + * Modifications Copyright (C) 2022-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. @@ -22,6 +24,7 @@ package org.onap.cps.spi.model; import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; +import java.io.Serializable; import java.util.Collection; import java.util.Collections; import java.util.List; @@ -29,7 +32,11 @@ import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import lombok.extern.slf4j.Slf4j; +import org.onap.cps.spi.exceptions.DataValidationException; import org.onap.cps.utils.YangUtils; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild; import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode; import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode; @@ -41,20 +48,34 @@ import org.opendaylight.yangtools.yang.data.api.schema.ValueNode; @Slf4j public class DataNodeBuilder { - private NormalizedNode normalizedNodeTree; + private ContainerNode containerNode; private String xpath; - private Map leaves = Collections.emptyMap(); + private String moduleNamePrefix; + private String parentNodeXpath = ""; + private Map leaves = Collections.emptyMap(); private Collection childDataNodes = Collections.emptySet(); + private String dataspaceName; + private String anchorName; + /** + * To use parent node xpath for creating {@link DataNode}. + * + * @param parentNodeXpath xpath of a parent node + * @return this {@link DataNodeBuilder} object + */ + public DataNodeBuilder withParentNodeXpath(final String parentNodeXpath) { + this.parentNodeXpath = parentNodeXpath; + return this; + } /** - * To use {@link NormalizedNode} for creating {@link DataNode}. + * To use {@link Collection} of Normalized Nodes for creating {@link DataNode}. * - * @param normalizedNodeTree used for creating the Data Node + * @param containerNode used for creating the Data Node * @return this {@link DataNodeBuilder} object */ - public DataNodeBuilder withNormalizedNodeTree(final NormalizedNode normalizedNodeTree) { - this.normalizedNodeTree = normalizedNodeTree; + public DataNodeBuilder withContainerNode(final ContainerNode containerNode) { + this.containerNode = containerNode; return this; } @@ -69,13 +90,46 @@ public class DataNodeBuilder { return this; } + /** + * To use dataspace name for creating {@link DataNode}. + * + * @param dataspaceName dataspace name for the data node + * @return DataNodeBuilder + */ + public DataNodeBuilder withDataspace(final String dataspaceName) { + this.dataspaceName = dataspaceName; + return this; + } + + /** + * To use anchor name for creating {@link DataNode}. + * + * @param anchorName anchor name for the data node + * @return DataNodeBuilder + */ + public DataNodeBuilder withAnchor(final String anchorName) { + this.anchorName = anchorName; + return this; + } + + /** + * To use module name for prefix for creating {@link DataNode}. + * + * @param moduleNamePrefix module name as prefix + * @return DataNodeBuilder + */ + public DataNodeBuilder withModuleNamePrefix(final String moduleNamePrefix) { + this.moduleNamePrefix = moduleNamePrefix; + return this; + } + /** * To use attributes for creating {@link DataNode}. * * @param leaves for the data node * @return DataNodeBuilder */ - public DataNodeBuilder withLeaves(final Map leaves) { + public DataNodeBuilder withLeaves(final Map leaves) { this.leaves = leaves; return this; } @@ -99,37 +153,67 @@ public class DataNodeBuilder { * @return {@link DataNode} */ public DataNode build() { - if (normalizedNodeTree != null) { - return buildFromNormalizedNodeTree(); - } else { - return buildFromAttributes(); + if (containerNode != null) { + return buildFromContainerNode(); } + return buildFromAttributes(); + } + + /** + * To build a {@link Collection} of {@link DataNode} objects. + * + * @return {@link DataNode} {@link Collection} + */ + public Collection buildCollection() { + if (containerNode != null) { + return buildCollectionFromContainerNode(); + } + return Collections.emptySet(); } private DataNode buildFromAttributes() { - final DataNode dataNode = new DataNode(); + final var dataNode = new DataNode(); dataNode.setXpath(xpath); + dataNode.setModuleNamePrefix(moduleNamePrefix); dataNode.setLeaves(leaves); dataNode.setChildDataNodes(childDataNodes); + dataNode.setDataspace(dataspaceName); + dataNode.setAnchorName(anchorName); return dataNode; } - private DataNode buildFromNormalizedNodeTree() { - final DataNode formalRootDataNode = new DataNodeBuilder().withXpath("").build(); - addDataNodeFromNormalizedNode(formalRootDataNode, normalizedNodeTree); - return formalRootDataNode.getChildDataNodes().iterator().next(); + private DataNode buildFromContainerNode() { + final Collection dataNodeCollection = buildCollectionFromContainerNode(); + if (!dataNodeCollection.iterator().hasNext()) { + throw new DataValidationException( + "Unsupported xpath: ", "Unsupported xpath as it is referring to one element"); + } + return dataNodeCollection.iterator().next(); + } + + private Collection buildCollectionFromContainerNode() { + final var parentDataNode = new DataNodeBuilder().withXpath(parentNodeXpath).build(); + if (containerNode.body() != null) { + for (final NormalizedNode normalizedNode: containerNode.body()) { + addDataNodeFromNormalizedNode(parentDataNode, normalizedNode); + } + } + return parentDataNode.getChildDataNodes(); } private static void addDataNodeFromNormalizedNode(final DataNode currentDataNode, - final NormalizedNode normalizedNode) { + final NormalizedNode normalizedNode) { - if (normalizedNode instanceof DataContainerNode) { - addYangContainer(currentDataNode, (DataContainerNode) normalizedNode); + if (normalizedNode instanceof ChoiceNode) { + addChoiceNode(currentDataNode, (ChoiceNode) normalizedNode); + } else if (normalizedNode instanceof DataContainerNode) { + addYangContainer(currentDataNode, (DataContainerNode) normalizedNode); } else if (normalizedNode instanceof MapNode) { addDataNodeForEachListElement(currentDataNode, (MapNode) normalizedNode); } else if (normalizedNode instanceof ValueNode) { - final ValueNode valuesNode = (ValueNode) normalizedNode; - addYangLeaf(currentDataNode, valuesNode.getNodeType().getLocalName(), valuesNode.getValue()); + final ValueNode valuesNode = (ValueNode) normalizedNode; + addYangLeaf(currentDataNode, valuesNode.getIdentifier().getNodeType().getLocalName(), + (Serializable) valuesNode.body()); } else if (normalizedNode instanceof LeafSetNode) { addYangLeafList(currentDataNode, (LeafSetNode) normalizedNode); } else { @@ -137,17 +221,20 @@ public class DataNodeBuilder { } } - private static void addYangContainer(final DataNode currentDataNode, final DataContainerNode dataContainerNode) { - final DataNode dataContainerDataNode = createAndAddChildDataNode(currentDataNode, - YangUtils.buildXpath(dataContainerNode.getIdentifier())); - final Collection> normalizedChildNodes = dataContainerNode.getValue(); - for (final NormalizedNode normalizedNode : normalizedChildNodes) { + private static void addYangContainer(final DataNode currentDataNode, final DataContainerNode dataContainerNode) { + final DataNode dataContainerDataNode = + (dataContainerNode.getIdentifier() instanceof YangInstanceIdentifier.AugmentationIdentifier) + ? currentDataNode + : createAndAddChildDataNode(currentDataNode, YangUtils.buildXpath(dataContainerNode.getIdentifier())); + final Collection normalizedChildNodes = dataContainerNode.body(); + for (final NormalizedNode normalizedNode : normalizedChildNodes) { addDataNodeFromNormalizedNode(dataContainerDataNode, normalizedNode); } } - private static void addYangLeaf(final DataNode currentDataNode, final String leafName, final Object leafValue) { - final Map leaves = new ImmutableMap.Builder() + private static void addYangLeaf(final DataNode currentDataNode, final String leafName, + final Serializable leafValue) { + final Map leaves = new ImmutableMap.Builder() .putAll(currentDataNode.getLeaves()) .put(leafName, leafValue) .build(); @@ -155,16 +242,16 @@ public class DataNodeBuilder { } private static void addYangLeafList(final DataNode currentDataNode, final LeafSetNode leafSetNode) { - final String leafListName = leafSetNode.getNodeType().getLocalName(); - final List leafListValues = ((Collection>) leafSetNode.getValue()) - .stream() - .map(normalizedNode -> ((ValueNode) normalizedNode).getValue()) - .collect(Collectors.toUnmodifiableList()); - addYangLeaf(currentDataNode, leafListName, leafListValues); + final String leafListName = leafSetNode.getIdentifier().getNodeType().getLocalName(); + final List leafListValues = ((Collection) leafSetNode.body()) + .stream() + .map(normalizedNode -> (normalizedNode).body()) + .collect(Collectors.toUnmodifiableList()); + addYangLeaf(currentDataNode, leafListName, (Serializable) leafListValues); } private static void addDataNodeForEachListElement(final DataNode currentDataNode, final MapNode mapNode) { - final Collection mapEntryNodes = mapNode.getValue(); + final Collection mapEntryNodes = mapNode.body(); for (final MapEntryNode mapEntryNode : mapEntryNodes) { addDataNodeFromNormalizedNode(currentDataNode, mapEntryNode); } @@ -172,7 +259,7 @@ public class DataNodeBuilder { private static DataNode createAndAddChildDataNode(final DataNode parentDataNode, final String childXpath) { - final DataNode newChildDataNode = new DataNodeBuilder() + final var newChildDataNode = new DataNodeBuilder() .withXpath(parentDataNode.getXpath() + childXpath) .build(); final Set allChildDataNodes = new ImmutableSet.Builder() @@ -183,4 +270,13 @@ public class DataNodeBuilder { return newChildDataNode; } + private static void addChoiceNode(final DataNode currentDataNode, final ChoiceNode choiceNode) { + + final Collection normalizedChildNodes = choiceNode.body(); + for (final NormalizedNode normalizedNode : normalizedChildNodes) { + addDataNodeFromNormalizedNode(currentDataNode, normalizedNode); + } + } + + }