protected boolean ensureDirtyFlagPath(Data root, QueryPath path) { Data current = root; boolean containsFlag = false; for (int i = 0; i < path.size(); i++) { Key key = path.get(i); if(i == path.size() - 1){ containsFlag = current.containsKey(key); break; } Data d = current.get(key); if (d == null) { containsFlag = false; break; } current = d; } return containsFlag; }
public void set(final QueryPath path, final Value value) { definition.ensurePath(root, path, value instanceof DataValue); if (path.size() > 1) { final QueryPath q = path.subPath(0, path.size() - 1); final Data d = root.query(q); d.set(path.get(path.size() - 1), value); } else { root.set(path.get(0), value); } }
public void remove(final QueryPath path) { QueryPath parent = null; QueryPath leavePath = null; if (path != null && path.size() >= 2) { parent = path.subPath(0, path.size() - 1); leavePath = path.subPath(path.size() - 1, path.size()); Object parentData = this.get(parent); if (parentData != null && parentData instanceof Data) { ((Data) parentData).remove( new Data.StringKey(leavePath.toString())); } } else if (path != null) { root.remove(new Data.StringKey(path.toString())); } }
public String translatePath(String path, String parentPath, int num) { String fieldPath; if (parentPath != null) { QueryPath parent = QueryPath.concat(parentPath); int i = parent.size(); QueryPath subPath = QueryPath.concat(path); String itemPath = subPath.subPath(i, subPath.size()).toString(); QueryPath qp = QueryPath.concat(parentPath, itemPath); fieldPath = qp.toString(); } else { fieldPath = path; } fieldPath = fieldPath.replace("*", "" + num); return fieldPath; }
public String translatePath(String path) { String fieldPath; if (parentPath != null) { QueryPath parent = QueryPath.concat(parentPath); int i = parent.size(); QueryPath subPath = QueryPath.concat(path); String itemPath = subPath.subPath(i, subPath.size()).toString(); QueryPath qp = QueryPath.concat(parentPath, itemPath); fieldPath = qp.toString(); } else { fieldPath = path; } fieldPath = fieldPath.replace('*', Character.forDigit(itemCount-1, 10)); return fieldPath; }
private static Metadata get(Metadata metadata, QueryPath frame, DataType type){ if(type == DataType.LIST){ return get(metadata.getProperties().get(QueryPath.getWildCard()), frame.subPath(1, frame.size())); } else{ return get(metadata.getProperties().get(frame.get(0).get()), frame.subPath(1, frame.size())); } } }
public static Metadata get(Metadata metadata, QueryPath frame) { if(frame.size() == 1) { return metadata.getProperties().get(frame.get(0).get()); } else { if (metadata.getDataType() == DataType.LIST){ return get(metadata, frame, DataType.LIST); } else{ return get(metadata.getProperties().get(frame.get(0).get()), frame.subPath(1, frame.size())); } } }
/** * Checks to see if data exists for the path passed in * @param sPath * @return */ public boolean isValidPath(String sPath) { QueryPath path = QueryPath.parse(sPath); boolean result = false; Data root = this.getRoot(); for (int i = 0; i < path.size(); i++) { Data.Key key = path.get(i); if (!root.containsKey(key)) { result = false; break; } else if (i < path.size() - 1) { root = (Data) root.get(key); } else { result = true; break; } } return result; }
private Object getCrossFieldMinValue(DataModel model, QueryPath path, Metadata meta) { Object v = null; List<ConstraintMetadata> constraints = meta.getConstraints(); for (int i = 0; i < constraints.size(); i++) { ConstraintMetadata cons = constraints.get(i); if (cons.getMinValue() != null && cons.getMinValue().contains("../")) { QueryPath crossFieldPath = QueryPath.parse(path.toString()); String crossFieldKey = cons.getMinValue().substring(3); crossFieldPath.remove(crossFieldPath.size() - 1); crossFieldPath.add(new StringKey(crossFieldKey)); v = model.get(crossFieldPath); } } return v; }
private Object getCrossFieldMaxValue(DataModel model, QueryPath path, Metadata meta) { Object v = null; List<ConstraintMetadata> constraints = meta.getConstraints(); for (int i = 0; i < constraints.size(); i++) { ConstraintMetadata cons = constraints.get(i); if (cons.getMaxValue() != null && cons.getMaxValue().contains("../")) { QueryPath crossFieldPath = QueryPath.parse(path.toString()); String crossFieldKey = cons.getMinValue().substring(3); crossFieldPath.remove(crossFieldPath.size() - 1); crossFieldPath.add(new StringKey(crossFieldKey)); v = model.get(crossFieldPath); } } return v; }
for (int i = 0; i < path.size(); i++) { if (d == null) { final QueryPath relative = path.subPath(i + 1, path.size()); if (!relative.isEmpty()) { for (Key wildcardKey : keys) { if (!("_runtimeData".equals(wildcardKey.get()))) { QueryPath wildcardPath = path.subPath(0, path.size() - 1); wildcardPath.add(wildcardKey); result.put(wildcardPath, d.get(wildcardKey)); } else if (i < path.size() - 1) { d = d.get(key); } else {
int i = parentPath.size(); QueryPath translatedPath = fullPath.subPath(0, fullPath.size()-1); translatedPath.add(new Data.StringKey("_runtimeData")); translatedPath.add(new Data.StringKey((String)fullPath.get(fullPath.size() - 1).get())); translatedPath.add(new Data.StringKey("id-translation")); fieldPath = translatedPath.subPath(i, translatedPath.size()); fieldPath = fullPath.subPath(i, fullPath.size()); fieldPath = fullPath.subPath(i, fullPath.size());
/** * Ensures that the path to the dirty flag exists * * @param root * the DataModel's root node * @param path * the path to the dirty flag */ protected void ensureDirtyFlagPath(Data root, QueryPath path) { Data current = root; for (int i = 0; i < path.size(); i++) { Key key = path.get(i); Data d = current.get(key); if (d == null) { d = new Data(); current.set(key, d); } current = d; } }
/** * Flags the data at the provided path as dirty * * @param model * the DataModel containing the dirty data * @param qPath * the path to the dirty data */ protected void setDirtyFlag(DataModel model, QueryPath qPath) { QueryPath parent = qPath.subPath(0, qPath.size() - 1); QueryPath qPathDirty = new QueryPath(); qPathDirty.addAll(parent); qPathDirty.add(RUNTIME_ROOT); qPathDirty.add(DIRTY_PATH); ensureDirtyFlagPath(model.getRoot(), qPathDirty); Data flags = model.get(qPathDirty); flags.set(qPath.get(qPath.size() - 1), Boolean.TRUE); }
private void dirtyCheckField(FieldDescriptor fieldDescriptor, DataModel model){ QueryPath fieldPath = QueryPath.parse(fieldDescriptor.getFieldKey()); QueryPath qPathDirty = fieldPath.subPath(0, fieldPath.size() - 1); qPathDirty.add(ModelWidgetBindingSupport.RUNTIME_ROOT); qPathDirty.add(ModelWidgetBindingSupport.DIRTY_PATH); qPathDirty.add(fieldPath.get(fieldPath.size()-1)); Boolean dirty = false; if(ensureDirtyFlagPath(model.getRoot(), qPathDirty)){ dirty = model.get(qPathDirty); } if(dirty){ setIsDirty(true); fieldDescriptor.setDirty(true); } }