Refine search
private static NodeType[] toArray(NodeTypeIterator nodeTypes) { ArrayList<NodeType> nts = new ArrayList<NodeType>(); while (nodeTypes.hasNext()) { nts.add(nodeTypes.nextNodeType()); } return nts.toArray(new NodeType[nts.size()]); }
private static NodeType[] toArray(NodeTypeIterator nodeTypes) { ArrayList<NodeType> nts = new ArrayList<NodeType>(); while (nodeTypes.hasNext()) { nts.add(nodeTypes.nextNodeType()); } return nts.toArray(new NodeType[nts.size()]); }
private static NodeType[] toArray(NodeTypeIterator nodeTypes) { ArrayList<NodeType> nts = new ArrayList<NodeType>(); while (nodeTypes.hasNext()) { nts.add(nodeTypes.nextNodeType()); } return nts.toArray(new NodeType[nts.size()]); }
/** * Return the set of node type names for the specified node types. */ private Set<String> asSetOfNames(NodeTypeIterator it) { Set<String> result = new HashSet<String>(); while (it.hasNext()) { result.add(it.nextNodeType().getName()); } return result; } }
private static List<String> getAllNodeTypes(ReadOnlyNodeTypeManager ntReg) { try { List<String> typeNames = newArrayList(); NodeTypeIterator ntItr = ntReg.getAllNodeTypes(); while (ntItr.hasNext()){ typeNames.add(ntItr.nextNodeType().getName()); } return typeNames; } catch (RepositoryException e) { throw new RuntimeException(e); } }
private Set<String> getSelfPlusSubTypes(final String nodeType, final NodeTypeIterator allTypes) throws RepositoryException { Set<String> subTypes = new LinkedHashSet<>(); while (allTypes.hasNext()) { NodeType nt = allTypes.nextNodeType(); if (nt.isNodeType(nodeType)) { subTypes.add(nt.getName()); } } return subTypes; }
/** * @return a string that is not the name of a mixin type */ public static String getNonExistingMixinName(Session session) throws RepositoryException { NodeTypeManager manager = session.getWorkspace().getNodeTypeManager(); NodeTypeIterator mixins = manager.getMixinNodeTypes(); StringBuffer s = new StringBuffer("X"); while (mixins.hasNext()) { s.append(mixins.nextNodeType().getName()); } return s.toString().replaceAll(":", ""); }
private Collection<NodeType> getDescendantNodeTypes(NodeType nt) { Collection<NodeType> result = new HashSet<>(); NodeTypeIterator subNodeTypes = nt.getDeclaredSubtypes(); while (subNodeTypes.hasNext()) { NodeType subNodeType = subNodeTypes.nextNodeType(); if (!subNodeType.isAbstract()) { result.add(subNodeType); } result.addAll(getDescendantNodeTypes(subNodeType)); } return result; }
private Collection<NodeType> getDescendentNodeTypes(NodeType nt) { Collection<NodeType> result = new HashSet<NodeType>(); NodeTypeIterator subNodeTypes = nt.getDeclaredSubtypes(); while (subNodeTypes.hasNext()) { NodeType subNodeType = subNodeTypes.nextNodeType(); if (!subNodeType.isAbstract()) { result.add(subNodeType); } result.addAll(getDescendentNodeTypes(subNodeType)); } return result; }
@Override public NodeTypeIterator getPrimaryNodeTypes() throws RepositoryException { List<NodeType> list = Lists.newArrayList(); NodeTypeIterator iterator = getAllNodeTypes(); while (iterator.hasNext()) { NodeType type = iterator.nextNodeType(); if (!type.isMixin()) { list.add(type); } } return new NodeTypeIteratorAdapter(list); }
@Override public NodeTypeIterator getMixinNodeTypes() throws RepositoryException { List<NodeType> list = Lists.newArrayList(); NodeTypeIterator iterator = getAllNodeTypes(); while (iterator.hasNext()) { NodeType type = iterator.nextNodeType(); if (type.isMixin()) { list.add(type); } } return new NodeTypeIteratorAdapter(list); }
@Override public NodeTypeIterator getPrimaryNodeTypes() throws RepositoryException { List<NodeType> list = Lists.newArrayList(); NodeTypeIterator iterator = getAllNodeTypes(); while (iterator.hasNext()) { NodeType type = iterator.nextNodeType(); if (!type.isMixin()) { list.add(type); } } return new NodeTypeIteratorAdapter(list); }
@Override public NodeTypeIterator getPrimaryNodeTypes() throws RepositoryException { List<NodeType> list = Lists.newArrayList(); NodeTypeIterator iterator = getAllNodeTypes(); while (iterator.hasNext()) { NodeType type = iterator.nextNodeType(); if (!type.isMixin()) { list.add(type); } } return new NodeTypeIteratorAdapter(list); }
@Override public NodeTypeIterator getMixinNodeTypes() throws RepositoryException { List<NodeType> list = Lists.newArrayList(); NodeTypeIterator iterator = getAllNodeTypes(); while (iterator.hasNext()) { NodeType type = iterator.nextNodeType(); if (type.isMixin()) { list.add(type); } } return new NodeTypeIteratorAdapter(list); }
@Override public NodeTypeIterator getMixinNodeTypes() throws RepositoryException { List<NodeType> list = Lists.newArrayList(); NodeTypeIterator iterator = getAllNodeTypes(); while (iterator.hasNext()) { NodeType type = iterator.nextNodeType(); if (type.isMixin()) { list.add(type); } } return new NodeTypeIteratorAdapter(list); }
private List<RestNodeType> registerCND( HttpServletRequest request, boolean allowUpdate, InputStream cndInputStream, org.modeshape.jcr.api.nodetype.NodeTypeManager modeshapeTypeManager ) throws IOException, RepositoryException { NodeTypeIterator nodeTypeIterator = modeshapeTypeManager.registerNodeTypes(cndInputStream, allowUpdate); List<RestNodeType> result = new ArrayList<RestNodeType>(); String baseUrl = RestHelper.repositoryUrl(request); while (nodeTypeIterator.hasNext()) { result.add(new RestNodeType(nodeTypeIterator.nextNodeType(), baseUrl)); } return result; } }
private synchronized LinkedHashSet<QNodeTypeDefinition> getNodeTypes(String namespacePrefix) throws RepositoryException { NodeTypeIterator it = ntMgr.getAllNodeTypes(); TreeMap<String, NodeType> typesMap = new TreeMap<>(); while (it.hasNext()) { NodeType nt = it.nextNodeType(); if (nt.getName().startsWith(namespacePrefix)) { typesMap.put(nt.getName(), nt); } } LinkedHashSet<QNodeTypeDefinition> result = new LinkedHashSet<>(); for (NodeType type : typesMap.values()) { visit(namespacePrefix, type, new HashSet<>(), result); } return result; }
private Set<String> getSelfPlusSubTypes(final String primaryNodeType) throws RepositoryException { Set<String> subTypes = new LinkedHashSet<>(); NodeTypeManager ntMgr = session.getWorkspace().getNodeTypeManager(); NodeTypeIterator allTypes = ntMgr.getAllNodeTypes(); while (allTypes.hasNext()) { NodeType nt = allTypes.nextNodeType(); if (nt.isNodeType(primaryNodeType)) { subTypes.add(nt.getName()); } } return subTypes; }
/** * Test if getMixinNodeTypes does return exclusively mixin node types */ public void testGetMixinNodeTypes() throws RepositoryException { NodeTypeIterator types = manager.getMixinNodeTypes(); while (types.hasNext()) { assertTrue("getMixinNodeTypes() must return exclusively mixin " + "node types", types.nextNodeType().isMixin()); } }
/** * Test if getPrimaryNodeTypes does not return any mixin node types */ public void testGetPrimaryNodeTypes() throws RepositoryException { NodeTypeIterator types = manager.getPrimaryNodeTypes(); while (types.hasNext()) { assertFalse("getPrimaryNodeTypes() must not return mixin " + "node types", types.nextNodeType().isMixin()); } }