import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
private Node getNode(final String baseResourcePath, final String label) throws RepositoryException {
    try {
        final Node frozenNode = getJcrSession(session).getNodeByIdentifier(label);

        /*
         * We found a node whose identifier is the "label" for the version.  Now
         * we must do due diligence to make sure it's a frozen node representing
         * a version of the subject node.
         */
        final Property p = frozenNode.getProperty("jcr:frozenUuid");
        if (p != null) {
            final Node subjectNode = getJcrSession(session).getNode(baseResourcePath);
            if (p.getString().equals(subjectNode.getIdentifier())) {
                return frozenNode;
            }
        }

    } catch (final ItemNotFoundException ex) {
        /*
         * the label wasn't a uuid of a frozen node but
         * instead possibly a version label.
         */
    }
    return null;
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
private NodeImpl createNode(@Nonnull String path, @Nonnull Map<String, Object> properties) throws ItemNotFoundException, ItemExistsException {
    NodeImpl node = new NodeImpl((SessionImpl)session, path);

    for (String propName : properties.keySet()) {
        Object mapVal = properties.get(propName);
        setNodeProperty(node, propName, mapVal);
    }
    return node;
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Override
@Nullable
public Item getAncestor(int depth) throws ItemNotFoundException, RepositoryException {
    int myDepth = getDepth();
    if (depth > myDepth) throw new ItemNotFoundException();
    return (depth < myDepth) ? ((NodeImpl)getParent()).getAncestor(depth) : null;
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Override
@Nonnull
public Node getParent() throws ItemNotFoundException, RepositoryException {
    if (session.getRootNode() == this) throw new ItemNotFoundException();
    if (Strings.isNullOrEmpty(Paths.parent(path))) return session.getRootNode();
    return session.getNode(Paths.parent(path));
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Deprecated
@Override
public void checkPermission(ItemId id, int permissions)
        throws AccessDeniedException, ItemNotFoundException,
        RepositoryException {
    out(String.format("checkPermission %s %s", id, permissions));
    if(!isGranted(id, permissions)) {
        throw new AccessDeniedException(String.format(
                "access denied on %s with permissions %s", id, permissions));
    }
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Deprecated
@Override
public boolean isGranted(ItemId id, int permissions)
        throws ItemNotFoundException, RepositoryException {
    out(String.format("isGranted %s %s", id, permissions));
    Permission p = getPermission(id);
    boolean result;
    result = (permissions == org.apache.jackrabbit.core.security.authorization.Permission.READ)
            ?p.isRead():p.isWrite();
    out("isGranted: "+result);
    return result;
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
public void grant(Principal principal, String path, Permission permission) throws RepositoryException {
    ItemId id = resolvePath(ctx.getNamePathResolver().getQPath(path));
    if(id != null) {
        PermissionStore.getInstance().grant(ctx.getSession(), "default", principal.getName(), id.toString(), permission);
    } else {
        throw new ItemNotFoundException(String.format("could not resolve path %s to id", path));
    }
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
private void sendNotification(Session session, User to, String msg)
    throws ItemNotFoundException, RepositoryException {
  NotificationDAO notificationDao = new NotificationDAO(session, jcrom);
  Notification notification = new Notification(to, msg);
  notificationDao.create(notification);
  session.save();
  fileStore.getEventManager().tell(Events.create(notification));
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
public String getWebResourceGroupForNode(Node childNode)
		throws RepositoryException {

	if (childNode.isNodeType(WebResourceGroup.NODE_TYPE)) {
		return childNode.getProperty(WebResourceGroup.NAME).getString();
	}
	int depth = childNode.getDepth();
	if (depth > 0) {
		return getWebResourceGroupForNode(childNode.getParent());
	} else {
		throw new ItemNotFoundException();
	}
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
private Node getFrozenNode(final String label) throws RepositoryException {
    try {
        final Session session = getSession();

        final Node frozenNode = session.getNodeByIdentifier(label);

        final String baseUUID = getNode().getIdentifier();

        /*
         * We found a node whose identifier is the "label" for the version.  Now
         * we must do due dilligence to make sure it's a frozen node representing
         * a version of the subject node.
         */
        final Property p = frozenNode.getProperty(JCR_FROZEN_UUID);
        if (p != null) {
            if (p.getString().equals(baseUUID)) {
                return frozenNode;
            }
        }
        /*
         * Though a node with an id of the label was found, it wasn't the
         * node we were looking for, so fall through and look for a labeled
         * node.
         */
    } catch (final ItemNotFoundException ex) {
        /*
         * the label wasn't a uuid of a frozen node but
         * instead possibly a version label.
         */
    }
    return null;
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Test(expected = RepositoryException.class)
public void badProperty() throws AccessDeniedException,
                         ItemNotFoundException, RepositoryException {
    when(mockProperty.getParent()).thenThrow(
            new RepositoryException("Bad property!"));
    // we exhaust the mock of mockProperty.getParent() to replace it with an
    // exception
    mockProperty.getParent();
    createSingleValuedLiteralTriple();
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Test
public void testDoForwardWithExplicitVersionedDatastream() throws Exception {
    when(session.getNodeByIdentifier("x")).thenThrow(new ItemNotFoundException());
    when(mockVersionManager.getVersionHistory("/" + path)).thenReturn(mockVersionHistory);
    when(mockVersionHistory.hasVersionLabel("x")).thenReturn(true);
    when(mockVersionHistory.getVersionByLabel("x")).thenReturn(mockVersion);
    when(mockVersion.getFrozenNode()).thenReturn(versionedNode);
    final FedoraResource converted = converter.convert(versionedResource);
    assertEquals(versionedNode, getJcrNode(converted));
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Test(expected = RepositoryRuntimeException.class)
public void testDoForwardWithMissingVersionedDatastream() throws Exception {
    when(session.getNodeByIdentifier("x")).thenThrow(new ItemNotFoundException());
    when(mockVersionManager.getVersionHistory("/" + path)).thenReturn(mockVersionHistory);
    when(mockVersionHistory.hasVersionLabel("x")).thenReturn(false);
    converter.convert(versionedResource);
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
protected Node checkId(String id) throws NotFoundException {
	// TODO improve
	try {
		return getTemplate().getNodeByUUID(id);
	} catch (DataRetrievalFailureException e) {
		if (e.getCause() instanceof ItemNotFoundException) {
			throw new NotFoundException("Id '" + id + "' not found");
		}
		
		throw e;
	}		
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
private T internalGetEntity(String id) throws RepositoryException {
	Node n = null;
	try {
		n = session.getNodeByIdentifier(id);
	} catch (ItemNotFoundException e) {
		// else: no matching node found -> ignore exception.
	}

	return getEntity(n);
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Test(expected = ItemNotFoundException.class)
public void getAncestorWithFiveThrowsException() throws Exception {
	Node testObj = aNode("/content/ko/foobar");
	
	testObj.getAncestor(5);
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Test(expected = ItemNotFoundException.class)
public void getAncestorWithNegativeValueThrowsException() throws Exception {
	Node testObj = aNode("/content/ko/foobar");
	
	testObj.getAncestor(-10);
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Test(expected = ItemNotFoundException.class)
public void getPrimaryItemThrowsException() throws Exception {
	Node testObj = aNode("/content");
	
	testObj.getPrimaryItem();
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Override
public Node getNodeByUUID(String uuid) throws ItemNotFoundException, RepositoryException {
    return null;  //TODO: Implement IDs
}
 

import javax.jcr.ItemNotFoundException; //导入依赖的package包/类
@Override
public Node getNodeByIdentifier(String id) throws ItemNotFoundException, RepositoryException {
    return null;  //TODO: Implement IDs
}