jackrabbit-oak-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From resc...@apache.org
Subject svn commit: r1335629 - in /jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype: NodeTypeDelegate.java NodeTypeImpl.java NodeTypeManagerImpl.java
Date Tue, 08 May 2012 16:44:46 GMT
Author: reschke
Date: Tue May  8 16:44:45 2012
New Revision: 1335629

URL: http://svn.apache.org/viewvc?rev=1335629&view=rev
Log:
OAK-66: refactor classes into session-aware parts and core parts (WIP)

Added:
    jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeDelegate.java
Modified:
    jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeImpl.java
    jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeManagerImpl.java

Added: jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeDelegate.java
URL: http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeDelegate.java?rev=1335629&view=auto
==============================================================================
--- jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeDelegate.java
(added)
+++ jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeDelegate.java
Tue May  8 16:44:45 2012
@@ -0,0 +1,83 @@
+/*
+ * 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.jcr.nodetype;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class NodeTypeDelegate {
+
+    private final String name;
+    private final String[] declaredSuperTypeNames;
+    private final String primaryItemName;
+    private final boolean isMixin;
+    private final boolean isAbstract;
+    private final boolean hasOrderableChildNodes;
+
+    private final List<PropertyDefinitionDelegate> declaredPropertyDefinitionDelegates
= new ArrayList<PropertyDefinitionDelegate>();
+    private final List<NodeDefinitionDelegate> declaredChildNodeDefinitionDelegates
= new ArrayList<NodeDefinitionDelegate>();
+
+    public NodeTypeDelegate(String name, String[] declaredSuperTypeNames, String primaryItemName,
boolean isMixin,
+            boolean isAbstract, boolean hasOrderableChildNodes) {
+        this.name = name;
+        this.declaredSuperTypeNames = declaredSuperTypeNames;
+        this.primaryItemName = primaryItemName;
+        this.isMixin = isMixin;
+        this.isAbstract = isAbstract;
+        this.hasOrderableChildNodes = hasOrderableChildNodes;
+    }
+
+    public void addPropertyDefinitionDelegate(PropertyDefinitionDelegate declaredPropertyDefinitionDelegate)
{
+        this.declaredPropertyDefinitionDelegates.add(declaredPropertyDefinitionDelegate);
+    }
+
+    public void addChildNodeDefinitionDelegate(NodeDefinitionDelegate declaredChildNodeDefinitionDelegate)
{
+        this.declaredChildNodeDefinitionDelegates.add(declaredChildNodeDefinitionDelegate);
+    }
+
+    public String[] getDeclaredSuperTypeNames() {
+        return declaredSuperTypeNames;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPrimaryItemName() {
+        return primaryItemName;
+    }
+
+    public List<NodeDefinitionDelegate> getChildNodeDefinitionDelegates() {
+        return this.declaredChildNodeDefinitionDelegates;
+    }
+
+    public List<PropertyDefinitionDelegate> getPropertyDefinitionDelegates() {
+        return this.declaredPropertyDefinitionDelegates;
+    }
+
+    public boolean hasOrderableChildNodes() {
+        return hasOrderableChildNodes;
+    }
+
+    public boolean isAbstract() {
+        return isAbstract;
+    }
+
+    public boolean isMixin() {
+        return isMixin;
+    }
+}

Modified: jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeImpl.java
URL: http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeImpl.java?rev=1335629&r1=1335628&r2=1335629&view=diff
==============================================================================
--- jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeImpl.java
(original)
+++ jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeImpl.java
Tue May  8 16:44:45 2012
@@ -34,100 +34,72 @@ import javax.jcr.nodetype.NodeTypeManage
 import javax.jcr.nodetype.PropertyDefinition;
 
 import org.apache.jackrabbit.commons.iterator.NodeTypeIteratorAdapter;
+import org.apache.jackrabbit.oak.jcr.value.ValueFactoryImpl;
 import org.apache.jackrabbit.oak.namepath.NameMapper;
 
 class NodeTypeImpl implements NodeType {
 
     private final NodeTypeManager manager;
-
     private final NameMapper mapper;
-    
-    private final String name;
-
-    private final String[] declaredSuperTypeNames;
-
-    private final boolean isAbstract;
-
-    private final boolean mixin;
-
-    private final boolean hasOrderableChildNodes;
-
-    private final String primaryItemName;
+    private final ValueFactoryImpl valueFactory;
 
-    private final List<PropertyDefinition> declaredPropertyDefinitions = new ArrayList<PropertyDefinition>();
+    private final NodeTypeDelegate dlg;
 
-    private final List<NodeDefinition> declaredChildNodeDefinitions =
-            new ArrayList<NodeDefinition>();
-
-    public NodeTypeImpl(NodeTypeManager manager, NameMapper mapper, String name, String[]
declaredSuperTypeNames,
-            String primaryItemName, boolean mixin, boolean isAbstract, boolean hasOrderableChildNodes)
{
+    public NodeTypeImpl(NodeTypeManager manager, ValueFactoryImpl valueFactory, NameMapper
mapper, NodeTypeDelegate delegate) {
         this.manager = manager;
+        this.valueFactory = valueFactory;
         this.mapper = mapper;
-        this.name = name;
-        this.declaredSuperTypeNames = declaredSuperTypeNames;
-        this.primaryItemName = primaryItemName;
-        this.mixin = mixin;
-        this.isAbstract = isAbstract;
-        this.hasOrderableChildNodes = hasOrderableChildNodes;
-    }
-    
-    public void addPropertyDefinition(PropertyDefinition declaredPropertyDefinition) {
-        this.declaredPropertyDefinitions.add(declaredPropertyDefinition);
-    }
-
-    public void addChildNodeDefinition(NodeDefinition declaredChildNodeDefinition) {
-        this.declaredChildNodeDefinitions.add(declaredChildNodeDefinition);
+        this.dlg = delegate;
     }
 
     @Override
     public String getName() {
-        return mapper.getJcrName(name);
+        return mapper.getJcrName(dlg.getName());
     }
 
     @Override
     public String[] getDeclaredSupertypeNames() {
         List<String> names = new ArrayList<String>();
-        boolean addNtBase = !mixin;
-        for (String name : declaredSuperTypeNames) {
-            
-            String jcrName = mapper.getJcrName(name); 
-            
+        boolean addNtBase = !isMixin();
+        for (String name : dlg.getDeclaredSuperTypeNames()) {
+
+            String jcrName = mapper.getJcrName(name);
+
             // TODO: figure out a more performant way
             // check of at least one declared super type being a non-mixin type
             if (addNtBase) {
                 try {
                     NodeType nt = manager.getNodeType(jcrName);
-                    if (! nt.isMixin()) {
+                    if (!nt.isMixin()) {
                         addNtBase = false;
                     }
-                }
-                catch (RepositoryException ex) {
+                } catch (RepositoryException ex) {
                     // ignored
                 }
-            }    
+            }
             names.add(jcrName);
         }
-        
+
         if (addNtBase) {
             names.add(mapper.getJcrName("nt:base"));
         }
-        
+
         return names.toArray(new String[names.size()]);
     }
 
     @Override
     public boolean isAbstract() {
-        return isAbstract;
+        return dlg.isAbstract();
     }
 
     @Override
     public boolean isMixin() {
-        return mixin;
+        return dlg.isMixin();
     }
 
     @Override
     public boolean hasOrderableChildNodes() {
-        return hasOrderableChildNodes;
+        return dlg.hasOrderableChildNodes();
     }
 
     @Override
@@ -137,6 +109,7 @@ class NodeTypeImpl implements NodeType {
 
     @Override
     public String getPrimaryItemName() {
+        String primaryItemName = dlg.getPrimaryItemName();
         if (primaryItemName != null) {
             return mapper.getJcrName(primaryItemName);
         } else {
@@ -146,14 +119,26 @@ class NodeTypeImpl implements NodeType {
 
     @Override
     public PropertyDefinition[] getDeclaredPropertyDefinitions() {
-        return declaredPropertyDefinitions.toArray(
-                new PropertyDefinition[declaredPropertyDefinitions.size()]);
+        List<PropertyDefinitionDelegate> definitionDelegates = dlg.getPropertyDefinitionDelegates();
+        PropertyDefinition[] result = new PropertyDefinition[definitionDelegates.size()];
+
+        for (int i = 0; i < result.length; i++) {
+            result[i] = new PropertyDefinitionImpl(this, mapper, valueFactory, definitionDelegates.get(i));
+        }
+
+        return result;
     }
 
     @Override
     public NodeDefinition[] getDeclaredChildNodeDefinitions() {
-        return declaredChildNodeDefinitions.toArray(
-                new NodeDefinition[declaredChildNodeDefinitions.size()]);
+        List<NodeDefinitionDelegate> definitionDelegates = dlg.getChildNodeDefinitionDelegates();
+        NodeDefinition[] result = new NodeDefinition[definitionDelegates.size()];
+
+        for (int i = 0; i < result.length; i++) {
+            result[i] = new NodeDefinitionImpl(manager, this, mapper, definitionDelegates.get(i));
+        }
+
+        return result;
     }
 
     @Override
@@ -161,8 +146,7 @@ class NodeTypeImpl implements NodeType {
         try {
             Collection<NodeType> types = new ArrayList<NodeType>();
             Set<String> added = new HashSet<String>();
-            Queue<String> queue = new LinkedList<String>(
-                    Arrays.asList(getDeclaredSupertypeNames()));
+            Queue<String> queue = new LinkedList<String>(Arrays.asList(getDeclaredSupertypeNames()));
             while (!queue.isEmpty()) {
                 String name = queue.remove();
                 if (added.add(name)) {
@@ -173,8 +157,7 @@ class NodeTypeImpl implements NodeType {
             }
             return types.toArray(new NodeType[types.size()]);
         } catch (RepositoryException e) {
-            throw new IllegalStateException(
-                    "Inconsistent node type: " + this, e);
+            throw new IllegalStateException("Inconsistent node type: " + this, e);
         }
     }
 
@@ -188,8 +171,7 @@ class NodeTypeImpl implements NodeType {
             }
             return types;
         } catch (RepositoryException e) {
-            throw new IllegalStateException(
-                    "Inconsistent node type: " + this, e);
+            throw new IllegalStateException("Inconsistent node type: " + this, e);
         }
     }
 
@@ -206,8 +188,7 @@ class NodeTypeImpl implements NodeType {
             }
             return new NodeTypeIteratorAdapter(types);
         } catch (RepositoryException e) {
-            throw new IllegalStateException(
-                    "Inconsistent node type: " + this, e);
+            throw new IllegalStateException("Inconsistent node type: " + this, e);
         }
     }
 
@@ -227,8 +208,7 @@ class NodeTypeImpl implements NodeType {
             }
             return new NodeTypeIteratorAdapter(types);
         } catch (RepositoryException e) {
-            throw new IllegalStateException(
-                    "Inconsistent node type: " + this, e);
+            throw new IllegalStateException("Inconsistent node type: " + this, e);
         }
     }
 
@@ -247,11 +227,9 @@ class NodeTypeImpl implements NodeType {
 
     @Override
     public PropertyDefinition[] getPropertyDefinitions() {
-        Collection<PropertyDefinition> definitions =
-                new ArrayList<PropertyDefinition>();
+        Collection<PropertyDefinition> definitions = new ArrayList<PropertyDefinition>();
         for (NodeType type : getSupertypes()) {
-            definitions.addAll(Arrays.asList(
-                    type.getDeclaredPropertyDefinitions()));
+            definitions.addAll(Arrays.asList(type.getDeclaredPropertyDefinitions()));
         }
         definitions.addAll(Arrays.asList(getDeclaredPropertyDefinitions()));
         return definitions.toArray(new PropertyDefinition[definitions.size()]);
@@ -259,11 +237,9 @@ class NodeTypeImpl implements NodeType {
 
     @Override
     public NodeDefinition[] getChildNodeDefinitions() {
-        Collection<NodeDefinition> definitions =
-                new ArrayList<NodeDefinition>();
+        Collection<NodeDefinition> definitions = new ArrayList<NodeDefinition>();
         for (NodeType type : getSupertypes()) {
-            definitions.addAll(Arrays.asList(
-                    type.getDeclaredChildNodeDefinitions()));
+            definitions.addAll(Arrays.asList(type.getDeclaredChildNodeDefinitions()));
         }
         definitions.addAll(Arrays.asList(getDeclaredChildNodeDefinitions()));
         return definitions.toArray(new NodeDefinition[definitions.size()]);

Modified: jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeManagerImpl.java
URL: http://svn.apache.org/viewvc/jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeManagerImpl.java?rev=1335629&r1=1335628&r2=1335629&view=diff
==============================================================================
--- jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeManagerImpl.java
(original)
+++ jackrabbit/oak/trunk/oak-jcr/src/main/java/org/apache/jackrabbit/oak/jcr/nodetype/NodeTypeManagerImpl.java
Tue May  8 16:44:45 2012
@@ -29,14 +29,12 @@ import java.util.Map;
 import javax.jcr.RepositoryException;
 import javax.jcr.UnsupportedRepositoryOperationException;
 import javax.jcr.nodetype.NoSuchNodeTypeException;
-import javax.jcr.nodetype.NodeDefinition;
 import javax.jcr.nodetype.NodeDefinitionTemplate;
 import javax.jcr.nodetype.NodeType;
 import javax.jcr.nodetype.NodeTypeDefinition;
 import javax.jcr.nodetype.NodeTypeIterator;
 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.CompactNodeTypeDefReader;
@@ -53,23 +51,25 @@ import org.apache.jackrabbit.oak.namepat
 
 public class NodeTypeManagerImpl implements NodeTypeManager {
 
+    private final ValueFactoryImpl vf;
     private final NameMapper mapper;
-    private final List<NodeType> types;
+    private final List<NodeTypeDelegate> typeDelegates;
 
     private final Map<String, NodeType> typemap = new HashMap<String, NodeType>();
 
     public NodeTypeManagerImpl(ValueFactoryImpl vf, NameMapper mapper) throws RepositoryException
{
+        this.vf = vf;
         this.mapper = mapper;
 
         try {
             InputStream stream = NodeTypeManagerImpl.class.getResourceAsStream("builtin_nodetypes.cnd");
             Reader reader = new InputStreamReader(stream, "UTF-8");
             try {
-                DefinitionBuilderFactory<NodeType, Map<String, String>> dbf =
new DefinitionBuilderFactoryImpl(this, vf, mapper);
-                CompactNodeTypeDefReader<NodeType, Map<String, String>> cndr
= new CompactNodeTypeDefReader<NodeType, Map<String, String>>(
+                DefinitionBuilderFactory<NodeTypeDelegate, Map<String, String>>
dbf = new DefinitionDelegateBuilderFactory(vf);
+                CompactNodeTypeDefReader<NodeTypeDelegate, Map<String, String>>
cndr = new CompactNodeTypeDefReader<NodeTypeDelegate, Map<String, String>>(
                         reader, null, dbf);
 
-                types = cndr.getNodeTypeDefinitions();
+                typeDelegates = cndr.getNodeTypeDefinitions();
             } catch (ParseException ex) {
                 throw new RepositoryException("Failed to load built-in node types", ex);
             } finally {
@@ -82,8 +82,9 @@ public class NodeTypeManagerImpl impleme
 
     private void init() {
         if (typemap.isEmpty()) {
-            for (NodeType t : types) {
-                typemap.put(t.getName(), t);
+            for (NodeTypeDelegate t : typeDelegates) {
+                NodeType nt = new NodeTypeImpl(this, vf, mapper, t);
+                typemap.put(t.getName(), nt);
             }
         }
     }
@@ -179,18 +180,14 @@ public class NodeTypeManagerImpl impleme
         throw new UnsupportedRepositoryOperationException();
     }
 
-    private class DefinitionBuilderFactoryImpl extends DefinitionBuilderFactory<NodeType,
Map<String, String>> {
+    private class DefinitionDelegateBuilderFactory extends DefinitionBuilderFactory<NodeTypeDelegate,
Map<String, String>> {
 
         private Map<String, String> nsmap = new HashMap<String, String>();
 
-        private final NodeTypeManager ntm;
         private final ValueFactoryImpl vf;
-        private final NameMapper mapper;
 
-        public DefinitionBuilderFactoryImpl(NodeTypeManager ntm, ValueFactoryImpl vf, NameMapper
mapper) {
-            this.ntm = ntm;
+        public DefinitionDelegateBuilderFactory(ValueFactoryImpl vf) {
             this.vf = vf;
-            this.mapper = mapper;
         }
 
         @Override
@@ -199,9 +196,9 @@ public class NodeTypeManagerImpl impleme
         }
 
         @Override
-        public org.apache.jackrabbit.commons.cnd.DefinitionBuilderFactory.AbstractNodeTypeDefinitionBuilder<NodeType>
newNodeTypeDefinitionBuilder()
+        public org.apache.jackrabbit.commons.cnd.DefinitionBuilderFactory.AbstractNodeTypeDefinitionBuilder<NodeTypeDelegate>
newNodeTypeDefinitionBuilder()
                 throws RepositoryException {
-            return new NodeTypeDefinitionBuilderImpl(ntm, vf, mapper);
+            return new NodeTypeDefinitionDelegateBuilder(vf);
         }
 
         @Override
@@ -215,22 +212,18 @@ public class NodeTypeManagerImpl impleme
         }
     }
 
-    private class NodeTypeDefinitionBuilderImpl extends AbstractNodeTypeDefinitionBuilder<NodeType>
{
+    private class NodeTypeDefinitionDelegateBuilder extends AbstractNodeTypeDefinitionBuilder<NodeTypeDelegate>
{
 
-        private List<PropertyDefinitionBuilderImpl> propertyDefinitions = new ArrayList<PropertyDefinitionBuilderImpl>();
-        private List<NodeDefinitionBuilderImpl> childNodeDefinitions = new ArrayList<NodeDefinitionBuilderImpl>();
+        private List<PropertyDefinitionDelegateBuilder> propertyDefinitions = new ArrayList<PropertyDefinitionDelegateBuilder>();
+        private List<NodeDefinitionDelegateBuilder> childNodeDefinitions = new ArrayList<NodeDefinitionDelegateBuilder>();
 
-        private final NodeTypeManager ntm;
         private final ValueFactoryImpl vf;
-        private final NameMapper mapper;
 
         private String primaryItemName;
         private List<String> declaredSuperTypes = new ArrayList<String>();
 
-        public NodeTypeDefinitionBuilderImpl(NodeTypeManager ntm, ValueFactoryImpl vf, NameMapper
mapper) {
-            this.ntm = ntm;
+        public NodeTypeDefinitionDelegateBuilder(ValueFactoryImpl vf) {
             this.vf = vf;
-            this.mapper = mapper;
         }
 
         @Override
@@ -244,51 +237,50 @@ public class NodeTypeManagerImpl impleme
         }
 
         @Override
-        public AbstractPropertyDefinitionBuilder<NodeType> newPropertyDefinitionBuilder()
throws RepositoryException {
-            return new PropertyDefinitionBuilderImpl(this);
+        public AbstractPropertyDefinitionBuilder<NodeTypeDelegate> newPropertyDefinitionBuilder()
throws RepositoryException {
+            return new PropertyDefinitionDelegateBuilder(this);
         }
 
         @Override
-        public AbstractNodeDefinitionBuilder<NodeType> newNodeDefinitionBuilder() throws
RepositoryException {
-            return new NodeDefinitionBuilderImpl(this);
+        public AbstractNodeDefinitionBuilder<NodeTypeDelegate> newNodeDefinitionBuilder()
throws RepositoryException {
+            return new NodeDefinitionDelegateBuilder(this);
         }
 
         @Override
-        public NodeType build() throws RepositoryException {
+        public NodeTypeDelegate build() throws RepositoryException {
 
-            NodeTypeImpl result = new NodeTypeImpl(ntm, mapper, name, declaredSuperTypes.toArray(new
String[declaredSuperTypes
-                    .size()]), primaryItemName, isMixin, isAbstract, isOrderable);
+            NodeTypeDelegate result = new NodeTypeDelegate(name, declaredSuperTypes.toArray(new
String[declaredSuperTypes.size()]),
+                    primaryItemName, isMixin, isAbstract, isOrderable);
 
-            for (PropertyDefinitionBuilderImpl pdb : propertyDefinitions) {
-                result.addPropertyDefinition(new PropertyDefinitionImpl(result, mapper, vf,
pdb.getPropertyDefinitionDelegate(vf
-                        .getCoreValueFactory())));
+            for (PropertyDefinitionDelegateBuilder pdb : propertyDefinitions) {
+                result.addPropertyDefinitionDelegate(pdb.getPropertyDefinitionDelegate(vf.getCoreValueFactory()));
             }
 
-            for (NodeDefinitionBuilderImpl ndb : childNodeDefinitions) {
-                result.addChildNodeDefinition(new NodeDefinitionImpl(ntm, result, mapper,
ndb.getNodeDefinitionDelegate()));
+            for (NodeDefinitionDelegateBuilder ndb : childNodeDefinitions) {
+                result.addChildNodeDefinitionDelegate(ndb.getNodeDefinitionDelegate());
             }
 
             return result;
         }
 
-        public void addPropertyDefinition(PropertyDefinitionBuilderImpl pd) {
+        public void addPropertyDefinition(PropertyDefinitionDelegateBuilder pd) {
             this.propertyDefinitions.add(pd);
         }
 
-        public void addNodeDefinition(NodeDefinitionBuilderImpl nd) {
+        public void addNodeDefinition(NodeDefinitionDelegateBuilder nd) {
             this.childNodeDefinitions.add(nd);
         }
     }
 
-    private class NodeDefinitionBuilderImpl extends AbstractNodeDefinitionBuilder<NodeType>
{
+    private class NodeDefinitionDelegateBuilder extends AbstractNodeDefinitionBuilder<NodeTypeDelegate>
{
 
         private String declaringNodeType;
         private String defaultPrimaryType;
         private List<String> requiredPrimaryTypes = new ArrayList<String>();
 
-        private final NodeTypeDefinitionBuilderImpl ndtb;
+        private final NodeTypeDefinitionDelegateBuilder ndtb;
 
-        public NodeDefinitionBuilderImpl(NodeTypeDefinitionBuilderImpl ntdb) {
+        public NodeDefinitionDelegateBuilder(NodeTypeDefinitionDelegateBuilder ntdb) {
             this.ndtb = ntdb;
         }
 
@@ -318,15 +310,15 @@ public class NodeTypeManagerImpl impleme
         }
     }
 
-    private class PropertyDefinitionBuilderImpl extends AbstractPropertyDefinitionBuilder<NodeType>
{
+    private class PropertyDefinitionDelegateBuilder extends AbstractPropertyDefinitionBuilder<NodeTypeDelegate>
{
 
         private String declaringNodeType;
         private List<String> defaultValues = new ArrayList<String>();
         private List<String> valueConstraints = new ArrayList<String>();
 
-        private final NodeTypeDefinitionBuilderImpl ndtb;
+        private final NodeTypeDefinitionDelegateBuilder ndtb;
 
-        public PropertyDefinitionBuilderImpl(NodeTypeDefinitionBuilderImpl ntdb) {
+        public PropertyDefinitionDelegateBuilder(NodeTypeDefinitionDelegateBuilder ntdb)
{
             this.ndtb = ntdb;
         }
 



Mime
View raw message