// or ABORT (see 15.2 Check-In: Creating a Version).
Set<Name> propNames = new HashSet<Name>();
PropertyState[] props = freeze.getFrozenProperties();
for (PropertyState prop : props) {
// don't restore jcr:activity
Name name = prop.getName();
if (!name.equals(NameConstants.JCR_ACTIVITY)) {
state.copyFrom(prop);
propNames.add(name);
}
}
// For each property P present on N but not on F:
// - If P has an OPV of COPY, VERSION or ABORT then N/P is removed. Note that
// while a node with a child item of OPV ABORT cannot be versioned, it is
// legal for a previously versioned node to have such a child item added to it
// and then for it to be restored to the state that it had before that item was
// added, as this step indicates.
// - If P has an OPV of IGNORE then no change is made to N/P.
// - If P has an OPV of INITIALIZE then, if N/P has a default value (either
// defined in the node type of N or implementation-defined) its value is
// changed to that default value. If N/P has no default value then it is left
// unchanged.
// - If P has an OPV of COMPUTE then the value of N/P may be changed
// according to an implementation-specific mechanism.
// remove properties that do not exist in the frozen representation
for (PropertyState prop: state.getProperties()) {
Name propName = prop.getName();
if (!propNames.contains(propName)) {
int opv = state.getDefinition(prop).getOnParentVersion();
if (opv == OnParentVersionAction.COPY
|| opv == OnParentVersionAction.VERSION
|| opv == OnParentVersionAction.ABORT) {
state.removeProperty(propName);
} else if (opv == OnParentVersionAction.INITIALIZE) {
InternalValue[] values = computeAutoValues(state, state.getDefinition(prop), true);
if (values != null) {
state.setPropertyValues(propName, prop.getType(), values, prop.isMultiValued());
}
} else if (opv == OnParentVersionAction.COMPUTE) {
InternalValue[] values = computeAutoValues(state, state.getDefinition(prop), false);
if (values != null) {
state.setPropertyValues(propName, prop.getType(), values, prop.isMultiValued());
}
}
}
}
// add 'auto-create' properties that do not exist yet
for (QPropertyDefinition def: state.getEffectiveNodeType().getAutoCreatePropDefs()) {
if (!state.hasProperty(def.getName())) {
InternalValue[] values = computeAutoValues(state, def, true);
if (values != null) {
state.setPropertyValues(def.getName(), def.getRequiredType(), values, def.isMultiple());
}
}
}
// For each child node C present on N but not on F:
// - If C has an OPV of COPY, VERSION or ABORT then N/C is removed.
// Note that while a node with a child item of OPV ABORT cannot be
// versioned, it is legal for a previously versioned node to have such
// a child item added to it and then for it to be restored to the state
// that it had before that item was added, as this step indicates.
// - If C has an OPV of IGNORE then no change is made to N/C.
// - If C has an OPV of INITIALIZE then N/C is re-initialized as if it
// were newly created, as defined in its node type.
// - If C has an OPV of COMPUTE then N/C may be re-initialized according
// to an implementation-specific mechanism.
LinkedList<ChildNodeEntry> toDelete = new LinkedList<ChildNodeEntry>();
for (ChildNodeEntry entry: state.getState().getChildNodeEntries()) {
if (!freeze.hasFrozenChildNode(entry.getName(), entry.getIndex())) {
NodeStateEx child = state.getNode(entry.getName(), entry.getIndex());
int opv = child.getDefinition().getOnParentVersion();
if (copy || opv == OnParentVersionAction.COPY
|| opv == OnParentVersionAction.VERSION
|| opv == OnParentVersionAction.ABORT) {
toDelete.addFirst(entry);
} else if (opv == OnParentVersionAction.INITIALIZE) {
log.warn("OPV.INITIALIZE not supported yet on restore of existing child nodes: " + safeGetJCRPath(child));
} else if (opv == OnParentVersionAction.COMPUTE) {
log.warn("OPV.COMPUTE not supported yet on restore of existing child nodes: " + safeGetJCRPath(child));
}
}
}
for (ChildNodeEntry entry: toDelete) {
state.removeNode(entry.getName(), entry.getIndex());
}
// need to sync with state manager
state.store();
// For each child node C present on F:
// - F will never have a child node with an OPV of IGNORE, INITIALIZE,
// COMPUTE or ABORT (see 15.2 Check-In: Creating a Version).
for (ChildNodeEntry entry : freeze.getFrozenChildNodes()) {
InternalFreeze child = freeze.getFrozenChildNode(entry.getName(), entry.getIndex());
NodeStateEx restoredChild = null;
if (child instanceof InternalFrozenNode) {
// - If C has an OPV of COPY or VERSION:
// - B is true, then F/C and its subgraph is copied to N/C, replacing
// any existing N/C and its subgraph and any node in the workspace
// with the same identifier as C or a node in the subgraph of C is
// removed.
// - B is false, then F/C and its subgraph is copied to N/C, replacing
// any existing N/C and its subgraph unless there exists a node in the
// workspace with the same identifier as C, or a node in the subgraph
// of C, in which case an ItemExistsException is thrown , all
// changes made by the restore are rolled back leaving N unchanged.
InternalFrozenNode f = (InternalFrozenNode) child;
// if node is present, remove it
state.removeNode(entry.getName(), entry.getIndex());
// check for existing
if (f.getFrozenId() != null) {
if (stateMgr.hasItemState(f.getFrozenId())) {
NodeStateEx existing = state.getNode(f.getFrozenId());
if (removeExisting) {
NodeStateEx parent = existing.getParent();
parent.removeNode(existing);
parent.store();
} else if (existing.getState().isShareable()) {
// if existing node is shareable, then clone it
restoredChild = state.moveFrom(existing, existing.getName(), true);
} else if (!existing.hasAncestor(state.getNodeId())){
String msg = "Unable to restore node, item already exists " +
"outside of restored tree: " + safeGetJCRPath(existing);
log.error(msg);
throw new ItemExistsException(msg);
}
}
}
if (restoredChild == null) {
restoredChild = state.addNode(f.getName(), f.getFrozenPrimaryType(), f.getFrozenId());
restoredChild.setMixins(f.getFrozenMixinTypes());
}
internalRestoreFrozen(restoredChild, f, vsel, restored, removeExisting, true);
} else if (child instanceof InternalFrozenVersionHistory) {
// Each child node C of N where C has an OPV of VERSION and C is
// mix:versionable, is represented in F not as a copy of N/C but as
// special node containing a reference to the version history of
// C. On restore, the following occurs:
// - If the workspace currently has an already existing node corresponding
// to C's version history and the removeExisting flag of the restore is
// set to true, then that instance of C becomes the child of the restored N.
// - If the workspace currently has an already existing node corresponding
// to C's version history and the removeExisting flag of the restore is
// set to false then an ItemExistsException is thrown.
// - If the workspace does not have an instance of C then one is restored from
// C's version history:
// - If the restore was initiated through a restoreByLabel where L is
// the specified label and there is a version of C with the label L then
// that version is restored.
// - If the version history of C does not contain a version with the label
// L or the restore was initiated by a method call that does not specify
// a label then the workspace in which the restore is being performed
// will determine which particular version of C will be restored. This
// determination depends on the configuration of the workspace and
// is outside the scope of this specification.
InternalFrozenVersionHistory fh = (InternalFrozenVersionHistory) child;
InternalVersionHistory vh = vMgr.getVersionHistory(fh.getVersionHistoryId());
// get desired version from version selector
InternalVersion v = vsel.select(vh);
Name oldVersion = null;
// check if representing versionable already exists somewhere
NodeId nodeId = vh.getVersionableId();
if (stateMgr.hasItemState(nodeId)) {
restoredChild = state.getNode(nodeId);