@Override public boolean propertyDeleted(PropertyState before) { builder.removeProperty(before.getName()); return true; }
@Override public boolean propertyDeleted(PropertyState before) { builder.removeProperty(before.getName()); return true; }
@Override public void removeProperty(@Nonnull String name) { getNodeBuilder().removeProperty(checkNotNull(name)); } }
@Override public void removeProperty(@NotNull String name) { getNodeBuilder().removeProperty(checkNotNull(name)); } }
@Override public NodeBuilder removeProperty(String name) { getWrappedNodeBuilder().removeProperty(name); return this; }
public static void removeVersionProperties(NodeBuilder versionableBuilder, TypePredicate isReferenceable) { assert versionableBuilder.exists(); removeMixin(versionableBuilder, MIX_VERSIONABLE); // we don't know if the UUID is otherwise referenced, // so make sure the node remains referencable if (!isReferenceable.apply(versionableBuilder.getNodeState())) { addMixin(versionableBuilder, MIX_REFERENCEABLE); } versionableBuilder.removeProperty(JCR_VERSIONHISTORY); versionableBuilder.removeProperty(JCR_PREDECESSORS); versionableBuilder.removeProperty(JCR_BASEVERSION); versionableBuilder.removeProperty(JCR_ISCHECKEDOUT); }
public static void revertSwitch(NodeBuilder idxBuilder, String indexPath) { PropertyState previousAsync = idxBuilder.getProperty(ASYNC_PREVIOUS); checkState(previousAsync != null, "No previous async state property found for index [%s]", indexPath); if (isNone(previousAsync)) { idxBuilder.removeProperty(IndexConstants.ASYNC_PROPERTY_NAME); } else { idxBuilder.setProperty(clone(IndexConstants.ASYNC_PROPERTY_NAME, previousAsync)); } idxBuilder.removeProperty(ASYNC_PREVIOUS); }
@Override public void setOrderableChildren(boolean enable) { if (enable) { updateChildOrder(true); } else { getNodeBuilder().removeProperty(OAK_CHILD_ORDER); } }
@Override public void setOrderableChildren(boolean enable) { if (enable) { updateChildOrder(true); } else { getNodeBuilder().removeProperty(OAK_CHILD_ORDER); } }
private static void removeMixin(NodeBuilder builder, String name) { if (builder.hasProperty(JCR_MIXINTYPES)) { final Set<String> mixins = newHashSet(builder.getProperty(JCR_MIXINTYPES).getValue(Type.NAMES)); if (mixins.remove(name)) { if (mixins.isEmpty()) { builder.removeProperty(JCR_MIXINTYPES); } else { builder.setProperty(nameProperty(JCR_MIXINTYPES, mixins)); } } } }
@Override public void unlock(ClusteredLockToken token) throws CommitFailedException { String leaseName = AsyncIndexUpdate.leasify(token.laneName); NodeBuilder builder = nodeStore.getRoot().builder(); NodeBuilder async = builder.child(":async"); async.removeProperty(leaseName); async.removeProperty(lockName(token.laneName)); NodeStoreUtils.mergeWithConcurrentCheck(nodeStore, builder); log.info("Remove the lock for async indexer lane [{}]", token.laneName); }
@Override public void propertyAdded(final PropertyState after) throws CommitFailedException { if (shallWeProcessProperty(after, path, builder)) { setUniqueCounter(after.getValue(LONG)); builder.removeProperty(PROP_INCREMENT); } }
@Override public boolean propertyDeleted(PropertyState before) { PropertyState other = builder.getProperty(before.getName()); if (other == null) { deleteDeletedProperty(builder, before); } else if (other.equals(before)) { builder.removeProperty(before.getName()); } else { deleteChangedProperty(builder, before); } return true; }
void close() throws CommitFailedException { if (isLeaseCheckEnabled(leaseTimeOut)) { NodeBuilder builder = store.getRoot().builder(); NodeBuilder async = builder.child(ASYNC); async.removeProperty(leaseName); mergeWithConcurrencyCheck(store, validatorProviders, builder, async.getString(name), lease, name); } }
private void removeRandomProperty(NodeBuilder nodeBuilder) { int count = (int) nodeBuilder.getPropertyCount(); if (count > 0) { PropertyState property = get(nodeBuilder.getProperties(), rnd.nextInt(count)); nodeBuilder.removeProperty(property.getName()); } }
@Override public void leave(NodeState before, NodeState after) { if (glob != null && isACE.apply(after) && !builder.hasChildNode(REP_RESTRICTIONS)) { NodeBuilder restrictions = builder.setChildNode(REP_RESTRICTIONS); restrictions.setProperty(JCR_PRIMARYTYPE, NT_REP_RESTRICTIONS, NAME); restrictions.setProperty(glob); builder.removeProperty(REP_GLOB); } }
@Test public void testPropertyDeleted() { NodeState before = builder.getNodeState(); builder = before.builder(); builder.removeProperty("foo"); NodeState after = builder.getNodeState(); expect(diff.propertyDeleted(before.getProperty("foo"))).andReturn(true); replay(diff); after.compareAgainstBaseState(before, diff); verify(diff); }
@Test public void getIndexNodeForStringPropertyNames() throws Exception { rootBuilder.child(INDEX_DEFINITIONS_NAME).child("nodetype") .removeProperty(PROPERTY_NAMES) .setProperty(PropertyStates.createProperty(PROPERTY_NAMES, PROP_NAMES, STRINGS)); commit(); Filter f = createFilter(root, "nt:unstructured"); assertNotNull("propertyNames with String[] should also find index node", new PropertyIndexLookup(root).getIndexNode(root, JCR_PRIMARYTYPE, f)); }
@Test public void removePropertyFromRootStore() throws Exception { NodeBuilder builder = store.getRoot().builder(); builder.removeProperty("prop"); store.merge(builder, EmptyHook.INSTANCE, CommitInfo.EMPTY); assertFalse("Property must be removed from composite store", store.getRoot().hasProperty("prop")); assertFalse("Property must be removed from owning (root) store", globalStore.getRoot().hasProperty("prop")); }
@Test public void removeProperty() throws Exception { NodeBuilder builder = ns.getRoot().builder(); builder.child("foo").setProperty("p", "v"); TestUtils.merge(ns, builder); builder = ns.getRoot().builder(); builder.child("foo").removeProperty("p"); triggerBranchCommit(builder); TestUtils.merge(ns, builder); NodeDocument doc = docForPath("/foo"); assertNotNull(doc); assertEquals(1, doc.getLocalBranchCommits().size()); }