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