Example #1
0
 /**
  * This method trims doc (1st arg) according to projected (2nd arg), which may have been modified
  * by projection. This method works in-place, meaning that the doc may be mutated.
  */
 private static void trim(DataMap doc, DataMap projected) {
   DataMap toAddDoc = new DataMap();
   Set<String> fields = doc.keySet();
   List<String> toRemoveDoc = new ArrayList<String>(fields.size());
   for (String f : fields) {
     Object v = doc.get(f);
     if (f.equals(PatchConstants.DELETE_COMMAND)) {
       DataList deletedFields = (DataList) v;
       DataList filteredDeleteFields = new DataList();
       for (Object patchDeleteField : deletedFields) {
         if (projected.containsKey(patchDeleteField)) {
           filteredDeleteFields.add(patchDeleteField);
         }
       }
       toRemoveDoc.add(f);
       if (!filteredDeleteFields.isEmpty()) {
         toAddDoc.put(PatchConstants.DELETE_COMMAND, filteredDeleteFields);
       }
     } else if (f.equals(PatchConstants.SET_COMMAND)) {
       DataMap setFields = (DataMap) v;
       Set<String> setFieldNames = setFields.keySet();
       List<String> toRemove = new LinkedList<String>();
       DataMap filteredSetFields = new DataMap();
       for (String setFieldName : setFieldNames) {
         if (projected.containsKey(setFieldName)) {
           filteredSetFields.put(setFieldName, projected.get(setFieldName));
         }
         toRemove.add(setFieldName);
       }
       for (String fieldToRemove : toRemove) {
         setFields.remove(fieldToRemove);
         if (filteredSetFields.containsKey(fieldToRemove)) {
           setFields.put(fieldToRemove, filteredSetFields.get(fieldToRemove));
         }
       }
       if (setFields.isEmpty()) {
         toRemoveDoc.add(f);
       }
     } else if (v instanceof DataMap) {
       if (projected.containsKey(f)) {
         trim((DataMap) v, (DataMap) projected.get(f));
       } else {
         toRemoveDoc.add(f);
       }
     }
   }
   // apply changes to doc
   for (String f : toRemoveDoc) {
     doc.remove(f);
   }
   for (String f : toAddDoc.keySet()) {
     doc.put(f, toAddDoc.get(f));
   }
 }
Example #2
0
  // TODO modify this method to accept a CollectionRequest as it's first parameter once our server
  // code has been
  //      updated to work with the new representation of BatchUpdateRequests and
  // BatchPartialUpdateRequests. As of now
  //      we are still converting to the old representation using
  // CollectionRequestUtil.convertToBatchRequest
  private static void checkInput(
      DataMap dataMap, Map<Long, Greeting> inputMap, Set<String> uriIds) {
    Assert.assertEquals(dataMap.size(), uriIds.size());

    for (String key : dataMap.keySet()) {
      DataMap inputDM = dataMap.getDataMap(key);
      Greeting expectedGreeting = inputMap.get(Long.parseLong(key));
      Assert.assertTrue(uriIds.contains(key));
      Assert.assertTrue(inputDM.equals(expectedGreeting.data()));
    }
  }
Example #3
0
 /**
  * This method 'exposes' changes conveyed in the patch's meta commands to the main document.
  * Contents of $set commands are moved to the node which contains $set command. Names of removed
  * fields from $delete commands are moved to the nod which contains $delete command. The effect is
  * that patch will resemble structurally document which it is supposed to modify. This allows
  * application of projection to such patch to discover which changes relate to fields specified by
  * that projection. Examples: $delete: ['x', 'y', 'z'] => x: true, y: true, z: true $set: {x: 10,
  * y: {z: 'yeey'}, t: [10]} => x: 10, y: {z: 'yeey'}, t: [10]
  *
  * <p>This method works in-place, meaning that the doc may be mutated.
  */
 private static void expose(DataMap doc) {
   Set<String> fields = doc.keySet();
   DataMap toAdd = new DataMap();
   for (String f : fields) {
     Object v = doc.get(f);
     if (f.equals(PatchConstants.DELETE_COMMAND)) {
       for (Object removedFields : (DataList) v) {
         toAdd.put((String) removedFields, true);
       }
     } else if (f.equals(PatchConstants.SET_COMMAND)) {
       toAdd.putAll((DataMap) v);
     } else if (v instanceof DataMap) {
       expose((DataMap) v);
     }
   }
   doc.putAll(toAdd);
 }