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   //Key - new property id, Value - orig property value
  29   private Map<String, Object> newParameterIdsToPropertiesFromOrigNodeTemplate = new HashMap<>();
  30   //handled nested files
  31   private Set<String> handledNestedFiles = new HashSet<>();
  32
  33   public Map<String, String> getNodesRelatedAbstractNode() {
  34     return nodesRelatedAbstractNode;
  35   }
  36
  37   public void setNodesRelatedAbstractNode(
  38       Map<String, String> nodesRelatedAbstractNode) {
  39     this.nodesRelatedAbstractNode = nodesRelatedAbstractNode;
  40   }
  41
  42   public Map<String, String> getNodesRelatedSubstitutionServiceTemplateNode() {
  43     return nodesRelatedSubstitutionServiceTemplateNode;
  44   }
  45
  46   public void setNodesRelatedSubstitutionServiceTemplateNode(
  47       Map<String, String> nodesRelatedSubstitutionServiceTemplateNode) {
  48     this.nodesRelatedSubstitutionServiceTemplateNode = nodesRelatedSubstitutionServiceTemplateNode;
  49   }
  50
  51   public String getNodeRelatedAbstractNode(String origNodeId) {
  52     return this.nodesRelatedAbstractNode.get(origNodeId);
  53   }
  54
  55   public Collection<String> getAllRelatedAbstractNodeIds() {
  56     return this.nodesRelatedAbstractNode.values();
  57   }
  58
  59   public Collection<String> getAllUnifiedNestedNodeTemplateIds() {
  60     return this.nestedNodeTemplateRelatedUnifiedTranslatedId.values();
  61   }
  62
  63   /**
  64    * Add cleaned node template.
  65    *
  66    * @param nodeTemplateId           the node template id
  67    * @param unifiedCompositionEntity the unified composition entity
  68    * @param nodeTemplate             the node template
  69    */
  70   public void addCleanedNodeTemplate(String nodeTemplateId,
  71                                      UnifiedCompositionEntity unifiedCompositionEntity,
  72                                      NodeTemplate nodeTemplate) {
  73     NodeTemplateInformation nodeTemplateInformation = new NodeTemplateInformation(
  74         unifiedCompositionEntity, nodeTemplate);
  75     this.cleanedNodeTemplates.putIfAbsent(nodeTemplateId, nodeTemplateInformation);
  76   }
  77
  78   public NodeTemplate getCleanedNodeTemplate(String nodeTemplateId) {
  79     return this.cleanedNodeTemplates.get(nodeTemplateId).getNodeTemplate().clone();
  80   }
  81
  82   public UnifiedCompositionEntity getCleanedNodeTemplateCompositionEntity(String nodeTemplateId) {
  83     return this.cleanedNodeTemplates.get(nodeTemplateId).getUnifiedCompositionEntity();
  84   }
  85
  86   public void addUnifiedNestedNodeTemplateId(String nestedNodeTemplateId,
  87                                              String unifiedNestedNodeRelatedId) {
  88     this.nestedNodeTemplateRelatedUnifiedTranslatedId
  89         .put(nestedNodeTemplateId, unifiedNestedNodeRelatedId);
  90   }
  91
  92   public Optional<String> getUnifiedNestedNodeTemplateId(String nestedNodeTemplateId) {
  93     return this.nestedNodeTemplateRelatedUnifiedTranslatedId.get(nestedNodeTemplateId) == null
  94         ? Optional.empty()
  95         : Optional.of(this.nestedNodeTemplateRelatedUnifiedTranslatedId.get(nestedNodeTemplateId));
  96   }
  97
  98   public void addUnifiedNestedNodeTypeId(String nestedNodeTypeId,
  99                                          String unifiedNestedNodeRelatedId) {
 100     this.nestedNodeTypeRelatedUnifiedTranslatedId.put(nestedNodeTypeId, unifiedNestedNodeRelatedId);
 101   }
 102
 103   public Optional<String> getUnifiedNestedNodeTypeId(String nestedNodeTypeId) {
 104     return this.nestedNodeTypeRelatedUnifiedTranslatedId.get(nestedNodeTypeId) == null ? Optional
 105         .empty()
 106         : Optional.of(this.nestedNodeTypeRelatedUnifiedTranslatedId.get(nestedNodeTypeId));
 107   }
 108
 109   public void addHandledComputeType(String nestedServiceTemplateFileName,
 110                                     String handledComputeType) {
 111
 112     if (this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(handledComputeType)) {
 113       Integer timesHandled =
 114           this.handledComputeTypesInNestedSubstitutionTemplate.get(handledComputeType);
 115       this.handledComputeTypesInNestedSubstitutionTemplate
 116           .put(handledComputeType, timesHandled + 1);
 117     } else {
 118       this.handledNestedFiles.add(nestedServiceTemplateFileName);
 119       handledComputeTypesInNestedSubstitutionTemplate.put(handledComputeType, 0);
 120     }
 121   }
 122
 123   public boolean isComputeTypeHandledInServiceTemplate(String computeType) {
 124     return this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(computeType);
 125   }
 126
 127   public int getHandledNestedComputeNodeTemplateIndex(String computeType) {
 128     return this.handledComputeTypesInNestedSubstitutionTemplate.containsKey(computeType) ?
 129         this.handledComputeTypesInNestedSubstitutionTemplate.get(computeType):
 130         0;
 131   }
 132
 133   public boolean isNestedServiceTemplateWasHandled(String nestedServiceTemplateFileName) {
 134     return this.handledNestedFiles.contains(nestedServiceTemplateFileName);
 135   }
 136
 137   public void addNestedFileToUsedNestedComputeType(String computeType,
 138                                                    String nestedServiceTemplateFileName){
 139     this.handledNestedComputeTypesNestedFiles.putIfAbsent(computeType, new HashSet<>());
 140     this.handledNestedComputeTypesNestedFiles.get(computeType).add(nestedServiceTemplateFileName);
 141   }
 142
 143   public int getGlobalNodeTypeIndex(String computeType){
 144     return this.handledNestedComputeTypesNestedFiles.get(computeType).size() == 1 ? 0:
 145         this.handledNestedComputeTypesNestedFiles.get(computeType).size() - 1;
 146   }
 147
 148   public void addNewPropertyIdToNodeTemplate(String newPropertyId,
 149                                              Object origPropertyValue){
 150     newParameterIdsToPropertiesFromOrigNodeTemplate.putIfAbsent(newPropertyId, origPropertyValue);
 151   }
 152
 153   public Optional<Object> getNewPropertyInputParam(String newPropertyId){
 154     if(!newParameterIdsToPropertiesFromOrigNodeTemplate.containsKey(newPropertyId)){
 155       return Optional.empty();
 156     }
 157
 158     return Optional.of(newParameterIdsToPropertiesFromOrigNodeTemplate.get(newPropertyId));
 159   }
 160
 161   public Map<String, Object> getAllNewPropertyInputParamIds(){
 162     return this.newParameterIdsToPropertiesFromOrigNodeTemplate;
 163   }
 164 }