if (embeddedList!=null) { for (EmbeddedEntity embeddedEntity: embeddedList) { list.add((T) embeddedEntity.getProperty("value")); if (list!=null) { for (T item: list) { EmbeddedEntity embeddedItem = new EmbeddedEntity(); embeddedItem.setUnindexedProperty("value", item); embeddedList.add(embeddedItem);
Person p = new Person(id); p.setName((String) e.getProperty("name")); p.setToken((String) e.getProperty("token")); p.setMessages((List<String>) e.getProperty("messages")); p.setCompletedTests((List<String>) e.getProperty("completedTests")); Map<String, String> ti = new HashMap<>(); EmbeddedEntity ee = (EmbeddedEntity) e.getProperty("testInformation"); if (ee != null) { for (String key : ee.getProperties().keySet()) { ti.put(key, (String) ee.getProperty(key)); } p.setTestInformation(ti); } p.setEntity(e);
Entity e = new Entity("2d"); EmbeddedEntity ee = new EmbeddedEntity(); ArrayList<String> x = new ArrayList<String>(); // add stuff to x ArrayList<String> y = new ArrayList<String>(); // add stuff to y ArrayList<String> z = new ArrayList<String>(); // add stuff to z ee.setProperty("1", x); ee.setProperty("2", y); ee.setProperty("3", z); e.setProperty("2dArray", ee);
// Entity contactInfo = /*...*/; EmbeddedEntity embeddedContactInfo = new EmbeddedEntity(); Key infoKey; infoKey = contactInfo.getKey(); embeddedContactInfo.setKey(infoKey);
@Test public void findOrInsert() { EmbeddedEntity entity = new EmbeddedEntity(); int index1 = StringPools.findOrInsertStringInPool(entity, "pool", "HH1"); int index2 = StringPools.findOrInsertStringInPool(entity, "pool", "HH2"); int index3 = StringPools.findOrInsertStringInPool(entity, "pool", "HH2"); int index4 = StringPools.findOrInsertStringInPool(entity, "pool", "HHH2"); Blob pool = (Blob) entity.getProperty("pool"); assertThat(StringPools.toArray(pool), Matchers.arrayContaining("HH1", "HH2", "HHH2")); assertThat(index1, equalTo(1)); assertThat(index2, equalTo(2)); assertThat(index3, equalTo(2)); assertThat(index4, equalTo(3)); }
public void setFieldValues(FormClass formClass, Map<ResourceId, FieldValue> values) { if(fieldValues == null) { fieldValues = new EmbeddedEntity(); } for (FormField field : formClass.getFields()) { if(values.containsKey(field.getId())) { FieldValue value = values.get(field.getId()); if(value == null) { fieldValues.removeProperty(field.getName()); } else { FieldConverter converter = FieldConverters.forType(field.getType()); fieldValues.setUnindexedProperty(field.getName(), converter.toHrdProperty(value)); } } } }
public static EmbeddedEntity toEmbeddedEntity(JsonValue record) { EmbeddedEntity entity = new EmbeddedEntity(); for (Map.Entry<String, JsonValue> entry : record.entrySet()) { entity.setUnindexedProperty(entry.getKey(), toPropertyValue(entry.getValue())); } return entity; }
EmbeddedEntity newRec0 = new EmbeddedEntity(); newRec0.setProperty("stringData", "check6009464"); newRec0.setProperty("timestamp", new Date()); assertEquals("have entity property", readRec.getProperty("stringData")); assertEquals(readRec.getProperty("entityDat").getClass(), EmbeddedEntity.class); Entity e = new Entity(ee2.getKey()); e.setPropertiesFrom(ee2); assertEquals("check6009464", e.getProperty("stringData"));
private byte[] block(String string) { assert string.length() <= 16; EmbeddedEntity entity = new EmbeddedEntity(); for (int i = 0; i < string.length(); i++) { BlobBitSet.update(entity, "bits", i, string.charAt(i) == 'X'); } return BlobBitSet.read(entity, "bits"); }
private Optional<String> periodKeyFromPeriodField(FormRecordSnapshotEntity snapshot) { Optional<FormField> periodField = formClass.getFieldIfPresent(ResourceId.valueOf("period")); if (periodField.isPresent()) { FieldConverter converter = FieldConverters.forType(periodField.get().getType()); Object period = snapshot.getRecord().getFieldValues().getProperty(periodField.get().getName()); FieldValue periodValue = converter.toFieldValue(period); return periodValue != null ? Optional.of(periodValue.toString()) : Optional.absent(); } else { return Optional.absent(); } }
private long estimateSizeInBytes(FormRecordEntity entity) { int numFields = entity.getFieldValues().getProperties().size(); return 40L + (numFields * 20L); }
@Test public void updateZero() { EmbeddedEntity block = new EmbeddedEntity(); OffsetArray.updateOffset(block, PROPERTY, 0, (char)19); OffsetArray.updateOffset(block, PROPERTY, 1, (char)534); // Update the zero in the beginning of the array OffsetArray.updateOffset(block, PROPERTY, 0, (char)0); assertThat(OffsetArray.get(block, PROPERTY, 0), equalTo(0)); // Update the zero at the end of the array OffsetArray.updateOffset(block, PROPERTY, 1, (char)0); assertThat(OffsetArray.get(block, PROPERTY, 0), equalTo(0)); assertThat(OffsetArray.get(block, PROPERTY, 1), equalTo(0)); // Update a zero beyond the allocate range OffsetArray.updateOffset(block, PROPERTY, 2, (char)0); assertThat(OffsetArray.get(block, PROPERTY, 0), equalTo(0)); assertThat(OffsetArray.get(block, PROPERTY, 1), equalTo(0)); byte[] bytes = ((Blob) block.getProperty(PROPERTY)).getBytes(); assertThat(bytes.length, equalTo(4)); }
@Test public void test() { EmbeddedEntity entity = new EmbeddedEntity(); BlobBitSet.update(entity, "bits", 1, true); BlobBitSet.update(entity, "bits", 3, true); BlobBitSet.update(entity, "bits", 50, false); BlobBitSet.update(entity, "bits", 230, true); BlobBitSet.update(entity, "bits", 10240, false); BlobBitSet.update(entity, "bits", 1, false); byte[] bytes = BlobBitSet.read(entity, "bits"); assertThat(bytes.length, equalTo(29)); assertThat(BlobBitSet.get(bytes, 0), equalTo(false)); assertThat(BlobBitSet.get(bytes, 1), equalTo(false)); assertThat(BlobBitSet.get(bytes, 3), equalTo(true)); assertThat(BlobBitSet.get(bytes, 4), equalTo(false)); assertThat(BlobBitSet.get(bytes, 50), equalTo(false)); assertThat(BlobBitSet.get(bytes, 230), equalTo(true)); assertThat(BlobBitSet.get(bytes, 10240), equalTo(false)); assertThat(BlobBitSet.cardinality(bytes), equalTo(2)); }
public void onNext(EmbeddedEntity entity) { Object value = entity.getProperty(name); if(value == null) { observer.onNext(null); } else { observer.onNext(converter.toFieldValue(value)); } } }
public static JsonValue fromEmbeddedEntity(EmbeddedEntity entity) { JsonValue record = Json.createObject(); for (Map.Entry<String, Object> entry : entity.getProperties().entrySet()) { if(entry.getValue() != null) { record.add(entry.getKey(), fromPropertyValue(entry.getValue())); } } return record; }
@Test public void test() { EmbeddedEntity block = new EmbeddedEntity(); assertTrue(OffsetArray.updateOffset(block, PROPERTY, 0, (char)19)); assertTrue(OffsetArray.updateOffset(block, PROPERTY, 1, (char)534)); assertFalse(OffsetArray.updateOffset(block, PROPERTY, 2, (char)0)); assertTrue(OffsetArray.updateOffset(block, PROPERTY, 3, (char)2)); assertTrue(OffsetArray.updateOffset(block, PROPERTY, 4, (char)1024)); byte[] bitset = ((Blob) block.getProperty(PROPERTY)).getBytes(); assertThat(OffsetArray.get(bitset, 0), equalTo(19)); assertThat(OffsetArray.get(bitset, 1), equalTo(534)); assertThat(OffsetArray.get(bitset, 2), equalTo(0)); assertThat(OffsetArray.get(bitset, 3), equalTo(2)); assertThat(OffsetArray.get(bitset, 4), equalTo(1024)); }
@Override public boolean savePerson(Person p) { if (p.getEntity() == null) { return false; } p.getEntity().setProperty("name", p.getName()); p.getEntity().setProperty("token", p.getToken()); p.getEntity().setProperty("messages", p.getMessages()); p.getEntity().setProperty("completedTests", p.getCompletedTests()); EmbeddedEntity ee = new EmbeddedEntity(); Map<String, String> testInformation = p.getTestInformation(); for (String key : testInformation.keySet()) { // TODO: maybe there is a more efficient way of solving this ee.setProperty(key, testInformation.get(key)); } p.getEntity().setProperty("testInformation", ee); DatastoreServiceFactory.getDatastoreService().put(p.getEntity()); return true; }
public Map<ResourceId, FieldValue> toFieldValueMap(FormClass formClass) { Map<ResourceId, FieldValue> map = new HashMap<>(); for (FormField formField : formClass.getFields()) { Object value = fieldValues.getProperty(formField.getName()); if(value != null) { FieldConverter<?> converter = FieldConverters.forType(formField.getType()); map.put(formField.getId(), converter.toFieldValue(value)); } } return map; }
@Test public void test() throws Exception { EmbeddedEntity embedded = new EmbeddedEntity(); embedded.setProperty("string", "foo"); Entity entity = createTestEntity(); entity.setProperty("embedded", embedded); Key key = service.put(entity); Entity storedEntity = service.get(key); EmbeddedEntity storedEmbedded = (EmbeddedEntity) storedEntity.getProperty("embedded"); assertEquals(embedded, storedEmbedded); } }
@Override public void onNext(Entity value) { EmbeddedEntity fieldValues = (EmbeddedEntity) value.getProperty("fieldValues"); Object property = fieldValues.getProperty(PROPERTY_NAME); if(property instanceof String) { observer.onNext(periodType.parseString((String) property)); } else { Key recordKey = value.getKey(); Key formKey = recordKey.getParent(); RecordRef ref = new RecordRef(ResourceId.valueOf(formKey.getName()), ResourceId.valueOf(recordKey.getName())); observer.onNext(periodType.fromSubFormKey(ref)); } }