private JcrNodeType nodeTypeFrom( NodeTypeDefinition nodeType, List<JcrNodeType> supertypes ) throws RepositoryException { PropertyDefinition[] propDefns = nodeType.getDeclaredPropertyDefinitions(); NodeDefinition[] childDefns = nodeType.getDeclaredChildNodeDefinitions(); List<JcrPropertyDefinition> properties = new ArrayList<JcrPropertyDefinition>(); List<JcrNodeDefinition> childNodes = new ArrayList<JcrNodeDefinition>(); if (propDefns != null) { for (PropertyDefinition propDefn : propDefns) { properties.add(propertyDefinitionFrom(propDefn)); } } if (childDefns != null) { for (NodeDefinition childNodeDefn : childDefns) { childNodes.add(childNodeDefinitionFrom(childNodeDefn)); } } Name name = nameFactory.create(nodeType.getName()); Name primaryItemName = nameFactory.create(nodeType.getPrimaryItemName()); boolean mixin = nodeType.isMixin(); boolean isAbstract = nodeType.isAbstract(); boolean queryable = nodeType.isQueryable(); boolean orderableChildNodes = nodeType.hasOrderableChildNodes(); NodeKey prototypeKey = repository.repositoryCache().getSystemKey(); return new JcrNodeType(prototypeKey, this.context, null, this, name, supertypes, primaryItemName, childNodes, properties, mixin, isAbstract, queryable, orderableChildNodes); }
private Node processNodeTypeDefinition( Node outputNode, NodeTypeDefinition nodeTypeDefinition ) throws RepositoryException { Node nodeTypeNode = outputNode.addNode(nodeTypeDefinition.getName(), NODE_TYPE); nodeTypeNode.setProperty(IS_MIXIN, nodeTypeDefinition.isMixin()); nodeTypeNode.setProperty(IS_ABSTRACT, nodeTypeDefinition.isAbstract()); nodeTypeNode.setProperty(IS_QUERYABLE, nodeTypeDefinition.isQueryable()); nodeTypeNode.setProperty(NODE_TYPE_NAME, nodeTypeDefinition.getName()); nodeTypeNode.setProperty(HAS_ORDERABLE_CHILD_NODES, nodeTypeDefinition.hasOrderableChildNodes()); String[] declaredSupertypeNames = nodeTypeDefinition.getDeclaredSupertypeNames(); nodeTypeNode.setProperty(SUPERTYPES, declaredSupertypeNames != null ? declaredSupertypeNames : new String[0]); if (nodeTypeDefinition.getPrimaryItemName() != null) { nodeTypeNode.setProperty(PRIMARY_ITEM_NAME, nodeTypeDefinition.getPrimaryItemName()); } return nodeTypeNode; } }
/** * Internal constructor to avoid resolving def.getName() 3 times. * @param name name of the definition * @param def node type definition * @param resolver resolver * @param qValueFactory value factory * @throws RepositoryException if an error occurs */ private QNodeTypeDefinitionImpl(Name name, NodeTypeDefinition def, NamePathResolver resolver, QValueFactory qValueFactory) throws RepositoryException { this(name, getNames(def.getDeclaredSupertypeNames(), resolver), null, def.isMixin(), def.isAbstract(), def.isQueryable(), def.hasOrderableChildNodes(), def.getPrimaryItemName() == null ? null : resolver.getQName(def.getPrimaryItemName()), createQPropertyDefinitions(name, def.getDeclaredPropertyDefinitions(), resolver, qValueFactory), createQNodeDefinitions(name, def.getDeclaredChildNodeDefinitions(), resolver)); }
if (ntd.isAbstract()) { options.add(Lexer.ABSTRACT[0]); if (ntd.hasOrderableChildNodes()) { options.add(Lexer.ORDERABLE[0]); if (ntd.isMixin()) { options.add(Lexer.MIXIN[0]); if (!ntd.isQueryable()) { options.add(Lexer.NOQUERY[0]); String pin = ntd.getPrimaryItemName(); if (pin != null) { options.add(Lexer.PRIMARYITEM[0]);
/** * @param oldDef old definition * @param newDef new definition * @return the diff */ public static NodeTypeDefDiff create(NodeTypeDefinition oldDef, NodeTypeDefinition newDef) { if (oldDef == null || newDef == null) { throw new IllegalArgumentException("arguments can not be null"); } if (!oldDef.getName().equals(newDef.getName())) { throw new IllegalArgumentException("at least node type names must be matching"); } return new NodeTypeDefDiff(oldDef, newDef); }
private void storeNodeTypeDefinition( Node outputNode, NodeTypeDefinition nodeTypeDefinition ) throws RepositoryException { Node nodeTypeNode = processNodeTypeDefinition(outputNode, nodeTypeDefinition); PropertyDefinition[] declaredPropertyDefinitions = nodeTypeDefinition.getDeclaredPropertyDefinitions(); if (declaredPropertyDefinitions != null) { for (PropertyDefinition propertyDefinition : declaredPropertyDefinitions) { processPropertyDefinition(nodeTypeNode, propertyDefinition); } } NodeDefinition[] declaredChildNodeDefinitions = nodeTypeDefinition.getDeclaredChildNodeDefinitions(); if (declaredChildNodeDefinitions != null) { for (NodeDefinition childNodeDefinition : declaredChildNodeDefinitions) { processChildNodeDefinition(nodeTypeNode, childNodeDefinition); } } }
boolean isMixin = nodeType.isMixin(); boolean needsPrimaryAncestor = !isMixin; String nodeTypeName = nodeType.getName(); for (String supertypeNameStr : nodeType.getDeclaredSupertypeNames()) { Name supertypeName = nameFactory.create(supertypeNameStr); JcrNodeType supertype = findTypeInMapOrList(supertypeName, pendingTypes);
public PropertyDefinition[] getDeclaredPropertyDefinitions() { if (ntd != null) { return ntd.getDeclaredPropertyDefinitions(); } else if (propDefList.size() != 0) { return propDefList.toArray(new PropertyDefinition[0]); } else { return new PropertyDefinition[0]; } }
/** * Returns the set of declared supertype names without 'nt:base', which is * irrelevant for a diff of supertypes. * * @param def a NodeTypeDefinition. * @return the set of declared supertype names. */ private Set<String> getDeclaredSuperTypeNames(NodeTypeDefinition def) { Set<String> names = new HashSet<String>(Arrays.asList(def.getDeclaredSupertypeNames())); names.remove(JcrConstants.NT_BASE); return names; }
public NodeDefinition[] getDeclaredChildNodeDefinitions() { if (ntd != null) { return ntd.getDeclaredChildNodeDefinitions(); } else if (nodeDefList.size() != 0) { return nodeDefList.toArray(new NodeDefinition[0]); } else { return new NodeDefinition[0]; } } }
/** * @return <code>true</code> if abstract flag diff */ public int abstractFlagDiff() { return oldDef.isAbstract() && !newDef.isAbstract() ? MAJOR : NONE; }
if (ntd.isAbstract()) { options.add(Lexer.ABSTRACT[0]); if (ntd.hasOrderableChildNodes()) { options.add(Lexer.ORDERABLE[0]); if (ntd.isMixin()) { options.add(Lexer.MIXIN[0]); if (!ntd.isQueryable()) { options.add(Lexer.NOQUERY[0]); String pin = ntd.getPrimaryItemName(); if (pin != null) { options.add(Lexer.PRIMARYITEM[0]);
/** * @param oldDef old definition * @param newDef new definition * @return the diff */ public static NodeTypeDefDiff create(NodeTypeDefinition oldDef, NodeTypeDefinition newDef) { if (oldDef == null || newDef == null) { throw new IllegalArgumentException("arguments can not be null"); } if (!oldDef.getName().equals(newDef.getName())) { throw new IllegalArgumentException("at least node type names must be matching"); } return new NodeTypeDefDiff(oldDef, newDef); }
private void storeNodeTypeDefinition( Node outputNode, NodeTypeDefinition nodeTypeDefinition ) throws RepositoryException { Node nodeTypeNode = processNodeTypeDefinition(outputNode, nodeTypeDefinition); PropertyDefinition[] declaredPropertyDefinitions = nodeTypeDefinition.getDeclaredPropertyDefinitions(); if (declaredPropertyDefinitions != null) { for (PropertyDefinition propertyDefinition : declaredPropertyDefinitions) { processPropertyDefinition(nodeTypeNode, propertyDefinition); } } NodeDefinition[] declaredChildNodeDefinitions = nodeTypeDefinition.getDeclaredChildNodeDefinitions(); if (declaredChildNodeDefinitions != null) { for (NodeDefinition childNodeDefinition : declaredChildNodeDefinitions) { processChildNodeDefinition(nodeTypeNode, childNodeDefinition); } } }
boolean isMixin = nodeType.isMixin(); boolean needsPrimaryAncestor = !isMixin; String nodeTypeName = nodeType.getName(); for (String supertypeNameStr : nodeType.getDeclaredSupertypeNames()) { Name supertypeName = nameFactory.create(supertypeNameStr); JcrNodeType supertype = findTypeInMapOrList(supertypeName, pendingTypes);
int maxType = NONE; Map<PropertyDefinitionId, PropertyDefinition> oldDefs = new HashMap<PropertyDefinitionId, PropertyDefinition>(); for (PropertyDefinition def : oldDef.getDeclaredPropertyDefinitions()) { oldDefs.put(new PropertyDefinitionId(def), def); for (PropertyDefinition def : newDef.getDeclaredPropertyDefinitions()) { newDefs.put(new PropertyDefinitionId(def), def);
/** * Returns the set of declared supertype names without 'nt:base', which is * irrelevant for a diff of supertypes. * * @param def a NodeTypeDefinition. * @return the set of declared supertype names. */ private Set<String> getDeclaredSuperTypeNames(NodeTypeDefinition def) { Set<String> names = new HashSet<String>(Arrays.asList(def.getDeclaredSupertypeNames())); names.remove(JcrConstants.NT_BASE); return names; }
/** * @return diff type */ private int buildChildNodeDefDiffs() { int maxType = NONE; final Map<NodeDefinitionId, List<NodeDefinition>> oldDefs = collectChildNodeDefs(oldDef.getDeclaredChildNodeDefinitions()); final Map<NodeDefinitionId, List<NodeDefinition>> newDefs = collectChildNodeDefs(newDef.getDeclaredChildNodeDefinitions()); for (NodeDefinitionId defId : oldDefs.keySet()) { final ChildNodeDefDiffs childNodeDefDiffs = new ChildNodeDefDiffs(oldDefs.get(defId), newDefs.get(defId)); this.childNodeDefDiffs.addAll(childNodeDefDiffs.getChildNodeDefDiffs()); newDefs.remove(defId); } for (NodeDefinitionId defId : newDefs.keySet()) { final ChildNodeDefDiffs childNodeDefDiffs = new ChildNodeDefDiffs(null, newDefs.get(defId)); this.childNodeDefDiffs.addAll(childNodeDefDiffs.getChildNodeDefDiffs()); } for (ChildNodeDefDiff diff : childNodeDefDiffs) { if (diff.getType() > maxType) { maxType = diff.getType(); } } return maxType; }