@VisibleForTesting boolean isNonEntityReturnedType(Class returnedType) { return this.datastoreTemplate.getDatastoreEntityConverter().getConversions() .getDatastoreCompatibleType(returnedType).isPresent(); }
@SuppressWarnings("unchecked") private <T> T convertOnReadSingleEmbedded(Object value, TypeInformation<?> targetTypeInformation) { Assert.notNull(value, "Cannot convert a null value."); if (value instanceof BaseEntity) { return (T) this.datastoreEntityConverter.read(targetTypeInformation.getType(), (BaseEntity) value); } throw new DatastoreDataException("Embedded entity was expected, but " + value.getClass() + " found"); }
private <T, R> Map<T, R> convertOnReadSingleEmbeddedMap(Object value, Class<T> keyType, TypeInformation<R> targetComponentType) { Assert.notNull(value, "Cannot convert a null value."); if (value instanceof BaseEntity) { return this.datastoreEntityConverter.readAsMap(keyType, targetComponentType, (BaseEntity) value); } throw new DatastoreDataException( "Embedded entity was expected, but " + value.getClass() + " found"); }
private EntityValue convertOnWriteSingleEmbedded(Object val, String kindName) { return applyEntityValueBuilder(kindName, (builder) -> this.datastoreEntityConverter.write(val, builder)); }
private EntityValue convertOnWriteSingleEmbedded(Object val, String kindName) { return applyEntityValueBuilder(kindName, (builder) -> this.datastoreEntityConverter.write(val, builder)); }
/** * Convert collection-like param from the query method into an array of compatible types * for Datastore. * @param param the raw param * @return an array of a compatible type. */ protected Object[] convertCollectionParamToCompatibleArray(List<?> param) { List converted = param.stream() .map((x) -> this.datastoreTemplate.getDatastoreEntityConverter().getConversions().convertOnWriteSingle(x) .get()) .collect(Collectors.toList()); return converted.toArray( (Object[]) Array.newInstance(converted.isEmpty() ? String.class // if there are no items in the param : converted.get(0).getClass(), converted.size())); }
private Entity convertToEntityForSave(Object entity, Key... ancestors) { if (ancestors != null) { for (Key ancestor : ancestors) { validateKey(entity, keyToPathElement(ancestor)); } } Key key = getKey(entity, true, ancestors); Builder builder = Entity.newBuilder(key); this.datastoreEntityConverter.write(entity, builder); saveDescendents(entity, key); saveReferences(entity, builder); return builder.build(); }
private <T, R> Map<T, R> convertOnReadSingleEmbeddedMap(Object value, Class<T> keyType, TypeInformation<R> targetComponentType) { Assert.notNull(value, "Cannot convert a null value."); if (value instanceof BaseEntity) { return this.datastoreEntityConverter.readAsMap(keyType, targetComponentType, (BaseEntity) value); } throw new DatastoreDataException( "Embedded entity was expected, but " + value.getClass() + " found"); }
@SuppressWarnings("unchecked") private <T> T convertOnReadSingleEmbedded(Object value, TypeInformation<?> targetTypeInformation) { Assert.notNull(value, "Cannot convert a null value."); if (value instanceof BaseEntity) { return (T) this.datastoreEntityConverter.read(targetTypeInformation.getType(), (BaseEntity) value); } throw new DatastoreDataException("Embedded entity was expected, but " + value.getClass() + " found"); }
/** * Convert collection-like param from the query method into an array of compatible types * for Datastore. * @param param the raw param * @return an array of a compatible type. */ protected Object[] convertCollectionParamToCompatibleArray(List<?> param) { List converted = param.stream() .map((x) -> this.datastoreTemplate.getDatastoreEntityConverter().getConversions().convertOnWriteSingle(x) .get()) .collect(Collectors.toList()); return converted.toArray( (Object[]) Array.newInstance(converted.isEmpty() ? String.class // if there are no items in the param : converted.get(0).getClass(), converted.size())); }
private Entity convertToEntityForSave(Object entity, Key... ancestors) { if (ancestors != null) { for (Key ancestor : ancestors) { validateKey(entity, keyToPathElement(ancestor)); } } Key key = getKey(entity, true, ancestors); Builder builder = Entity.newBuilder(key); this.datastoreEntityConverter.write(entity, builder); saveDescendents(entity, key); saveReferences(entity, builder); return builder.build(); }
@Override public <T> Map<String, T> findByIdAsMap(Key key, Class<T> valueType) { Assert.notNull(key, "A non-null Key is required."); Assert.notNull(valueType, "A non-null valueType is required."); Entity entity = getDatastoreReadWriter().get(key); return this.datastoreEntityConverter.readAsMap(String.class, ClassTypeInformation.from(valueType), entity); }
private <T> void convertEntityResolveDescendantsAndReferences(Class<T> entityClass, List<T> results, DatastorePersistentEntity datastorePersistentEntity, BaseEntity entity) { T convertedObject = this.datastoreEntityConverter.read(entityClass, entity); results.add(convertedObject); resolveDescendantProperties(datastorePersistentEntity, entity, convertedObject); resolveReferenceProperties(datastorePersistentEntity, entity, convertedObject); }
boolean isNonEntityReturnedType(Class returnedType) { return this.datastoreTemplate.getDatastoreEntityConverter().getConversions() .getDatastoreCompatibleType(returnedType).isPresent(); }
this.datastoreEntityConverter.write(probe, probeEntityBuilder);
@Override public <T> Map<String, T> findByIdAsMap(Key key, Class<T> valueType) { Assert.notNull(key, "A non-null Key is required."); Assert.notNull(valueType, "A non-null valueType is required."); Entity entity = getDatastoreReadWriter().get(key); return this.datastoreEntityConverter.readAsMap(String.class, ClassTypeInformation.from(valueType), entity); }
private <T> void convertEntityResolveDescendantsAndReferences(Class<T> entityClass, List<T> results, DatastorePersistentEntity datastorePersistentEntity, BaseEntity entity) { T convertedObject = this.datastoreEntityConverter.read(entityClass, entity); results.add(convertedObject); resolveDescendantProperties(datastorePersistentEntity, entity, convertedObject); resolveReferenceProperties(datastorePersistentEntity, entity, convertedObject); }
@Override public <V> void writeMap(Key datastoreKey, Map<String, V> map) { Assert.notNull(datastoreKey, "A non-null Key is required."); Assert.notNull(map, "A non-null map is required."); Builder builder = Entity.newBuilder(datastoreKey); map.forEach( (key, value) -> builder.set(key, this.datastoreEntityConverter.getConversions().convertOnWriteSingle(value))); Entity entity = builder.build(); getDatastoreReadWriter().put(entity); }
@Override public <V> void writeMap(Key datastoreKey, Map<String, V> map) { Assert.notNull(datastoreKey, "A non-null Key is required."); Assert.notNull(map, "A non-null map is required."); Builder builder = Entity.newBuilder(datastoreKey); map.forEach( (key, value) -> builder.set(key, this.datastoreEntityConverter.getConversions().convertOnWriteSingle(value))); Entity entity = builder.build(); getDatastoreReadWriter().put(entity); }
private Object convertSingularResult(Class returnedItemType, boolean isNonEntityReturnType, List rawResult) { if (this.queryMethod.isCountQuery()) { return rawResult.size(); } else if (this.queryMethod.isExistsQuery()) { return !rawResult.isEmpty(); } if (rawResult.size() > 1) { throw new DatastoreDataException( "The query method returns a singular object but " + "the query returned more than one result."); } return isNonEntityReturnType ? this.datastoreTemplate.getDatastoreEntityConverter().getConversions() .convertOnRead(rawResult.get(0), null, returnedItemType) : this.queryMethod.getResultProcessor().processResult(rawResult.get(0)); }