![[Jenkins]](/jenkins/static/5c0124f8/images/svgs/logo.svg){kind=logo}
Package: AssArray
AssArray
| name | instruction | branch | complexity | line | method | ||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| AssArray(AbstractVariableDefinition, Map) |
|
|
|
|
|
||||||||||||||||||||
| convertAssignmentList(Map) |
|
|
|
|
|
||||||||||||||||||||
| createAssArray(RouterConfiguration, String) |
|
|
|
|
|
||||||||||||||||||||
| filterAssignments(RouterConfiguration, Map.Entry, List) |
|
|
|
|
|
||||||||||||||||||||
| getAsses() |
|
|
|
|
|
||||||||||||||||||||
| getDefinition() |
|
|
|
|
|
||||||||||||||||||||
| getIndexes(String) |
|
|
|
|
|
||||||||||||||||||||
| getValues(RouterConfiguration, String, List) |
|
|
|
|
|
||||||||||||||||||||
| recursiveFilter(RouterConfiguration, Map.Entry, AbstractVariableDefinition, List, List) |
|
|
|
|
|
||||||||||||||||||||
Coverage
1: /**
2: *
3: */
4: package model.assignmentarray;
5:
6: import java.util.ArrayList;
7: import java.util.HashMap;
8: import java.util.Iterator;
9: import java.util.List;
10: import java.util.Map;
11: import java.util.Map.Entry;
12: import java.util.regex.Matcher;
13: import java.util.regex.Pattern;
14:
15: import model.RouterConfiguration;
16: import model.assignment.VariableAssignment;
17: import model.definition.AbstractVariableDefinition;
18: import model.definition.VariableDefinitionArray;
19: import model.exceptions.DefinitionNotFoundException;
20:
21: /**
22: * @author Muri
23: *
24: */
25: public final class AssArray {
26:
27: /**
28: *
29: */
30: private final transient AbstractVariableDefinition definition;
31: /**
32: *
33: */
34: private final transient Map<ArrayList<Integer>, VariableAssignment> asses;
35:
36: /**
37: *
38: * @param definition
39: * definition
40: * @param asses
41: * asses
42: */
43: private AssArray(final AbstractVariableDefinition definition,
44: final Map<String, VariableAssignment> asses) {
45: this.definition = definition;
46: this.asses = convertAssignmentList(asses);
47: }
48:
49: /**
50: *
51: * @param rc
52: * The router configuration.
53: * @param varDefName
54: * variableDefinitionName
55: * @throws DefinitionNotFoundException
56: * DefinitionNotFoundException
57: * @return AssArray
58: */
59: private static AssArray createAssArray(final RouterConfiguration rc, final String varDefName)
60: throws DefinitionNotFoundException {
61: final AbstractVariableDefinition definition =
62: rc.getRouterSoftware().findDefinition(varDefName);
63:• if (definition == null) {
64: throw new DefinitionNotFoundException(basic.ModelConstants.DEFNOTFOUND_EXCEPTION);
65: }
66: final Map<String, VariableAssignment> asses = rc.findAssesByDefinition(definition);
67:
68: final AssArray newAssArray = new AssArray(definition, asses);
69:
70: final List<ArrayList<Integer>> toBeRemoved = new ArrayList<ArrayList<Integer>>();
71: final Iterator<Entry<ArrayList<Integer>, VariableAssignment>> ator =
72: newAssArray.getAsses().entrySet().iterator();
73:• while (ator.hasNext()) {
74: newAssArray.filterAssignments(rc, ator.next(), toBeRemoved);
75: }
76:• for (final ArrayList<Integer> key : toBeRemoved) {
77: newAssArray.getAsses().remove(key);
78: }
79:
80: return newAssArray;
81: }
82:
83: /**
84: *
85: * @param rc
86: * The router configuration.
87: * @param varName
88: * varName
89: * @param indexes
90: * indexes
91: * @return String
92: * @throws DefinitionNotFoundException
93: * DefinitionNotFoundException
94: */
95: public static Map<ArrayList<Integer>, VariableAssignment> getValues(
96: final RouterConfiguration rc, final String varName, final List<Integer> indexes)
97: throws DefinitionNotFoundException {
98: final AssArray assArray = createAssArray(rc, varName);
99: final Map<ArrayList<Integer>, VariableAssignment> reducedAsses =
100: new HashMap<ArrayList<Integer>, VariableAssignment>();
101: reducedAsses.putAll(assArray.asses);
102: Integer indexCount = 0;
103:• for (Integer index : indexes) {
104:
105: final Iterator<Entry<ArrayList<Integer>, VariableAssignment>> iter =
106: reducedAsses.entrySet().iterator();
107:• while (iter.hasNext()) {
108: final Entry<ArrayList<Integer>, VariableAssignment> entry = iter.next();
109: final ArrayList<Integer> currentKey = entry.getKey();
110:• if (!currentKey.get(indexCount).equals(index)) {
111: iter.remove();
112: }
113: }
114: indexCount++;
115: }
116: return reducedAsses;
117: }
118:
119: /**
120: *
121: * @param rc
122: * The router configuration.
123: * @param checkAss
124: * assignment to filter.
125: * @param toBeRemoved
126: * The asignments to be removed.
127: * @throws DefinitionNotFoundException
128: * DefinitionNotFoundException
129: */
130: private void filterAssignments(final RouterConfiguration rc,
131: final Entry<ArrayList<Integer>, VariableAssignment> checkAss,
132: final List<ArrayList<Integer>> toBeRemoved) throws DefinitionNotFoundException {
133:
134: final AbstractVariableDefinition assDef = checkAss.getValue().getDefinition();
135:• if (assDef instanceof VariableDefinitionArray) {
136:
137: final AbstractVariableDefinition varN =
138: ((VariableDefinitionArray) assDef).getVariableN();
139:
140: final List<Integer> assIndexes = new ArrayList<Integer>();
141:• for (Integer index : checkAss.getKey()) {
142: assIndexes.add(index);
143: }
144:
145: recursiveFilter(rc, checkAss, varN, assIndexes, toBeRemoved);
146: }
147: }
148:
149: /**
150: *
151: * @param rc
152: * The router configuration.
153: * @param checkAss
154: * Assignment to check for filtering.
155: * @param varN
156: * current recursive iteration VariableN changes with every iteration.
157: * @param assIndexes
158: * assignment indexes. removes one on every iteration.
159: * @param toBeRemoved
160: * The asignments to be removed.
161: * @throws DefinitionNotFoundException
162: * DefinitionNotFoundException
163: */
164: private void recursiveFilter(final RouterConfiguration rc,
165: final Entry<ArrayList<Integer>, VariableAssignment> checkAss,
166: final AbstractVariableDefinition varN, final List<Integer> assIndexes,
167: final List<ArrayList<Integer>> toBeRemoved) throws DefinitionNotFoundException {
168: final Integer removedIndex = assIndexes.remove(assIndexes.size() - 1);
169:
170: final Map<ArrayList<Integer>, VariableAssignment> varNAssMap =
171: getValues(rc, varN.getName(), assIndexes);
172:
173: // entrySet().iterator().next().getValue() is used to get the first (and only one)
174: // element out of the Map returned by getValues(). Its the only one because the VarN
175: // can only be an Array with one dimension less than the Array where the assignment
176: // comes from and we are providing n-1 indexes. Where n are all Indexes of the
177: // Assigment.
178: final VariableAssignment varNAss = varNAssMap.entrySet().iterator().next().getValue();
179:
180: final Integer varNVal = Integer.valueOf(varNAss.getValue());
181:
182:• if (varNVal <= removedIndex) {
183: toBeRemoved.add(checkAss.getKey());
184: } else {
185:• if (varN instanceof VariableDefinitionArray) {
186: this.recursiveFilter(rc, checkAss, varN, assIndexes, toBeRemoved);
187: }
188: }
189: }
190:
191: /**
192: *
193: * @param assList
194: * list of Assignments.
195: * @return converted List of Assignments.
196: */
197: private Map<ArrayList<Integer>, VariableAssignment>
198: convertAssignmentList(final Map<String, VariableAssignment> assList) {
199: final HashMap<ArrayList<Integer>, VariableAssignment> convertedList =
200: new HashMap<ArrayList<Integer>, VariableAssignment>();
201:
202:• for (Entry<String, VariableAssignment> assignment : assList.entrySet()) {
203: convertedList.put((ArrayList<Integer>) getIndexes(assignment.getKey()),
204: assignment.getValue());
205: }
206: return convertedList;
207: }
208:
209: /**
210: * @return the asses
211: */
212: public Map<ArrayList<Integer>, VariableAssignment> getAsses() {
213: return this.asses;
214: }
215:
216: /**
217: *
218: * @param identifier
219: * identifier
220: * @return ArrayList<Integer>
221: */
222: public List<Integer> getIndexes(final String identifier) {
223: final String string = identifier;
224: final ArrayList<Integer> result = new ArrayList<Integer>();
225:
226: final Pattern patttern = Pattern.compile("(_([0-9]+)_)|(_([0-9]+)$)");
227: final Matcher matcher = patttern.matcher(new StringBuilder(string));
228:• while (matcher.find()) {
229: final String tmpString = matcher.group(0);
230: final String number = tmpString.replaceFirst(".*?(\\d+).*", "$1");
231: result.add(Integer.parseInt(number));
232: }
233: return result;
234: }
235:
236: /**
237: * @return the definition
238: */
239: public AbstractVariableDefinition getDefinition() {
240: return this.definition;
241: }
242:
243: }