Index: dna-jcr/src/test/java/org/jboss/dna/jcr/SessionCacheTest.java =================================================================== --- dna-jcr/src/test/java/org/jboss/dna/jcr/SessionCacheTest.java (revision 795) +++ dna-jcr/src/test/java/org/jboss/dna/jcr/SessionCacheTest.java (working copy) @@ -188,6 +188,8 @@ } } else if (propertyName.equals(JcrLexicon.PRIMARY_TYPE)) { // This is okay + } else if (propertyName.equals(DnaIntLexicon.MULTI_VALUED_PROPERTIES)) { + // This is okay } else { fail("missing property \"" + propertyName + "\" on " + dnaNode); } Index: dna-jcr/src/test/java/org/jboss/dna/jcr/JcrTckTest.java =================================================================== --- dna-jcr/src/test/java/org/jboss/dna/jcr/JcrTckTest.java (revision 853) +++ dna-jcr/src/test/java/org/jboss/dna/jcr/JcrTckTest.java (working copy) @@ -62,6 +62,8 @@ import org.apache.jackrabbit.test.api.SetPropertyInputStreamTest; import org.apache.jackrabbit.test.api.SetPropertyLongTest; import org.apache.jackrabbit.test.api.SetPropertyNodeTest; +import org.apache.jackrabbit.test.api.SetPropertyStringTest; +import org.apache.jackrabbit.test.api.SetPropertyValueTest; import org.apache.jackrabbit.test.api.SetValueBinaryTest; import org.apache.jackrabbit.test.api.SetValueBooleanTest; import org.apache.jackrabbit.test.api.SetValueConstraintViolationExceptionTest; @@ -216,8 +218,8 @@ addTestSuite(SetPropertyInputStreamTest.class); addTestSuite(SetPropertyLongTest.class); addTestSuite(SetPropertyNodeTest.class); - // addTestSuite(SetPropertyStringTest.class); - // addTestSuite(SetPropertyValueTest.class); + addTestSuite(SetPropertyStringTest.class); + addTestSuite(SetPropertyValueTest.class); addTestSuite(SetPropertyConstraintViolationExceptionTest.class); // addTestSuite(SetPropertyAssumeTypeTest.class); Index: dna-jcr/src/main/java/org/jboss/dna/jcr/SessionCache.java =================================================================== --- dna-jcr/src/main/java/org/jboss/dna/jcr/SessionCache.java (revision 854) +++ dna-jcr/src/main/java/org/jboss/dna/jcr/SessionCache.java (working copy) @@ -53,6 +53,7 @@ import javax.jcr.nodetype.PropertyDefinition; import net.jcip.annotations.ThreadSafe; import org.jboss.dna.common.i18n.I18n; +import org.jboss.dna.common.util.Logger; import org.jboss.dna.graph.ExecutionContext; import org.jboss.dna.graph.Graph; import org.jboss.dna.graph.Location; @@ -128,6 +129,8 @@ */ private static final boolean INCLUDE_PROPERTIES_NOT_ALLOWED_BY_NODE_TYPE_OR_MIXINS = true; + private static final Set EMPTY_NAMES = Collections.emptySet(); + private final JcrSession session; private final String workspaceName; protected final ExecutionContext context; @@ -391,6 +394,7 @@ mixinTypeNames, property.property(), property.getType(), + property.property().isSingle(), false); if (definition == null) { throw new ConstraintViolationException(JcrI18n.noDefinition.text("property", @@ -748,7 +752,8 @@ PropertyInfo info = findPropertyInfo(propertyId); // throws PathNotFoundException if node not there if (info == null) return null; // no such property on this node - if (DnaLexicon.NODE_DEFINITON.equals(info.getPropertyName())) return null; + // Skip all internal properties ... + if (info.getPropertyName().getNamespaceUri().equals(DnaIntLexicon.Namespace.URI)) return null; // Now create the appropriate JCR Property object ... return createAndCacheJcrPropertyFor(info); @@ -760,7 +765,7 @@ Set propertyNames = info.getPropertyNames(); Collection result = new ArrayList(propertyNames.size()); for (Name propertyName : propertyNames) { - if (!DnaLexicon.NODE_DEFINITON.equals(propertyName)) { + if (!propertyName.getNamespaceUri().equals(DnaIntLexicon.Namespace.URI)) { result.add(findJcrProperty(new PropertyId(nodeUuid, propertyName))); } } @@ -1080,8 +1085,7 @@ assert name != null; assert values != null; - // TODO: Re-add following line! - // checkCardinalityOfExistingProperty(name, true); + checkCardinalityOfExistingProperty(name, true); int len = values.length; Value[] newValues = null; @@ -1171,8 +1175,8 @@ } } // Create the DNA property ... - int type = newValues.length != 0 ? newValues[0].getType() : definition.getRequiredType(); - Object[] objValues = new Object[newValues.length]; + int type = numValues != 0 ? newValues[0].getType() : definition.getRequiredType(); + Object[] objValues = new Object[numValues]; int propertyType = definition.getRequiredType(); if (propertyType == PropertyType.UNDEFINED || propertyType == type) { // Can use the values as is ... @@ -1198,6 +1202,23 @@ // Finally update the cached information and record the change ... node.setProperty(newProperty, factories()); operations.set(dnaProp).on(currentLocation); + + // If there is a single value, we need to record that this property is actually a multi-valued property definition ... + if (numValues == 1) { + if (node.setSingleMultiProperty(name)) { + Set names = node.getSingleMultiPropertyNames(); + // Added this property name to the set, so record the change ... + PropertyInfo singleMulti = createSingleMultiplePropertyInfo(node.getUuid(), + node.getPrimaryTypeName(), + node.getMixinTypeNames(), + names); + node.setProperty(singleMulti, factories()); + operations.set(singleMulti.getProperty()).on(currentLocation); + } + } else { + removeSingleMultiProperty(node, name); + } + return newProperty.getPropertyId(); } @@ -1208,13 +1229,35 @@ * @return true if there was a property with the supplied name, or false if no such property existed */ public boolean removeProperty( Name name ) { - if (node.removeProperty(name) != null) { + PropertyInfo info = node.removeProperty(name); + if (info != null) { operations.remove(name).on(currentLocation); + // Is this named in the single-multi property names? ... + removeSingleMultiProperty(node, name); return true; } return false; } + private void removeSingleMultiProperty( ChangedNodeInfo node, + Name propertyName ) { + if (node.removeSingleMultiProperty(propertyName)) { + Set names = node.getSingleMultiPropertyNames(); + if (names == null || names.isEmpty()) { + node.removeProperty(DnaIntLexicon.MULTI_VALUED_PROPERTIES); + operations.remove(DnaIntLexicon.MULTI_VALUED_PROPERTIES).on(currentLocation); + } else { + // Added this property name to the set, so record the change ... + PropertyInfo singleMulti = createSingleMultiplePropertyInfo(node.getUuid(), + node.getPrimaryTypeName(), + node.getMixinTypeNames(), + names); + node.setProperty(singleMulti, factories()); + operations.set(singleMulti.getProperty()).on(currentLocation); + } + } + } + /** * Move the child specified by the supplied UUID to be a child of this node, appending the child to the end of the current * list of children. This method automatically disconnects the node from its current parent. @@ -1255,7 +1298,7 @@ try { JcrValue value = new JcrValue(factories(), SessionCache.this, PropertyType.STRING, definition.getId() .getString()); - setProperty(DnaLexicon.NODE_DEFINITON, value); + setProperty(DnaIntLexicon.NODE_DEFINITON, value); } catch (ConstraintViolationException e) { // We can't set this property on the node (according to the node definition). // But we still want the node info to have the correct node definition. @@ -1264,7 +1307,7 @@ node.setDefinitionId(definition.getId()); // And remove the property from the info ... - newChildEditor.removeProperty(DnaLexicon.NODE_DEFINITON); + newChildEditor.removeProperty(DnaIntLexicon.NODE_DEFINITON); } } @@ -1428,7 +1471,7 @@ // Create the properties ... Map properties = new HashMap(); Property primaryTypeProp = propertyFactory.create(JcrLexicon.PRIMARY_TYPE, primaryTypeName); - Property nodeDefinitionProp = propertyFactory.create(DnaLexicon.NODE_DEFINITON, definition.getId().getString()); + Property nodeDefinitionProp = propertyFactory.create(DnaIntLexicon.NODE_DEFINITON, definition.getId().getString()); // Now add the "jcr:uuid" property if and only if referenceable ... if (primaryType.isNodeType(JcrMixLexicon.REFERENCEABLE)) { @@ -1457,6 +1500,7 @@ node.getMixinTypeNames(), primaryTypeProp, PropertyType.NAME, + true, false); PropertyDefinitionId primaryTypeDefinitionId = primaryTypeDefn.getId(); PropertyInfo primaryTypeInfo = new PropertyInfo(new PropertyId(desiredUuid, primaryTypeProp.getName()), @@ -1469,6 +1513,7 @@ node.getMixinTypeNames(), nodeDefinitionProp, PropertyType.STRING, + false, false); if (nodeDefnDefn != null) { PropertyDefinitionId nodeDefnDefinitionId = nodeDefnDefn.getId(); @@ -1538,6 +1583,8 @@ * to include in the search * @param dnaProperty the new property that is to be set on this node * @param propertyType the property type; must be a valid {@link PropertyType} value + * @param isSingle true if the property definition should be single-valued, or false if the property definition should allow + * multiple values * @param skipProtected true if this operation is being done from within the public JCR node and property API, or false if * this operation is being done from within internal implementations * @return the property definition that allows setting this property, or null if there is no such definition @@ -1546,6 +1593,7 @@ List mixinTypeNamesOfParent, Property dnaProperty, int propertyType, + boolean isSingle, boolean skipProtected ) { JcrPropertyDefinition definition = null; if (propertyType == PropertyType.UNDEFINED) { @@ -1553,7 +1601,7 @@ } // If single-valued ... - if (dnaProperty.isSingle()) { + if (isSingle) { // Create a value for the DNA property value ... Object value = dnaProperty.getFirstValue(); Value jcrValue = new JcrValue(factories(), SessionCache.this, propertyType, value); @@ -2047,7 +2095,7 @@ // Look for a node definition stored on the node ... JcrNodeDefinition definition = null; - org.jboss.dna.graph.property.Property nodeDefnProperty = graphProperties.get(DnaLexicon.NODE_DEFINITON); + org.jboss.dna.graph.property.Property nodeDefnProperty = graphProperties.get(DnaIntLexicon.NODE_DEFINITON); if (nodeDefnProperty != null && !nodeDefnProperty.isEmpty()) { String nodeDefinitionString = stringFactory.create(nodeDefnProperty.getFirstValue()); NodeDefinitionId id = NodeDefinitionId.fromString(nodeDefinitionString, nameFactory); @@ -2089,7 +2137,7 @@ if (primaryType.isNodeType(JcrMixLexicon.REFERENCEABLE)) referenceable = true; // The process the mixin types ... - org.jboss.dna.graph.property.Property mixinTypesProperty = graphProperties.get(JcrLexicon.MIXIN_TYPES); + Property mixinTypesProperty = graphProperties.get(JcrLexicon.MIXIN_TYPES); List mixinTypeNames = null; if (mixinTypesProperty != null && !mixinTypesProperty.isEmpty()) { for (Object mixinTypeValue : mixinTypesProperty) { @@ -2102,17 +2150,31 @@ } } + // Create the set of multi-valued property names ... + Set multiValuedPropertyNames = EMPTY_NAMES; + Set newSingleMultiPropertyNames = null; + Property multiValuedPropNamesProp = graphProperties.get(DnaIntLexicon.MULTI_VALUED_PROPERTIES); + if (multiValuedPropNamesProp != null && !multiValuedPropNamesProp.isEmpty()) { + multiValuedPropertyNames = getSingleMultiPropertyNames(multiValuedPropNamesProp, location.getPath(), uuid); + } + // Now create the JCR property object wrappers around the other properties ... Map props = new HashMap(); - for (org.jboss.dna.graph.property.Property dnaProp : graphProperties.values()) { + for (Property dnaProp : graphProperties.values()) { Name name = dnaProp.getName(); + // Is this is single-valued property? + boolean isSingle = dnaProp.isSingle(); + // Make sure that this isn't a multi-valued property with one value ... + if (isSingle && multiValuedPropertyNames.contains(name)) isSingle = false; + // Figure out the JCR property type for this property ... int propertyType = PropertyTypeUtil.jcrPropertyTypeFor(dnaProp); PropertyDefinition propertyDefinition = findBestPropertyDefintion(primaryTypeName, mixinTypeNames, dnaProp, propertyType, + isSingle, false); // If there still is no property type defined ... @@ -2138,6 +2200,12 @@ continue; } + // Update the list of single-valued multi-property names ... + if (isMultiple && isSingle) { + if (newSingleMultiPropertyNames == null) newSingleMultiPropertyNames = new HashSet(); + newSingleMultiPropertyNames.add(name); + } + // Figure out the property type ... int definitionType = propertyDefinition.getRequiredType(); if (definitionType != PropertyType.UNDEFINED) { @@ -2173,6 +2241,15 @@ // Make sure the "dna:uuid" property did not get in there ... props.remove(DnaLexicon.UUID); + // Make sure the single-valued multi-property names are stored as a property ... + if (newSingleMultiPropertyNames != null) { + PropertyInfo info = createSingleMultiplePropertyInfo(uuid, + primaryTypeName, + mixinTypeNames, + newSingleMultiPropertyNames); + props.put(info.getPropertyName(), info); + } + // Create the node information ... UUID parentUuid = parentInfo != null ? parentInfo.getUuid() : null; List locations = graphNode.getChildren(); @@ -2181,6 +2258,69 @@ return new ImmutableNodeInfo(location, primaryTypeName, mixinTypeNames, definition.getId(), parentUuid, children, props); } + protected final PropertyInfo createSingleMultiplePropertyInfo( UUID uuid, + Name primaryTypeName, + List mixinTypeNames, + Set newSingleMultiPropertyNames ) { + int number = newSingleMultiPropertyNames.size(); + String[] names = new String[number]; + JcrValue[] values = new JcrValue[number]; + if (number == 1) { + String str = newSingleMultiPropertyNames.iterator().next().getString(namespaces); + names[0] = str; + values[0] = new JcrValue(factories(), this, PropertyType.STRING, str); + } else { + int index = 0; + for (Name name : newSingleMultiPropertyNames) { + String str = name.getString(namespaces); + names[index] = str; + values[index] = new JcrValue(factories(), this, PropertyType.STRING, str); + ++index; + } + } + PropertyDefinition propertyDefinition = nodeTypes().findPropertyDefinition(primaryTypeName, + mixinTypeNames, + DnaIntLexicon.MULTI_VALUED_PROPERTIES, + values, + false); + Property dnaProp = propertyFactory.create(DnaIntLexicon.MULTI_VALUED_PROPERTIES, newSingleMultiPropertyNames.iterator() + .next()); + PropertyId propId = new PropertyId(uuid, dnaProp.getName()); + JcrPropertyDefinition defn = (JcrPropertyDefinition)propertyDefinition; + return new PropertyInfo(propId, defn.getId(), PropertyType.STRING, dnaProp, defn.isMultiple(), true, false); + } + + protected final Set getSingleMultiPropertyNames( Property dnaProperty, + Path knownPath, + UUID knownUuid ) { + Set multiValuedPropertyNames = new HashSet(); + for (Object value : dnaProperty) { + try { + multiValuedPropertyNames.add(nameFactory.create(value)); + } catch (ValueFormatException e) { + String msg = "{0} value \"{1}\" on {2} in \"{3}\" workspace is not a valid name and is being ignored"; + String path = null; + if (knownPath != null) { + path = knownPath.getString(namespaces); + } else { + assert knownUuid != null; + try { + path = getPathFor(knownUuid).getString(namespaces); + } catch (RepositoryException err) { + path = knownUuid.toString(); + } + } + Logger.getLogger(getClass()).trace(e, + msg, + DnaIntLexicon.MULTI_VALUED_PROPERTIES.getString(namespaces), + value, + path, + workspaceName()); + } + } + return multiValuedPropertyNames; + } + /** * This method finds the {@link NodeInfo} for the node with the supplied UUID and marks it as being deleted, and does the same * for all decendants (e.g., children, grandchildren, great-grandchildren, etc.) that have been cached or changed. Index: dna-jcr/src/main/java/org/jboss/dna/jcr/cache/ChangedNodeInfo.java =================================================================== --- dna-jcr/src/main/java/org/jboss/dna/jcr/cache/ChangedNodeInfo.java (revision 844) +++ dna-jcr/src/main/java/org/jboss/dna/jcr/cache/ChangedNodeInfo.java (working copy) @@ -32,6 +32,7 @@ import java.util.Map; import java.util.Set; import java.util.UUID; +import net.jcip.annotations.NotThreadSafe; import org.jboss.dna.graph.JcrLexicon; import org.jboss.dna.graph.Location; import org.jboss.dna.graph.property.Name; @@ -40,7 +41,7 @@ import org.jboss.dna.graph.property.ValueFactories; import org.jboss.dna.graph.property.ValueFactory; import org.jboss.dna.graph.property.Path.Segment; -import org.jboss.dna.jcr.DnaLexicon; +import org.jboss.dna.jcr.DnaIntLexicon; import org.jboss.dna.jcr.NodeDefinitionId; /** @@ -49,6 +50,7 @@ * Each instance maintains a reference to the original (usually immutable) NodeInfo representation that was probably read from the * repository. */ +@NotThreadSafe public class ChangedNodeInfo implements NodeInfo { protected static final PropertyInfo DELETED_PROPERTY = null; @@ -88,6 +90,8 @@ private List peers; + private Set singleMultiPropertyNames; + /** * Create an immutable NodeInfo instance. * @@ -127,6 +131,19 @@ peers.add(peerUuid); } + public boolean setSingleMultiProperty( Name name ) { + if (singleMultiPropertyNames == null) singleMultiPropertyNames = new HashSet(); + return singleMultiPropertyNames.add(name); + } + + public boolean removeSingleMultiProperty( Name name ) { + return singleMultiPropertyNames == null ? false : singleMultiPropertyNames.remove(name); + } + + public Set getSingleMultiPropertyNames() { + return singleMultiPropertyNames; + } + /** * Return the original node information. May be null if this is a new node. * @@ -213,8 +230,8 @@ /** * Set the identifier of the node definition for this node. This should normally be changed by - * {@link #setProperty(PropertyInfo, ValueFactories) setting} the {@link DnaLexicon#NODE_DEFINITON} property. However, since - * that property is not always allowed, this method provides a way to set it locally (without requiring a property). + * {@link #setProperty(PropertyInfo, ValueFactories) setting} the {@link DnaIntLexicon#NODE_DEFINITON} property. However, + * since that property is not always allowed, this method provides a way to set it locally (without requiring a property). * * @param definitionId the new property definition identifier; may not be null * @see #setProperty(PropertyInfo, ValueFactories) @@ -404,7 +421,7 @@ for (Object value : newProperty.getProperty()) { changedMixinTypeNames.add(nameFactory.create(value)); } - } else if (name.equals(DnaLexicon.NODE_DEFINITON)) { + } else if (name.equals(DnaIntLexicon.NODE_DEFINITON)) { ValueFactory stringFactory = factories.getStringFactory(); String value = stringFactory.create(newProperty.getProperty().getFirstValue()); changedDefinitionId = NodeDefinitionId.fromString(value, factories.getNameFactory()); Index: dna-jcr/src/main/java/org/jboss/dna/jcr/DnaLexicon.java =================================================================== --- dna-jcr/src/main/java/org/jboss/dna/jcr/DnaLexicon.java (revision 849) +++ dna-jcr/src/main/java/org/jboss/dna/jcr/DnaLexicon.java (working copy) @@ -31,9 +31,8 @@ */ public class DnaLexicon extends org.jboss.dna.repository.DnaLexicon { - public static final Name DEFINED = new BasicName(Namespace.URI, "defined"); + public static final Name BASE = new BasicName(Namespace.URI, "base"); public static final Name NAMESPACE = new BasicName(Namespace.URI, "namespace"); - public static final Name NODE_DEFINITON = new BasicName(Namespace.URI, "nodeDefinition"); public static final Name NODE_TYPES = new BasicName(Namespace.URI, "nodeTypes"); public static final Name ROOT = new BasicName(Namespace.URI, "root"); public static final Name SYSTEM = new BasicName(Namespace.URI, "system"); Index: dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNamespaceRegistry.java =================================================================== --- dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNamespaceRegistry.java (revision 776) +++ dna-jcr/src/main/java/org/jboss/dna/jcr/JcrNamespaceRegistry.java (working copy) @@ -71,7 +71,7 @@ static final String XML_SCHEMA_NAMESPACE_URI = "http://www.w3.org/2001/XMLSchema"; static final String XML_SCHEMA_INSTANCE_NAMESPACE_PREFIX = "xsi"; static final String XML_SCHEMA_INSTANCE_NAMESPACE_URI = "http://www.w3.org/2001/XMLSchema-instance"; - + static final Set STANDARD_BUILT_IN_PREFIXES; static final Set STANDARD_BUILT_IN_URIS; static final Map STANDARD_BUILT_IN_NAMESPACES_BY_PREFIX; @@ -90,6 +90,7 @@ namespaces.put(XML_SCHEMA_NAMESPACE_PREFIX, XML_SCHEMA_NAMESPACE_URI); namespaces.put(XML_SCHEMA_INSTANCE_NAMESPACE_PREFIX, XML_SCHEMA_INSTANCE_NAMESPACE_URI); namespaces.put(DnaLexicon.Namespace.PREFIX, DnaLexicon.Namespace.URI); + namespaces.put(DnaIntLexicon.Namespace.PREFIX, DnaIntLexicon.Namespace.URI); // Set up the reverse map for the standard namespaces ... Map prefixes = new HashMap(); for (Map.Entry entry : namespaces.entrySet()) { Index: dna-jcr/src/main/java/org/jboss/dna/jcr/JcrBuiltinNodeTypeSource.java =================================================================== --- dna-jcr/src/main/java/org/jboss/dna/jcr/JcrBuiltinNodeTypeSource.java (revision 836) +++ dna-jcr/src/main/java/org/jboss/dna/jcr/JcrBuiltinNodeTypeSource.java (working copy) @@ -65,25 +65,17 @@ // Value trueValue = new JcrValue(context.getValueFactories(), null, PropertyType.BOOLEAN, Boolean.TRUE); Value ntBaseValue = new JcrValue(context.getValueFactories(), null, PropertyType.NAME, JcrNtLexicon.BASE); - JcrNodeType defined = new JcrNodeType( - context, - NO_NODE_TYPE_MANAGER, - DnaLexicon.DEFINED, - NO_SUPERTYPES, - DnaLexicon.NODE_DEFINITON, - NO_CHILD_NODES, - Arrays.asList(new JcrPropertyDefinition[] {new JcrPropertyDefinition( - context, - null, - DnaLexicon.NODE_DEFINITON, - OnParentVersionBehavior.INITIALIZE.getJcrValue(), - false, - false, - true, - NO_DEFAULT_VALUES, - PropertyType.STRING, - NO_CONSTRAINTS, - false),}), + JcrNodeType defined = new JcrNodeType(context, NO_NODE_TYPE_MANAGER, DnaLexicon.BASE, NO_SUPERTYPES, + DnaIntLexicon.NODE_DEFINITON, NO_CHILD_NODES, + Arrays.asList(new JcrPropertyDefinition[] { + new JcrPropertyDefinition(context, null, DnaIntLexicon.NODE_DEFINITON, + OnParentVersionBehavior.INITIALIZE.getJcrValue(), + false, false, true, NO_DEFAULT_VALUES, + PropertyType.STRING, NO_CONSTRAINTS, false), + new JcrPropertyDefinition(context, null, DnaIntLexicon.MULTI_VALUED_PROPERTIES, + OnParentVersionBehavior.INITIALIZE.getJcrValue(), + false, false, true, NO_DEFAULT_VALUES, + PropertyType.STRING, NO_CONSTRAINTS, true),}), IS_A_MIXIN, UNORDERABLE_CHILD_NODES); // Stubbing in child node and property definitions for now JcrNodeType base = new JcrNodeType(context, NO_NODE_TYPE_MANAGER, JcrNtLexicon.BASE, @@ -636,7 +628,7 @@ // Disabling version-related types until DNA supports versioning, as per section 4.11 of the 1.0.1 specification nodeTypes.addAll(Arrays.asList(new JcrNodeType[] {defined, base, unstructured, childNodeDefinition, file, folder, frozenNode, hierarchyNode, linkedFile, nodeType, propertyDefinition, query, resource, nodeType /*, version, versionHistory, - versionLabels, versionedChild */})); + versionLabels, versionedChild */})); JcrNodeType lockable = new JcrNodeType(context, NO_NODE_TYPE_MANAGER, JcrMixLexicon.LOCKABLE, NO_SUPERTYPES, NO_PRIMARY_ITEM_NAME, NO_CHILD_NODES, Arrays.asList(new JcrPropertyDefinition[] { Index: dna-jcr/src/main/java/org/jboss/dna/jcr/DnaIntLexicon.java =================================================================== --- dna-jcr/src/main/java/org/jboss/dna/jcr/DnaIntLexicon.java (revision 0) +++ dna-jcr/src/main/java/org/jboss/dna/jcr/DnaIntLexicon.java (revision 0) @@ -0,0 +1,41 @@ +/* + * JBoss DNA (http://www.jboss.org/dna) + * See the COPYRIGHT.txt file distributed with this work for information + * regarding copyright ownership. Some portions may be licensed + * to Red Hat, Inc. under one or more contributor license agreements. + * See the AUTHORS.txt file in the distribution for a full listing of + * individual contributors. + * + * Unless otherwise indicated, all code in JBoss DNA is licensed + * to you under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * JBoss DNA is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this software; if not, write to the Free + * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA, or see the FSF site: http://www.fsf.org. + */ +package org.jboss.dna.jcr; + +import org.jboss.dna.graph.property.Name; +import org.jboss.dna.graph.property.basic.BasicName; + +/** + * A lexicon of internal and implementation-specific information + */ +public class DnaIntLexicon { + + public static class Namespace { + public static final String URI = "http://www.jboss.org/dna/internal/1.0"; + public static final String PREFIX = "dnaint"; + } + + public static final Name NODE_DEFINITON = new BasicName(Namespace.URI, "nodeDefinition"); + public static final Name MULTI_VALUED_PROPERTIES = new BasicName(Namespace.URI, "multiValuedProperties"); +}