import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
/**
 * Returns the namespace neutral CND of the given node type definition.
 * @param def the node type definition
 * @return the CND
 */
private static String getCnd(NodeTypeDefinition def) {
    StringWriter out = new StringWriter();
    CompactNodeTypeDefWriter cndWriter = new CompactNodeTypeDefWriter(out, new CompactNodeTypeDefWriter.NamespaceMapping(){
        @Override
        public String getNamespaceURI(String s) {
            return s;
        }
    }, false);
    try {
        cndWriter.write(def);
    } catch (IOException e) {
        // should never occur
        log.error("Error generating CND of " + def, e);
        throw new IllegalStateException(e);
    }
    return out.toString();
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
@Override
public void beforeEach() throws Exception {
    super.beforeEach();

    URL cndResource = getClass().getResource("/nodetypes-modeshape.cnd");
    File cnd = null;
    try {
        cnd = new File(cndResource.toURI());

        SimpleProblems problems = new SimpleProblems();
        ExecutionContext context = new ExecutionContext();
        context.getNamespaceRegistry().register("sling", "http://sling.apache.org/jcr/sling/1.0");
        context.getNamespaceRegistry().register("cq", "http://www.day.com/jcr/cq/1.0");

        // Set up the importer ...
        CndImporter importer = new CndImporter(context, true);
        importer.importFrom(cnd, problems);

        List<NodeTypeDefinition> ntds = importer.getNodeTypeDefinitions();
        // Retrieve node type manager from the session
        NodeTypeManager nodeTypeManager = ((Session) session).getWorkspace().getNodeTypeManager();
        nodeTypeManager.registerNodeTypes(ntds.toArray(new NodeTypeDefinition[] {}), true);
        for (NodeTypeDefinition ntd : ntds) {
            System.out.println("Registered: " + ntd.getName());
        }
    } catch (Exception e) {
        e.printStackTrace();
        fail(e.getMessage());
    }
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
NodeTypeTemplateImpl(NameMapper mapper, NodeTypeDefinition definition)
        throws ConstraintViolationException {
    super(mapper, definition.getName());

    setMixin(definition.isMixin());
    setOrderableChildNodes(definition.hasOrderableChildNodes());
    setAbstract(definition.isAbstract());
    setQueryable(definition.isQueryable());
    String primaryItemName = definition.getPrimaryItemName();
    if (primaryItemName != null) {
        setPrimaryItemName(primaryItemName);
    }
    setDeclaredSuperTypeNames(definition.getDeclaredSupertypeNames());

    PropertyDefinition[] pds = definition.getDeclaredPropertyDefinitions();
    if (pds != null) {
        propertyDefinitionTemplates =
                Lists.newArrayListWithCapacity(pds.length);
        for (PropertyDefinition pd : pds) {
            propertyDefinitionTemplates.add(
                    new PropertyDefinitionTemplateImpl(mapper, pd));
        }
    }

    NodeDefinition[] nds = definition.getDeclaredChildNodeDefinitions();
    if (nds != null) {
        nodeDefinitionTemplates =
                Lists.newArrayListWithCapacity(nds.length);
        for (NodeDefinition nd : nds) {
            nodeDefinitionTemplates.add(
                    new NodeDefinitionTemplateImpl(mapper, nd));
        }
    }
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
@Override
public NodeType registerNodeType(
        NodeTypeDefinition ntd, boolean allowUpdate)
        throws RepositoryException {
    return registerNodeTypes(
            new NodeTypeDefinition[]{ntd}, allowUpdate).nextNodeType();
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
@Override
public void onLoaded(AbstractResourceModelContext modelContext) {
    try {
        final Session session= this.sessionFactory.getInternalSession();
        /* make sure that the scape namespace is available in fcrepo */
        final Dataset namespace =
                this.repositoryService.getNamespaceRegistryDataset(session, new DefaultIdentifierTranslator());
        UpdateAction.parseExecute(
                "INSERT {<http://scapeproject.eu/model#> <" +
                        RdfLexicon.HAS_NAMESPACE_PREFIX + "> \"scape\"} WHERE {}",
                namespace);
        session.save();
        // Get the node type manager ...
        final NodeTypeManager mgr =
                session.getWorkspace().getNodeTypeManager();

        // Create templates for the node types ...
        final NodeTypeTemplate planType = mgr.createNodeTypeTemplate();
        planType.setName("scape:plan");
        planType.setDeclaredSuperTypeNames(new String[] {
                "fedora:resource", "fedora:object"});
        planType.setMixin(true);
        planType.setQueryable(true);
        planType.setAbstract(false);
        planType.getPropertyDefinitionTemplates().add(createMultiPropertyDefTemplate(session, mgr, "scape:hasExecState"));


        // and register them
        mgr.registerNodeTypes(new NodeTypeDefinition[] {planType}, true);

    } catch (RepositoryException e) {
        LOG.error("Error while setting up scape namespace", e);
        throw new RuntimeException("Unable to setup scape on fedora");
    }
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
@Test
public void testRdfTypeInheritance() throws RepositoryException {
    final Session jcrSession = getJcrSession(session);
    final NodeTypeManager mgr = jcrSession.getWorkspace().getNodeTypeManager();
    //create supertype mixin
    final NodeTypeTemplate type1 = mgr.createNodeTypeTemplate();
    type1.setName("test:aSupertype");
    type1.setMixin(true);
    final NodeTypeDefinition[] nodeTypes = new NodeTypeDefinition[]{type1};
    mgr.registerNodeTypes(nodeTypes, true);

    //create a type inheriting above supertype
    final NodeTypeTemplate type2 = mgr.createNodeTypeTemplate();
    type2.setName("test:testInher");
    type2.setMixin(true);
    type2.setDeclaredSuperTypeNames(new String[]{"test:aSupertype"});
    final NodeTypeDefinition[] nodeTypes2 = new NodeTypeDefinition[]{type2};
    mgr.registerNodeTypes(nodeTypes2, true);

    //create object with inheriting type
    FedoraResource object = containerService.findOrCreate(session, "/testNTTnheritanceObject");
    final javax.jcr.Node node = getJcrNode(object);
    node.addMixin("test:testInher");

    session.commit();
    session.expire();
    session = repo.login();

    object = containerService.findOrCreate(session, "/testNTTnheritanceObject");

    //test that supertype has been inherited as rdf:type
    final Node s = createGraphSubjectNode(object);
    final Node p = type.asNode();
    final Node o = createProperty("info:fedora/test/aSupertype").asNode();
    assertTrue("supertype test:aSupertype not found inherited in test:testInher!",
            object.getTriples(subjects, PROPERTIES).collect(toModel()).getGraph().contains(s, p, o));
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
@Override
public NodeTypeTemplate createNodeTypeTemplate(NodeTypeDefinition ntd)
        throws RepositoryException {
    throw new UnsupportedRepositoryOperationException();
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
/**
 * This implementation always throws a {@link UnsupportedRepositoryOperationException}.
 */
@Override
public NodeType registerNodeType(NodeTypeDefinition ntd, boolean allowUpdate) throws RepositoryException {
    throw new UnsupportedRepositoryOperationException();
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
/**
 * This implementation always throws a {@link UnsupportedRepositoryOperationException}.
 */
@Override
public NodeTypeIterator registerNodeTypes(NodeTypeDefinition[] ntds, boolean allowUpdate) throws RepositoryException {
    throw new UnsupportedRepositoryOperationException();
}
 

import javax.jcr.nodetype.NodeTypeDefinition; //导入依赖的package包/类
@Override
public NodeTypeTemplate createNodeTypeTemplate(NodeTypeDefinition ntd)
        throws ConstraintViolationException {
    return new NodeTypeTemplateImpl(getNamePathMapper(), ntd);
}