From 3713e2043d7791b92f4eaad80c831a3e64bfc263 Mon Sep 17 00:00:00 2001 From: Jukka Zitting Date: Thu, 17 Jan 2013 09:40:36 +0200 Subject: [PATCH] OAK-562: Clean up duplicate name conversion in plugins/nodetype Refactor type template classes to use Oak names internally and to better avoid code duplication. Instead of extending the builder base classes from jcr-commons, we implement everything locally to be able to better share the name mapping code and to avoid extra CND handling complexity. As a consequence we use CndImporter instead of the lower-level CompactNodeTypeDefReader mechanism for importing CND files. --- .../plugins/name/ReadWriteNamespaceRegistry.java | 7 + .../plugins/nodetype/AbstractNamedTemplate.java | 137 ++++++++++ .../oak/plugins/nodetype/BuiltInNodeTypes.java | 73 ++++-- .../oak/plugins/nodetype/DefBuilderFactory.java | 82 ------ .../nodetype/ItemDefinitionTemplateImpl.java | 140 +++++++++++ .../nodetype/NodeDefinitionTemplateImpl.java | 198 ++++----------- .../oak/plugins/nodetype/NodeTypeTemplateImpl.java | 261 +++++++------------- .../nodetype/PropertyDefinitionTemplateImpl.java | 179 +++++--------- .../plugins/nodetype/ReadOnlyNodeTypeManager.java | 9 +- .../plugins/nodetype/ReadWriteNodeTypeManager.java | 62 ----- .../jackrabbit/oak/jcr/TestContentLoader.java | 15 +- 11 files changed, 550 insertions(+), 613 deletions(-) create mode 100644 oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/AbstractNamedTemplate.java delete mode 100644 oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/DefBuilderFactory.java create mode 100644 oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ItemDefinitionTemplateImpl.java diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/name/ReadWriteNamespaceRegistry.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/name/ReadWriteNamespaceRegistry.java index 5e084d5..ca0652e 100644 --- a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/name/ReadWriteNamespaceRegistry.java +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/name/ReadWriteNamespaceRegistry.java @@ -16,6 +16,8 @@ */ package org.apache.jackrabbit.oak.plugins.name; +import java.util.Map; + import javax.jcr.NamespaceException; import javax.jcr.RepositoryException; @@ -73,6 +75,11 @@ public abstract class ReadWriteNamespaceRegistry @Override public void registerNamespace(String prefix, String uri) throws RepositoryException { + Map map = Namespaces.getNamespaceMap(getReadTree()); + if (uri.equals(map.get(prefix))) { + return; // Namespace already registered, so we do nothing + } + try { Root root = getWriteRoot(); Tree namespaces = diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/AbstractNamedTemplate.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/AbstractNamedTemplate.java new file mode 100644 index 0000000..2b2ca02 --- /dev/null +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/AbstractNamedTemplate.java @@ -0,0 +1,137 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jackrabbit.oak.plugins.nodetype; + +import static com.google.common.base.Preconditions.checkNotNull; + +import javax.annotation.CheckForNull; +import javax.annotation.Nonnull; +import javax.jcr.nodetype.ConstraintViolationException; + +import org.apache.jackrabbit.oak.namepath.JcrNameParser; +import org.apache.jackrabbit.oak.namepath.NameMapper; + +/** + * Abstract base class for the template implementations in this package. + * Keeps track of the Oak name of this template and provides utility methods + * for mapping between JCR and Oak names. + */ +abstract class AbstractNamedTemplate { + + private final NameMapper mapper; + + private String oakName = null; // not defined by default + + protected AbstractNamedTemplate(NameMapper mapper) { + this.mapper = mapper; + } + + protected AbstractNamedTemplate(NameMapper mapper, String jcrName) + throws ConstraintViolationException { + this(mapper); + if (jcrName != null) { + setName(jcrName); + } + } + + /** + * Returns the name of this template, or {@code null} if the name + * has not yet been set. + * + * @return JCR name, or {@code null} + */ + @CheckForNull + public String getName() { + return getJcrNameAllowNull(oakName); + } + + /** + * Sets the name of this template. + * + * @param jcrName JCR name + * @throws ConstraintViolationException if the name is invalid + */ + public void setName(@Nonnull String jcrName) + throws ConstraintViolationException { + if (jcrName == null) { + throw new ConstraintViolationException("missing template name"); + } + this.oakName = getOakNameOrThrowConstraintViolation(jcrName); + } + + /** + * Like {@link NameMapper#getJcrName(String)}, but allows the given Oak + * name to be {@code null}, in which case the return value is also + * {@code null}. Useful for the template implementations where + * {@code null} values are used to indicate undefined attributes. + * + * @param oakName Oak name, or {@code null} + * @return JCR name, or {@code null} + */ + @CheckForNull + protected String getJcrNameAllowNull(@CheckForNull String oakName) { + if (oakName != null) { + return mapper.getJcrName(oakName); + } else { + return null; + } + } + + + @CheckForNull + protected String[] getJcrNames(@CheckForNull String[] oakNames) { + String[] jcrNames = null; + if (oakNames != null) { + jcrNames = new String[oakNames.length]; + for (int i = 0; i < oakNames.length; i++) { + jcrNames[i] = mapper.getJcrName(oakNames[i]); + } + } + return jcrNames; + } + + @CheckForNull + protected String getOakNameOrThrowConstraintViolation( + @CheckForNull String jcrName) throws ConstraintViolationException { + if (jcrName == null) { + return null; + } + + String oakName = mapper.getOakNameOrNull(jcrName); + if (oakName == null || !JcrNameParser.validate(jcrName)) { + throw new ConstraintViolationException( + "Invalid name: " + jcrName); + } + return oakName; + } + + @CheckForNull + protected String[] getOakNamesOrThrowConstraintViolation( + @CheckForNull String[] jcrNames) + throws ConstraintViolationException { + String[] oakNames = null; + if (jcrNames != null) { + oakNames = new String[jcrNames.length]; + for (int i = 0; i < jcrNames.length; i++) { + oakNames[i] = getOakNameOrThrowConstraintViolation( + checkNotNull(jcrNames[i])); + } + } + return oakNames; + } + +} diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/BuiltInNodeTypes.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/BuiltInNodeTypes.java index aa2f7e0..6444976 100644 --- a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/BuiltInNodeTypes.java +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/BuiltInNodeTypes.java @@ -16,15 +16,30 @@ */ package org.apache.jackrabbit.oak.plugins.nodetype; +import static org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants.NODE_TYPES_PATH; + +import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; +import java.util.Map; import javax.annotation.Nonnull; +import javax.jcr.NamespaceRegistry; +import javax.jcr.RepositoryException; +import javax.jcr.ValueFactory; +import javax.jcr.nodetype.NodeTypeManager; +import org.apache.jackrabbit.commons.cnd.CndImporter; +import org.apache.jackrabbit.commons.cnd.ParseException; import org.apache.jackrabbit.oak.api.Root; import org.apache.jackrabbit.oak.api.Tree; +import org.apache.jackrabbit.oak.namepath.GlobalNameMapper; +import org.apache.jackrabbit.oak.namepath.NamePathMapperImpl; +import org.apache.jackrabbit.oak.plugins.name.Namespaces; +import org.apache.jackrabbit.oak.plugins.name.ReadWriteNamespaceRegistry; +import org.apache.jackrabbit.oak.plugins.value.ValueFactoryImpl; -import static org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants.NODE_TYPES_PATH; +import com.google.common.base.Charsets; /** * BuiltInNodeTypes is a utility class that registers the built-in @@ -32,7 +47,11 @@ import static org.apache.jackrabbit.oak.plugins.nodetype.NodeTypeConstants.NODE_ */ public class BuiltInNodeTypes { - private final ReadWriteNodeTypeManager ntMgr; + private final NodeTypeManager ntMgr; + + private final NamespaceRegistry nsReg; + + private final ValueFactory vf; private BuiltInNodeTypes(final Root root) { this.ntMgr = new ReadWriteNodeTypeManager() { @@ -47,6 +66,25 @@ public class BuiltInNodeTypes { return root; } }; + + this.nsReg = new ReadWriteNamespaceRegistry() { + @Override + protected Tree getReadTree() { + return root.getTree("/"); + } + @Override + protected Root getWriteRoot() { + return root; + } + }; + + this.vf = new ValueFactoryImpl(null, new NamePathMapperImpl( + new GlobalNameMapper() { + @Override + protected Map getNamespaceMap() { + return Namespaces.getNamespaceMap(root.getTree("/")); + } + })); } /** @@ -60,24 +98,25 @@ public class BuiltInNodeTypes { private void registerBuiltinNodeTypes() { // FIXME: migrate custom node types as well. - if (!nodeTypesInContent()) { + try { + InputStream stream = BuiltInNodeTypes.class.getResourceAsStream("builtin_nodetypes.cnd"); try { - InputStream stream = BuiltInNodeTypes.class.getResourceAsStream("builtin_nodetypes.cnd"); - try { - ntMgr.registerNodeTypes(new InputStreamReader(stream, "UTF-8")); - } finally { - stream.close(); - } - } catch (Exception e) { - throw new IllegalStateException( - "Unable to load built-in node types", e); + CndImporter.registerNodeTypes( + new InputStreamReader(stream, Charsets.UTF_8), + "built-in node types", ntMgr, nsReg, vf, false); + } finally { + stream.close(); } + } catch (IOException e) { + throw new IllegalStateException( + "Unable to read built-in node types", e); + } catch (ParseException e) { + throw new IllegalStateException( + "Unable to parse built-in node types", e); + } catch (RepositoryException e) { + throw new IllegalStateException( + "Unable to register built-in node types", e); } } - private boolean nodeTypesInContent() { - Tree types = ntMgr.getTypes(); - return types != null && types.getChildrenCount() > 0; - } - } diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/DefBuilderFactory.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/DefBuilderFactory.java deleted file mode 100644 index 39ec8ca..0000000 --- a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/DefBuilderFactory.java +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.jackrabbit.oak.plugins.nodetype; - -import java.util.Map; - -import javax.jcr.nodetype.NodeTypeTemplate; - -import org.apache.jackrabbit.JcrConstants; -import org.apache.jackrabbit.commons.cnd.DefinitionBuilderFactory; -import org.apache.jackrabbit.oak.api.Tree; -import org.apache.jackrabbit.oak.namepath.GlobalNameMapper; -import org.apache.jackrabbit.oak.plugins.name.NamespaceConstants; -import org.apache.jackrabbit.oak.plugins.name.Namespaces; - -class DefBuilderFactory extends - DefinitionBuilderFactory> { - - private final Tree root; - - public DefBuilderFactory(Tree root) { - this.root = root; - } - - @Override - public NodeTypeTemplateImpl newNodeTypeDefinitionBuilder() { - return new NodeTypeTemplateImpl(new GlobalNameMapper() { - @Override - protected Map getNamespaceMap() { - return getNamespaceMapping(); - } - }); - } - - @Override - public Map getNamespaceMapping() { - return Namespaces.getNamespaceMap(root); - } - - @Override - public void setNamespaceMapping(Map namespaces) { - throw new UnsupportedOperationException(); - } - - @Override - public void setNamespace(String prefix, String uri) { - if (Namespaces.getNamespaceMap(root).containsValue(uri)) { - return; // namespace already exists - } - - Tree namespaces = getOrCreate( - JcrConstants.JCR_SYSTEM, NamespaceConstants.REP_NAMESPACES); - namespaces.setProperty(prefix, uri); - } - - private Tree getOrCreate(String... path) { - Tree tree = root; - for (String name : path) { - Tree child = tree.getChild(name); - if (child == null) { - child = tree.addChild(name); - } - tree = child; - } - return tree; - } - -} diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ItemDefinitionTemplateImpl.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ItemDefinitionTemplateImpl.java new file mode 100644 index 0000000..86c0c25 --- /dev/null +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ItemDefinitionTemplateImpl.java @@ -0,0 +1,140 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jackrabbit.oak.plugins.nodetype; + +import javax.annotation.CheckForNull; +import javax.annotation.Nonnull; +import javax.jcr.nodetype.ConstraintViolationException; +import javax.jcr.nodetype.ItemDefinition; +import javax.jcr.nodetype.NodeType; +import javax.jcr.version.OnParentVersionAction; + +import org.apache.jackrabbit.oak.namepath.NameMapper; + +/** + * Base class for the node and property definition template implementations + * in this package. Takes care of the shared item definition attributes and + * manages mappings between JCR and Oak names. + */ +class ItemDefinitionTemplateImpl extends AbstractNamedTemplate + implements ItemDefinition { + + private boolean residual = false; + + private boolean isAutoCreated = false; + + private int onParentVersion = OnParentVersionAction.COPY; + + protected boolean isProtected = false; + + protected boolean isMandatory = false; + + protected ItemDefinitionTemplateImpl(NameMapper mapper) { + super(mapper); + } + + protected ItemDefinitionTemplateImpl( + NameMapper mapper, ItemDefinition definition) + throws ConstraintViolationException { + super(mapper, definition.getName()); + setProtected(definition.isProtected()); + setMandatory(definition.isMandatory()); + setAutoCreated(definition.isAutoCreated()); + setOnParentVersion(definition.getOnParentVersion()); + } + + /** + * Returns the name of this template, or {@code null} if the name + * has not yet been set. The special name "*" is used for residual + * item definitions. + * + * @return JCR name, "*", or {@code null} + */ + @Override @CheckForNull + public String getName() { + if (residual) { + return NodeTypeConstants.RESIDUAL_NAME; + } else { + return super.getName(); + } + } + + /** + * Sets the name of this template. Use the special name "*" for a residual + * item definition. + * + * @param jcrName JCR name, or "*" + * @throws ConstraintViolationException if the name is invalid + */ + @Override + public void setName(@Nonnull String jcrName) + throws ConstraintViolationException { + residual = NodeTypeConstants.RESIDUAL_NAME.equals(jcrName); + if (!residual) { + super.setName(jcrName); + } + } + + /** + * Returns {@code null} since an item definition template is not + * attached to a live, already registered node type. + * + * @return {@code null} + */ + @Override + public NodeType getDeclaringNodeType() { + return null; + } + + @Override + public boolean isAutoCreated() { + return isAutoCreated; + } + + public void setAutoCreated(boolean isAutoCreated) { + this.isAutoCreated = isAutoCreated; + } + + @Override + public boolean isMandatory() { + return isMandatory; + } + + public void setMandatory(boolean isMandatory) { + this.isMandatory = isMandatory; + } + + @Override + public int getOnParentVersion() { + return onParentVersion; + } + + public void setOnParentVersion(int onParentVersion) { + OnParentVersionAction.nameFromValue(onParentVersion); // validate + this.onParentVersion = onParentVersion; + } + + @Override + public boolean isProtected() { + return isProtected; + } + + public void setProtected(boolean isProtected) { + this.isProtected = isProtected; + } + +} diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/NodeDefinitionTemplateImpl.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/NodeDefinitionTemplateImpl.java index 2dd3043..33ad3a9 100644 --- a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/NodeDefinitionTemplateImpl.java +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/NodeDefinitionTemplateImpl.java @@ -16,205 +16,93 @@ */ package org.apache.jackrabbit.oak.plugins.nodetype; -import java.util.ArrayList; -import java.util.List; - -import javax.jcr.RepositoryException; -import javax.jcr.UnsupportedRepositoryOperationException; import javax.jcr.nodetype.ConstraintViolationException; +import javax.jcr.nodetype.NodeDefinition; import javax.jcr.nodetype.NodeDefinitionTemplate; import javax.jcr.nodetype.NodeType; -import javax.jcr.nodetype.NodeTypeTemplate; -import javax.jcr.version.OnParentVersionAction; -import org.apache.jackrabbit.commons.cnd.DefinitionBuilderFactory.AbstractNodeDefinitionBuilder; -import org.apache.jackrabbit.oak.namepath.JcrNameParser; import org.apache.jackrabbit.oak.namepath.NameMapper; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -class NodeDefinitionTemplateImpl - extends AbstractNodeDefinitionBuilder +class NodeDefinitionTemplateImpl extends ItemDefinitionTemplateImpl implements NodeDefinitionTemplate { - private static final Logger log = - LoggerFactory.getLogger(NodeDefinitionTemplateImpl.class); - - private String defaultPrimaryTypeName; + private boolean allowSameNameSiblings = false; - private final NameMapper mapper; - private String[] requiredPrimaryTypeNames; + private String defaultPrimaryTypeOakName = null; - protected NodeType getNodeType(String name) throws RepositoryException { - throw new UnsupportedRepositoryOperationException(); - } + private String[] requiredPrimaryTypeOakNames = null; public NodeDefinitionTemplateImpl(NameMapper mapper) { - this.mapper = mapper; - onParent = OnParentVersionAction.COPY; - } - - @Override - public void build() { - // do nothing by default - } - - @Override - public NodeType getDeclaringNodeType() { - return null; - } - - @Override - public void setDeclaringNodeType(String name) { - // ignore - } - - @Override - public void setName(String name) throws ConstraintViolationException { - JcrNameParser.checkName(name, true); - this.name = mapper.getJcrName(mapper.getOakNameOrNull(name)); - } - - @Override - public boolean isAutoCreated() { - return autocreate; - } - - @Override - public void setAutoCreated(boolean autocreate) { - this.autocreate = autocreate; + super(mapper); } - @Override - public boolean isProtected() { - return isProtected; - } - - @Override - public void setProtected(boolean isProtected) { - this.isProtected = isProtected; - } - - @Override - public boolean isMandatory() { - return isMandatory; - } - - @Override - public void setMandatory(boolean isMandatory) { - this.isMandatory = isMandatory; - } - - @Override - public int getOnParentVersion() { - return onParent; - } - - @Override - public void setOnParentVersion(int onParent) { - this.onParent = onParent; + public NodeDefinitionTemplateImpl( + NameMapper mapper, NodeDefinition definition) + throws ConstraintViolationException { + super(mapper, definition); + setSameNameSiblings(definition.allowsSameNameSiblings()); + setDefaultPrimaryTypeName(definition.getDefaultPrimaryTypeName()); + setRequiredPrimaryTypeNames(definition.getRequiredPrimaryTypeNames()); } @Override public boolean allowsSameNameSiblings() { - return allowSns; + return allowSameNameSiblings; } @Override - public void setSameNameSiblings(boolean allowSns) { - this.allowSns = allowSns; - } - - @Override - public void setAllowsSameNameSiblings(boolean allowSns) { - setSameNameSiblings(allowSns); + public void setSameNameSiblings(boolean allowSameNameSiblings) { + this.allowSameNameSiblings = allowSameNameSiblings; } + /** + * Returns {@code null} since an item definition template is not + * attached to a live, already registered node type. + * + * @return {@code null} + */ @Override public NodeType getDefaultPrimaryType() { - if (defaultPrimaryTypeName != null) { - try { - return getNodeType(defaultPrimaryTypeName); - } catch (RepositoryException e) { - log.warn("Unable to access default primary type " - + defaultPrimaryTypeName + " of " + name, e); - } - } return null; } @Override public String getDefaultPrimaryTypeName() { - return defaultPrimaryTypeName; + return getJcrNameAllowNull(defaultPrimaryTypeOakName); } @Override - public void setDefaultPrimaryTypeName(String name) throws ConstraintViolationException { - if (name == null) { - this.defaultPrimaryTypeName = null; - } - else { - JcrNameParser.checkName(name, false); - this.defaultPrimaryTypeName = mapper.getJcrName(mapper.getOakNameOrNull(name)); - } - } - - @Override - public void setDefaultPrimaryType(String name) throws ConstraintViolationException { - setDefaultPrimaryTypeName(name); + public void setDefaultPrimaryTypeName(String jcrName) + throws ConstraintViolationException { + this.defaultPrimaryTypeOakName = + getOakNameOrThrowConstraintViolation(jcrName); } + /** + * Returns {@code null} since an item definition template is not + * attached to a live, already registered node type. + * + * @return {@code null} + */ @Override public NodeType[] getRequiredPrimaryTypes() { - if (requiredPrimaryTypeNames == null) { - return null; - } else { - List types = - new ArrayList(requiredPrimaryTypeNames.length); - for (String requiredPrimaryTypeName : requiredPrimaryTypeNames) { - try { - types.add(getNodeType(requiredPrimaryTypeName)); - } - catch (RepositoryException e) { - log.warn("Unable to required primary primary type " - + requiredPrimaryTypeName + " of " + name, e); - } - } - return types.toArray(new NodeType[types.size()]); - } + return null; } @Override public String[] getRequiredPrimaryTypeNames() { - return requiredPrimaryTypeNames; + return getJcrNames(requiredPrimaryTypeOakNames); } @Override - public void setRequiredPrimaryTypeNames(String[] names) throws ConstraintViolationException { - if (names == null) { - throw new ConstraintViolationException("null is not a valid array of JCR names"); + public void setRequiredPrimaryTypeNames(String[] jcrNames) + throws ConstraintViolationException { + if (jcrNames == null) { + throw new ConstraintViolationException( + "missing required primary type names"); } - int k = 0; - String[] n = new String[names.length]; - for (String name : names) { - JcrNameParser.checkName(name, false); - n[k++] = mapper.getJcrName(mapper.getOakNameOrNull(name)); - } - this.requiredPrimaryTypeNames = n; - } - - @Override - public void addRequiredPrimaryType(String name) throws ConstraintViolationException { - JcrNameParser.checkName(name, false); - if (requiredPrimaryTypeNames == null) { - requiredPrimaryTypeNames = new String[] { mapper.getJcrName(mapper.getOakNameOrNull(name)) }; - } else { - String[] names = new String[requiredPrimaryTypeNames.length + 1]; - System.arraycopy(requiredPrimaryTypeNames, 0, names, 0, requiredPrimaryTypeNames.length); - names[requiredPrimaryTypeNames.length] = mapper.getJcrName(mapper.getOakNameOrNull(name)); - requiredPrimaryTypeNames = names; - } - + this.requiredPrimaryTypeOakNames = + getOakNamesOrThrowConstraintViolation(jcrNames); } -} \ No newline at end of file +} diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/NodeTypeTemplateImpl.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/NodeTypeTemplateImpl.java index 82f2751..3f73454 100644 --- a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/NodeTypeTemplateImpl.java +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/NodeTypeTemplateImpl.java @@ -16,155 +16,104 @@ */ package org.apache.jackrabbit.oak.plugins.nodetype; -import java.util.ArrayList; import java.util.List; -import javax.jcr.RepositoryException; -import javax.jcr.Value; -import javax.jcr.ValueFactory; -import javax.jcr.ValueFormatException; +import javax.annotation.Nonnull; import javax.jcr.nodetype.ConstraintViolationException; import javax.jcr.nodetype.NodeDefinition; import javax.jcr.nodetype.NodeDefinitionTemplate; -import javax.jcr.nodetype.NodeType; import javax.jcr.nodetype.NodeTypeDefinition; -import javax.jcr.nodetype.NodeTypeManager; import javax.jcr.nodetype.NodeTypeTemplate; import javax.jcr.nodetype.PropertyDefinition; import javax.jcr.nodetype.PropertyDefinitionTemplate; -import org.apache.jackrabbit.commons.cnd.DefinitionBuilderFactory.AbstractNodeTypeDefinitionBuilder; -import org.apache.jackrabbit.oak.namepath.JcrNameParser; import org.apache.jackrabbit.oak.namepath.NameMapper; -import org.apache.jackrabbit.value.ValueFactoryImpl; -final class NodeTypeTemplateImpl - extends AbstractNodeTypeDefinitionBuilder - implements NodeTypeTemplate { +import com.google.common.collect.Lists; - private final NodeTypeManager manager; +final class NodeTypeTemplateImpl extends AbstractNamedTemplate + implements NodeTypeTemplate { - private final NameMapper mapper; + private static final PropertyDefinition[] EMPTY_PROPERTY_DEFINITION_ARRAY = + new PropertyDefinition[0]; - private final ValueFactory factory; + private static final NodeDefinition[] EMPTY_NODE_DEFINITION_ARRAY = + new NodeDefinition[0]; - private String primaryItemName; + protected boolean isMixin; - private String[] superTypeNames = new String[0]; + protected boolean isOrderable; - private List propertyDefinitionTemplates; + protected boolean isAbstract; - private List nodeDefinitionTemplates; + protected boolean queryable; - public NodeTypeTemplateImpl(NodeTypeManager manager, NameMapper mapper, ValueFactory factory) { - this.manager = manager; - this.mapper = mapper; - this.factory = factory; - } + private String primaryItemOakName = null; // not defined by default + + @Nonnull + private String[] superTypeOakNames = new String[0]; + + private List propertyDefinitionTemplates = null; + + private List nodeDefinitionTemplates = null; public NodeTypeTemplateImpl(NameMapper mapper) { - this(null, mapper, ValueFactoryImpl.getInstance()); + super(mapper); } - public NodeTypeTemplateImpl( - NodeTypeManager manager, NameMapper mapper, ValueFactory factory, - NodeTypeDefinition ntd) throws ConstraintViolationException { - this(manager, mapper, factory); - - setName(ntd.getName()); - setAbstract(ntd.isAbstract()); - setMixin(ntd.isMixin()); - setOrderableChildNodes(ntd.hasOrderableChildNodes()); - setQueryable(ntd.isQueryable()); - String name = ntd.getPrimaryItemName(); - if (name != null) { - setPrimaryItemName(name); + 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(ntd.getDeclaredSupertypeNames()); - - getPropertyDefinitionTemplates(); // Make sure propertyDefinitionTemplates is initialised - for (PropertyDefinition pd : ntd.getDeclaredPropertyDefinitions()) { - PropertyDefinitionTemplateImpl pdt = newPropertyDefinitionBuilder(); - pdt.setDeclaringNodeType(pd.getDeclaringNodeType().getName()); - pdt.setName(pd.getName()); - pdt.setProtected(pd.isProtected()); - pdt.setMandatory(pd.isMandatory()); - pdt.setAutoCreated(pd.isAutoCreated()); - pdt.setOnParentVersion(pd.getOnParentVersion()); - pdt.setMultiple(pd.isMultiple()); - pdt.setRequiredType(pd.getRequiredType()); - pdt.setDefaultValues(pd.getDefaultValues()); - pdt.setValueConstraints(pd.getValueConstraints()); - pdt.setFullTextSearchable(pd.isFullTextSearchable()); - pdt.setAvailableQueryOperators(pd.getAvailableQueryOperators()); - pdt.setQueryOrderable(pd.isQueryOrderable()); - pdt.build(); + setDeclaredSuperTypeNames(definition.getDeclaredSupertypeNames()); + + PropertyDefinition[] pds = definition.getDeclaredPropertyDefinitions(); + if (pds != null) { + propertyDefinitionTemplates = + Lists.newArrayListWithCapacity(pds.length); + for (int i = 0; pds != null && i < pds.length; i++) { + propertyDefinitionTemplates.add( + new PropertyDefinitionTemplateImpl(mapper, pds[i])); + } } - getNodeDefinitionTemplates(); // Make sure nodeDefinitionTemplates is initialised - for (NodeDefinition nd : ntd.getDeclaredChildNodeDefinitions()) { - NodeDefinitionTemplateImpl ndt = newNodeDefinitionBuilder(); - ndt.setDeclaringNodeType(nd.getDeclaringNodeType().getName()); - ndt.setName(nd.getName()); - ndt.setProtected(nd.isProtected()); - ndt.setMandatory(nd.isMandatory()); - ndt.setAutoCreated(nd.isAutoCreated()); - ndt.setOnParentVersion(nd.getOnParentVersion()); - ndt.setSameNameSiblings(nd.allowsSameNameSiblings()); - ndt.setDefaultPrimaryTypeName(nd.getDefaultPrimaryTypeName()); - ndt.setRequiredPrimaryTypeNames(nd.getRequiredPrimaryTypeNames()); - ndt.build(); + NodeDefinition[] nds = definition.getDeclaredChildNodeDefinitions(); + if (nds != null) { + nodeDefinitionTemplates = + Lists.newArrayListWithCapacity(nds.length); + for (int i = 0; i < nds.length; i++) { + nodeDefinitionTemplates.add( + new NodeDefinitionTemplateImpl(mapper, nds[i])); + } } } @Override - public NodeTypeTemplate build() { - return this; - } - - @Override - public PropertyDefinitionTemplateImpl newPropertyDefinitionBuilder() { - return new PropertyDefinitionTemplateImpl(mapper) { - @Override - protected Value createValue(String value, int type) - throws ValueFormatException { - return factory.createValue(value, type); - } - @Override - public void build() { - getPropertyDefinitionTemplates().add(this); - } - }; + public boolean isMixin() { + return isMixin; } @Override - public NodeDefinitionTemplateImpl newNodeDefinitionBuilder() { - return new NodeDefinitionTemplateImpl(mapper) { - @Override - protected NodeType getNodeType(String name) - throws RepositoryException { - if (manager != null) { - return manager.getNodeType(name); - } else { - return super.getNodeType(name); - } - } - @Override - public void build() { - getNodeDefinitionTemplates().add(this); - } - }; + public void setMixin(boolean mixin) { + this.isMixin = mixin; } @Override - public String getName() { - return name; + public boolean hasOrderableChildNodes() { + return isOrderable ; } @Override - public void setName(String name) throws ConstraintViolationException { - JcrNameParser.checkName(name, false); - this.name = mapper.getJcrName(mapper.getOakNameOrNull(name)); + public void setOrderableChildNodes(boolean orderable) { + this.isOrderable = orderable; } @Override @@ -178,26 +127,6 @@ final class NodeTypeTemplateImpl } @Override - public boolean isMixin() { - return isMixin; - } - - @Override - public void setMixin(boolean mixin) { - this.isMixin = mixin; - } - - @Override - public boolean hasOrderableChildNodes() { - return isOrderable ; - } - - @Override - public void setOrderableChildNodes(boolean orderable) { - this.isOrderable = orderable; - } - - @Override public boolean isQueryable() { return queryable; } @@ -209,78 +138,64 @@ final class NodeTypeTemplateImpl @Override public String getPrimaryItemName() { - return primaryItemName ; + return getJcrNameAllowNull(primaryItemOakName); } @Override - public void setPrimaryItemName(String name) throws ConstraintViolationException { - if (name == null) { - this.primaryItemName = null; - } - else { - JcrNameParser.checkName(name, false); - this.primaryItemName = mapper.getJcrName(mapper.getOakNameOrNull(name)); - } + public void setPrimaryItemName(String jcrName) + throws ConstraintViolationException { + this.primaryItemOakName = getOakNameOrThrowConstraintViolation(jcrName); } @Override public String[] getDeclaredSupertypeNames() { - return superTypeNames; + return getJcrNames(superTypeOakNames); } @Override - public void setDeclaredSuperTypeNames(String[] names) throws ConstraintViolationException { - if (names == null) { - throw new ConstraintViolationException("null is not a valid array of JCR names"); - } - int k = 0; - String[] n = new String[names.length]; - for (String name : names) { - JcrNameParser.checkName(name, false); - n[k++] = mapper.getJcrName(mapper.getOakNameOrNull(name)); + public void setDeclaredSuperTypeNames(String[] jcrNames) + throws ConstraintViolationException { + if (jcrNames == null) { + throw new ConstraintViolationException("missing super type names"); } - this.superTypeNames = n; + this.superTypeOakNames = + getOakNamesOrThrowConstraintViolation(jcrNames); } @Override - public void addSupertype(String name) throws RepositoryException { - JcrNameParser.checkName(name, false); - String[] names = new String[superTypeNames.length + 1]; - System.arraycopy(superTypeNames, 0, names, 0, superTypeNames.length); - names[superTypeNames.length] = mapper.getJcrName(mapper.getOakName(name)); - superTypeNames = names; + public PropertyDefinition[] getDeclaredPropertyDefinitions() { + if (propertyDefinitionTemplates != null) { + return propertyDefinitionTemplates.toArray( + EMPTY_PROPERTY_DEFINITION_ARRAY); + } else { + return null; + } } @Override public List getPropertyDefinitionTemplates() { if (propertyDefinitionTemplates == null) { - propertyDefinitionTemplates = new ArrayList(); + propertyDefinitionTemplates = Lists.newArrayList(); } return propertyDefinitionTemplates; } @Override - public List getNodeDefinitionTemplates() { - if (nodeDefinitionTemplates == null) { - nodeDefinitionTemplates = new ArrayList(); + public NodeDefinition[] getDeclaredChildNodeDefinitions() { + if (nodeDefinitionTemplates != null) { + return nodeDefinitionTemplates.toArray( + EMPTY_NODE_DEFINITION_ARRAY); + } else { + return null; } - return nodeDefinitionTemplates; } @Override - public PropertyDefinition[] getDeclaredPropertyDefinitions() { - return propertyDefinitionTemplates == null - ? null - : propertyDefinitionTemplates.toArray( - new PropertyDefinition[propertyDefinitionTemplates.size()]); - } - - @Override - public NodeDefinition[] getDeclaredChildNodeDefinitions() { - return nodeDefinitionTemplates == null - ? null - : nodeDefinitionTemplates.toArray( - new NodeDefinition[nodeDefinitionTemplates.size()]); + public List getNodeDefinitionTemplates() { + if (nodeDefinitionTemplates == null) { + nodeDefinitionTemplates = Lists.newArrayList(); + } + return nodeDefinitionTemplates; } } \ No newline at end of file diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/PropertyDefinitionTemplateImpl.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/PropertyDefinitionTemplateImpl.java index 0d4a6a4..e0d75de 100644 --- a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/PropertyDefinitionTemplateImpl.java +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/PropertyDefinitionTemplateImpl.java @@ -16,104 +16,70 @@ */ package org.apache.jackrabbit.oak.plugins.nodetype; +import static com.google.common.base.Preconditions.checkNotNull; + import javax.jcr.PropertyType; -import javax.jcr.RepositoryException; -import javax.jcr.UnsupportedRepositoryOperationException; import javax.jcr.Value; import javax.jcr.nodetype.ConstraintViolationException; -import javax.jcr.nodetype.NodeType; -import javax.jcr.nodetype.NodeTypeTemplate; +import javax.jcr.nodetype.PropertyDefinition; import javax.jcr.nodetype.PropertyDefinitionTemplate; -import javax.jcr.version.OnParentVersionAction; +import javax.jcr.query.qom.QueryObjectModelConstants; -import org.apache.jackrabbit.commons.cnd.DefinitionBuilderFactory.AbstractPropertyDefinitionBuilder; -import org.apache.jackrabbit.oak.namepath.JcrNameParser; import org.apache.jackrabbit.oak.namepath.NameMapper; -class PropertyDefinitionTemplateImpl - extends AbstractPropertyDefinitionBuilder +class PropertyDefinitionTemplateImpl extends ItemDefinitionTemplateImpl implements PropertyDefinitionTemplate { - private String[] valueConstraints; - - private final NameMapper mapper; - private Value[] defaultValues; - - public PropertyDefinitionTemplateImpl(NameMapper mapper) { - this.mapper = mapper; - onParent = OnParentVersionAction.COPY; - requiredType = PropertyType.STRING; - } - - protected Value createValue(String value, int type) - throws RepositoryException { - throw new UnsupportedRepositoryOperationException(); - } - - @Override - public void build() { - // do nothing by default - } + private static final String[] ALL_OPERATORS = new String[]{ + QueryObjectModelConstants.JCR_OPERATOR_EQUAL_TO, + QueryObjectModelConstants.JCR_OPERATOR_GREATER_THAN, + QueryObjectModelConstants.JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO, + QueryObjectModelConstants.JCR_OPERATOR_LESS_THAN, + QueryObjectModelConstants.JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO, + QueryObjectModelConstants.JCR_OPERATOR_LIKE, + QueryObjectModelConstants.JCR_OPERATOR_NOT_EQUAL_TO + }; - @Override - public NodeType getDeclaringNodeType() { - return null; - } - - @Override - public void setDeclaringNodeType(String name) { - // ignore - } + private int requiredType = PropertyType.STRING; - @Override - public void setName(String name) throws ConstraintViolationException { - JcrNameParser.checkName(name, true); - this.name = mapper.getJcrName(mapper.getOakNameOrNull(name)); - } + private boolean isMultiple = false; - @Override - public boolean isAutoCreated() { - return autocreate; - } + private boolean fullTextSearchable = true; - @Override - public void setAutoCreated(boolean autocreate) { - this.autocreate = autocreate; - } + private boolean queryOrderable = true; - @Override - public boolean isProtected() { - return isProtected; - } + private String[] queryOperators = ALL_OPERATORS; - @Override - public void setProtected(boolean isProtected) { - this.isProtected = isProtected; - } + private String[] valueConstraints = null; - @Override - public boolean isMandatory() { - return isMandatory; - } + private Value[] defaultValues = null; - @Override - public void setMandatory(boolean isMandatory) { - this.isMandatory = isMandatory; + PropertyDefinitionTemplateImpl(NameMapper mapper) { + super(mapper); } - @Override - public int getOnParentVersion() { - return onParent; + public PropertyDefinitionTemplateImpl( + NameMapper mapper, PropertyDefinition definition) + throws ConstraintViolationException { + super(mapper, definition); + setRequiredType(definition.getRequiredType()); + setMultiple(definition.isMultiple()); + setFullTextSearchable(definition.isFullTextSearchable()); + setQueryOrderable(definition.isQueryOrderable()); + setAvailableQueryOperators(definition.getAvailableQueryOperators()); + setValueConstraints(definition.getValueConstraints()); + setDefaultValues(definition.getDefaultValues()); } @Override - public void setOnParentVersion(int onParent) { - this.onParent = onParent; + public int getRequiredType() { + return requiredType; } @Override - public void setRequiredType(int requiredType) { - this.requiredType = requiredType; + public void setRequiredType(int type) { + PropertyType.nameFromValue(type); // validation + this.requiredType = type; } @Override @@ -127,16 +93,6 @@ class PropertyDefinitionTemplateImpl } @Override - public boolean isQueryOrderable() { - return queryOrderable; - } - - @Override - public void setQueryOrderable(boolean queryOrderable) { - this.queryOrderable = queryOrderable; - } - - @Override public boolean isFullTextSearchable() { return fullTextSearchable; } @@ -147,57 +103,56 @@ class PropertyDefinitionTemplateImpl } @Override - public String[] getAvailableQueryOperators() { - return queryOperators; + public boolean isQueryOrderable() { + return queryOrderable; } @Override - public void setAvailableQueryOperators(String[] queryOperators) { - this.queryOperators = queryOperators; + public void setQueryOrderable(boolean queryOrderable) { + this.queryOrderable = queryOrderable; } @Override - public Value[] getDefaultValues() { - return defaultValues; + public String[] getAvailableQueryOperators() { + return queryOperators; } @Override - public void setDefaultValues(Value[] defaultValues) { - this.defaultValues = defaultValues; + public void setAvailableQueryOperators(String[] operators) { + checkNotNull(operators); + this.queryOperators = new String[operators.length]; + System.arraycopy(operators, 0, this.queryOperators, 0, operators.length); } @Override - public void addDefaultValues(String value) throws RepositoryException { - if (defaultValues == null) { - defaultValues = new Value[] { createValue(value, getRequiredType()) }; - } else { - Value[] values = new Value[defaultValues.length + 1]; - System.arraycopy(defaultValues, 0, values, 0, defaultValues.length); - values[defaultValues.length] = createValue(value, getRequiredType()); - defaultValues = values; - } + public String[] getValueConstraints() { + return valueConstraints; // no problem if modified by client } @Override - public String[] getValueConstraints() { - return valueConstraints; + public void setValueConstraints(String[] constraints) { + if (constraints == null) { + this.valueConstraints = null; + } else { + this.valueConstraints = new String[constraints.length]; + System.arraycopy( + constraints, 0, valueConstraints, 0, constraints.length); + } } @Override - public void setValueConstraints(String[] constraints) { - this.valueConstraints = constraints; + public Value[] getDefaultValues() { + return defaultValues; // no problem if modified by client } @Override - public void addValueConstraint(String constraint) { - if (valueConstraints == null) { - valueConstraints = new String[] { constraint }; + public void setDefaultValues(Value[] values) { + if (values == null) { + this.defaultValues = null; } else { - String[] constraints = new String[valueConstraints.length + 1]; - System.arraycopy(valueConstraints, 0, constraints, 0, valueConstraints.length); - constraints[valueConstraints.length] = constraint; - valueConstraints = constraints; + this.defaultValues = new Value[values.length]; + System.arraycopy(values, 0, defaultValues, 0, values.length); } } -} \ No newline at end of file +} diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ReadOnlyNodeTypeManager.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ReadOnlyNodeTypeManager.java index ce41ba3..150d4ce 100644 --- a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ReadOnlyNodeTypeManager.java +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ReadOnlyNodeTypeManager.java @@ -196,13 +196,14 @@ public abstract class ReadOnlyNodeTypeManager implements NodeTypeManager, Effect } @Override - public NodeTypeTemplate createNodeTypeTemplate() throws RepositoryException { - return new NodeTypeTemplateImpl(this, getNamePathMapper(), getValueFactory()); + public NodeTypeTemplate createNodeTypeTemplate() { + return new NodeTypeTemplateImpl(getNamePathMapper()); } @Override - public NodeTypeTemplate createNodeTypeTemplate(NodeTypeDefinition ntd) throws RepositoryException { - return new NodeTypeTemplateImpl(this, getNamePathMapper(), getValueFactory(), ntd); + public NodeTypeTemplate createNodeTypeTemplate(NodeTypeDefinition ntd) + throws ConstraintViolationException { + return new NodeTypeTemplateImpl(getNamePathMapper(), ntd); } @Override diff --git a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ReadWriteNodeTypeManager.java b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ReadWriteNodeTypeManager.java index 1449b4b..6820bc9 100644 --- a/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ReadWriteNodeTypeManager.java +++ b/oak-core/src/main/java/org/apache/jackrabbit/oak/plugins/nodetype/ReadWriteNodeTypeManager.java @@ -16,10 +16,8 @@ */ package org.apache.jackrabbit.oak.plugins.nodetype; -import java.io.Reader; import java.util.Arrays; import java.util.List; -import java.util.Map; import javax.annotation.Nonnull; import javax.jcr.PropertyType; @@ -32,14 +30,10 @@ import javax.jcr.nodetype.NodeType; import javax.jcr.nodetype.NodeTypeDefinition; import javax.jcr.nodetype.NodeTypeExistsException; import javax.jcr.nodetype.NodeTypeIterator; -import javax.jcr.nodetype.NodeTypeTemplate; import javax.jcr.nodetype.PropertyDefinition; import javax.jcr.version.OnParentVersionAction; import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import org.apache.jackrabbit.commons.cnd.CompactNodeTypeDefReader; -import org.apache.jackrabbit.commons.cnd.ParseException; import org.apache.jackrabbit.commons.iterator.NodeTypeIteratorAdapter; import org.apache.jackrabbit.oak.api.CommitFailedException; import org.apache.jackrabbit.oak.api.Root; @@ -67,7 +61,6 @@ import static org.apache.jackrabbit.JcrConstants.JCR_SAMENAMESIBLINGS; import static org.apache.jackrabbit.JcrConstants.JCR_SUPERTYPES; import static org.apache.jackrabbit.JcrConstants.JCR_SYSTEM; import static org.apache.jackrabbit.JcrConstants.JCR_VALUECONSTRAINTS; -import static org.apache.jackrabbit.JcrConstants.NT_BASE; import static org.apache.jackrabbit.JcrConstants.NT_CHILDNODEDEFINITION; import static org.apache.jackrabbit.JcrConstants.NT_NODETYPE; import static org.apache.jackrabbit.JcrConstants.NT_PROPERTYDEFINITION; @@ -133,61 +126,6 @@ public abstract class ReadWriteNodeTypeManager extends ReadOnlyNodeTypeManager { protected void refresh() throws RepositoryException { } - /** - * Utility method for registering node types from a CND format. - * @param cnd reader for the CND - * @throws ParseException if parsing the CND fails - * @throws RepositoryException if registering the node types fails - */ - public void registerNodeTypes(Reader cnd) throws ParseException, RepositoryException { - Root root = getWriteRoot(); - - CompactNodeTypeDefReader> reader = - new CompactNodeTypeDefReader>( - cnd, null, new DefBuilderFactory(root.getTree("/"))); - - Map templates = Maps.newHashMap(); - for (NodeTypeTemplate template : reader.getNodeTypeDefinitions()) { - templates.put(template.getName(), template); - } - - for (NodeTypeTemplate template : templates.values()) { - // TODO: NT_BASE is the oak-name, while the template is an JCR level API which might have local namespace remapping - if (!template.isMixin() && !NT_BASE.equals(template.getName())) { - String[] supertypes = template.getDeclaredSupertypeNames(); - if (supertypes.length == 0) { - template.setDeclaredSuperTypeNames(new String[] {NT_BASE}); - } else { - // Check whether we need to add the implicit "nt:base" supertype - boolean needsNtBase = true; - for (String name : supertypes) { - NodeTypeDefinition st = templates.get(name); - if (st == null) { - st = getNodeType(name); - } - if (st != null && !st.isMixin()) { - needsNtBase = false; - } - } - if (needsNtBase) { - String[] withBase = new String[supertypes.length + 1]; - withBase[0] = NT_BASE; - System.arraycopy(supertypes, 0, withBase, 1, supertypes.length); - template.setDeclaredSuperTypeNames(withBase); - } - } - } - } - - try { - internalRegister(root, templates.values(), true); - root.commit(); - refresh(); - } catch (CommitFailedException e) { - throw new RepositoryException(e); - } - } - //----------------------------------------------------< NodeTypeManager >--- @Override diff --git a/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/TestContentLoader.java b/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/TestContentLoader.java index 7485aca..0d7e4e9 100644 --- a/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/TestContentLoader.java +++ b/oak-jcr/src/test/java/org/apache/jackrabbit/oak/jcr/TestContentLoader.java @@ -29,13 +29,14 @@ import javax.jcr.RepositoryException; import javax.jcr.Session; import javax.jcr.Value; import javax.jcr.ValueFactory; -import javax.jcr.nodetype.NodeTypeManager; import org.apache.jackrabbit.commons.JcrUtils; +import org.apache.jackrabbit.commons.cnd.CndImporter; import org.apache.jackrabbit.commons.cnd.ParseException; -import org.apache.jackrabbit.oak.plugins.nodetype.ReadWriteNodeTypeManager; import org.apache.jackrabbit.value.BinaryValue; +import com.google.common.base.Charsets; + public class TestContentLoader { /** @@ -47,7 +48,7 @@ public class TestContentLoader { session.getWorkspace().getNamespaceRegistry().registerNamespace( "test", "http://www.apache.org/jackrabbit/test"); - registerTestNodeTypes(session.getWorkspace().getNodeTypeManager()); + registerTestNodeTypes(session); Node data = getOrAddNode(session.getRootNode(), "testdata"); addPropertyTestData(getOrAddNode(data, "property")); @@ -64,13 +65,11 @@ public class TestContentLoader { session.save(); } - private static void registerTestNodeTypes(NodeTypeManager ntm) throws RepositoryException, ParseException, IOException { + private static void registerTestNodeTypes(Session session) throws RepositoryException, ParseException, IOException { InputStream stream = TestContentLoader.class.getResourceAsStream("test_nodetypes.cnd"); try { - if (!(ntm instanceof ReadWriteNodeTypeManager)) { - throw new IllegalArgumentException("Need ReadWriteNodeTypeManager"); - } - ((ReadWriteNodeTypeManager)ntm).registerNodeTypes(new InputStreamReader(stream, "UTF-8")); + CndImporter.registerNodeTypes( + new InputStreamReader(stream, Charsets.UTF_8), session); } finally { stream.close(); } -- 1.7.10.msysgit.1