Example #1
0
 @SuppressWarnings("unchecked")
 private void merge(Map.Entry<Path, Object> simpleEntry, Map<String, Object> compositionMap) {
   Path path = simpleEntry.getKey();
   String head = path.head();
   assert head != null;
   Object nextLevelComposition = compositionMap.get(head);
   Path tail = path.tail();
   Object simpleValue = simpleEntry.getValue();
   if (nextLevelComposition == null) {
     mergeEntryIntoEmptySlot(compositionMap, head, tail, simpleValue);
   } else if (Types.isSimple(nextLevelComposition)) {
     mergeEntryWithSimple(compositionMap, nextLevelComposition, head, tail, simpleValue);
   } else {
     mergeEntryWithStructure((Map<String, Object>) nextLevelComposition, tail, simpleValue);
   }
 }
Example #2
0
 private void mergeEntryIntoEmptySlot(
     Map<String, Object> composition, String head, Path tail, Object simpleValue) {
   if (tail.isEmpty()) {
     composition.put(head, simpleValue);
   } else {
     composition.put(head, composeMap(Collections.singletonMap(tail, simpleValue)));
   }
 }
Example #3
0
 private void mergeEntryWithStructure(
     Map<String, Object> nextLevelComposition, Path tail, Object simpleValue) {
   if (tail.isEmpty()) {
     // INCONSISTENCY!! there is a simple value at the same level as a complex object
     // Resolve this by putting this value at the special key "@ROOT" inside the complex object.
     Object previousValue = nextLevelComposition.put(INCONSISTENT_ROOT, simpleValue);
     // not possible to have a previous value, there can only be one key with this path
     if (previousValue != null) {
       // merging two simple values at same level, this cannot happen because map keys are unique
       throw new IllegalStateException("two simple values at same level?");
     }
   } else {
     // simply advance to next level since the head matches a key already there
     merge(new SimpleEntry<Path, Object>(tail, simpleValue), nextLevelComposition);
   }
 }
Example #4
0
  private void mergeEntryWithSimple(
      Map<String, Object> composition,
      Object nextLevelComposition,
      String head,
      Path tail,
      Object simpleValue) {
    if (tail.isEmpty()) {
      // merging two simple values at same level, this cannot happen because map keys are unique
      throw new IllegalStateException("two simple values at same level?");
    }

    // merging longer path with simple value
    Map<String, Object> map = composeMap(Collections.singletonMap(tail, simpleValue));
    map.put(INCONSISTENT_ROOT, nextLevelComposition);
    // replace the simple value with map containing simple value and inconsistent root
    composition.put(head, map);
  }