org.ojai.FieldPath Java Examples

@Test
public void testFieldPathEscapedInvalidSequences() {
  String[] validSequences = {"\\`", "\\\"", "\\\\", "\\.", "\\[", "\\]"};
  String sequence = null;
  try {
    for (String validSequence : validSequences) {
      sequence = validSequence;
      FieldPath.parseFrom(validSequence);

      // quoted with double-quote
      sequence = "\"" + validSequence + "\"";
      FieldPath.parseFrom(sequence);

      // quoted with back-tick
      sequence = "`" + validSequence + "`";
      FieldPath.parseFrom(sequence);
    }
  } catch (IllegalArgumentException e) {
    fail("FieldPath parsing failed for sequence: " + hexDump(sequence));
  }
}
 

static DocumentStream newDocumentStream(FileSystem fs,
    Path path, Map<FieldPath, Type> map, Events.Delegate delegate)
        throws IllegalArgumentException, IOException {
  final InputStream in = fs.open(path);
  return new JsonDocumentStream(in, map, delegate) {
    @Override
    public void close() {
      try {
        super.close();
      } finally {
        try {
          in.close();
        } catch (IOException e) {
          throw new OjaiException(e);
        }
      }
    }
  };
}
 

private void handleUpdate(ChangeDataRecord changeDataRecord) {

        String documentId = changeDataRecord.getId().getString();
        log.debug("Updated document with id = '{}'", documentId);

        if (this.onUpdate == null) {
            return;
        }

        ObjectNode changes = mapper.createObjectNode();
        for (Map.Entry<FieldPath, ChangeNode> changeNodeEntry : changeDataRecord) {

            ChangeNode changeNode = changeNodeEntry.getValue();
            String jsonString = changeNode.getValue().asJsonString();
            String fieldPathAsString = changeNodeEntry.getKey().asPathString();
            changes.set(fieldPathAsString, parseJsonString(jsonString));
        }

        this.onUpdate.callback(documentId, changes);
    }
 

@Test
public void testSimplePathSingleSegment() {
  FieldPath fp = FieldPath.parseFrom("a");
  assertTrue(fp.getRootSegment().isLeaf());
  assertEquals("\"a\"", fp.asPathString(true));
  assertEquals("a", fp.asPathString());
  assertEquals("\"a\"", fp.asJsonString());
}
 

@Test
public void testEscapedPathDoubleSegment() {
  FieldPath fp = FieldPath.parseFrom("\"a.b\"");
  assertTrue(fp.getRootSegment().isLeaf());
  assertEquals("\"a.b\"", fp.asPathString());
  assertEquals("\"a.b\"", fp.asPathString(false));
  assertEquals("\"\\\"a.b\\\"\"", fp.asJsonString());
}
 

@Test
public void testQuotedEscapedPath() {
  FieldPath fp = FieldPath.parseFrom("\"the\\\"quick.brown\\\\fox\"");
  assertTrue(fp.getRootSegment().isLastPath());
  assertEquals("\"the\\\"quick.brown\\\\fox\"", fp.asPathString(true));
  assertEquals("\"the\\\"quick.brown\\\\fox\"", fp.asPathString(false));
  assertEquals("\"the\\\"quick.brown\\\\fox\"", fp.asPathString());
  assertEquals("\"\\\"the\\\\\"quick.brown\\\\fox\\\"\"", fp.asJsonString());
}
 

@Test
public void testPathWithSpace() {
  FieldPath fp = FieldPath.parseFrom("work phone.cell phone");
  assertFalse(fp.getRootSegment().isLeaf());
  assertTrue(fp.getRootSegment().getChild().isLeaf());
  assertEquals("\"work phone\".\"cell phone\"", fp.asPathString(true));
  assertEquals("work phone.cell phone", fp.asPathString());
  assertEquals("\"work phone.cell phone\"", fp.asJsonString());

  fp = FieldPath.parseFrom("a[ ]");
  assertEquals("\"a\"[]", fp.asPathString(true));
  assertEquals("a[]", fp.asPathString());
  assertEquals("\"a[]\"", fp.asJsonString());
}
 

@Test
public void testCloneWithNewParent() {
  FieldPath fp1 = FieldPath.parseFrom("a.b.c");
  FieldPath fp2 = fp1.cloneWithNewParent("v");
  assertEquals("v.a.b.c", fp2.asPathString());
  assertEquals(fp1.getRootSegment(), fp2.getRootSegment().getChild());
}
 

@Override
public double getDouble(FieldPath fieldPath) {
  checkForArrayNotation(fieldPath);
  JsonValue value = getKeyValueAt(fieldPath.iterator());
  testNoSuchElement(fieldPath, value);
  return value.getDouble();
}
 

public static void checkForArrayNotation(FieldPath fp) {
  FieldSegment curSegment = fp.getRootSegment();
  while (curSegment != null) {
    if (curSegment.isIndexed() && !curSegment.getIndexSegment().hasIndex()) {
      throw new IllegalArgumentException(
          ELEMENTS_ALL + " cannot be used to get/set/delete" +
              " a value in a Document");
    }
    curSegment = curSegment.getChild();
  }
}
 

@Override
public OInterval getInterval(FieldPath fieldPath) {
  JsonValue v = getKeyValueAt(fieldPath.iterator());
  if (v != null) {
    return v.getInterval();
  }
  return null;
}
 

protected BaseFieldProjector(@NonNullable Collection<FieldPath> includedPaths) {
  rootSegment = new ProjectionTree(DOCUMENT_ROOT, null);
  for (FieldPath includedPath : Preconditions.checkNotNull(includedPaths)) {
    rootSegment.addOrGetChild(includedPath.getRootSegment());
  }
  finishConstruction();
}
 

@Override
public BigDecimal getDecimal(FieldPath fieldPath) {
  checkForArrayNotation(fieldPath);
  JsonValue v = getKeyValueAt(fieldPath.iterator());
  if (v != null) {
    return v.getDecimal();
  }
  return null;
}
 

@Override
public Float getFloatObj(FieldPath fieldPath) {
  checkForArrayNotation(fieldPath);
  JsonValue value = getKeyValueAt(fieldPath.iterator());
  if (value != null) {
    return value.getFloat();
  }
  return null;
}
 

@Override
public Document setArray(FieldPath fieldPath, String[] values) {
  return setCommonFromObjectArray(fieldPath, values);
}
 

private void testNoSuchElement(FieldPath fieldPath, JsonValue value) {
  if (value == null) {
    throw new NoSuchElementException("Field '"
        + fieldPath.asPathString() + "' not found in the document.");
  }
}
 

@Override
public Document set(FieldPath fieldPath, boolean value) {
  return setCommon(fieldPath, new JsonValue(value, Type.BOOLEAN));
}
 

@Override
public Document set(FieldPath fieldPath, float value) {
  throw readOnly();
}
 

@Override
public Document set(FieldPath fieldPath, int value) {

  return setCommon(fieldPath, new JsonValue(value, Type.INT));
}
 

@Override
public Document set(FieldPath fieldPath, OInterval value) {
  throw readOnly();
}
 

@Override
public Document set(String fieldPath, byte value) {
  return set(FieldPath.parseFrom(fieldPath), value);
}
 

Map<FieldPath, Type> getFieldPathTypeMap() {
  return fieldPathTypeMap;
}
 

@Override
public short getShort(FieldPath fieldPath) {
  return wrapped.getShort(fieldPath);
}
 

@Override
public Byte getByteObj(FieldPath fieldPath) {
  return wrapped.getByteObj(fieldPath);
}
 

@Override
public int getInt(String fieldPath) {
  return getInt(FieldPath.parseFrom(fieldPath));
}
 

/**
 * Returns the value at the specified fieldPath as a {@link Value} or the
 * specified {@code defaultValue} if the specified {@code FieldPath} does not
 * exist in the document.
 */
public static Value getValue(@NonNullable Document document,
    @NonNullable FieldPath fieldPath, @Nullable Value defaultValue) {
  Value docValue = document.getValue(fieldPath);
  return docValue != null ? docValue : defaultValue;
}
 

@Override
public Document setArray(String fieldPath, byte[] values) {
  return setArray(FieldPath.parseFrom(fieldPath), values);
}
 

@Override
public double getDouble(String fieldPath) {
  return getDouble(FieldPath.parseFrom(fieldPath));
}
 

@Override
public Document setArray(String fieldPath, float[] values) {
  return setArray(FieldPath.parseFrom(fieldPath), values);
}
 

@Override
public OTimestamp getTimestamp(String fieldPath) {
  return getTimestamp(FieldPath.parseFrom(fieldPath));
}