private static void merge(NodeBuilder parent, PropertyState ours, PropertyState theirs) { Set<String> theirOrder = Sets.newHashSet(theirs.getValue(Type.NAMES)); PropertyBuilder<String> merged = PropertyBuilder.array(Type.NAME).assignFrom(theirs); // Append child node names from ours that are not in theirs for (String ourChild : ours.getValue(Type.NAMES)) { if (!theirOrder.contains(ourChild)) { merged.addValue(ourChild); } } // Remove child node names of nodes that have been removed for (String child : merged.getValues()) { if (!parent.hasChildNode(child)) { merged.removeValue(child); } } parent.setProperty(merged.getPropertyState()); }
private static void mergeChange(NodeBuilder parent, PropertyState ours, PropertyState theirs, Set<String> base) { PropertyBuilder<String> merged = PropertyBuilder.array(Type.STRING); merged.setName(UserConstants.REP_MEMBERS); Set<String> theirMembers = Sets.newHashSet(theirs.getValue(Type.STRINGS)); Set<String> ourMembers = Sets.newHashSet(ours.getValue(Type.STRINGS)); // merge ours and theirs to a de-duplicated set Set<String> combined = Sets.newHashSet(Sets.intersection(ourMembers, theirMembers)); for (String m : Sets.difference(ourMembers, theirMembers)) { if (!base.contains(m)) { combined.add(m); } } for (String m : Sets.difference(theirMembers, ourMembers)) { if (!base.contains(m)) { combined.add(m); } } merged.addValues(combined); parent.setProperty(merged.getPropertyState()); }
private PropertyState migrateProperty(PropertyState propertyState) throws IOException { Blob oldBlob = propertyState.getValue(Type.BINARY); String blobId = getIdentity(oldBlob); if (blobStore.isMigrated(blobId)) { return null; } String newBlobId = blobStore.writeBlob(oldBlob.getNewStream()); Blob newBlob = new BlobStoreBlob(blobStore, newBlobId); PropertyBuilder<Blob> builder = new PropertyBuilder<Blob>(Type.BINARY); builder.assignFrom(propertyState); builder.setValue(newBlob); return builder.getPropertyState(); }
/** * Create a new instance for building array {@code PropertyState} instances * of the given {@code type}. * @param type type of the {@code PropertyState} instances to be built. * @return {@code PropertyBuilder} for {@code type} */ public static <T> PropertyBuilder<T> array(Type<T> type) { return new PropertyBuilder<T>(type).setArray(); }
/** * Create a new instance for building array {@code PropertyState} instances * of the given {@code type}. The builder is initialised with the * given {@code name}. * Equivalent to * <pre> * MemoryPropertyBuilder.create(type).setName(name).setArray(); * </pre> * @param type type of the {@code PropertyState} instances to be built. * @param name initial name * @return {@code PropertyBuilder} for {@code type} */ public static <T> PropertyBuilder<T> array(Type<T> type, String name) { return scalar(type).setName(name).setArray(); }
/** * Create a new instance for building scalar {@code PropertyState} instances * of the given {@code type}. The builder is initialised with the * given {@code name}. * Equivalent to * <pre> * MemoryPropertyBuilder.create(type).setName(name); * </pre> * @param type type of the {@code PropertyState} instances to be built. * @param name initial name * @return {@code PropertyBuilder} for {@code type} */ public static <T> PropertyBuilder<T> scalar(Type<T> type, String name) { return scalar(type).setName(name); }
PropertyBuilder<Object> builder = (PropertyBuilder<Object>) PropertyBuilder.array(baseType); builder.setName(""); for (PropertyValue v : list) { if (type.isArray()) { for (Object value : (Iterable<?>) v.getValue(type)) { builder.addValue(value); builder.addValue(v.getValue(type)); PropertyState s = builder.getPropertyState(); return PropertyValues.create(s);
NodeBuilder successor = getVersionById(vh, succId); PropertyBuilder<String> pb = PropertyBuilder.array(Type.REFERENCE); pb.setName(JCR_PREDECESSORS).setValues(successor.getProperty(JCR_PREDECESSORS).getValue(Type.REFERENCES)); pb.removeValue(versionId); pb.addValues(predecessorIds.getValue(Type.REFERENCES)); successor.setProperty(pb.getPropertyState()); PropertyBuilder<String> pb = PropertyBuilder.array(Type.REFERENCE); pb.setName(JCR_SUCCESSORS).setValues(predecessor.getProperty(JCR_SUCCESSORS).getValue(Type.REFERENCES)); pb.removeValue(versionId); pb.addValues(successorIds.getValue(Type.REFERENCES)); predecessor.setProperty(pb.getPropertyState());
@Test public void testStringProperty() { PropertyBuilder builder = PropertyBuilder.scalar(Type.STRING); builder.setName("foo").setValue("bar"); Assert.assertEquals(StringPropertyState.stringProperty("foo", "bar"), builder.getPropertyState()); builder.setArray(); Assert.assertEquals(MultiStringPropertyState.stringProperty("foo", Arrays.asList("bar")), builder.getPropertyState()); }
@Test public void testStringsProperty() { PropertyBuilder builder = PropertyBuilder.array(Type.STRING); builder.setName("foo") .addValue("one") .addValue("two"); assertEquals(MultiStringPropertyState.stringProperty("foo", Arrays.asList("one", "two")), builder.getPropertyState()); builder.setScalar(); try { builder.getPropertyState(); } catch (IllegalStateException expected) { // success } builder.removeValue("one"); assertEquals(StringPropertyState.stringProperty("foo", "two"), builder.getPropertyState()); }
propertyBuilder = PropertyBuilder.array(Type.NAME, REP_AGGREGATES); } else { propertyBuilder = PropertyBuilder.copy(Type.NAME, aggregates); if (!propertyBuilder.hasValue(name)) { propertyBuilder.addValue(name); jcrAll.setProperty(propertyBuilder.getPropertyState());
@Test public void testAssignFromDate() { String date = "1970-01-01T00:00:00.000Z"; PropertyState source = GenericPropertyState.dateProperty("foo", date); PropertyBuilder builder = PropertyBuilder.scalar(Type.DATE); builder.assignFrom(source); assertEquals(source, builder.getPropertyState()); }
private static void addChild(NodeBuilder target, String name, NodeState state) { target.setChildNode(name, state); PropertyState childOrder = target.getProperty(TreeConstants.OAK_CHILD_ORDER); if (childOrder != null) { PropertyBuilder<String> builder = PropertyBuilder.copy(NAME, childOrder); builder.addValue(name); target.setProperty(builder.getPropertyState()); } }
@NotNull protected PropertyState createMultiState( String oakName, List<Value> values, Type<?> type) throws RepositoryException { if (values.isEmpty()) { Type<?> base = type.getBaseType(); if (base == UNDEFINED) { base = STRING; } return PropertyBuilder.array(base) .setName(oakName).getPropertyState(); } if (type == UNDEFINEDS) { type = Type.fromTag(values.get(0).getType(), true); } if (type == NAMES || type == PATHS) { Type<?> base = type.getBaseType(); List<String> strings = newArrayListWithCapacity(values.size()); for (Value value : values) { strings.add(getOakValue(value, base)); } return createProperty(oakName, strings, type); } else { return createProperty(oakName, values, type.tag()); } }
for (String ref : members) { if (prop == null) { prop = PropertyBuilder.array(Type.WEAKREFERENCE, UserConstants.REP_MEMBERS); prop.addValue(ref); count++; if (count > MembershipWriter.DEFAULT_MEMBERSHIP_THRESHOLD) { node.setProperty(prop.getPropertyState()); prop = null; if (refList == null) { node.setProperty(prop.getPropertyState());
PropertyState refs = t.getProperty(UserConstants.REP_MEMBERS); if (refs != null) { PropertyBuilder<String> prop = PropertyBuilder.copy(Type.WEAKREFERENCE, refs); Iterator<Map.Entry<String,String>> it = memberIds.entrySet().iterator(); while (it.hasNext() && !prop.isEmpty()) { String memberContentId = it.next().getKey(); if (prop.hasValue(memberContentId)) { prop.removeValue(memberContentId); it.remove(); if (prop.isEmpty()) { if (t == groupTree) { t.removeProperty(UserConstants.REP_MEMBERS); t.setProperty(prop.getPropertyState());
bestTree = createMemberRefTree(groupTree, membersList); propertyBuilder = PropertyBuilder.array(Type.WEAKREFERENCE, UserConstants.REP_MEMBERS); propCnt = 0; } else { propertyBuilder = PropertyBuilder.copy(Type.WEAKREFERENCE, bestProperty); propCnt = bestCount; propCnt++; propertyBuilder.addValues(s); bestTree.setProperty(propertyBuilder.getPropertyState()); propertyBuilder = PropertyBuilder.array(Type.WEAKREFERENCE, UserConstants.REP_MEMBERS); propertyBuilder.addValues(memberIds.keySet()); bestTree.setProperty(propertyBuilder.getPropertyState());
private static long addNestedCugPath(@NotNull NodeBuilder parentBuilder, @NotNull NodeBuilder builder, @NotNull String pathWithNewCug) { PropertyState ps = parentBuilder.getProperty(HIDDEN_NESTED_CUGS); PropertyBuilder<String> pb = getHiddenPropertyBuilder(ps); if (ps != null) { List<String> moveToNestedCug = Lists.newArrayList(); for (String p : ps.getValue(Type.STRINGS)) { if (Text.isDescendant(pathWithNewCug, p)) { pb.removeValue(p); moveToNestedCug.add(p); } else if (p.equals(pathWithNewCug)) { // already present with parent -> remove to avoid duplicate entries log.debug("Path of node holding a new nested CUG is already listed with the parent CUG."); pb.removeValue(p); } } if (!moveToNestedCug.isEmpty()) { PropertyBuilder<String> pb2 = getHiddenPropertyBuilder(builder.getProperty(HIDDEN_NESTED_CUGS)); pb2.addValues(moveToNestedCug); builder.setProperty(pb2.getPropertyState()); } } // update the nested-cug property of the parent pb.addValue(pathWithNewCug); parentBuilder.setProperty(pb.getPropertyState()); return pb.count(); }
private PropertyState migrateMultiProperty(PropertyState propertyState) throws IOException { Iterable<Blob> oldBlobs = propertyState.getValue(Type.BINARIES); List<Blob> newBlobs = new ArrayList<Blob>(); PropertyBuilder<Blob> builder = new PropertyBuilder<Blob>(Type.BINARY); builder.assignFrom(propertyState); boolean blobUpdated = false; for (Blob oldBlob : oldBlobs) { String blobId = getIdentity(oldBlob); if (blobStore.isMigrated(blobId)) { newBlobs.add(new BlobStoreBlob(blobStore, blobId)); } else { String newBlobId = blobStore.writeBlob(oldBlob.getNewStream()); Blob newBlob = new BlobStoreBlob(blobStore, newBlobId); newBlobs.add(newBlob); blobUpdated = true; } } if (blobUpdated) { builder.setValues(newBlobs); return builder.getPropertyState(); } else { return null; } }
private static int removeNestedCugPath(@NotNull NodeBuilder parentBuilder, @NotNull String toRemove, @NotNull Iterable<String> toReconnect) { PropertyState ps = parentBuilder.getProperty(HIDDEN_NESTED_CUGS); PropertyBuilder<String> pb = getHiddenPropertyBuilder(ps); if (pb.hasValue(toRemove)) { pb.removeValue(toRemove); pb.addValues(toReconnect); if (pb.isEmpty()) { parentBuilder.removeProperty(HIDDEN_NESTED_CUGS); return 0; } else { parentBuilder.setProperty(pb.getPropertyState()); return pb.count(); } } else { log.debug("Parent CUG doesn't contain expected entry for removed nested CUG"); return -1; } }