-/**\r
- * ============LICENSE_START=======================================================\r
- * Model Loader\r
- * ================================================================================\r
- * Copyright © 2017 AT&T Intellectual Property.\r
- * Copyright © 2017 Amdocs\r
- * All rights reserved.\r
- * ================================================================================\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- * ============LICENSE_END=========================================================\r
- *\r
- * ECOMP and OpenECOMP are trademarks\r
- * and service marks of AT&T Intellectual Property.\r
- */\r
-package org.openecomp.modelloader.entity.model;\r
-\r
-import jline.internal.Log;\r
-\r
-import org.openecomp.modelloader.entity.Artifact;\r
-\r
-import java.util.ArrayList;\r
-import java.util.Collection;\r
-import java.util.HashMap;\r
-import java.util.HashSet;\r
-import java.util.Iterator;\r
-import java.util.List;\r
-\r
-/**\r
- * Utility class to sort the given Models according to their dependencies.\r
- * Example: Given a list of Models [A, B, C] where B depends on A, and A depends\r
- * on C, the sorted result will be [C, A, B]\r
- */\r
-public class ModelSorter {\r
-\r
- /**\r
- * Wraps a Model object to form dependencies other Models using Edges.\r
- */\r
- static class Node {\r
- private final ModelArtifact model;\r
- private final HashSet<Edge> inEdges;\r
- private final HashSet<Edge> outEdges;\r
-\r
- public Node(ModelArtifact model) {\r
- this.model = model;\r
- inEdges = new HashSet<Edge>();\r
- outEdges = new HashSet<Edge>();\r
- }\r
-\r
- public Node addEdge(Node node) {\r
- Edge edge = new Edge(this, node);\r
- outEdges.add(edge);\r
- node.inEdges.add(edge);\r
- return this;\r
- }\r
-\r
- @Override\r
- public String toString() {\r
- return model.getModelInvariantId();\r
- }\r
-\r
- @Override\r
- public boolean equals(Object other) {\r
- ModelArtifact otherModel = ((Node) other).model;\r
- return this.model.getModelInvariantId().equals(otherModel.getModelInvariantId());\r
- }\r
-\r
- @Override\r
- public int hashCode() {\r
- return this.model.getModelInvariantId().hashCode();\r
-\r
- }\r
- }\r
-\r
- /**\r
- * Represents a dependency between two Nodes.\r
- */\r
- static class Edge {\r
- public final Node from;\r
- public final Node to;\r
-\r
- public Edge(Node from, Node to) {\r
- this.from = from;\r
- this.to = to;\r
- }\r
-\r
- @Override\r
- public boolean equals(Object obj) {\r
- Edge edge = (Edge) obj;\r
- return edge.from == from && edge.to == to;\r
- }\r
- }\r
-\r
- /**\r
- * Returns the list of models sorted by order of dependency.\r
- * \r
- * @param originalList\r
- * the list that needs to be sorted\r
- * @return a list of sorted models\r
- */\r
- public List<Artifact> sort(List<Artifact> originalList) {\r
-\r
- if (originalList.size() <= 1) {\r
- return originalList;\r
- }\r
-\r
- Collection<Node> nodes = createNodes(originalList);\r
- Collection<Node> sortedNodes = sortNodes(nodes);\r
-\r
- List<Artifact> sortedModelsList = new ArrayList<Artifact>(sortedNodes.size());\r
- for (Node node : sortedNodes) {\r
- sortedModelsList.add(node.model);\r
- }\r
-\r
- return sortedModelsList;\r
- }\r
-\r
- /**\r
- * Create nodes from the list of models and their dependencies.\r
- * \r
- * @param models\r
- * what the nodes creation is based upon\r
- * @return Collection of Node objects\r
- */\r
- private Collection<Node> createNodes(Collection<Artifact> models) {\r
-\r
- // load list of models into a map, so we can later replace referenceIds with\r
- // real Models\r
- HashMap<String, ModelArtifact> versionIdToModelMap = new HashMap<String, ModelArtifact>();\r
- for (Artifact art : models) {\r
- ModelArtifact ma = (ModelArtifact) art;\r
- versionIdToModelMap.put(ma.getModelModelVerCombinedKey(), ma);\r
- }\r
-\r
- HashMap<String, Node> nodes = new HashMap<String, Node>();\r
- // create a node for each model and its referenced models\r
- for (Artifact art : models) {\r
- ModelArtifact model = (ModelArtifact) art;\r
-\r
- // node might have been created by another model referencing it\r
- Node node = nodes.get(model.getModelModelVerCombinedKey());\r
-\r
- if (null == node) {\r
- node = new Node(model);\r
- nodes.put(model.getModelModelVerCombinedKey(), node);\r
- }\r
-\r
- for (String referencedModelId : model.getDependentModelIds()) {\r
- // node might have been created by another model referencing it\r
- Node referencedNode = nodes.get(referencedModelId);\r
-\r
- if (null == referencedNode) {\r
- // create node\r
- ModelArtifact referencedModel = versionIdToModelMap.get(referencedModelId);\r
- if (referencedModel == null) {\r
- Log.debug("ignoring " + referencedModelId);\r
- continue; // referenced model not supplied, no need to sort it\r
- }\r
- referencedNode = new Node(referencedModel);\r
- nodes.put(referencedModelId, referencedNode);\r
- }\r
- referencedNode.addEdge(node);\r
- }\r
- }\r
-\r
- return nodes.values();\r
- }\r
-\r
- /**\r
- * Sorts the given Nodes by order of dependency.\r
- * \r
- * @param originalList\r
- * the collection of nodes to be sorted\r
- * @return a sorted collection of the given nodes\r
- */\r
- private Collection<Node> sortNodes(Collection<Node> unsortedNodes) {\r
-\r
- // L <- Empty list that will contain the sorted elements\r
- ArrayList<Node> nodeList = new ArrayList<Node>();\r
-\r
- // S <- Set of all nodes with no incoming edges\r
- HashSet<Node> nodeSet = new HashSet<Node>();\r
- for (Node unsortedNode : unsortedNodes) {\r
- if (unsortedNode.inEdges.size() == 0) {\r
- nodeSet.add(unsortedNode);\r
- }\r
- }\r
-\r
- // while S is non-empty do\r
- while (!nodeSet.isEmpty()) {\r
- // remove a node n from S\r
- Node node = nodeSet.iterator().next();\r
- nodeSet.remove(node);\r
-\r
- // insert n into L\r
- nodeList.add(node);\r
-\r
- // for each node m with an edge e from n to m do\r
- for (Iterator<Edge> it = node.outEdges.iterator(); it.hasNext();) {\r
- // remove edge e from the graph\r
- Edge edge = it.next();\r
- Node to = edge.to;\r
- it.remove();// Remove edge from n\r
- to.inEdges.remove(edge);// Remove edge from m\r
-\r
- // if m has no other incoming edges then insert m into S\r
- if (to.inEdges.isEmpty()) {\r
- nodeSet.add(to);\r
- }\r
- }\r
- }\r
- // Check to see if all edges are removed\r
- boolean cycle = false;\r
- for (Node node : unsortedNodes) {\r
- if (!node.inEdges.isEmpty()) {\r
- cycle = true;\r
- break;\r
- }\r
- }\r
- if (cycle) {\r
- throw new RuntimeException(\r
- "Circular dependency present between models, topological sort not possible");\r
- }\r
-\r
- return nodeList;\r
- }\r
-\r
-}\r
+/**
+ * ============LICENSE_START=======================================================
+ * Model Loader
+ * ================================================================================
+ * Copyright © 2017 AT&T Intellectual Property.
+ * Copyright © 2017 Amdocs
+ * All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ *
+ * ECOMP and OpenECOMP are trademarks
+ * and service marks of AT&T Intellectual Property.
+ */
+package org.openecomp.modelloader.entity.model;
+
+import jline.internal.Log;
+
+import org.openecomp.modelloader.entity.Artifact;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Utility class to sort the given Models according to their dependencies.
+ * Example: Given a list of Models [A, B, C] where B depends on A, and A depends
+ * on C, the sorted result will be [C, A, B]
+ */
+public class ModelSorter {
+
+ /**
+ * Wraps a Model object to form dependencies other Models using Edges.
+ */
+ static class Node {
+ private final AbstractModelArtifact model;
+ private final HashSet<Edge> inEdges;
+ private final HashSet<Edge> outEdges;
+
+ public Node(AbstractModelArtifact model) {
+ this.model = model;
+ inEdges = new HashSet<Edge>();
+ outEdges = new HashSet<Edge>();
+ }
+
+ public Node addEdge(Node node) {
+ Edge edge = new Edge(this, node);
+ outEdges.add(edge);
+ node.inEdges.add(edge);
+ return this;
+ }
+
+ @Override
+ public String toString() {
+ return model.getUniqueIdentifier();
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ AbstractModelArtifact otherModel = ((Node) other).model;
+ return this.model.getUniqueIdentifier().equals(otherModel.getUniqueIdentifier());
+ }
+
+ @Override
+ public int hashCode() {
+ return this.model.getUniqueIdentifier().hashCode();
+ }
+ }
+
+ /**
+ * Represents a dependency between two Nodes.
+ */
+ static class Edge {
+ public final Node from;
+ public final Node to;
+
+ public Edge(Node from, Node to) {
+ this.from = from;
+ this.to = to;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ Edge edge = (Edge) obj;
+ return edge.from == from && edge.to == to;
+ }
+ }
+
+ /**
+ * Returns the list of models sorted by order of dependency.
+ *
+ * @param originalList
+ * the list that needs to be sorted
+ * @return a list of sorted models
+ */
+ public List<Artifact> sort(List<Artifact> originalList) {
+
+ if (originalList.size() <= 1) {
+ return originalList;
+ }
+
+ Collection<Node> nodes = createNodes(originalList);
+ Collection<Node> sortedNodes = sortNodes(nodes);
+
+ List<Artifact> sortedModelsList = new ArrayList<Artifact>(sortedNodes.size());
+ for (Node node : sortedNodes) {
+ sortedModelsList.add(node.model);
+ }
+
+ return sortedModelsList;
+ }
+
+ /**
+ * Create nodes from the list of models and their dependencies.
+ *
+ * @param models
+ * what the nodes creation is based upon
+ * @return Collection of Node objects
+ */
+ private Collection<Node> createNodes(Collection<Artifact> models) {
+
+ // load list of models into a map, so we can later replace referenceIds with
+ // real Models
+ HashMap<String, AbstractModelArtifact> versionIdToModelMap = new HashMap<String, AbstractModelArtifact>();
+ for (Artifact art : models) {
+ AbstractModelArtifact ma = (AbstractModelArtifact) art;
+ versionIdToModelMap.put(ma.getUniqueIdentifier(), ma);
+ }
+
+ HashMap<String, Node> nodes = new HashMap<String, Node>();
+ // create a node for each model and its referenced models
+ for (Artifact art : models) {
+
+ AbstractModelArtifact model = (AbstractModelArtifact) art;
+
+ // node might have been created by another model referencing it
+ Node node = nodes.get(model.getUniqueIdentifier());
+
+ if (null == node) {
+ node = new Node(model);
+ nodes.put(model.getUniqueIdentifier(), node);
+ }
+
+ for (String referencedModelId : model.getDependentModelIds()) {
+ // node might have been created by another model referencing it
+ Node referencedNode = nodes.get(referencedModelId);
+
+ if (null == referencedNode) {
+ // create node
+ AbstractModelArtifact referencedModel = versionIdToModelMap.get(referencedModelId);
+ if (referencedModel == null) {
+ Log.debug("ignoring " + referencedModelId);
+ continue; // referenced model not supplied, no need to sort it
+ }
+ referencedNode = new Node(referencedModel);
+ nodes.put(referencedModelId, referencedNode);
+ }
+ referencedNode.addEdge(node);
+ }
+ }
+
+ return nodes.values();
+ }
+
+ /**
+ * Sorts the given Nodes by order of dependency.
+ *
+ * @param originalList
+ * the collection of nodes to be sorted
+ * @return a sorted collection of the given nodes
+ */
+ private Collection<Node> sortNodes(Collection<Node> unsortedNodes) {
+ // L <- Empty list that will contain the sorted elements
+ ArrayList<Node> nodeList = new ArrayList<Node>();
+
+ // S <- Set of all nodes with no incoming edges
+ HashSet<Node> nodeSet = new HashSet<Node>();
+ for (Node unsortedNode : unsortedNodes) {
+ if (unsortedNode.inEdges.size() == 0) {
+ nodeSet.add(unsortedNode);
+ }
+ }
+
+ // while S is non-empty do
+ while (!nodeSet.isEmpty()) {
+ // remove a node n from S
+ Node node = nodeSet.iterator().next();
+ nodeSet.remove(node);
+
+ // insert n into L
+ nodeList.add(node);
+
+ // for each node m with an edge e from n to m do
+ for (Iterator<Edge> it = node.outEdges.iterator(); it.hasNext();) {
+ // remove edge e from the graph
+ Edge edge = it.next();
+ Node to = edge.to;
+ it.remove();// Remove edge from n
+ to.inEdges.remove(edge);// Remove edge from m
+
+ // if m has no other incoming edges then insert m into S
+ if (to.inEdges.isEmpty()) {
+ nodeSet.add(to);
+ }
+ }
+ }
+ // Check to see if all edges are removed
+ boolean cycle = false;
+ for (Node node : unsortedNodes) {
+ if (!node.inEdges.isEmpty()) {
+ cycle = true;
+ break;
+ }
+ }
+ if (cycle) {
+ throw new RuntimeException(
+ "Circular dependency present between models, topological sort not possible");
+ }
+
+ return nodeList;
+ }
+
+
+}
Code Review / aai / model-loader.git / blobdiff