openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/main/java/org/openecomp/sdc/translator/datatypes/heattotosca/unifiedmodel/composition/UnifiedSubstitutionData.java

   1 package org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition;
   2
   3 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
   4
   5 import java.util.Collection;
   6 import java.util.HashMap;
   7 import java.util.HashSet;
   8 import java.util.Map;
   9 import java.util.Optional;
  10 import java.util.Set;
  11
  12 public class UnifiedSubstitutionData {
  13
  14   //Key - node template id, Value - related abstract node template id
  15   private Map<String, String> nodesRelatedAbstractNode = new HashMap<>();
  16   //Key - node template id, Value - related node template id in the substitution service template
  17   private Map<String, String> nodesRelatedSubstitutionServiceTemplateNode = new HashMap<>();
  18   private Map<String, NodeTemplateInformation> cleanedNodeTemplates = new HashMap<>();
  19   //Key - nested node template id, Value - related unified nested node template id
  20   private Map<String, String> nestedNodeTemplateRelatedUnifiedTranslatedId = new HashMap<>();
  21   //Key - nested node type id, Value - related unified nested node template id
  22   private Map<String, String> nestedNodeTypeRelatedUnifiedTranslatedId = new HashMap<>();
  23   //Key - handled compute type, Value - number of times it was handled
  24   private Map<String, Integer> handledComputeTypesInNestedSubstitutionTemplate =
  25       new HashMap<>();
  26   //Key - nested compute type, Value - list of nested files that the compute type is present
  27   private Map<String, Set<String>> handledNestedComputeTypesNestedFiles = new HashMap<>();
  28   //handled nested files
  29   private Set<String> handledNestedFiles = new HashSet<>();
  30
  31   public Map<String, String> getNodesRelatedAbstractNode() {
  32     return nodesRelatedAbstractNode;
  33   }
  34
  35   public void setNodesRelatedAbstractNode(
  36       Map<String, String> nodesRelatedAbstractNode) {
  37     this.nodesRelatedAbstractNode = nodesRelatedAbstractNode;
  38   }
  39
  40   public Map<String, String> getNodesRelatedSubstitutionServiceTemplateNode() {
  41     return nodesRelatedSubstitutionServiceTemplateNode;
  42   }
  43
  44   public void setNodesRelatedSubstitutionServiceTemplateNode(
  45       Map<String, String> nodesRelatedSubstitutionServiceTemplateNode) {
  46     this.nodesRelatedSubstitutionServiceTemplateNode = nodesRelatedSubstitutionServiceTemplateNode;
  47   }
  48
  49   public String getNodeRelatedAbstractNode(String origNodeId) {
  50     return this.nodesRelatedAbstractNode.get(origNodeId);
  51   }
  52
  53   public Collection<String> getAllRelatedAbstractNodeIds() {
  54     return this.nodesRelatedAbstractNode.values();
  55   }
  56
  57   public Collection<String> getAllUnifiedNestedNodeTemplateIds() {
  58     return this.nestedNodeTemplateRelatedUnifiedTranslatedId.values();
  59   }
  60
  61   /**
  62    * Add cleaned node template.
  63    *
  64    * @param nodeTemplateId           the node template id
  65    * @param unifiedCompositionEntity the unified composition entity
  66    * @param nodeTemplate             the node template
  67    */
  68   public void addCleanedNodeTemplate(String nodeTemplateId,
  69                                      UnifiedCompositionEntity unifiedCompositionEntity,
  70                                      NodeTemplate nodeTemplate) {
  71     NodeTemplateInformation nodeTemplateInformation = new NodeTemplateInformation(
  72         unifiedCompositionEntity, nodeTemplate);
  73     this.cleanedNodeTemplates.putIfAbsent(nodeTemplateId, nodeTemplateInformation);
  74   }
  75
  76   public NodeTemplate getCleanedNodeTemplate(String nodeTemplateId) {
  77     return this.cleanedNodeTemplates.get(nodeTemplateId).getNodeTemplate().clone();
  78   }
  79
  80   public UnifiedCompositionEntity getCleanedNodeTemplateCompositionEntity(String nodeTemplateId) {
  81     return this.cleanedNodeTemplates.get(nodeTemplateId).getUnifiedCompositionEntity();
  82   }
  83
  84   public void addUnifiedNestedNodeTemplateId(String nestedNodeTemplateId,
  85                                              String unifiedNestedNodeRelatedId) {
  86     this.nestedNodeTemplateRelatedUnifiedTranslatedId
  87         .put(nestedNodeTemplateId, unifiedNestedNodeRelatedId);
  88   }
  89
  90   public Optional<String> getUnifiedNestedNodeTemplateId(String nestedNodeTemplateId) {
  91     return this.nestedNodeTemplateRelatedUnifiedTranslatedId.get(nestedNodeTemplateId) == null
  92         ? Optional.empty()
  93         : Optional.of(this.nestedNodeTemplateRelatedUnifiedTranslatedId.get(nestedNodeTemplateId));
  94   }
  95
  96   public void addUnifiedNestedNodeTypeId(String nestedNodeTypeId,
  97                                          String unifiedNestedNodeRelatedId) {
  98     this.nestedNodeTypeRelatedUnifiedTranslatedId.put(nestedNodeTypeId, unifiedNestedNodeRelatedId);
  99   }
 100
 101   public Optional<String> getUnifiedNestedNodeTypeId(String nestedNodeTypeId) {
 102     return this.nestedNodeTypeRelatedUnifiedTranslatedId.get(nestedNodeTypeId) == null ? Optional
 103         .empty()
 104         : Optional.of(this.nestedNodeTypeRelatedUnifiedTranslatedId.get(nestedNodeTypeId));
 105   }
 106
 107   public void addHandledComputeType(String nestedServiceTemplateFileName,
 108                                     String handledComputeType) {
 109
 110     if (this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(handledComputeType)) {
 111       Integer timesHandled =
 112           this.handledComputeTypesInNestedSubstitutionTemplate.get(handledComputeType);
 113       this.handledComputeTypesInNestedSubstitutionTemplate
 114           .put(handledComputeType, timesHandled + 1);
 115     } else {
 116       this.handledNestedFiles.add(nestedServiceTemplateFileName);
 117       handledComputeTypesInNestedSubstitutionTemplate.put(handledComputeType, 0);
 118     }
 119   }
 120
 121   public boolean isComputeTypeHandledInServiceTemplate(String computeType) {
 122     return this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(computeType);
 123   }
 124
 125   public int getHandledNestedComputeNodeTemplateIndex(String computeType) {
 126     return this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(computeType) ?
 127         this.handledComputeTypesInNestedSubstitutionTemplate.get(computeType):
 128         0;
 129   }
 130
 131   public boolean isNestedServiceTemplateWasHandled(String nestedServiceTemplateFileName) {
 132     return this.handledNestedFiles.contains(nestedServiceTemplateFileName);
 133   }
 134
 135   public void addNestedFileToUsedNestedComputeType(String computeType,
 136                                                    String nestedServiceTemplateFileName){
 137     this.handledNestedComputeTypesNestedFiles.putIfAbsent(computeType, new HashSet<>());
 138     this.handledNestedComputeTypesNestedFiles.get(computeType).add(nestedServiceTemplateFileName);
 139   }
 140
 141   public int getGlobalNodeTypeIndex(String computeType){
 142     return this.handledNestedComputeTypesNestedFiles.get(computeType).size() == 1 ? 0:
 143         this.handledNestedComputeTypesNestedFiles.get(computeType).size() - 1;
 144   }
 145 }