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.apache.commons.collections4.MapUtils;
   4 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
   5
   6 import java.util.Collection;
   7 import java.util.HashMap;
   8 import java.util.HashSet;
   9 import java.util.Map;
  10 import java.util.Objects;
  11 import java.util.Optional;
  12 import java.util.Set;
  13
  14 public class UnifiedSubstitutionData {
  15
  16   //Key - node template id, Value - related abstract node template id
  17   private Map<String, String> nodesRelatedAbstractNode = new HashMap<>();
  18   //Key - node template id, Value - related node template id in the substitution service template
  19   private Map<String, String> nodesRelatedSubstitutionServiceTemplateNode = new HashMap<>();
  20   private Map<String, NodeTemplateInformation> cleanedNodeTemplates = new HashMap<>();
  21   //Key - nested node template id, Value - related unified nested node template id
  22   private Map<String, String> nestedNodeTemplateRelatedUnifiedTranslatedId = new HashMap<>();
  23   //Key - nested node type id, Value - related unified nested node template id
  24   private Map<String, String> nestedNodeTypeRelatedUnifiedTranslatedId = new HashMap<>();
  25   //Key - handled compute type, Value - number of times it was handled
  26   private Map<String, Integer> handledComputeTypesInNestedSubstitutionTemplate =
  27       new HashMap<>();
  28   //Key - nested compute type, Value - list of nested files that the compute type is present
  29   private Map<String, Integer> handledNestedComputeTypesNestedFiles = new HashMap<>();
  30   //Key - new property id, Value - orig property value
  31   private Map<String, Object> newParameterIdsToPropertiesFromOrigNodeTemplate = new HashMap<>();
  32   //handled nested files
  33   private Set<String> handledNestedFiles = new HashSet<>();
  34   //handled nested nodes
  35   private Set<String> handledNestedNodes = new HashSet<>();
  36
  37   public Map<String, String> getNodesRelatedAbstractNode() {
  38     return nodesRelatedAbstractNode;
  39   }
  40
  41   public void setNodesRelatedAbstractNode(
  42       Map<String, String> nodesRelatedAbstractNode) {
  43     this.nodesRelatedAbstractNode = nodesRelatedAbstractNode;
  44   }
  45
  46   public void addHandledNestedNodes(String handledNestedNodeId) {
  47     this.handledNestedNodes.add(handledNestedNodeId);
  48   }
  49
  50   public Map<String, String> getNodesRelatedSubstitutionServiceTemplateNode() {
  51     return nodesRelatedSubstitutionServiceTemplateNode;
  52   }
  53
  54   public void setNodesRelatedSubstitutionServiceTemplateNode(
  55       Map<String, String> nodesRelatedSubstitutionServiceTemplateNode) {
  56     this.nodesRelatedSubstitutionServiceTemplateNode = nodesRelatedSubstitutionServiceTemplateNode;
  57   }
  58
  59   public String getNodeRelatedAbstractNode(String origNodeId) {
  60     return this.nodesRelatedAbstractNode.get(origNodeId);
  61   }
  62
  63   public Collection<String> getAllRelatedAbstractNodeIds() {
  64     return this.nodesRelatedAbstractNode.values();
  65   }
  66
  67   public Collection<String> getAllUnifiedNestedNodeTemplateIds() {
  68     return this.nestedNodeTemplateRelatedUnifiedTranslatedId.values();
  69   }
  70
  71   /**
  72    * Add cleaned node template.
  73    *
  74    * @param nodeTemplateId           the node template id
  75    * @param unifiedCompositionEntity the unified composition entity
  76    * @param nodeTemplate             the node template
  77    */
  78   public void addCleanedNodeTemplate(String nodeTemplateId,
  79                                      UnifiedCompositionEntity unifiedCompositionEntity,
  80                                      NodeTemplate nodeTemplate) {
  81     NodeTemplateInformation nodeTemplateInformation = new NodeTemplateInformation(
  82         unifiedCompositionEntity, nodeTemplate);
  83     this.cleanedNodeTemplates.putIfAbsent(nodeTemplateId, nodeTemplateInformation);
  84   }
  85
  86   public NodeTemplate getCleanedNodeTemplate(String nodeTemplateId) {
  87     return this.cleanedNodeTemplates.get(nodeTemplateId).getNodeTemplate().clone();
  88   }
  89
  90   public UnifiedCompositionEntity getCleanedNodeTemplateCompositionEntity(String nodeTemplateId) {
  91     return this.cleanedNodeTemplates.get(nodeTemplateId).getUnifiedCompositionEntity();
  92   }
  93
  94   public void addUnifiedNestedNodeTemplateId(String nestedNodeTemplateId,
  95                                              String unifiedNestedNodeRelatedId) {
  96     this.nestedNodeTemplateRelatedUnifiedTranslatedId
  97         .put(nestedNodeTemplateId, unifiedNestedNodeRelatedId);
  98   }
  99
 100   public Optional<String> getUnifiedNestedNodeTemplateId(String nestedNodeTemplateId) {
 101     return this.nestedNodeTemplateRelatedUnifiedTranslatedId.get(nestedNodeTemplateId) == null
 102         ? Optional.empty()
 103         : Optional.of(this.nestedNodeTemplateRelatedUnifiedTranslatedId.get(nestedNodeTemplateId));
 104   }
 105
 106   public void addUnifiedNestedNodeTypeId(String nestedNodeTypeId,
 107                                          String unifiedNestedNodeRelatedId) {
 108     this.nestedNodeTypeRelatedUnifiedTranslatedId.put(nestedNodeTypeId, unifiedNestedNodeRelatedId);
 109   }
 110
 111   public Optional<String> getUnifiedNestedNodeTypeId(String nestedNodeTypeId) {
 112     return this.nestedNodeTypeRelatedUnifiedTranslatedId.get(nestedNodeTypeId) == null ? Optional
 113         .empty()
 114         : Optional.of(this.nestedNodeTypeRelatedUnifiedTranslatedId.get(nestedNodeTypeId));
 115   }
 116
 117   public Set<String> getAllRelatedNestedNodeTypeIds(){
 118     if(MapUtils.isEmpty(nestedNodeTypeRelatedUnifiedTranslatedId)){
 119       return new HashSet<>();
 120     }
 121     return new HashSet<>(this.nestedNodeTypeRelatedUnifiedTranslatedId.values());
 122   }
 123
 124   public void addHandledComputeType(String handledComputeType) {
 125
 126     if (this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(handledComputeType)) {
 127       Integer timesHandled =
 128           this.handledComputeTypesInNestedSubstitutionTemplate.get(handledComputeType);
 129       this.handledComputeTypesInNestedSubstitutionTemplate
 130           .put(handledComputeType, timesHandled + 1);
 131     } else {
 132       //this.handledNestedFiles.add(nestedServiceTemplateFileName);
 133       handledComputeTypesInNestedSubstitutionTemplate.put(handledComputeType, 0);
 134     }
 135   }
 136
 137   public boolean isComputeTypeHandledInServiceTemplate(String computeType) {
 138     return this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(computeType);
 139   }
 140
 141   public int getHandledNestedComputeNodeTemplateIndex(String computeType) {
 142     return this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(computeType) ?
 143         this.handledComputeTypesInNestedSubstitutionTemplate.get(computeType) : 0;
 144   }
 145
 146   public void addHandlesNestedServiceTemplate(String nestedServiceTemplateFileName){
 147     this.handledNestedFiles.add(nestedServiceTemplateFileName);
 148   }
 149
 150   public boolean isNestedServiceTemplateWasHandled(String nestedServiceTemplateFileName) {
 151     return this.handledNestedFiles.contains(nestedServiceTemplateFileName);
 152   }
 153
 154   public void updateUsedTimesForNestedComputeNodeType(String computeType) {
 155     this.handledNestedComputeTypesNestedFiles.putIfAbsent(computeType, 0);
 156
 157     Integer usedNumber = this.handledNestedComputeTypesNestedFiles.get(computeType);
 158     this.handledNestedComputeTypesNestedFiles.put(computeType, usedNumber + 1);
 159
 160   }
 161
 162   public int getGlobalNodeTypeIndex(String computeType) {
 163     return Objects.isNull(this.handledNestedComputeTypesNestedFiles.get(computeType))
 164         || this.handledNestedComputeTypesNestedFiles.get(computeType)== 0 ? 0
 165         : this.handledNestedComputeTypesNestedFiles.get(computeType);
 166   }
 167
 168   public boolean isNestedNodeWasHandled(String nestedNodeId) {
 169     return this.handledNestedNodes.contains(nestedNodeId);
 170   }
 171
 172
 173   public Map<String, Object> getAllNewPropertyInputParamIds(){
 174     return this.newParameterIdsToPropertiesFromOrigNodeTemplate;
 175   }
 176
 177   public void addNewPropertyIdToNodeTemplate(String newPropertyId,
 178                                              Object origPropertyValue){
 179     if(!newParameterIdsToPropertiesFromOrigNodeTemplate.containsKey(newPropertyId)) {
 180       newParameterIdsToPropertiesFromOrigNodeTemplate.put(newPropertyId, origPropertyValue);
 181     }
 182   }
 183
 184   public Optional<Object> getNewPropertyInputParam(String newPropertyId){
 185     if(!newParameterIdsToPropertiesFromOrigNodeTemplate.containsKey(newPropertyId)){
 186       return Optional.empty();
 187     }
 188
 189     return Optional.of(newParameterIdsToPropertiesFromOrigNodeTemplate.get(newPropertyId));
 190   }
 191
 192 }