1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
package org.openecomp.sdc.be.components.merge.property;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.lang.StringUtils;
import org.openecomp.sdc.be.components.impl.ImportUtils;
public abstract class PropertyValueMerger {
abstract Object merge(Object oldVal, Object newVal, List<String> someStrings);
@SuppressWarnings("unchecked")
/**
* merges property value oldVal into property value newVal recursively
* @param oldVal - cannot be {@code Null}
*/
protected Object mergeValues(Object oldVal, Object newVal, List<String> getInputNamesToMerge) {
if (isEmptyValue(newVal)) {
return removeUnwantedGetInputValues(oldVal, getInputNamesToMerge);
}
if (isMapTypeValues(oldVal, newVal)) {
return mergeMapValue((Map<String, Object>) oldVal, (Map<String, Object>) newVal, getInputNamesToMerge);
}
if (isListTypeValues(oldVal, newVal)) {
return mergeListValue((List<Object>) oldVal, (List<Object>) newVal, getInputNamesToMerge);
}
if (isSameTypeValues(oldVal, newVal)) {
return mergeScalarValue(oldVal, newVal);
}
return newVal;
}
private Map<String, Object> mergeMapValue(Map<String, Object> oldValMap, Map<String, Object> newValMap, List<String> getInputNamesToMerge) {
mergeEntriesExistInNewValue(oldValMap, newValMap, getInputNamesToMerge);//continue the recursion
setOldEntriesNotExistInNewValue(oldValMap, newValMap, getInputNamesToMerge);
return newValMap;
}
private void mergeEntriesExistInNewValue(Map<String, Object> oldValMap, Map<String, Object> newValMap, List<String> getInputNamesToMerge) {
for (Map.Entry<String, Object> newValEntry : newValMap.entrySet()) {
Object oldVal = oldValMap.get(newValEntry.getKey());
if (oldVal != null) {
newValMap.put(newValEntry.getKey(), merge(oldVal, newValEntry.getValue(), getInputNamesToMerge));
}
}
}
private void setOldEntriesNotExistInNewValue(Map<String, Object> oldVal, Map<String, Object> newVal, List<String> getInputNamesToMerge) {
for (Map.Entry<String, Object> oldValEntry : oldVal.entrySet()) {
if (!isGetInputEntry(oldValEntry) || isGetInputToMerge(getInputNamesToMerge, oldValEntry)) {
Object oldValObj = oldValEntry.getValue();
newVal.computeIfAbsent(oldValEntry.getKey(), key -> removeUnwantedGetInputValues(oldValObj, getInputNamesToMerge));
}
}
}
private List<Object> mergeListValue(List<Object> oldVal, List<Object> newVal, List<String> getInputNamesToMerge) {
List<Object> mergedList = mergeLists(oldVal, newVal, getInputNamesToMerge);
copyRestOfBiggerList(oldVal, newVal, getInputNamesToMerge, mergedList);
return mergedList;
}
private void copyRestOfBiggerList(List<Object> oldVal, List<Object> newVal, List<String> getInputNamesToMerge, List<Object> mergedList) {
if (oldVal.size() == newVal.size()) {
return;
}
int maxListSize = Math.max(oldVal.size(), newVal.size());
List<Object> greaterList = newVal.size() == maxListSize ? newVal : oldVal;
for (int i = mergedList.size(); i < maxListSize; i ++) {
Object listVal = greaterList.get(i);
Object listValToMerge = greaterList == oldVal ? removeUnwantedGetInputValues(listVal, getInputNamesToMerge) : listVal;
mergedList.add(listValToMerge);
}
}
private List<Object> mergeLists(List<Object> oldVal, List<Object> newVal, List<String> getInputNamesToMerge) {
int minListSize = Math.min(oldVal.size(), newVal.size());
List<Object> mergedList = new ArrayList<>();
for (int i = 0; i < minListSize; i++) {
Object mergedVal = merge(oldVal.get(i), newVal.get(i), getInputNamesToMerge);
mergedList.add(mergedVal);
}
return mergedList;
}
Object mergeScalarValue(Object oldVal, Object newVal) {
return isEmptyValue(newVal) ? oldVal : newVal;
}
@SuppressWarnings("unchecked")
Object removeUnwantedGetInputValues(Object val, List<String> getInputNamesToMerge) {
if (val instanceof Map) {
return removeUnwantedGetInputValues((Map<String, Object>) val, getInputNamesToMerge);
}
if (val instanceof List) {
return removeUnwantedGetInputValues((List<Object>)val, getInputNamesToMerge);
}
return val;
}
private List<Object> removeUnwantedGetInputValues(List<Object> listVal, List<String> getInputNamesToMerge) {
return listVal.stream().map(val -> removeUnwantedGetInputValues(val, getInputNamesToMerge)).collect(Collectors.toList());
}
private Map<String, Object> removeUnwantedGetInputValues(Map<String, Object> val, List<String> getInputNamesToMerge) {
return val.entrySet().stream().filter(entry -> !isGetInputEntry(entry) || isGetInputToMerge(getInputNamesToMerge, entry))
.collect(Collectors.toMap(Map.Entry::getKey, entry -> removeUnwantedGetInputValues(entry.getValue(), getInputNamesToMerge)));
}
private boolean isGetInputToMerge(List<String> getInputNamesToMerge, Map.Entry<String, Object> entry) {
return getInputNamesToMerge.contains(retrieveGetInputInputName(entry.getValue()));
}
private boolean isMapTypeValues(Object oldVal, Object newVal) {
return newVal instanceof Map && oldVal instanceof Map;
}
private boolean isListTypeValues(Object oldVal, Object newVal) {
return newVal instanceof List && oldVal instanceof List;
}
private boolean isSameTypeValues(Object oldVal, Object newVal) {
return oldVal.getClass().equals(newVal.getClass());
}
private String retrieveGetInputInputName(Object getInputValue) {
return getInputValue instanceof List ? (String)((List) getInputValue).get(0) : (String)getInputValue;
}
private boolean isGetInputEntry(Map.Entry<String, Object> oldValEntry) {
return oldValEntry.getKey().equals(ImportUtils.ToscaTagNamesEnum.GET_INPUT.getElementName());
}
private boolean isEmptyValue(Object val) {
return val == null ||
val instanceof String && StringUtils.isEmpty((String)val) ||
val instanceof Map && ((Map) val).isEmpty() ||
val instanceof List && ((List) val).isEmpty();
}
}
|
